cPtrFacade.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cPtrFacade_H
#define _INC_cPtrFacade_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "PtrCast.h"
#include "cDebugAssert.h"
 
namespace Gray
{
        template<class TYPE>
        class cPtrFacade
        {
 
                typedef cPtrFacade<TYPE> THIS_t;
 
        protected:
                TYPE* m_p;      
 
        public:
                cPtrFacade(TYPE* p = nullptr) noexcept
                        : m_p(p)
                {
                }
                cPtrFacade(THIS_t&& ref) noexcept
                {
                        this->m_p = ref.m_p; ref.m_p = nullptr;
                }
 
                bool isValidPtr() const noexcept
                {
                        return m_p != nullptr;
                }
 
                TYPE** get_PPtr()
                {
                        ASSERT(m_p == nullptr);         // MUST not have current value.
                        return &m_p;
                }
                TYPE* get_Ptr() const noexcept
                {
                        return m_p;
                }
 
                void put_Ptr(TYPE* p) noexcept
                {
                        m_p = p;
                }
                void ReleasePtr() noexcept
                {
                        m_p = nullptr;
                }
 
                void AttachPtr(TYPE* p) noexcept
                {
                        m_p = p;
                }
                TYPE* DetachPtr() noexcept
                {
                        TYPE* p = m_p;
                        m_p = nullptr;  // NOT ReleasePtr();
                        return p;
                }
 
                THIS_t& operator = (TYPE* p) noexcept
                {
                        m_p = p;
                        return *this;
                }
                THIS_t& operator = (THIS_t&& ref) noexcept
                {
                        this->m_p = ref.m_p; ref.m_p = nullptr;
                        return *this;
                }
 
                operator TYPE* () const noexcept
                {
                        return m_p;
                }
 
                TYPE& get_Ref() const
                {
                        ASSERT(m_p != nullptr); return *m_p;
                }
 
                TYPE& operator * () const
                {
                        return get_Ref();
                }
 
                TYPE* operator -> () const
                {
                        ASSERT(m_p != nullptr); return m_p;
                }
 
                bool operator!() const noexcept
                {
                        return m_p == nullptr;
                }
                bool operator != ( /* const*/ TYPE* p2) const noexcept
                {
                        return p2 != m_p;
                }
                bool operator == ( /* const*/ TYPE* p2) const noexcept
                {
                        return p2 == m_p;
                }
        };
 
        // Similar to COM QueryInterface() this checks to see if the class is supported.
#define SMART_CAST(_DSTCLASS,p)         DYNPTR_CAST(_DSTCLASS,(p).get_Ptr())
#define SMARTS_CAST(_DSTCLASS,p)        CHECKPTR_CAST(_DSTCLASS,(p).get_Ptr())
 
}
 
#endif // _INC_cPtrFacade_H