SmartPtr.h

/*
 * Copyright (C) 2006 by Tommi Maekitalo
 * Copyright (C) 2006 by Marc Boris Duerner
 * Copyright (C) 2006 by Stefan Bueder
 * Copyright (C) 2010-2010 by Aloysius Indrayanto
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * As a special exception, you may use this file as part of a free
 * software library without restriction. Specifically, if other files
 * instantiate templates or use macros or inline functions from this
 * file, or you compile this file and link it with other files to
 * produce an executable, this file does not by itself cause the
 * resulting executable to be covered by the GNU General Public
 * License. This exception does not however invalidate any other
 * reasons why the executable file might be covered by the GNU Library
 * General Public License.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef PT_SMARTPTR_H
#define PT_SMARTPTR_H
 
#include <Pt/Api.h>
#include <Pt/Atomicity.h>
#include <Pt/SerializationInfo.h>
 
namespace Pt {

template <typename T>
class RefLinked
{
    private:
        mutable const RefLinked* prev;
        mutable const RefLinked* next;
 
    protected:
        RefLinked()
        : prev(0),
          next(0)
          { }

        bool unlink(T* object)
        {
            bool ret = false;
            if (object)
            {
                if (next == this)
                {
                    ret = true;
                }
                else
                {
                    next->prev = prev;
                    prev->next = next;
                }
                next = prev = this;
            }
            return ret;
        }

        void link(const RefLinked& ptr, T* object)
        {
            if (object)
            {
                prev = &ptr;
                next = ptr.next;
                prev->next = this;
                next->prev = this;
            }
        }
};

 
template <typename T>
class InternalRefCounted
{
    protected:
        bool unlink(T* object)
        {
            if (object)
                object->release();
            return false;
        }

        void link(const InternalRefCounted& ptr, T* object)
        {
            if (object)
                object->addRef();
        }
};
 

template <typename T>
class ExternalRefCounted
{
    public:
        int refs() const
        { return _count ? *_count : 0; }
 
    protected:
        ExternalRefCounted()
        : _count(0)
        { }

        bool unlink(T* object)
        {
            if ( _count && --*_count <= 0)
            {
                delete _count;
                // no need to set _count to 0 since the pointer is either
                // destroyed or another object is linked in
                return true;
            }
            else
                return false;
        }

        void link(const ExternalRefCounted& ptr, T* object)
        {
            if(object)
            {
                if(ptr._count == 0) {
                    _count = new unsigned(1);
                }
                else
                {
                    _count = ptr._count;
                    ++*_count;
                }
            }
            else
                _count = 0;
        }
 
    private:
        unsigned* _count;
};
 
 
template <typename T>
class ExternalAtomicRefCounted
{
    public:
        int refs() const
        { return rc ? atomicGet(*rc) : 0; }
 
    protected:
        ExternalAtomicRefCounted()
        : rc(0)
        { }
 
        bool unlink(T* object)
        {
            if (object && atomicDecrement(*rc) <= 0)
            {
                delete rc;
                // no need to set rc to 0 since the pointer is either
                // destroyed or another object is linked in
                return true;
            }
            else
                return false;
        }
 
        void link(const ExternalAtomicRefCounted& ptr, T* object)
        {
            if (object)
            {
                if (ptr.rc == 0)
                    rc = new atomic_t(1);
                else
                {
                    rc = ptr.rc;
                    atomicIncrement(*rc);
                }
            }
            else
                rc = 0;
        }
 
    private:
        volatile atomic_t* rc;
};

 
template <typename T>
class DeletePolicy
{
    protected:
        static void destroy(T* ptr)
        { delete ptr; }
};
 
 
template <typename T>
class FreeDestroyPolicy
{
    protected:
        void destroy(T* ptr)
        { free(ptr); }
};
 
 
template <typename ObjectType>
class ArrayDestroyPolicy
{
    protected:
        static void destroy(ObjectType* ptr)
        { delete[] ptr; }
};
 
 
template<typename T>
struct AutoPtrRef 
{
    T* ptr;
    
    explicit AutoPtrRef(T* rhs)
    : ptr(rhs)
    { }
};
 

template<typename T,
         typename Destroy = DeletePolicy<T> >
class AutoPtr : public Destroy
{
    public:
        typedef T element_type;
 
    public:
        explicit AutoPtr(T* ptr = 0)
        : ap(ptr)
        { }

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

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

        ~AutoPtr()
        { this->destroy(ap); }

        template<class Y>
        operator AutoPtrRef<Y>()
        {
            return AutoPtrRef<Y>( release() );
        }

        T* get() const {
            return ap;
        }

        T& operator*() const {
            return *ap;
        }

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

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

        T* release() 
        {
            T* tmp(ap);
            ap = 0;
            return tmp;
        }

        void reset(T* ptr = 0) 
        {
            if (ap != ptr) 
            {
                this->destroy(ap);
                ap = ptr;
            }
        }
                
    private:
        AutoPtr(AutoPtr &p);
  
        AutoPtr& operator= (AutoPtr& p);
 
    private:
        T* ap;
};
 
template <typename T>
AutoPtr<T> move(AutoPtr<T>& p)
{
    return AutoPtr<T>( AutoPtrRef<T>(p) );
}

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

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

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

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

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

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

template <typename T,
          typename OwnershipPolicy = ExternalRefCounted<T>,
          typename DestroyPolicy = DeletePolicy<T> >
class SmartPtr : public OwnershipPolicy,
                 public DestroyPolicy
{
    private:
        T* object;
 
    public:
        SmartPtr()
        : object(0)
        {}

        explicit SmartPtr(T* ptr)
        : object(ptr)
        { this->link(*this, ptr); }

        SmartPtr(const SmartPtr& ptr)
        : object(ptr.object)
        { this->link(ptr, ptr.object); }

        ~SmartPtr()
        { 
            if (this->unlink(object))
                this->destroy(object); 
        }

        SmartPtr& operator=(const SmartPtr& ptr)
        {
            if(object == ptr.object)
                return *this;
 
            if( this->unlink(object) )
                this->destroy(object);
 
            object = ptr.object;
 
            this->link(ptr, object);
 
            return *this;
        }
 
        void reset(T* ptr = 0)
        {
            if(object == ptr)
                return;
 
            if( this->unlink(object) )
                this->destroy(object);
 
            object = ptr;
 
            this->link(*this, object);
        }

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

        T& operator*() const
        { return *object; }

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

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

        T* get()
        { return object; }

        const T* get() const
        { return object; }
};
 

template <typename T, class O, typename D, typename T2, typename O2, typename D2>
bool operator==(const SmartPtr<T, O, D>& a, const SmartPtr<T2, O2, D2>& b)
{ return a.get() == b.get(); }

template <typename T, typename O, typename D, typename T2>
bool operator==(const SmartPtr<T, O, D>& a, const T2* b)
{ return a.get() == b; }
 

template <typename T, typename O, typename D, typename T2, typename O2, typename D2>
bool operator!=(const SmartPtr<T, O, D>& a, const SmartPtr<T2, O2, D2>& b)
{ return a.get() != b.get(); }

template <typename T, typename O, typename D, typename T2>
bool operator!=(const SmartPtr<T, O, D>& a, const T2* b)
{ return a.get() != b; }
 

template <typename T, typename O, typename D, typename T2, typename O2, typename D2>
bool operator<(const SmartPtr<T, O, D>& a, const SmartPtr<T2, O2, D2>& b)
{ return a.get() < b.get(); }

template <typename T, typename O, typename D, typename T2>
bool operator<(const SmartPtr<T, O, D>& a, const T2* b)
{ return a.get() < b; }
 

template <typename T, typename M, typename D >
void fixup(const Pt::FixupInfo& fixup, SmartPtr<T, M, D>& fixme)
{
    if( fixup.isNull() )
    {
        fixme = SmartPtr<T,M, D>();
    }
    else
    {
        const SmartPtr<T,M, D>* to = fixup.getTarget< SmartPtr<T, M, D> >();
        fixme = *to;
    }
}

template <typename T, typename M, typename D >
void load(const LoadInfo& li, SmartPtr<T, M, D>& sp)
{
    if( li.in().isReference() )
    {
        li.in().loadReference(sp);
    }
    else
    {
        li.load(sp);
    }
}

template <typename T, typename M>
void operator >>=(const Pt::SerializationInfo& si, SmartPtr<T, M>& sp)
{
    sp.reset( new T() );
    si >>= *sp;
}

template <typename T, typename M, typename D >
void save(Pt::SaveInfo& si, const SmartPtr<T, M, D>& sp)
{
    if( ! sp.get() || ! si.save( *sp ) )
    {
        si.out() <<= sp.get();
    }
}

template <typename T, typename M, typename D >
void operator <<=(Pt::SerializationInfo& si, const SmartPtr<T, M, D>& sp)
{
    if( sp.getPointer() )
    {
        si <<= *sp;
    }
    else
    {
        si <<= sp.getPointer();
    }
}
 
} // namespace Pt
 
#endif // PT_SMARTPTR_H