---

allocatingpointer.h

Go to the documentation of this file.

#ifndef __ALLOCATING_POINTER_H__
#define __ALLOCATING_POINTER_H__

#include <functional>


template<class T>
struct CopyAsNominalType : public std::unary_function<T,T*>
{  T* operator() (const T& value) {  return new T(value);  }  };



template<class T>
struct CopyUsingClone : public std::unary_function<T,T*>
{  T* operator() (const T& value) {  return value.clone();  }  };



template<class T, class Cloner=CopyAsNominalType<T>, bool default_own=false >
class OwningPointer {
  typedef OwningPointer<T,Cloner> self;

public:
  OwningPointer(const T& value)
    : vp(allocate(value)), allocated(vp) { }
  
  OwningPointer(T* value_pointer, bool owns_object=default_own)
    : vp(value_pointer), allocated(owns_object? value_pointer : 0) { }

  OwningPointer(const self& other)
    : vp       (other.externalpointer()? other.vp : allocate(*(other.vp))),
      allocated(other.externalpointer()? 0        : vp    ) { }

  ~OwningPointer()
    {  delete allocated;  }
  
  void operator= (const T& new_value) { *vp=new_value; }

  self& operator= (const self& o) {
    if (this == &o) return *this;    
    if (allocated) {
      delete allocated; allocated=0;
    }

    if (o.externalpointer()) vp=o.vp;
    else allocated=vp=allocate(*(o.vp));

    return *this;
  }

  inline      operator bool()  const {  return bool(vp); }

  inline const T& operator*()  const {  return *vp; }

  inline const T* operator->() const {  return vp;  }

  inline       T* operator->()       {  return vp;  }

  inline T* valueptr() const {  return  vp;  }

  inline T*& valueptrref()   {  return  vp;  }

  /* Automatic conversion to type T (disabled) */
  //operator T() const { return *vp; }

  void relink(T* ptr) {  if (externalpointer()) vp = ptr;  }
  
private:
  T* vp;

  T* allocated;

  inline bool externalpointer() const {  return (allocated!=vp);  }

protected:
  inline T* allocate(const T& value) const
    {  return Cloner()(value);  }
};



template<class T, class Cloner=CopyAsNominalType<T>, bool default_own=false >
class AllocatingPointer : public OwningPointer<T,Cloner,default_own> {
public:
  AllocatingPointer(const T& value=T())
    : OwningPointer<T,Cloner,default_own>(allocate(value),true) { }
  
  AllocatingPointer(T* value_pointer, bool owns_object=default_own)
    : OwningPointer<T,Cloner,default_own>(value_pointer,owns_object) { }

  void operator= (const T& new_value) { *valueptr()=new_value; }
};



template<class T>
class MemoryReference {
  typedef MemoryReference<T> self;
  
public:
  MemoryReference(T* pointer=0)
    : allocated(pointer) { }

  MemoryReference(const MemoryReference&) : allocated(0) { }

  ~MemoryReference()  {  delete allocated;  }
  
  self& operator= (const MemoryReference&) { }

private:
  T* allocated;
};


#endif /* __ALLOCATING_POINTER_H__ */

---