refPtr.h

/* Copyright (c) 2005-2015, Stefan Eilemann <eile@equalizergraphics.com>
 *                          Daniel Nachbaur <danielnachbaur@gmail.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.1 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 ) {}

    // cppcheck-suppress noExplicitConstructor
    RefPtr( T* const ptr ) : _ptr( ptr ) { _ref(); }

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

    // cppcheck-suppress noExplicitConstructor
    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               { return ( _ptr==0 ); }

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

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

    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)
        {
#ifdef NDEBUG
            _ptr->unref( this );
#else
            if( _ptr->unref( this ))
                _ptr = 0;
#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( )); }
}

#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 = 0;
    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_REFPTR_H