dynamic_memoryblock.h

Go to the documentation of this file.

#pragma once
 
#include <adtf_base.h>
 
namespace adtf
{
 
namespace disptb
{
 
namespace graphicslib
{
 
namespace dengar
{

class IDynamicMemoryBlock
{
public:
    virtual tResult Append(const tVoid* pvData, tInt nDataSize) = 0;

    virtual tVoid* GetPtr() = 0;

    virtual tSize GetSize() = 0;

    virtual tResult Reset() = 0;

    virtual tResult SetIncrement(tInt nNewIncrement) = 0;

    virtual tVoid Destroy() = 0;
 
protected:
    ~IDynamicMemoryBlock()
    {
    }
};
 
#define DEFAULT_MEMORY_BLOCK_INCREMENT 256

class cDynamicMemoryBlock : public IDynamicMemoryBlock
{
public:
    cDynamicMemoryBlock()
    {
        m_pData = NULL;
        m_ui32BlockSize = 0;
        m_ui32UsedSize = 0;
        m_ui32BlockIncrement = DEFAULT_MEMORY_BLOCK_INCREMENT;
    }

    virtual ~cDynamicMemoryBlock()
    {
        if (nullptr != m_pData)
        {
            m_pData->Free();
            delete m_pData;
            m_pData = nullptr;
        }
    }
 
public: // implements IDynamicMemoryBlock
    tResult Append(const tVoid* pvData, tInt nDataSize)
    {
        RETURN_IF_POINTER_NULL(pvData);
 
        if (nDataSize > 0)
        {
            RETURN_IF_FAILED(AdjustMemoryBlock(nDataSize));
 
            // Append the data.
            m_pData->MemCopy((tVoid*) ((tUInt8*) m_pData->GetPtr() + m_ui32UsedSize), pvData, nDataSize);
            m_ui32UsedSize += nDataSize;
        }
        else if (nDataSize < 0)
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
 
        RETURN_NOERROR;
    }
 
    tVoid* GetPtr()
    {
        if (NULL == m_pData)
        {
            return NULL;
        }
 
        return m_pData->GetPtr();
    }
 
    tSize GetSize()
    {
        return m_ui32UsedSize;
    }
 
    tResult Reset()
    {
        m_ui32UsedSize = 0;
 
        RETURN_NOERROR;
    }
 
    tResult SetIncrement(tInt nNewIncrement)
    {
        if (nNewIncrement < 0)
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
 
        m_ui32BlockIncrement = (nNewIncrement > 0 ? nNewIncrement : DEFAULT_MEMORY_BLOCK_INCREMENT);
 
        RETURN_NOERROR;
    }
 
    tVoid Destroy()
    {
        delete this;
    }
 
protected:
    util::cMemoryBlock* m_pData;
    tUInt32 m_ui32BlockSize;
    tUInt32 m_ui32BlockIncrement;
    tUInt32 m_ui32UsedSize;
 
private:
    tResult AdjustMemoryBlock(tInt nBytesToAppend)
    {
        tUInt32 ui32FreeBytes = m_ui32BlockSize - m_ui32UsedSize;
 
        if (ui32FreeBytes < static_cast<tUInt32>(nBytesToAppend))
        {
            // Increase the internal memoryblock.
 
            // Calculate the new size.
            tUInt32 ui32OverlappingBytes = nBytesToAppend - ui32FreeBytes;
            tUInt32 ui32IncrementsToApply = ui32OverlappingBytes / m_ui32BlockIncrement;
            if (0 != (ui32OverlappingBytes % m_ui32BlockIncrement))
            {
                ui32IncrementsToApply++;
            }
 
            tUInt32 ui32NewSize = m_ui32BlockSize + ui32IncrementsToApply * m_ui32BlockIncrement;
 
            // Allocate a new block.
            tResult nResult = ERR_NOERROR;
            auto pNewMemBlock = new adtf_util::cMemoryBlock();
            RETURN_IF_POINTER_NULL(pNewMemBlock);
 
            nResult = pNewMemBlock->Alloc(ui32NewSize);
            if (IS_FAILED(nResult))
            {
                LOG_ERROR("Unable to allocate memory block!");
                delete pNewMemBlock;
                RETURN_ERROR(nResult);
            }
 
            // "Nullify" the new memory block.
            nResult = pNewMemBlock->Zero();
            if (IS_FAILED(nResult))
            {
                LOG_ERROR("Unable to set the new memory block to zero!");
                delete pNewMemBlock;
                RETURN_ERROR(nResult);
            }
 
            // Fill the new block with the old data.
            if (nullptr != m_pData)
            {
                pNewMemBlock->MemCopy(pNewMemBlock->GetPtr(), m_pData->GetPtr(), m_ui32UsedSize);
 
                // Clean up the old memory block.
                m_pData->Free();
                delete m_pData;
            }
 
            // Reassign the new block.
            m_pData = pNewMemBlock;
            m_ui32BlockSize = ui32NewSize;
        }
        else
        {
            // Internal memoryblock is big enough, so don't act.
        }
 
        RETURN_NOERROR;
    }
};
 
} // namespace dengar
using dengar::IDynamicMemoryBlock;
using dengar::cDynamicMemoryBlock;
 
} // namespace graphicslib
 
} // namespace disptb
 
} // namespace adtf