AutoPtr.h

 
#ifndef COSMO_AUTO_PTR_H
#define COSMO_AUTO_PTR_H
 
#include <Pt/Cosmo/Api.h>
 
namespace Pt {
 
namespace Cosmo {

template<typename T>
class AutoPtrImpl
{
  public:
    AutoPtrImpl(T* ptr)
    : _ptr(ptr)
    { }
 
    virtual ~AutoPtrImpl()
    { }
 
    void reset(T* ptr = 0)
    {
      if(_ptr)
        onReset(_ptr);
      
      _ptr = ptr;
    }
 
    void destroy()
    {
      onDestroy();
    }
 
    T* get()
    {
      return _ptr;
    }
 
  protected:
    virtual void onReset(T* ptr) = 0;
 
    virtual void onDestroy() = 0;
 
  private:
    T* _ptr;
};

template <typename Y, typename B, typename D>
class AutoPtrData : public AutoPtrImpl<B>
{
  public:
    AutoPtrData(Y* res, D del)
    : AutoPtrImpl<B>(res)
    , _del(del)
    { }
 
  protected:
    virtual void onReset(B* ptr)
    {
      _del( static_cast<Y*>(ptr) );
    }
 
    virtual void onDestroy()
    {
      delete this;
    }
 
  private:
    D  _del;
};

template<typename T>
struct AutoPtrRef 
{
  AutoPtrImpl<T>* ptr;
    
  explicit AutoPtrRef(AutoPtrImpl<T>* ap)
  : ptr(ap)
  { }
};

template<typename T>
class AutoPtr
{
  private:
    template <typename Y>
    class DefaultDelete
    {
      public:
        void operator()(Y* res)
        {
          delete res;
        }
    };
 
    public:
        typedef T element_type;
 
    public:
        AutoPtr()
        : _ptr(0)
        { }

        template <typename Y>
        explicit AutoPtr(Y* ptr)
        : _ptr(0)
        {
            DefaultDelete<Y> deleter;
            _ptr = new AutoPtrData<Y, T, DefaultDelete<Y> >(ptr, deleter);
        }

        template <typename Y, typename Deleter>
        AutoPtr(Y* ptr, Deleter deleter)
        : _ptr(0)
        { 
            _ptr = new AutoPtrData<Y, T, Deleter>(ptr, deleter);
        }

        AutoPtr(AutoPtrRef<T> rhs)
        : _ptr(rhs.ptr) 
        { }

        AutoPtr(AutoPtr&& other)
        : _ptr(other._ptr)
        { other._ptr = 0; }

        ~AutoPtr()
        { 
            reset(); 
        }

        AutoPtr& operator=(AutoPtr&& other)
        {
            if( this != &other )
            {
                reset();
                _ptr = other._ptr;
                other._ptr = 0;
            }
            return *this;
        }

        AutoPtr& operator= (AutoPtrRef<T> rhs)
        {           
            this->reset();
            _ptr = rhs.ptr;
            return *this;
        }

        template<class Y>
        operator AutoPtrRef<Y>()
        {
            AutoPtrImpl<Y>* tmp = _ptr;
            _ptr = 0;
            return AutoPtrRef<Y>(tmp);
        }

        T* get() const 
        {
            return _ptr ? _ptr->get() : 0;
        }

        T& operator*() const 
        {
            return *_ptr->get();
        }

        T* operator->() const 
        {
            return _ptr->get();
        }

        bool operator !() const 
        {
            return _ptr == 0;
        }
        
        operator bool() const
        { 
            return _ptr != 0; 
        }

        T* release() 
        {
            if( ! _ptr )
              return 0;
 
            T* tmp = _ptr->get();
            _ptr->destroy();
            _ptr = 0;
 
            return tmp;
        }

        void reset()
        {
            if(_ptr)
            {
                _ptr->reset();
                _ptr->destroy();
                _ptr = 0;
            }
        }

        template <typename Y>
        void reset(Y* ptr)
        {
            if( ! ptr )
            {
              reset();
              return;
            }
 
            if(_ptr)
            {
                _ptr->reset(ptr);
            }
            else
            {
                DefaultDelete<Y> deleter;
                _ptr = new AutoPtrData<Y, T, DefaultDelete<Y> >(ptr, deleter);
            }
        }
 
    private:
        AutoPtr(AutoPtr &p);
 
        AutoPtr& operator =(AutoPtr& p);
 
    private:
        AutoPtrImpl<T>* _ptr;
};

template <typename T>
AutoPtr<T> move(AutoPtr<T>& p)
{
    return AutoPtr<T>( AutoPtrRef<T>(p) );
}

template <typename T, typename Y>
bool operator==(const AutoPtr<T>& a, const AutoPtr<Y>& b)
{ return a.get() == b.get(); }

template <typename T, typename Y>
bool operator==(const AutoPtr<T>& a, const Y* b)
{ return a.get() == b; }

template <typename T, typename Y>
bool operator!=(const AutoPtr<T>& a, const AutoPtr<Y>& b)
{ return a.get() != b.get(); }

template <typename T, typename Y>
bool operator!=(const AutoPtr<T>& a, const Y* b)
{ return a.get() != b; }

template <typename T, typename Y>
bool operator<(const AutoPtr<T>& a, const AutoPtr<Y>& b)
{ return a.get() < b.get(); }

template <typename T, typename Y>
bool operator<(const AutoPtr<T>& a, const Y* b)
{ return a.get() < b; }
 
} // namespace Cosmo
 
} // namespace Pt
 
#endif // include guard