memoryptr.h

Go to the documentation of this file.

 
#ifndef _MEMORY_PTR_HEADER_
#define _MEMORY_PTR_HEADER_
 
namespace A_UTILS_NS
{
// Use this mask to check the size parameter. If one of the upper bits is set
// the size parameter is negative or much too big
const tSize MEMPTR_WRONG_SIZE_PARAM_MASK = (tSize)1 << (sizeof(tSize)*8-1);
 
class DOEXPORT cMemoryPtr
{
    A_UTILS_D(cMemoryPtr)
 
    /**************************************/
    /* This still needs to be implemented.*/
    /**************************************/
    class cMemoryPtrPrivate : public d_ptr_impl<cMemoryPtr, cMemoryPtrPrivate>
    {
        friend class cMemoryPtr;
        public:
            cMemoryPtrPrivate(){};
            virtual ~cMemoryPtrPrivate(){};
    };
 
    protected:
        tUInt  m_nReferenceCounter; 
        tVoid* m_pvData;            
        tSize  m_nDataSize;         
        tBool  m_bReference;        
 
    public:
        cMemoryPtr()
        {
            //not yet in use
            //A_UTILS_D_CREATE(cMemoryPtr);
 
            m_nReferenceCounter = 1;
            m_pvData            = nullptr;
            m_nDataSize         = 0;
            m_bReference        = tFalse;
        }
 
        cMemoryPtr(tVoid* pvData, tSize nSize)
        {
            //not yet in use
            //A_UTILS_D_CREATE(cMemoryPtr);
            m_nReferenceCounter = 1;
            m_pvData            = nullptr;
            m_nDataSize         = 0;
            m_bReference        = tFalse;
 
            Assign(pvData, nSize);
        }
 
        cMemoryPtr(const cMemoryPtr& oMemObject)
        {
            //not yet in use
            //A_UTILS_D_CREATE(cMemoryPtr);
            m_nReferenceCounter = 1;
            m_pvData            = nullptr;
            m_nDataSize         = 0;
            m_bReference        = tFalse;
 
            Assign(oMemObject.m_pvData, oMemObject.m_nDataSize);
        }
 
        tBool IsReference()
        {
            return m_bReference;
        }
 
        tResult Attach(tVoid* pvData, tSize nSize)
        {
            Free();
            if ((nullptr == pvData)
                || (0 == nSize)
                || ((nSize & MEMPTR_WRONG_SIZE_PARAM_MASK) != 0) )
            {
                RETURN_ERROR(ERR_INVALID_ARG);
            }
            m_bReference = tTrue;
            m_pvData     = pvData;
            m_nDataSize  = nSize;
 
            RETURN_NOERROR;
        }
 
        tResult Attach(const cMemoryPtr& oMemObject)
        {
            return Attach(oMemObject.m_pvData, oMemObject.m_nDataSize);
        }
 
        tResult Detach()
        {
            // reference flag is handled by the free method itself
 
            Free();
 
            RETURN_NOERROR;
        }
 
        virtual ~cMemoryPtr()
        {
            Free();
        }
 
        tVoid Free()
        {
            if (!m_bReference && m_pvData != nullptr)
            {
                delete[] (tUInt*) m_pvData;
            }
            m_pvData = nullptr;
            m_nDataSize = 0;
            m_bReference = tFalse;
        }
 
        tResult Alloc(tSize nDataSize)
        {
            if ((nDataSize > 0) && (nDataSize <= m_nDataSize))
            {
                RETURN_NOERROR; // reuse buffer
            }
 
            Free();
 
            if ((nDataSize == 0) || (nDataSize & MEMPTR_WRONG_SIZE_PARAM_MASK) != 0)
            {
                RETURN_ERROR(ERR_INVALID_ARG);
            }
 
            m_pvData = new (std::nothrow) tUInt8[nDataSize];
            if (m_pvData == nullptr)
            {
                RETURN_ERROR(ERR_MEMORY);
            }
 
            m_nDataSize = nDataSize;
 
            RETURN_NOERROR;
        }
 
        tResult Assign(const tVoid* pvData, tSize nDataSize)
        {
            RETURN_IF_POINTER_NULL(pvData);
            RETURN_IF_FAILED(Alloc(nDataSize));
 
            cMemoryBlock::MemCopy(m_pvData, pvData, nDataSize);
 
            RETURN_NOERROR;
        }
 
        tResult Assign(const cMemoryPtr& oMemObject)
        {
            return Assign(oMemObject.m_pvData, oMemObject.m_nDataSize);
        }
 
        tResult CopyTo(tVoid* pvBuffer, tSize nBufferSize)
        {
            RETURN_IF_POINTER_NULL(pvBuffer);
 
            if ((nBufferSize == 0) ||
                (nBufferSize > m_nDataSize) ||
                ((nBufferSize & MEMPTR_WRONG_SIZE_PARAM_MASK) != 0))
            {
                RETURN_ERROR(ERR_INVALID_ARG);
            }
            if (m_pvData == nullptr)
            {
                RETURN_ERROR(ERR_NOT_INITIALIZED);
            }
 
            cMemoryBlock::MemCopy(pvBuffer, m_pvData, nBufferSize);
 
            RETURN_NOERROR;
        }
 
        const tVoid* GetPtr() const
        {
            return m_pvData;
        }
 
        tVoid* GetWritePtr() const
        {
            return m_pvData;
        }
 
        tSize GetSize() const
        {
            return m_nDataSize;
        }
 
    public: // reference management
        tUInt Ref()
        {
            return ++m_nReferenceCounter;
        }
 
        tUInt Unref()
        {
            if (m_nReferenceCounter > 0)
            {
                m_nReferenceCounter--;
            }
 
            tUInt nResult = m_nReferenceCounter;
 
            if (m_nReferenceCounter == 0)
            {
                Destroy();
            }
 
            return nResult;
        }
 
        tVoid Destroy()
        {
            Free();
 
            delete this;
        }
 
    public: // operators
        operator const tVoid*() const
        {
            return m_pvData;
        }
 
        tVoid* operator =(const cMemoryPtr& oMemObject)
        {
            Assign(oMemObject.m_pvData, oMemObject.m_nDataSize);
 
            return m_pvData;
        }
 
        tBool operator ==(tVoid* pvData) const
        {
            return (m_pvData == pvData);
        }
};
} // namespace A_UTILS_NS
 
#endif // _MEMORY_PTR_HEADER_