RCIPtr.h

Go to the documentation of this file.

#ifndef RCIPTR_H_
#define RCIPTR_H_

namespace spear {

class RCObject 
{
 public:
  void addReference();
  void removeReference();

 protected:
  RCObject();
  RCObject(const RCObject& rhs);
  RCObject& operator=(const RCObject& rhs);
  virtual ~RCObject() = 0;

 public:
  unsigned short refCount;
};

inline RCObject::RCObject()
  : refCount(0){} // std::cout << "RCObject constr\n"; }

inline RCObject::RCObject(const RCObject&)
  : refCount(0){} // std::cout << "RCObject copy constr\n"; }

inline RCObject& RCObject::operator=(const RCObject&)
{
  return *this;
}  

inline RCObject::~RCObject() {}

inline void RCObject::addReference() 
{
  ++refCount;
}

inline void RCObject::removeReference()
{
  if (--refCount == 0) delete this;
}

template<class T>
class RCIPtr 
{
 public:
  explicit RCIPtr(T* realPtr = 0);
  RCIPtr(const RCIPtr& rhs);
  ~RCIPtr();
  RCIPtr& operator=(const RCIPtr& rhs);

  T* operator->() const;
  T& operator*() const;

  void clear() {
    *this = RCIPtr<T>(0);
  };

private:
  T *pointee;
  void init() {
    if(pointee != 0) pointee->addReference();
  }
};

template<typename T>
inline bool operator== (const RCIPtr<T> & pointer, const RCIPtr<T> & other)
{
  return pointer.operator->() == other.operator->();
}

template<typename T>
inline bool operator!= (const RCIPtr<T> & pointer, const RCIPtr<T> & other)
{
  return pointer.operator->() != other.operator->();
}

template<typename T>
inline bool operator== (const RCIPtr<T> & pointer, const T * other)
{
  return pointer.operator->() == other;
}

template<typename T>
inline bool operator== (const T * other, const RCIPtr<T> & pointer)
{
  return pointer.operator->() == other;
}

template<typename T>
inline bool operator!= (const RCIPtr<T> & pointer, const T * other)
{
  return pointer.operator->() != other;
}

template<typename T>
inline bool operator!= (const T * other, const RCIPtr<T> & pointer)
{
  return pointer.operator->() != other;
}

template<class T>
RCIPtr<T>::RCIPtr(T* realPtr)
  : pointee(realPtr)
{ 
  init();
}

template<class T>
RCIPtr<T>::RCIPtr(const RCIPtr& rhs)
  : pointee(rhs.pointee)
{ 
  init(); 
}

template<class T>
RCIPtr<T>::~RCIPtr()
{ 
  if(pointee != 0) pointee->removeReference(); 
}

template<class T>
RCIPtr<T>& RCIPtr<T>::operator=(const RCIPtr& rhs)
{
  if (pointee != rhs.pointee) {         
    if(pointee != 0) pointee->removeReference();     
    pointee = rhs.pointee;
    init();
  }
  return *this;
}

template<class T>
T* RCIPtr<T>::operator->() const
{ return pointee; }

template<class T>
T& RCIPtr<T>::operator*() const
{ return *(pointee); }

} // end namespace spear

#endif /* RCI_PTR_H */