DeepCopyPointer.h

Go to the documentation of this file.

#ifndef DeepCopyPointer_H
#define DeepCopyPointer_H
 
#include <algorithm>
 
template <class T>
class DeepCopyPointer {
public:
  ~DeepCopyPointer() { delete theData; }
 
  DeepCopyPointer() : theData(0) {}
 
  DeepCopyPointer(T* t) : theData(t) {}
 
  DeepCopyPointer(const DeepCopyPointer& other) {
    if (other.theData)
      theData = new T(*other);
    else
      theData = 0;
  }
 
  DeepCopyPointer& operator=(const DeepCopyPointer& other) {
    if (theData != other.theData) {
      delete theData;
      if (other.theData)
        theData = new T(*other);
      else
        theData = 0;
    }
    return *this;
  }
 
  // straight from http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2027.html
  DeepCopyPointer(DeepCopyPointer&& other) : theData(other.theData) { other.theData = 0; }
  DeepCopyPointer& operator=(DeepCopyPointer&& other) {
    std::swap(theData, other.theData);
    return *this;
  }
 
  void replaceWith(T* otherP) {
    if (theData != otherP) {
      delete theData;
      theData = otherP;
    }
  }
 
  // assume that the replacement object is of the very same class!
  // at the moment all the work is done by the client i.e.
  // call the distructor
  // new in place
  // with c++0X a templated method can encasulate it all here...
  T* replaceInplace() { return theData; }
 
  T& operator*() { return *theData; }
  const T& operator*() const { return *theData; }
 
  T* operator->() { return theData; }
  const T* operator->() const { return theData; }
 
  operator bool() const { return theData != 0; }
 
  bool operator==(const T* otherP) const { return theData == otherP; }
 
private:
  T* theData;
};
 
#endif  // DeepCopyPointer_H