albaSmartPointer.h

Go to the documentation of this file.

/*=========================================================================
 
 Program: ALBA (Agile Library for Biomedical Applications)
 Module: albaSmartPointer
 Authors: based on vtkSmartPointer (www.vtk.org), rewritten by Marco Petrone
 
 Copyright (c) BIC
 All rights reserved. See Copyright.txt or
 
 
 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 __albaSmartPointer_h
#define __albaSmartPointer_h
 
#include "albaConfigure.h"
#include "albaBase.h"
 
//----------------------------------------------------------------------------
// forward declarations
//----------------------------------------------------------------------------
class albaReferenceCounted;
 
template <class T>
class albaAutoPointer : public albaBase
{
public:  
   albaAutoPointer(T* r=NULL,void *owner=NULL){
      m_Object=r;
      Register(owner);
   }
 
  
   albaAutoPointer(const albaAutoPointer& r){m_Object=r.m_Object;Register(NULL);}
  
   ~albaAutoPointer(){UnRegister(NULL);}
  
   albaAutoPointer& operator=(T* r){
      // make use of a temp auto-ptr to safely unregister, this
      // to avoid deallocation in case of self assignment
      albaAutoPointer(r).Swap(*this); 
      return *this;
   }
 
   albaAutoPointer& operator=(const albaAutoPointer<T>& r){
      // make use of a temp auto-ptr to safely unregister, this
      // to avoid deallocation in case of self assignment
      albaAutoPointer<T> tmp(r);
      tmp.Swap(*this); // swaps the two pointers
      return *this;
   }
 
  bool operator==(const albaAutoPointer<T>& r) const {return r.m_Object==m_Object;}
  bool operator==(const T *r) const {return r==m_Object;}
  
  T* GetPointer() const {return m_Object;}
 
  operator T *() const {return (T *)m_Object;}
  
  T* operator->() const { return static_cast<T*>(this->m_Object); }
 
   void UnRegister(void *owner){
      if(m_Object)
      {
         m_Object->UnRegister(owner);
         m_Object = NULL;
      }
   }
  
protected:
  // Internal utility methods.
   void Swap(albaAutoPointer& r){
      T* temp = r.m_Object;
      r.m_Object = m_Object;
      m_Object = temp;
   }
   void Register(void *owner){
      if(m_Object)
      {
         m_Object->Register(owner);
      }
   }
 
  T* m_Object; 
};
 
template <class T>
class albaSmartPointer: public albaAutoPointer<T>
{
public:
  albaSmartPointer() {this->m_Object=T::New();this->Register(NULL);}
 
  albaSmartPointer(T* r): albaAutoPointer<T>(r) {;}
  
  albaSmartPointer(const albaAutoPointer<T>& r): albaAutoPointer<T>(r) {;}
};
 
 
//----------------------------------------------------------------------------
template <class T>
inline bool operator == (const albaAutoPointer<T>& l, const albaAutoPointer<T>& r) \
//----------------------------------------------------------------------------
{ return (static_cast<void*>(l.GetPointer()) == static_cast<void*>(r.GetPointer())); }
 
//----------------------------------------------------------------------------
template <class T>
inline bool operator == (albaReferenceCounted* l, const albaAutoPointer<T>& r) \
//----------------------------------------------------------------------------
{ return (static_cast<void*>(l) == static_cast<void*>(r.GetPointer())); }
 
//----------------------------------------------------------------------------
template <class T>
inline bool operator == (const albaAutoPointer<T>& l, albaReferenceCounted* r) \
//----------------------------------------------------------------------------
{ return (static_cast<void*>(l.GetPointer()) == static_cast<void*>(r)); }
 
 
#endif