SharedPtr.h

/*
* Copyright (C) TES Electronic Solutions GmbH,
* All Rights Reserved.
* Contact: info@guiliani.de
*
* This file is part of the Guiliani HMI framework
* for the development of graphical user interfaces on embedded systems.
*/
 
#ifndef SHARED_PTR_H
#define SHARED_PTR_H
 
namespace NSmartPtr
{
    template<class C>
    class SharedPtr 
    {
    public:
        inline SharedPtr();
 
        inline SharedPtr(C* rawPtr);
 
        inline SharedPtr(const SharedPtr& rhs) :
            m_RawPtr(rhs.m_RawPtr)
        {
            if (m_RawPtr)
            {
                m_RawPtr->AddRef();
            }
        }
 
        template< class C2 >
        inline SharedPtr(const SharedPtr<C2>& otherSharedPtr) :
            m_RawPtr(otherSharedPtr.RawPtr())
        {
            if (m_RawPtr)
            {
                m_RawPtr->AddRef();
            }
        }
 
        inline ~SharedPtr();
 
        inline C* operator->() const;
 
        inline C& operator*() const;
 
        SharedPtr& operator =(const SharedPtr& rhs)
        {
            Assign(rhs.RawPtr());
 
            return *this;
        }
 
        template<class C2>
        inline SharedPtr<C>& operator=(const SharedPtr<C2>& otherSharedPtr)
        {
            Assign(otherSharedPtr.RawPtr());
 
            return *this;
        }
 
        template<class C2>
        inline SharedPtr& operator=(C2* rawPtr)
        {
            Assign(rawPtr);
 
            return *this;
        }
 
        inline bool operator!() const;
 
        inline operator bool() const;
 
        inline C* RawPtr() const;
 
    private:
        C * m_RawPtr;
 
        inline void Assign(C* rawPtr);
    };
 
    template<class C1, class C2>
    inline bool operator!=(
        const NSmartPtr::SharedPtr<C1>& a,
        const NSmartPtr::SharedPtr<C2>& b)
    {
        return (a.RawPtr() != b.RawPtr());
    }
 
    template<class C1, class C2>
    inline bool operator==(
        const NSmartPtr::SharedPtr<C1>& a,
        const NSmartPtr::SharedPtr<C2>& b)
    {
        return (a.RawPtr() == b.RawPtr());
    }
 
    template< class DEST_TYPE, class SOURCE_TYPE >
    NSmartPtr::SharedPtr< DEST_TYPE >
        StaticCast(const NSmartPtr::SharedPtr< SOURCE_TYPE >& source)
    {
        return static_cast< DEST_TYPE* >(source.RawPtr());
    }
 
    // inline methods
 
    template<class C>
    inline SharedPtr<C>::SharedPtr() :
        m_RawPtr(0)
    {
    }
 
    template<class C>
    inline SharedPtr<C>::SharedPtr(C* rawPtr) :
        m_RawPtr(rawPtr)
    {
        if (rawPtr)
        {
            m_RawPtr->AddRef();
        }
    }
 
    template<class C>
    inline SharedPtr<C>::~SharedPtr()
    {
        if (m_RawPtr)
        {
            m_RawPtr->Release();
        }
    }
 
    template<class C>
    inline C* SharedPtr<C>::operator->() const
    {
        return m_RawPtr;
    }
 
    template<class C>
    inline C& SharedPtr<C>::operator*() const
    {
        return *m_RawPtr;
    }
 
    template<class C>
    bool SharedPtr<C>::operator! () const
    {
        return (m_RawPtr == NULL);
    }
 
    template<class C>
    SharedPtr<C>::operator bool() const
    {
        return (m_RawPtr != NULL);
    }
 
    template<class C>
    C* SharedPtr<C>::RawPtr() const
    {
        return m_RawPtr;
    }
 
    template<class C>
    inline void SharedPtr<C>::Assign(C* rawPtr)
    {
        // call AddRef before Release, because rawPtr may be equal m_RawPtr
        if (rawPtr)
        {
            rawPtr->AddRef();
        }
        if (m_RawPtr)
        {
            m_RawPtr->Release();
        }
        m_RawPtr = rawPtr;
    }
 
} // namespace NSmartPtr
 
#endif // SMART_PTR_H