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