|  | VTK
    9.0.1
    | 
 
 
 
Go to the documentation of this file.
   43 #ifndef vtkWeakPointer_h 
   44 #define vtkWeakPointer_h 
   51 #include <type_traits>  
   61   template <
typename U = T>
 
   62   static void CheckTypes() noexcept
 
   65       "vtkWeakPointer<T>'s T type has not been defined. Missing " 
   68       "Cannot store an object with undefined type in " 
   69       "vtkWeakPointer. Missing include?");
 
   71       "Argument type is not compatible with vtkWeakPointer<T>'s " 
   74       "vtkWeakPointer can only be used with subclasses of " 
   97     vtkWeakPointer::CheckTypes<U>();
 
  110     vtkWeakPointer::CheckTypes<U>();
 
  121     vtkWeakPointer::CheckTypes();
 
  124   template <
typename U>
 
  128     vtkWeakPointer::CheckTypes<U>();
 
  145     vtkWeakPointer::CheckTypes<U>();
 
  165     vtkWeakPointer::CheckTypes<U>();
 
  178     vtkWeakPointer::CheckTypes();
 
  183   template <
typename U>
 
  186     vtkWeakPointer::CheckTypes<U>();
 
  197   T* 
GetPointer() const noexcept { 
return static_cast<T*
>(this->Object); }
 
  198   T* 
Get() const noexcept { 
return static_cast<T*
>(this->Object); }
 
  199   operator T*() 
const noexcept { 
return static_cast<T*
>(this->Object); }
 
  205   T& 
operator*() const noexcept { 
return *
static_cast<T*
>(this->Object); }
 
  210   T* 
operator->() const noexcept { 
return static_cast<T*
>(this->Object); }
 
  217 #if defined(__HP_aCC) || defined(__IBMCPP__) 
  218 #define VTK_WEAK_POINTER_DEFINE_OPERATOR_WORKAROUND(op)                                            \ 
  219   bool operator op(NullPointerOnly*) const { return ::operator op(*this, 0); } 
  222   class NullPointerOnly
 
  227   VTK_WEAK_POINTER_DEFINE_OPERATOR_WORKAROUND(==)
 
  228   VTK_WEAK_POINTER_DEFINE_OPERATOR_WORKAROUND(!=)
 
  229   VTK_WEAK_POINTER_DEFINE_OPERATOR_WORKAROUND(<)
 
  230   VTK_WEAK_POINTER_DEFINE_OPERATOR_WORKAROUND(<=)
 
  231   VTK_WEAK_POINTER_DEFINE_OPERATOR_WORKAROUND(>)
 
  232   VTK_WEAK_POINTER_DEFINE_OPERATOR_WORKAROUND(>=)
 
  233 #undef VTK_WEAK_POINTER_DEFINE_OPERATOR_WORKAROUND 
  248 #define VTK_WEAK_POINTER_DEFINE_OPERATOR(op)                                                       \ 
  249   template <class T, class U>                                                                      \ 
  250   inline bool operator op(const vtkWeakPointer<T>& l, const vtkWeakPointer<U>& r)                  \ 
  252     return (l.GetPointer() op r.GetPointer());                                                     \ 
  254   template <class T, class U>                                                                      \ 
  255   inline bool operator op(T* l, const vtkWeakPointer<U>& r)                                        \ 
  257     return (l op r.GetPointer());                                                                  \ 
  259   template <class T, class U>                                                                      \ 
  260   inline bool operator op(const vtkWeakPointer<T>& l, U* r)                                        \ 
  262     return (l.GetPointer() op r);                                                                  \ 
  264   template <class T, class U>                                                                      \ 
  265   inline bool operator op(const vtkNew<T>& l, const vtkWeakPointer<U>& r)                          \ 
  267     return (l.GetPointer() op r.GetPointer());                                                     \ 
  269   template <class T, class U>                                                                      \ 
  270   inline bool operator op(const vtkWeakPointer<T>& l, const vtkNew<U>& r)                          \ 
  272     return (l.GetPointer() op r.GetPointer);                                                       \ 
  285 #undef VTK_WEAK_POINTER_DEFINE_OPERATOR 
  292 template <
typename T>
 
  306   return os << static_cast<const vtkWeakPointerBase&>(p);
 
  
vtkWeakPointer & operator=(T *r)
Assign object to reference.
vtkWeakPointer & operator=(const vtkWeakPointer< U > &r)
Initialize smart pointer with the given smart pointer.
ostream & operator<<(ostream &os, const vtkWeakPointer< T > &p)
Streaming operator to print smart pointer like regular pointers.
T * Get() const noexcept
Initialize smart pointer with the given smart pointer.
vtkWeakPointer & operator=(const vtkWeakPointer &r)
Assign object to reference.
T * GetPointer() const noexcept
Get the contained pointer.
vtkWeakPointer(const vtkNew< U > &r)
Initialize smart pointer with the given smart pointer.
vtkWeakPointer(T *r, const NoReference &n)
Initialize smart pointer with the given smart pointer.
#define VTK_WEAK_POINTER_DEFINE_OPERATOR(op)
T & operator*() const noexcept
Dereference the pointer and return a reference to the contained object.
T * operator->() const noexcept
Provides normal pointer target member access using operator ->.
vtkWeakPointer & operator=(vtkWeakPointer &&r) noexcept
Move r's object into this weak pointer, setting r to nullptr.
vtkWeakPointer(vtkWeakPointer &&r) noexcept
Move r's object into the new weak pointer, setting r to nullptr.
vtkWeakPointer(const vtkWeakPointer< U > &r)
Initialize smart pointer with the given smart pointer.
Non-templated superclass for vtkWeakPointer.
Allocate and hold a VTK object.
vtkWeakPointer(T *r)
Initialize smart pointer to given object.
vtkWeakPointer(vtkWeakPointer< U > &&r) noexcept
Initialize smart pointer with the given smart pointer.
vtkWeakPointer< T > TakeWeakPointer(T *obj)
Construct a vtkWeakPointer<T> containing obj.
vtkWeakPointer(const vtkWeakPointer &r)
Initialize smart pointer with the given smart pointer.
Specialization of tuple ranges and iterators for vtkAOSDataArrayTemplate.
vtkWeakPointer & operator=(const vtkNew< U > &r)
Initialize smart pointer with the given smart pointer.
vtkWeakPointerBase & operator=(vtkObjectBase *r)
Assign object to reference.
a weak reference to a vtkObject.
vtkWeakPointer & operator=(vtkWeakPointer< U > &&r) noexcept
Initialize smart pointer with the given smart pointer.
vtkWeakPointer() noexcept
Initialize smart pointer to nullptr.