builds/digitalwerk/solutions/adtf_content/adtf_base/adtf_core/extern/pkg_ddl/include/adtfddl/codec/access_element.h

Go to the documentation of this file.

 
#pragma once
#include "struct_element.h"
#include <a_utils.h>
 
#include <adtfddl/pkg_ddl_deprecated.h>
 
namespace adtf_ddl
{
 
namespace access_element
{
 
namespace detail
{
 
template<typename T>
class is_factory : private T
{
    typedef char one;
    typedef long two;
 
    template<typename C>
    static one test(decltype(static_cast<size_t (T::*)() const>(&is_factory<C>::GetStaticElementCount)));
    template<typename C>
    static two test(...);
 
public:
    enum
    {
        value = sizeof(test<T>(static_cast<size_t (T::*)() const>(nullptr))) == sizeof(char)
    };
};
 
template <typename T, typename Enable = void>
struct dispatcher;
 
template<typename T>
struct dispatcher<T, typename std::enable_if<!is_factory<T>::value>::type>
{
    typedef typename T::DefinedStructElementType StructElementType;
    static inline size_t GetElementCount(const T& oType)
    {
        return oType.GetElementCount();
    }
 
    static inline tResult GetElement(const T& oType, size_t nElement, const StructElementType*& pElement)
    {
        return oType.GetElement(nElement, pElement);
    }
    
    static inline const char* GetElementName(const T& oType, const StructElementType* pElement)
    {
        return oType.GetStructElementName(pElement);
    }
};
 
template <typename T>
struct dispatcher<T, typename std::enable_if<is_factory<T>::value>::type>
{
    typedef typename T::DefinedStructElementType StructElementType;
    static inline size_t GetElementCount(const T& oType)
    {
        return oType.GetStaticElementCount();
    }
 
    static inline tResult GetElement(const T& oType, size_t nElement, const StructElementType*& pElement)
    {
        return oType.GetStaticElement(nElement, pElement);
    }
 
    static inline const char* GetElementName(const T& oType, const StructElementType* pElement)
    {
        return oType.GetStaticStructElementName(pElement);
    }
};
 
template <typename T>
tResult find_complex_index(const T& oDecoder, const A_UTILS_NS::cString& strStructName,
                           size_t& nIndex, const char* strPostfix)
{
    if (strStructName.IsEmpty())
    {
        nIndex = 0;
        RETURN_NOERROR;
    }
 
    size_t nElementCount = dispatcher<T>::GetElementCount(oDecoder);
    A_UTILS_NS::cString strPrefix = strStructName + strPostfix;
    for (size_t nElement = 0; nElement < nElementCount; ++nElement)
    {
        const typename dispatcher<T>::StructElementType* pElement;
        if (IS_OK(dispatcher<T>::GetElement(oDecoder, nElement, pElement)))
        {
            adtf_util::cString strElementName = detail::dispatcher<T>::GetElementName(oDecoder, pElement);
            if (strElementName.StartsWith(strPrefix))
            {
                nIndex = nElement;
                RETURN_NOERROR;
            }
        }
    }
 
    RETURN_ERROR(ERR_NOT_FOUND);
}
 
} //namespace detail
 
template <typename T>
tResult find_index(const T& oDecoder, const A_UTILS_NS::cString& strElementName, size_t& nIndex)
{
    size_t nElementCount = detail::dispatcher<T>::GetElementCount(oDecoder);
    for (size_t nElement = 0; nElement < nElementCount; ++nElement)
    {
        const typename detail::dispatcher<T>::StructElementType* pElement;
        if (IS_OK(detail::dispatcher<T>::GetElement(oDecoder, nElement, pElement)))
        {
            if (A_UTILS_NS::cStringUtil::IsEqual(strElementName.GetPtr(), detail::dispatcher<T>::GetElementName(oDecoder, pElement)))
            {
                nIndex = nElement;
                RETURN_NOERROR;
            }
        }
    }
 
    RETURN_ERROR(ERR_NOT_FOUND);
}
 
template <typename T>
tResult find_struct_index(const T& oDecoder, const A_UTILS_NS::cString& strStructName, size_t& nIndex)
{
    return detail::find_complex_index<T>(oDecoder, strStructName, nIndex, ".");
}
 
template <typename T>
tResult find_array_index(const T& oDecoder, const A_UTILS_NS::cString& strArrayName, size_t& nIndex)
{
    return detail::find_complex_index<T>(oDecoder, strArrayName, nIndex, "[");
}
 
template <typename T>
tResult find_array_end_index(const T& oDecoder, const A_UTILS_NS::cString& strArrayName, size_t& nIndex)
{
    size_t nElementCount = detail::dispatcher<T>::GetElementCount(oDecoder);
    A_UTILS_NS::cString strPrefix = strArrayName + "[";
    for (nIndex += 1; nIndex < nElementCount; ++nIndex)
    {
        const typename detail::dispatcher<T>::StructElementType* pElement;
        if (IS_FAILED(detail::dispatcher<T>::GetElement(oDecoder, nIndex, pElement)))
        {
            RETURN_NOERROR;
        }
        adtf_util::cString strElementName = detail::dispatcher<T>::GetElementName(oDecoder, pElement);
        if (!strElementName.StartsWith(strPrefix))
        {
            RETURN_NOERROR;
        }
    }
 
    RETURN_NOERROR;
}
 
template <typename T>
tResult get_value(const T& oDecoder, const A_UTILS_NS::cString& strElementName, void* pValue)
{
    size_t nElement = 0;
    RETURN_IF_FAILED(find_index(oDecoder, strElementName, nElement));
    return oDecoder.GetElementValue(nElement, pValue);
}
 
template <typename T>
tResult set_value(T& oCodec, const A_UTILS_NS::cString& strElementName, const void* pValue)
{
    size_t nElement = 0;
    RETURN_IF_FAILED(find_index(oCodec, strElementName, nElement));
    return oCodec.SetElementValue(nElement, pValue);
}
 
template <typename T>
A_UTILS_NS::cVariant get_value(const T& oDecoder, const A_UTILS_NS::cString& strElementName)
{
    A_UTILS_NS::cVariant oResult;
    size_t nElement = 0;
    if (IS_OK(find_index(oDecoder, strElementName, nElement)))
    {
        oDecoder.GetElementValue(nElement, oResult);
    }
    return oResult;
}
 
template <typename T>
tResult set_value(T& oCodec, const A_UTILS_NS::cString& strElementName, const A_UTILS_NS::cVariant& oValue)
{
    size_t nElement = 0;
    RETURN_IF_FAILED(find_index(oCodec, strElementName, nElement));
    return oCodec.SetElementValue(nElement, oValue);
}
 
template <typename T>
A_UTILS_NS::cVariant get_value(const T& oDecoder, size_t nElement)
{
    A_UTILS_NS::cVariant oResult;
    if (IS_OK(oDecoder.GetElementValue(nElement, oResult)))
    {
        return oResult;
    }
 
    return 0;
}
 
template <typename T>
const void* get_value_address(const T& oDecoder, const A_UTILS_NS::cString& strElementName)
{
    size_t nElement = 0;
    if (IS_OK(find_index(oDecoder, strElementName, nElement)))
    {
        return oDecoder.GetElementAddress(nElement);
    }
 
    return nullptr;
}
 
template <typename T>
void* get_value_address(T& oCodec, const A_UTILS_NS::cString& strElementName)
{
    size_t nElement = 0;
    if (IS_OK(find_index(oCodec, strElementName, nElement)))
    {
        return oCodec.GetElementAddress(nElement);
    }
 
    return nullptr;
}
 
template <typename Struct, typename T>
const Struct* get_struct_address(const T& oDecoder, const A_UTILS_NS::cString& strStructName)
{
    size_t nElement = 0;
    if (IS_OK(find_struct_index(oDecoder, strStructName, nElement)))
    {
        return reinterpret_cast<const Struct*>(oDecoder.GetElementAddress(nElement));
    }
 
    return nullptr;
}
 
template <typename Struct, typename T>
Struct* get_struct_address(T& oCodec, const A_UTILS_NS::cString& strStructName)
{
    size_t nElement = 0;
    if (IS_OK(find_struct_index(oCodec, strStructName, nElement)))
    {
        return reinterpret_cast<Struct*>(oCodec.GetElementAddress(nElement));
    }
 
    return nullptr;
}
 
template <typename T, typename Codec>
tResult get_struct_value(const Codec& oDecoder, const A_UTILS_NS::cString& strStructName, T* pStructValue)
{
    const T* pAddress = get_struct_address<T>(oDecoder, strStructName);
    if (!pAddress)
    {
        RETURN_ERROR(ERR_NOT_FOUND);
    }
 
    A_UTILS_NS::cMemoryBlock::MemCopy(pStructValue, pAddress, sizeof(T));
    RETURN_NOERROR;
}
 
template <typename T, typename Codec>
tResult set_struct_value(Codec& oCodec, const A_UTILS_NS::cString& strStructName, const T* pStructValue)
{
    T* pAddress = get_struct_address<T>(oCodec, strStructName);
    if (!pAddress)
    {
        RETURN_ERROR(ERR_NOT_FOUND);
    }
 
    A_UTILS_NS::cMemoryBlock::MemCopy(pAddress, pStructValue, sizeof(T));
    RETURN_NOERROR;
}
 
template <typename ArrayType, typename T>
const ArrayType* get_array_address(const T& oDecoder, const A_UTILS_NS::cString& strArrayName)
{
    size_t nElement = 0;
    if (IS_OK(find_array_index(oDecoder, strArrayName, nElement)))
    {
        return reinterpret_cast<const ArrayType*>(oDecoder.GetElementAddress(nElement));
    }
 
    return nullptr;
}
 
template <typename ArrayType, typename T>
ArrayType* get_array_address(T& oCodec, const A_UTILS_NS::cString& strArrayName)
{
    size_t nElement = 0;
    if (IS_OK(find_array_index(oCodec, strArrayName, nElement)))
    {
        return reinterpret_cast<ArrayType*>(oCodec.GetElementAddress(nElement));
    }
 
    return nullptr;
}
 
template <typename Codec>
tResult get_array(const Codec& oDecoder, const A_UTILS_NS::cString& strArrayName,
                  const void*& pStartAddress, size_t& nSize)
{
    size_t nStartIndex = 0;
    RETURN_IF_FAILED(find_array_index(oDecoder, strArrayName, nStartIndex));
    size_t nEndIndex = nStartIndex;
    RETURN_IF_FAILED(find_array_end_index(oDecoder, strArrayName, nEndIndex));
 
    pStartAddress = oDecoder.GetElementAddress(nStartIndex);
    if (!pStartAddress)
    {
        RETURN_ERROR(ERR_UNEXPECTED);
    }
 
    const void* pEndAddress = oDecoder.GetElementAddress(nEndIndex);
    if (pEndAddress)
    {
        nSize = static_cast<const uint8_t*>(pEndAddress) -
                static_cast<const uint8_t*>(pStartAddress);
    }
    else
    {
        // it reaches til the end
        size_t nStartOffset = static_cast<const uint8_t*>(pStartAddress) -
                             static_cast<const uint8_t*>(oDecoder.GetElementAddress(0));
        nSize = oDecoder.GetBufferSize(oDecoder.GetRepresentation()) - nStartOffset;
    }
 
    RETURN_NOERROR;
}
 
template <typename T, typename Codec>
tResult get_array_value(const Codec& oDecoder, const A_UTILS_NS::cString& strArrayName, T* pArrayValue)
{
    const void* pStartAddress = nullptr;
    size_t nSize = 0;
    RETURN_IF_FAILED(get_array(oDecoder, strArrayName, pStartAddress, nSize));
    A_UTILS_NS::cMemoryBlock::MemCopy(pArrayValue, pStartAddress, nSize);
    RETURN_NOERROR;
}
 
template <typename T> tResult reset(T& oCodec, const A_UTILS_NS::cString& strElementName)
{
    size_t nElement = 0;
    RETURN_IF_FAILED(find_index(oCodec, strElementName, nElement));
    uint64_t nZero = 0;
    return oCodec.SetElementValue(nElement, &nZero);
}
 
 
template <typename T>
A_UTILS_NS::cString get_value_as_string(const T& oDecoder, size_t nElement)
{
    return oDecoder.GetElementValueString(nElement);
}
 
template <typename T>
A_UTILS_NS::cString get_value_as_string(const T& oDecoder, const A_UTILS_NS::cString& strElementName)
{
    size_t nElement = 0;
    if (IS_OK(find_index(oDecoder, strElementName, nElement)))
    {
        return get_value_as_string(oDecoder, nElement);
    }
    return "";
}
 
}
 
}