refPtr.h

/* Copyright (c) 2005-2012, Stefan Eilemann <eile@equalizergraphics.com> 
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1q as published
 * by the Free Software Foundation.
 *  
 * 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 LUNCHBOX_REFPTR_H
#define LUNCHBOX_REFPTR_H

#include <lunchbox/debug.h>

#include <iostream>
#include <stdlib.h>

namespace lunchbox
{
    template< class T > class RefPtr 
    {
        typedef T* RefPtr::*bool_t;

    public:
        RefPtr()                     : _ptr( 0 )         {}

        RefPtr( T* const ptr )       : _ptr( ptr )       { _ref(); }

        RefPtr( const RefPtr& from ) : _ptr( from._ptr ) { _ref(); }

        template< class O > RefPtr( RefPtr< O > from )
                : _ptr( from.get( )) { _ref(); }

        ~RefPtr() { _unref(); _ptr = 0; }

        RefPtr& operator = ( const RefPtr& rhs )
            {
                if( _ptr == rhs._ptr )
                    return *this;

                T* tmp = _ptr;
                _ptr = rhs._ptr;
                _ref();
                if( tmp ) tmp->unref( this );
                return *this;
            }

        RefPtr& operator = ( T* ptr )
            {
                if( _ptr == ptr )
                    return *this;

                T* tmp = _ptr;
                _ptr = ptr;
                _ref();
                if( tmp ) tmp->unref( this );
                return *this;
            }

        bool operator == ( const RefPtr& rhs ) const 
            { return ( _ptr == rhs._ptr ); }

        bool operator != ( const RefPtr& rhs ) const
            { return ( _ptr != rhs._ptr ); }

        operator bool_t() const { return _ptr == 0 ? 0 : &RefPtr::_ptr; }

        bool operator < ( const RefPtr& rhs ) const
            { return ( _ptr < rhs._ptr ); }

        bool operator > ( const RefPtr& rhs ) const
            { return ( _ptr > rhs._ptr ); }

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

        bool operator == ( const T* ptr ) const { return ( _ptr == ptr ); }

        bool operator != ( const T* ptr ) const { return ( _ptr != ptr ); }

        T*       operator->()       
            { LBASSERTINFO( _ptr, className( this )); return _ptr; }
        const T* operator->() const
            { LBASSERTINFO( _ptr, className( this )); return _ptr; }
        T&       operator*()        
            { LBASSERTINFO( _ptr, className( this )); return *_ptr; }
        const T& operator*() const  
            { LBASSERTINFO( _ptr, className( this )); return *_ptr; }

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

        bool isValid() const { return ( _ptr != 0 ); }
        
    private:
        T* _ptr;

        void _ref()   { if(_ptr) _ptr->ref( this ); }

        void _unref() 
        {
            if(_ptr)
            {
#ifndef NDEBUG
                const bool abondon = (_ptr->getRefCount() == 1);
                _ptr->unref( this );
                if( abondon ) 
                    _ptr = 0;
#else
                _ptr->unref( this );
#endif
            }
        }
    };

    template< class T >
    inline std::ostream& operator << ( std::ostream& os, RefPtr< T > rp )
    {
        const T* p = rp.get();
        if( !p )
            return os << "RP[ 0:NULL ]";

        os << disableFlush << "RP[" << p->getRefCount() << ":" << *p << "]";
        p->printHolders( os );
        return os << enableFlush;
    }

    template< class T > inline std::string className( const RefPtr<T>& rp )
        { return className( rp.get( )); }
}

#ifdef LUNCHBOX_USE_BOOST
#  include <boost/serialization/split_free.hpp>

namespace boost
{
namespace serialization
{

template< class Archive, class T >
inline void save( Archive& ar, const lunchbox::RefPtr< T >& t,
                  const unsigned int /*version*/ )
{
    const T* ptr = t.get();
    ar << ptr;
}

template< class Archive, class T >
inline void load( Archive& ar, lunchbox::RefPtr< T >& t,
                  const unsigned int /*version*/ )
{
    T* obj;
    ar >> obj;
    t = obj;
}

template< class Archive, class T >
inline void serialize( Archive& ar, lunchbox::RefPtr< T >& t,
                       const unsigned int version )
{
    boost::serialization::split_free( ar, t, version );
}

}
}

#endif // LUNCHBOX_USE_BOOST
#endif //LUNCHBOX_REFPTR_H