rawmemory_base.h

Go to the documentation of this file.

 
#pragma once
#include <adtf_utils.h>
#include "adtf_base_type_traits.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)
    {
        static_assert(penguin::detail::always_false<T>,
                      "Unsupported type T! See documentation which types are supported."
                      "adtf_memory<T> only supports trivial types unless you specialize the adtf_memory_forward<T> for the type T!");
        return ERR_NOT_IMPL;
    }
    inline static const void* GetPtr(const T* pAssignValue)
    {
        static_assert(penguin::detail::always_false<T>,
                      "Unsupported type T! See documentation which types are supported."
                      "adtf_memory<T> only supports trivial types unless you specialize the adtf_memory_forward<T> for the type T!");
        return nullptr;
    }
    inline static size_t GetSize(const T* pAssignValue, const size_t szStaticSize)
    {
        static_assert(penguin::detail::always_false<T>,
                      "Unsupported type T! See documentation which types are supported."
                      "adtf_memory<T> only supports trivial types unless you specialize the adtf_memory_forward<T> for the type T!");
        return size_t(0);
    }
};
 
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 :
    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
 
namespace penguin
{
template<typename T, typename Enable = void>
class adtf_memory_trivial_type : public adtf::base::ant::IRawMemory
{
public:
    explicit adtf_memory_trivial_type(T* pValuePointer):
        m_pAssignedValue(pValuePointer)
    {
    }
    tResult Set(const void* pValue, size_t szSize) override
    {
        RETURN_IF_POINTER_NULL(pValue);
        RETURN_IF_POINTER_NULL(m_pAssignedValue);
        if (szSize == sizeof(T))
        {
            adtf_util::cMemoryBlock::MemCopy(m_pAssignedValue, pValue, szSize);
            RETURN_NOERROR;
        }
        else
        {
            RETURN_ERROR(ERR_MEMORY);
        }
    }
    size_t GetSize() const override
    {
        if(m_pAssignedValue)
        {
            return sizeof(T);
        }
        return size_t(0);
    }
    const void* Get() const override
    {
        return m_pAssignedValue;
    }
 
private:
    T* m_pAssignedValue = nullptr;
};
 
template<typename T>
class adtf_memory_trivial_type<T, typename std::enable_if<std::is_const<T>::value>::type> 
    : public adtf::base::ant::IRawMemory
{
public:
    explicit adtf_memory_trivial_type(T* pValuePointer): 
        m_pAssignedValue(pValuePointer)
    {
    }
    tResult Set(const void* /*pValue*/, size_t /*szSize*/) override
    {
        RETURN_ERROR(ERR_POINTER);
    }
    size_t GetSize() const override
    {
        if (m_pAssignedValue)
        {
            return sizeof(T);
        }
        return size_t(0);
    }
    const void* Get() const override
    {
        return m_pAssignedValue;
    }
private:
    T* m_pAssignedValue = nullptr;
};
 
 
template<typename T, size_t TSIZE = 0, typename Enable=void>
class adtf_memory : public adtf::base::ant::IRawMemory, protected adtf::base::ant::adtf_memory_forward<T>
{
    typedef adtf_memory<T, TSIZE, void> _myType;
    typedef T _myStorageType;
    typedef adtf::base::ant::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) override
    {
        constexpr auto szSizeToUse = std::conditional<std::is_void<T>::value,
                                                      adtf::base::penguin::detail::get_const_size<TSIZE>,
                                                      adtf::base::penguin::detail::get_size_of<T>>::type::value;
        if (pValue != nullptr)
        {
            return _myBase::Assign(m_pAssignValue, szSizeToUse, pValue, szSize);
        }
        else
        {
            RETURN_NOERROR;
        }
    }
    const void* Get() const override
    {
        if (m_pAssignValue != nullptr)
        {
            return _myBase::GetPtr(m_pAssignValue);
        }
        return nullptr;
    }
    size_t GetSize() const override
    {
        constexpr auto szSizeToUse = std::conditional<std::is_void<T>::value,
                                                      adtf::base::penguin::detail::get_const_size<TSIZE>,
                                                      adtf::base::penguin::detail::get_size_of<T>>::type::value;
        if (m_pAssignValue != nullptr)
        {
            return _myBase::GetSize(m_pAssignValue, szSizeToUse);
        }
        return size_t(0);
    }
};
 
template<typename T>
class adtf_memory<T, 0, typename std::enable_if<std::is_trivially_copyable<T>::value>::type>
    : public adtf_memory_trivial_type<T>
{
public:
    typedef adtf_memory<T, 0, typename std::enable_if<std::is_trivially_copyable<T>::value>::type> _myType;
    typedef T _myStorageType;
    typedef adtf_memory_trivial_type<T> _myBase;
 
public:
    explicit adtf_memory(T* pAssignValue):
        _myBase(pAssignValue)
    {
    }
};
 
}
 
using penguin::adtf_memory_trivial_type;
using ant::adtf_memory_forward;
using penguin::adtf_memory;
using ant::IRawMemory;
using ant::adtf_memory_buffer;
 
} //namespace base
 
} // namespace adtf