Object.h

//------------------------------------------------------------------------------
//
// Copyright (c) 2013 Glympse Inc.  All rights reserved.
//
//------------------------------------------------------------------------------

#ifndef OBJECT_H__GLYMPSE__
#define OBJECT_H__GLYMPSE__

namespace Glympse
{

// Provides explicit scope for Common class used in friend declaration below. Needed for
// blackberry compiler.
template< class T > class Common;

template< class T > class O
{
    private: T* _object;

    template< class U > friend class O;
    template< class V > friend class Common;
    
    public: O() 
        : _object(NULL)
    {
    }
    public: O(T* address)
        : _object(address)
    {
    }
    public: O(const O<T>& rO)
        : _object(rO._object)
    {
        retain();
    }
    public: template< class T2 > O(const O<T2>& rO)
        : _object(dynamic_cast<T*>(rO._object))
    {
        retain();
    }
    
    public: O<T>& operator=(T* address)
    {
        release();
        _object = address;
        return *this;
    }    
    public: O<T>& operator=(const O<T>& rO)
    {
        if ( this != &rO )
        {
            release();
            _object = rO._object;
            retain();
        }
        return *this;
    }
    public: template< class T2 > O<T>& operator=(const O<T2>& rO)
    {
        release();
        _object = dynamic_cast<T*>(rO._object);
        retain();
        return *this;
    }
    
    public: virtual ~O()
    {
        release();
    }

    public: template<class T2> bool operator==(const O<T2> &rO)
    {
        return _object == rO._object;
    }
    public: template<class T2> bool operator==(const O<T2> &rO) const
    {
        return _object == rO._object;
    }    
    public: template<class T2> bool operator!=(const O<T2> &rO)
    {
        return _object != rO._object;
    }
    public: template<class T2> bool operator!=(const O<T2> &rO) const
    {
        return _object != rO._object;
    }    
    public: template<class T2> bool operator<(const O<T2> &rO)
    {
        return _object < rO._object;
    }    
    public: template<class T2> bool operator<(const O<T2> &rO) const
    {
        return _object < rO._object;
    }
    
    public: bool operator==(T* address)
    {
        return (_object == address);
    }
    public: bool operator==(T* address) const
    {
        return (_object == address);
    }
    public: bool operator!=(T* address)
    {
        return (_object != address);
    }
    public: bool operator!=(T* address) const
    {
        return (_object != address);
    }
    
    T* operator->()
    {
        return _object;
    }
    T* operator->() const
    {
        return _object;
    }
        
    private: inline void retain()
    {
        if ( _object )
        {
            _object->retain();
        }
    }

    private: inline void release()
    {
        if ( _object )
        {
            _object->release();
            _object = NULL;
        }
    }
};

template< class T > inline bool operator==(void* lhs, const O<T>& rhs)
{
    return ( lhs == rhs.operator->() );
}

template< class T > inline bool operator!=(void* lhs, const O<T>& rhs)
{
    return ( lhs != rhs.operator->() );
}

class Object
{
    public: template<typename T> static inline O<T> fromThis(T* t)
    {
        const O<T>& o(t);
        o->retain();
        return o;
    }
};
        
}

#endif // !OBJECT_H__GLYMPSE__