vtkNew.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkNew.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkNew_h
#define vtkNew_h

#include "vtkIOStream.h"
#include "vtkMeta.h" // for IsComplete

#include <type_traits> // for is_base_of

class vtkObjectBase;

template <class T>
class vtkNew
{
  // Allow other smart pointers friend access:
  template <typename U> friend class vtkNew;
  template <typename U> friend class vtkSmartPointer;
  template <typename U> friend class vtkWeakPointer;

  // These static asserts only fire when the function calling CheckTypes is
  // used. Thus, this smart pointer class may still be used as a member variable
  // with a forward declared T, so long as T is defined by the time the calling
  // function is used.
  template <typename U = T>
  static void CheckTypes() noexcept
  {
    static_assert(vtk::detail::IsComplete<T>::value,
                  "vtkNew<T>'s T type has not been defined. Missing include?");
    static_assert(vtk::detail::IsComplete<U>::value,
                  "Cannot store an object with undefined type in "
                  "vtkNew. Missing include?");
    static_assert(std::is_base_of<T, U>::value,
                  "Argument type is not compatible with vtkNew<T>'s "
                  "T type.");
    static_assert(std::is_base_of<vtkObjectBase, T>::value,
                  "vtkNew can only be used with subclasses of vtkObjectBase.");
  }

public:
  vtkNew() : Object(T::New())
  {
    vtkNew::CheckTypes();
  }

  vtkNew(vtkNew &&o) noexcept
    : Object(o.Object)
  {
    o.Object = nullptr;
  }

  template <typename U>
  vtkNew(vtkNew<U> &&o) noexcept
    : Object(o.Object)
  {
    vtkNew::CheckTypes<U>();

    o.Object = nullptr;
  }


  ~vtkNew()
  {
    this->Reset();
  }

  void Reset()
  {
    T* obj = this->Object;
    if (obj)
    {
      this->Object = nullptr;
      obj->Delete();
    }
  }

  T* operator->() const noexcept
  {
    return this->Object;
  }


  T* GetPointer() const noexcept
  {
    return this->Object;
  }
  T* Get() const noexcept
  {
    return this->Object;
  }
  operator T* () const noexcept
  {
    return static_cast<T*>(this->Object);
  }

  T& operator*() const noexcept
  {
    return *static_cast<T*>(this->Object);
  }

private:
  vtkNew(vtkNew<T> const&) = delete;
  void operator=(vtkNew<T> const&) = delete;
  T* Object;
};

#endif
// VTK-HeaderTest-Exclude: vtkNew.h