rawmemory_intf.h

Go to the documentation of this file.

 
#pragma once
 
#include "rawmemory_base.h"
 
#include <vector>
#include <string>
 
namespace adtf
{
namespace base
{
namespace ant
{
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<tSize>(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<tSize>(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<>
struct adtf_memory_forward<const std::string>
{
public:
    static tResult Assign(const std::string* /* pAssignValue */,
                          const size_t /* szStaticSize */,
                          const void* /* pValueToSet */,
                          const size_t /* szSizeToSet */)
    {
        RETURN_ERROR(ERR_ACCESS_DENIED);
    }
    static const void* GetPtr(const std::string* pAssignValue)
    {
        return static_cast<const void*>(pAssignValue->data());
    }
    static size_t GetSize(const std::string* pAssignValue, const size_t /* szStaticSize */)
    {
        //there is no nulltermination within the std::string, we only write the size
        return pAssignValue->size();
    }
};
 
template<>
struct adtf_memory_forward<const std::u16string>
{
public:
    static tResult Assign(const std::u16string* /* pAssignValue */,
                          const size_t /* szStaticSize */,
                          const void* /* pValueToSet */,
                          const size_t /* szSizeToSet */)
    {
        RETURN_ERROR(ERR_ACCESS_DENIED);
    }
    static const void* GetPtr(const std::u16string* pAssignValue)
    {
        return static_cast<const void*>(pAssignValue->data());
    }
    static size_t GetSize(const std::u16string* pAssignValue, const size_t /* szStaticSize */)
    {
        return pAssignValue->size() * sizeof(typename std::u16string::value_type);
    }
};
 
template<>
struct adtf_memory_forward<std::string>
{
public:
    static tResult Assign(std::string* pAssignValue,
                          const size_t /* szStaticSize */,
                          const void* pValueToSet,
                          const size_t szSizeToSet)
    {
        if (szSizeToSet > 0)
        {
            const auto pValuePtr = static_cast<const typename std::string::value_type*>(pValueToSet);
            pAssignValue->reserve(szSizeToSet);
            pAssignValue->assign(pValuePtr, szSizeToSet);
        }
        RETURN_NOERROR;
    }
    static const void* GetPtr(const std::string* pAssignValue)
    {
        return static_cast<const void*>(pAssignValue->data());
    }
    static size_t GetSize(const std::string* pAssignValue, const size_t /* szStaticSize */)
    {
        //there is no nulltermination within the std::string, we only write the size
        return pAssignValue->size();
    }
};
 
template<>
struct adtf_memory_forward<std::u16string>
{
public:
    static tResult Assign(std::u16string* pAssignValue,
                          const size_t /* szStaticSize */,
                          const void* pValueToSet,
                          const size_t szSizeToSet)
    {
        if (szSizeToSet > 0)
        {
            const auto pValuePtr = static_cast<const typename std::u16string::value_type*>(pValueToSet);
            pAssignValue->reserve(szSizeToSet / sizeof(typename std::u16string::value_type));
            pAssignValue->assign(pValuePtr, szSizeToSet / sizeof(typename std::u16string::value_type));
        }
        RETURN_NOERROR;
    }
    static const void* GetPtr(const std::u16string* pAssignValue)
    {
        return static_cast<const void*>(pAssignValue->data());
    }
    static size_t GetSize(const std::u16string* pAssignValue, const size_t /* szStaticSize */)
    {
        // there is no nulltermination within the std::u16string, we only write the size in bytes
        return pAssignValue->size() * sizeof(typename std::u16string::value_type);
    }
};
 
template<typename... Args>
struct adtf_memory_forward<std::vector<Args...>>
{
public:
    static tResult Assign(std::vector<Args...>* pAssignValue,
                          const size_t /* szStaticSize */,
                          const void* pValueToSet,
                          const size_t szSizeToSet)
    {
        static_assert(std::is_trivially_copyable<typename std::vector<Args...>::value_type>::value,
                      "only trivial types are allowed for adtf_memory_forward with vector");
        pAssignValue->resize(szSizeToSet / sizeof(typename std::vector<Args...>::value_type));
        if (pAssignValue->size() * sizeof(typename std::vector<Args...>::value_type) == szSizeToSet)
        {
            adtf_util::cMemoryBlock::MemCopy(pAssignValue->data(), pValueToSet, szSizeToSet);
        }
        else
        {
            RETURN_ERROR(ERR_MEMORY);
        }
        RETURN_NOERROR;
    }
    static const void* GetPtr(const std::vector<Args...>* pAssignValue)
    {
        return pAssignValue->data();
    }
    static size_t GetSize(const std::vector<Args...>* pAssignValue, const size_t /* szStaticSize */)
    {
        return pAssignValue->size() * sizeof(typename std::vector<Args...>::value_type);
    }
};
 
template<typename... Args>
struct adtf_memory_forward<const std::vector<Args...>>
{
public:
    static tResult Assign(const std::vector<Args...>* /* pAssignValue */,
                          const size_t /* szStaticSize */,
                          const void* /* pValueToSet */,
                          const size_t /* szSizeToSet */)
    {
        RETURN_ERROR(ERR_ACCESS_DENIED);
    }
    static const void* GetPtr(const std::vector<Args...>* pAssignValue)
    {
        static_assert(std::is_trivially_copyable<typename std::vector<Args...>::value_type>::value,
                      "only trivial types are allowed for adtf_memory_forward with vector");
        return static_cast<const void*>(pAssignValue->data());
    }
    static size_t GetSize(const std::vector<Args...>* pAssignValue, const size_t /* szStaticSize */)
    {
        return pAssignValue->size() * sizeof(typename std::vector<Args...>::value_type);
    }
};
 
} // namespace ant
 
namespace spider
{
 
class cRawMemoryRedirect: public IRawMemory
{
public:
    cRawMemoryRedirect(std::function<tResult(const IRawMemory&)> fnForward):
        m_fnForward(std::move(fnForward))
    {
    }
 
    tResult Set(const void* pValue, size_t szSize) override
    {
        return m_fnForward(adtf_memory_buffer<const void>(pValue, szSize));
    }
 
    size_t GetSize() const override
    {
        return 0;
    }
 
    const void* Get() const override
    {
        return nullptr;
    }
 
private:
    std::function<tResult(const IRawMemory&)> m_fnForward;
};
 
}
 
using spider::cRawMemoryRedirect;
 
} // namespace base
} // namespace adtf
 
#define adtf_memory_intf(__utils_memblock__) adtf::base::adtf_memory<adtf_util::cMemoryBlock>(& (__utils_memblock__))