GUIRefCntPtr.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.
*/
 
#if !defined(GUIREFCNTPTR_H__)
#define GUIREFCNTPTR_H__
 
#include "RefCounted.h"
 
namespace NSmartPtr
{
template<typename T>
class CGUIRefCntPtr 
{
public:
    explicit CGUIRefCntPtr(T* p=(T*)0) throw()
        : m_h(new Holder(p))
    { m_h->AddRef(); }
 
    ~CGUIRefCntPtr()
    { m_h->Release(); }
 
    CGUIRefCntPtr(const CGUIRefCntPtr<T>& rkSource)
    {
        rkSource.m_h->AddRef();
        m_h = rkSource.m_h;
    }
 
    eC_Int GetNOFReferences() const
    { return m_h->RefCount(); }
 
    eC_Bool IsUnique() const
    { return m_h->Unique(); }
 
    template<typename T2>
    CGUIRefCntPtr<T2> StaticCast()
    {
        // This cast is a type safety check to avoid casts of this
        // pointer to unrelated types.
        if (static_cast<T2*>(m_h->m_ptr) != NULL) { }
        return CGUIRefCntPtr<T2>(
            reinterpret_cast<CGUIRefCntPtr<T2>&>(*this));
    }
 
#if defined(GUILIANI_USE_RTTI)
    template<typename T2>
    CGUIRefCntPtr<T2> DynamicCast()
    {
        T2* p = dynamic_cast<T2*>(m_h->m_ptr);
        if (p != NULL)
        {
            return CGUIRefCntPtr<T2>(
                reinterpret_cast<CGUIRefCntPtr<T2>&>(*this));
        }
        return CGUIRefCntPtr<T2>(NULL);
    }
#endif // GUILIANI_USE_RTTI
 
    CGUIRefCntPtr<T>& operator=(const CGUIRefCntPtr<T>& rkSource)
    {
        rkSource.m_h->AddRef();
        m_h->Release();
        m_h = rkSource.m_h;
        return *this;
    }
 
    T* operator->() const
    { return m_h->m_ptr; }
 
    T& operator*() const
    { return *m_h->m_ptr; }
 
    T* Get() const
    { return m_h->m_ptr; }
 
    eC_Bool operator==(const CGUIRefCntPtr<T>& rkRight) const
    { return m_h->m_ptr == rkRight.m_h->m_ptr; }
 
    template<typename T2>
    eC_Bool operator==(const CGUIRefCntPtr<T2>& rkRight) const
    { return m_h->m_ptr == static_cast<T*>(rkRight.m_h->m_ptr); }
 
    eC_Bool operator==(const T* pRight) const
    { return m_h->m_ptr == pRight; }
 
    eC_Bool operator!=(const CGUIRefCntPtr<T>& rkRight) const
    { return !(operator==(rkRight)); }
 
    eC_Bool operator<(const CGUIRefCntPtr<T>& rkRight) const
    { return *m_h->m_ptr < *rkRight.m_h->m_ptr; }
 
    template<typename T2>
    eC_Bool operator!=(const CGUIRefCntPtr<T2>& rkRight) const
    { return !(operator==(static_cast<T*>(rkRight.m_h->m_ptr))); }
 
    eC_Bool operator!=(const T* pRight) const
    { return !(operator==(pRight)); }
 
private:
    class Holder : public RefCounted
    {
    public:
        Holder(T* ptr)
            : RefCounted(), m_ptr(ptr)
        { }
 
        ~Holder()
        { if (m_ptr) delete m_ptr; m_ptr = NULL; };
 
        T* m_ptr;
    };
 
    Holder* m_h;
};
} // namespace NSmartPtr
 
#endif // GUIREFCNTPTR_H__