vtkSmartPointer.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkSmartPointer.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 vtkSmartPointer_h
#define vtkSmartPointer_h

#include "vtkSmartPointerBase.h"
#include "vtkNew.h"  // For converting New pointers to Smart pointers

template <class T>
class vtkSmartPointer: public vtkSmartPointerBase
{
  static T* CheckType(T* t) { return t; }
public:
  vtkSmartPointer() {}

  vtkSmartPointer(T* r): vtkSmartPointerBase(r) {}

  vtkSmartPointer(vtkNew<T>& r): vtkSmartPointerBase(r.GetPointer()) {}

  template <class U>
  vtkSmartPointer(const vtkSmartPointer<U>& r):
    vtkSmartPointerBase(CheckType(r.GetPointer())) {}


  vtkSmartPointer& operator=(T* r)
  {
    this->vtkSmartPointerBase::operator=(r);
    return *this;
  }


  vtkSmartPointer& operator=(vtkNew<T>& r)
  {
    this->vtkSmartPointerBase::operator=(r);
    return *this;
  }


  template <class U>
  vtkSmartPointer& operator=(const vtkSmartPointer<U>& r)
  {
    this->vtkSmartPointerBase::operator=(CheckType(r.GetPointer()));
    return *this;
  }


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

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

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

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

  void TakeReference(T* t)
  {
    *this = vtkSmartPointer<T>(t, NoReference());
  }

  static vtkSmartPointer<T> New()
  {
    return vtkSmartPointer<T>(T::New(), NoReference());
  }

  static vtkSmartPointer<T> NewInstance(T* t)
  {
    return vtkSmartPointer<T>(t->NewInstance(), NoReference());
  }

  static vtkSmartPointer<T> Take(T* t)
  {
    return vtkSmartPointer<T>(t, NoReference());
  }

  // Work-around for HP and IBM overload resolution bug.  Since
  // NullPointerOnly is a private type the only pointer value that can
  // be passed by user code is a null pointer.  This operator will be
  // chosen by the compiler when comparing against null explicitly and
  // avoid the bogus ambiguous overload error.
#if defined(__HP_aCC) || defined(__IBMCPP__)
# define VTK_SMART_POINTER_DEFINE_OPERATOR_WORKAROUND(op) \
  bool operator op (NullPointerOnly*) const        \
  {                                                     \
    return ::operator op (*this, 0);                      \
  }
private:
  class NullPointerOnly {};
public:
  VTK_SMART_POINTER_DEFINE_OPERATOR_WORKAROUND(==)
  VTK_SMART_POINTER_DEFINE_OPERATOR_WORKAROUND(!=)
  VTK_SMART_POINTER_DEFINE_OPERATOR_WORKAROUND(<)
  VTK_SMART_POINTER_DEFINE_OPERATOR_WORKAROUND(<=)
  VTK_SMART_POINTER_DEFINE_OPERATOR_WORKAROUND(>)
  VTK_SMART_POINTER_DEFINE_OPERATOR_WORKAROUND(>=)
# undef VTK_SMART_POINTER_DEFINE_OPERATOR_WORKAROUND
#endif
protected:
  vtkSmartPointer(T* r, const NoReference& n): vtkSmartPointerBase(r, n) {}
private:
  // These are purposely not implemented to prevent callers from
  // trying to take references from other smart pointers.
  void TakeReference(const vtkSmartPointerBase&) = delete;
  static void Take(const vtkSmartPointerBase&) = delete;
};

#define VTK_SMART_POINTER_DEFINE_OPERATOR(op) \
  template <class T> \
  inline bool \
  operator op (const vtkSmartPointer<T>& l, const vtkSmartPointer<T>& r) \
  { \
    return (l.GetPointer() op r.GetPointer()); \
  } \
  template <class T> \
  inline bool operator op (T* l, const vtkSmartPointer<T>& r) \
  { \
    return (l op r.GetPointer()); \
  } \
  template <class T> \
  inline bool operator op (const vtkSmartPointer<T>& l, T* r) \
  { \
    return (l.GetPointer() op r); \
  }

VTK_SMART_POINTER_DEFINE_OPERATOR(==)
VTK_SMART_POINTER_DEFINE_OPERATOR(!=)
VTK_SMART_POINTER_DEFINE_OPERATOR(<)
VTK_SMART_POINTER_DEFINE_OPERATOR(<=)
VTK_SMART_POINTER_DEFINE_OPERATOR(>)
VTK_SMART_POINTER_DEFINE_OPERATOR(>=)

#undef VTK_SMART_POINTER_DEFINE_OPERATOR

template <class T>
inline ostream& operator << (ostream& os, const vtkSmartPointer<T>& p)
{
  return os << static_cast<const vtkSmartPointerBase&>(p);
}

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