rawmemory_intf.h

Go to the documentation of this file.

 
#pragma once
#include <adtf_utils.h>
 
namespace adtf
{
namespace base
{
namespace ant
{
    class IRawMemory
    {
    public:
        virtual tResult      Set(const void* pValue, size_t szSize) = 0;
        virtual size_t        GetSize() const = 0;
        virtual const void* Get() const = 0;
    };
 
    template <typename T>
    struct adtf_memory_forward
    {
        inline static tResult Assign(T* pAssignValue,
                                     const size_t szStaticSize,
                                     const void* pValueToSet,
                                     const size_t  szSizeToSet);
        inline static const void* GetPtr(const T* pAssignValue);
        inline static size_t GetSize(const T* pAssignValue, const size_t szStaticSize);
    };
    template <>
    struct adtf_memory_forward<adtf_util::cMemoryBlock>
    {
    public:
        static tResult Assign(adtf_util::cMemoryBlock* pAssignValue,
                                const size_t /* szStaticSize */,
                                const void* pValueToSet,
                                const size_t  szSizeToSet)
        {
            return pAssignValue->Set(pValueToSet, szSizeToSet);
        }
        static const void* GetPtr(const adtf_util::cMemoryBlock* pAssignValue)
        {
            return pAssignValue->GetPtr();
        }
        static size_t GetSize(const adtf_util::cMemoryBlock* pAssignValue, const size_t /* szStaticSize */)
        {
            return static_cast<size_t>(pAssignValue->GetSize());
        }
    };
    template <>
    struct adtf_memory_forward<adtf_util::cMemoryPtr>
    {
    public:
        static tResult Assign(adtf_util::cMemoryPtr* pAssignValue,
            const size_t /* szStaticSize */,
            const void* pValueToSet,
            const size_t  szSizeToSet)
        {
            return pAssignValue->Assign(pValueToSet, szSizeToSet);
        }
        static const void* GetPtr(const adtf_util::cMemoryPtr* pAssignValue)
        {
            return pAssignValue->GetPtr();
        }
        static size_t GetSize(const adtf_util::cMemoryPtr* pAssignValue, const size_t /* szStaticSize */)
        {
            return static_cast<size_t>(pAssignValue->GetSize());
        }
    };
 
    template <>
    struct adtf_memory_forward<const void>
    {
    public:
        static tResult Assign(const void* /* pAssignValue */,
                                const size_t /* szStaticSize */,
                                const void* /* pValueToSet */,
                                const size_t  /* szSizeToSet */)
        {
            RETURN_ERROR(ERR_ACCESS_DENIED);
        }
        static const void* GetPtr(const void* pAssignValue)
        {
            return pAssignValue;
        }
        static size_t GetSize(const void* /* pAssignValue */, const size_t szStaticSize)
        {
            return szStaticSize;
        }
    };
 
    template <>
    struct adtf_memory_forward<void>
    {
    private:
        size_t m_szCurrentSize = g_npos;
    public:
        tResult Assign(void* pAssignValue,
                                const size_t szStaticSize,
                                const void* pValueToSet,
                                const size_t  szSizeToSet)
        {
            if (szSizeToSet <= szStaticSize)
            {
                adtf_util::cMemoryBlock::MemCopy(pAssignValue, pValueToSet, szSizeToSet);
                m_szCurrentSize = szSizeToSet;
                RETURN_NOERROR;
            }
            else
            {
                RETURN_ERROR(ERR_MEMORY);
            }
        }
        static const void* GetPtr(const void* pAssignValue)
        {
            return pAssignValue;
        }
        size_t GetSize(const void* /* pAssignValue */, const size_t szStaticSize) const
        {
            if (m_szCurrentSize != g_npos)
            {
                return m_szCurrentSize;
            }
            return szStaticSize;
        }
    };
 
    template <typename T, size_t TSIZE = 0>
    class adtf_memory : public IRawMemory,
                        protected adtf_memory_forward<T>
    {
        typedef adtf_memory<T, TSIZE>           _myType;
        typedef T                               _myStorageType;
        typedef adtf_memory_forward<T>          _myBase;
 
    private:
        T* m_pAssignValue;
        adtf_memory() {};
        adtf_memory(const adtf_memory&) = delete;
        adtf_memory& operator=(const adtf_memory&) = delete;
        adtf_memory(adtf_memory&&) = delete;
        adtf_memory& operator=(adtf_memory&&) = delete;
 
    public:
        explicit adtf_memory(T* pAssignValue)
        {
            m_pAssignValue = pAssignValue;
        }
        virtual ~adtf_memory()
        {
            m_pAssignValue = nullptr;
        }
 
        tResult Set(const void* pValue, size_t szSize)
        {
            if (pValue != nullptr)
            {
                return _myBase::Assign(m_pAssignValue, TSIZE,  pValue, szSize);
            }
            else
            {
                RETURN_ERROR(ERR_POINTER);
            }
        }
        const void* Get() const
        {
            if (m_pAssignValue != nullptr)
            {
                return _myBase::GetPtr(m_pAssignValue);
            }
            return nullptr;
        }
        size_t GetSize() const
        {
            if (m_pAssignValue != nullptr)
            {
                return _myBase::GetSize(m_pAssignValue, TSIZE);
            }
            return size_t(0);
        }
    };
 
    template <typename T, typename Enable = void>
    class adtf_memory_buffer;
 
    template<typename T>
    class adtf_memory_buffer<T, typename std::enable_if<!std::is_const<T>::value>::type> :
            public IRawMemory
    {
        private:
            T* m_pPtr;
            size_t m_szSize;
 
        public:
            adtf_memory_buffer(T* pPtr, size_t szSize):
                m_pPtr(pPtr),
                m_szSize(szSize)
            {
            }
 
            tResult Set(const void* pValue, size_t szSize) override
            {
                if (szSize > GetSize())
                {
                    RETURN_ERROR(ERR_OUT_OF_RANGE);
                }
 
                adtf_util::cMemoryBlock::MemCopy(m_pPtr, pValue, szSize);
 
                RETURN_NOERROR;
            }
 
            size_t GetSize() const override
            {
                return m_szSize;
            }
 
            const void* Get() const override
            {
                return m_pPtr;
            }
    };
 
    template <typename T>
    class adtf_memory_buffer<T, typename std::enable_if<std::is_const<T>::value>::type>:
            public IRawMemory
    {
        private:
            const T* m_pPtr;
            size_t m_szSize;
 
        public:
            adtf_memory_buffer(const T* pPtr, size_t szSize):
                m_pPtr(pPtr),
                m_szSize(szSize)
            {
            }
 
            tResult Set(const void* /* pValue */, size_t /* szSize */) override
            {
                RETURN_ERROR(ERR_NOACCESS);
            }
 
            size_t GetSize() const override
            {
                return m_szSize;
            }
 
            const void* Get() const override
            {
                return m_pPtr;
            }
    };
} //namespace ant
 
using ant::adtf_memory_forward;
using ant::adtf_memory;
using ant::IRawMemory;
using ant::adtf_memory_buffer;
 
} //namespace base
} // namespace adtf
 
#define adtf_memory_intf(__utils_memblock__) adtf::base::adtf_memory<adtf_util::cMemoryBlock>(& (__utils_memblock__))