sample_codec.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef USE_ADTF_MEDIA_DESCRIPTION_LEGACY
    #ifndef NO_ADTF_MEDIA_DESCRIPTION_LEGACY
        #include "legacy/sample_codec_legacy.h"
    #endif
#endif
 
#include <adtfstreaming3/sample_intf.h>
#include <adtfstreaming3/streamtype_intf.h>
#include <adtfmediadescription/sample_codec_access_types.h>
#include <adtfmediadescription/leaf_sample_codec_access.h>
#include <adtfmediadescription/sample_codec_access_legacy.h>
 
#include <utility>
#include <string>
#include <type_traits>
 
namespace adtf
{
namespace mediadescription
{
namespace osborn
{
 
class cSampleDecoderBase : public adtf_ddl_access::cDecoderLegacy
{
public:
    cSampleDecoderBase();
    cSampleDecoderBase(cSampleDecoderBase&&);
    cSampleDecoderBase& operator=(cSampleDecoderBase&&);
    tResult IsValid() const;
    //get legacy methods into scope
    #ifndef NO_ADTF_MEDIA_DESCRIPTION_LEGACY
    using adtf_ddl_access::cDecoderLegacy::GetElement;
    using adtf_ddl_access::cDecoderLegacy::GetElementValue;
    using adtf_ddl_access::cDecoderLegacy::GetElementAddress;
    using adtf_ddl_access::cDecoderLegacy::Resolve;
    #endif //NO_ADTF_MEDIA_DESCRIPTION_LEGACY
    typedef ddl::codec::DecoderElement<sample_decoder_access<const cSampleDecoderBase>> tElement;
    tElement GetElement(const tCodecIndex& oCodecIndex) const;
    tElement GetElement(const std::string& strElementFullName) const;
    typedef ddl::codec::ChildElements<sample_decoder_access<const cSampleDecoderBase>> tElements;
    const tElements& GetElements() const;
    size_t GetElementChildCount(const tCodecIndex& oCodecIndex) const;
    std::string GetElementFullName(const tCodecIndex& oCodecIndex) const;
    std::string GetElementName(const tCodecIndex& oCodecIndex) const;
    const std::string& GetElementBaseName(const tCodecIndex& oCodecIndex) const;
    size_t GetStaticBufferSize() const;
    size_t GetStaticBufferSize(ddl::tDataRepresentation oRep) const;
    ddl::tDataRepresentation GetRepresentation() const;
    template<typename T>
    T GetElementValue(const tCodecIndex& oCodecIndex) const
    {
        try
        {
            return getDecoder()->template getElementValue<T>(oCodecIndex);
        }
        catch (const std::exception&)
        {
            throw adtf::base::current_exception_to_result();
        }
    }
    template<typename T>
    T GetElementValue(const penguin::tLeafCodecIndex& oLeafCodecIndex) const
    {
        try
        {
            return getDecoder()->template getElementValue<T>(oLeafCodecIndex);
        }
        catch (const std::exception&)
        {
            throw adtf::base::current_exception_to_result();
        }
    }
    a_util::variant::Variant GetElementVariantValue(const tCodecIndex& oCodecIndex) const;
    void GetElementVariantValue(const tCodecIndex& oCodecIndex, a_util::variant::Variant& oValue) const;
    std::string GetElementStringValue(const tCodecIndex& oCodecIndex) const;
 
    void GetElementRawValue(const tCodecIndex& oCodecIndex, void* pValue, size_t szValueSize) const;
    const void* GetElementAddress(const tCodecIndex& oCodecIndex) const;
 
    void Resolve(tCodecIndex& oCodecIndex) const;
 
protected:
    void ResetFirst();
 
private:
    tElement m_oFirstElement;
};
 
class cStaticSampleDecoder : public cSampleDecoderBase
{
public:
    cStaticSampleDecoder() = default;
 
    cStaticSampleDecoder(cStaticSampleDecoder&&);
    cStaticSampleDecoder& operator=(cStaticSampleDecoder&&);
 
    inline const void* GetData() const
    {
        return m_pBuffer->GetPtr();
    }
 
    inline size_t GetDataSize() const
    {
        return m_pBuffer->GetSize();
    }
 
private:
    friend class cSampleCodecFactory;
    cStaticSampleDecoder(ddl::codec::StaticDecoder&& oDecoder,
                         adtf::ucom::object_ptr_shared_locked<const adtf::streaming::ISampleBuffer>&& pBuffer):
        m_oStaticDecoder(std::move(oDecoder)),
        m_pBuffer(std::move(pBuffer))
    {
        cSampleDecoderBase::ResetFirst();
    }
    const ddl::codec::StaticDecoder* getDecoder() const override;
 
private:
    ddl::codec::StaticDecoder m_oStaticDecoder;
    adtf::ucom::object_ptr_shared_locked<const adtf::streaming::ISampleBuffer> m_pBuffer;
};
 
class cStaticSampleCodec : public cSampleDecoderBase,
                           public adtf_ddl_access::cCodecLegacy<ddl::codec::StaticCodec>
{
public:
    cStaticSampleCodec();
    cStaticSampleCodec(cStaticSampleCodec&&);
    cStaticSampleCodec& operator=(cStaticSampleCodec&&);
 
    //get cSampleDecoderBase API into scope
    using cSampleDecoderBase::GetElements;
    using cSampleDecoderBase::GetElement;
    using cSampleDecoderBase::GetElementAddress;
    
    #ifndef NO_ADTF_MEDIA_DESCRIPTION_LEGACY
    //gets cCodecLegacy into scope
    using adtf_ddl_access::cCodecLegacy<ddl::codec::StaticCodec>::SetElementValue;
    using adtf_ddl_access::cCodecLegacy<ddl::codec::StaticCodec>::GetElementAddress;
    #endif //NO_ADTF_MEDIA_DESCRIPTION_LEGACY
 
    typedef ddl::codec::CodecElement<sample_codec_access<cStaticSampleCodec>> tElement;
    tElement GetElement(const tCodecIndex& oCodecIndex);
    tElement GetElement(const std::string& strElementFullName);   
    typedef ddl::codec::ChildElements<sample_codec_access<cStaticSampleCodec>> tElements;
    tElements& GetElements();
 
    template<typename T>
    void SetElementValue(const tCodecIndex& oCodecIndex, const T& oValue)
    {
        try
        {
            getCodec()->template setElementValue<T>(oCodecIndex, oValue);
        }
        catch(const std::exception&)
        {
            throw adtf::base::current_exception_to_result();
        }
    }
    template<typename T>
    void SetElementValue(const tLeafCodecIndex& oLeafCodecIndex, const T& oValue)
    {
        try
        {
            getCodec()->template setElementValue<T>(oLeafCodecIndex, oValue);
        }
        catch (const std::exception&)
        {
            throw adtf::base::current_exception_to_result();
        }
    }
    void SetElementVariantValue(const tCodecIndex& oCodecIndex, const a_util::variant::Variant& oValue);
    void SetElementStringValue(const tCodecIndex& oCodecIndex, const std::string& strValue);
    void SetElementRawValue(const tCodecIndex& oCodecIndex, const void* pValue, size_t szValueSize);
    void* GetElementAddress(const tCodecIndex& oCodecIndex);
    void* GetElementAddress(const std::string& strElementFullName);
 
    inline const void* GetData() const
    {
        return m_pBuffer->GetPtr();
    }
    inline void* GetData()
    {
        return m_pBuffer->GetPtr();
    }
 
    inline size_t GetDataSize() const
    {
        return m_pBuffer->GetSize();
    }
 
private:
    friend class cSampleCodecFactory;
    cStaticSampleCodec(ddl::codec::StaticCodec&& oDecoder,
                       adtf::ucom::object_ptr_locked<adtf::streaming::ISampleBuffer>&& pBuffer):
        m_oStaticCodec(std::move(oDecoder)),
        m_pBuffer(std::move(pBuffer)),
        m_oFirstElement(tCodecIndex(), *this)
    {
        cSampleDecoderBase::ResetFirst();
    }
    const ddl::codec::StaticDecoder* getDecoder() const override;
    ddl::codec::StaticCodec* getCodec() override;
    ddl::codec::StaticCodec m_oStaticCodec;
    adtf::ucom::object_ptr_locked<adtf::streaming::ISampleBuffer> m_pBuffer;
    tElement m_oFirstElement;
};
 
class cSampleDecoder : public cSampleDecoderBase
{
public:
    cSampleDecoder() = default;
 
    cSampleDecoder(cSampleDecoder&&);
    cSampleDecoder& operator=(cSampleDecoder&&);
    size_t GetBufferSize() const;
    size_t GetBufferSize(ddl::tDataRepresentation eRep) const;
 
    inline const void* GetData() const
    {
        return m_pBuffer->GetPtr();
    }
 
    inline size_t GetDataSize() const
    {
        return m_pBuffer->GetSize();
    }
 
private:
    friend class cSampleCodecFactory;
    cSampleDecoder(ddl::codec::Decoder&& oDecoder,
                   adtf::ucom::object_ptr_shared_locked<const adtf::streaming::ISampleBuffer>&& pBuffer):
        m_oDecoder(std::move(oDecoder)),
        m_pBuffer(std::move(pBuffer))
    {
        cSampleDecoderBase::ResetFirst();
    }
    const ddl::codec::StaticDecoder* getDecoder() const override;
    ddl::codec::Decoder m_oDecoder;
    adtf::ucom::object_ptr_shared_locked<const adtf::streaming::ISampleBuffer> m_pBuffer;
};
 
class cSampleCodec : public cSampleDecoderBase,
                     public adtf_ddl_access::cCodecLegacy<ddl::codec::Codec>
{
public:
    cSampleCodec();
 
    cSampleCodec(cSampleCodec&&);
    cSampleCodec& operator=(cSampleCodec&&);
 
    //gets cSampleDecoderBase into scope
    using cSampleDecoderBase::GetElement;
    using cSampleDecoderBase::GetElements;
    using cSampleDecoderBase::GetElementAddress;
 
    #ifndef NO_ADTF_MEDIA_DESCRIPTION_LEGACY
    //gets cCodecLegacy into scope
    using adtf_ddl_access::cCodecLegacy<ddl::codec::Codec>::SetElementValue;
    using adtf_ddl_access::cCodecLegacy<ddl::codec::Codec>::GetElementAddress;
    #endif //NO_ADTF_MEDIA_DESCRIPTION_LEGACY
    template<typename T>
    void SetElementValue(const tCodecIndex& oCodecIndex, const T& oValue)
    {
        try
        {
            getCodec()->template setElementValue<T>(oCodecIndex, oValue);
        }
        catch (const std::exception&)
        {
            throw adtf::base::current_exception_to_result();
        }
    }
    template<typename T>
    void SetElementValue(const tLeafCodecIndex& oLeafCodecIndex, const T& oValue)
    {
        try
        {
            getCodec()->template setElementValue<T>(oLeafCodecIndex, oValue);
        }
        catch (const std::exception&)
        {
            throw adtf::base::current_exception_to_result();
        }
    }
    void SetElementVariantValue(const tCodecIndex& oCodecIndex, const a_util::variant::Variant& oValue);
    void SetElementStringValue(const tCodecIndex& oCodecIndex, const std::string& strValue);
    void SetElementRawValue(const tCodecIndex& oCodecIndex, const void* pValue, size_t szValueSize);
    void* GetElementAddress(const tCodecIndex& oCodecIndex);
    typedef ddl::codec::CodecElement<sample_codec_access<cSampleCodec>> tElement;
    tElement GetElement(const tCodecIndex& oCodecIndex);
    tElement GetElement(const std::string& strElementFullName);
    typedef ddl::codec::ChildElements<sample_codec_access<cSampleCodec>> tElements;
    tElements& GetElements();
    void* GetElementAddress(const std::string& strElementFullName);
    size_t GetBufferSize() const;
    size_t GetBufferSize(ddl::tDataRepresentation eRep) const;
 
    inline const void* GetData() const
    {
        return m_pBuffer->GetPtr();
    }
    inline void* GetData()
    {
        return m_pBuffer->GetPtr();
    }
 
    inline size_t GetDataSize() const
    {
        return m_pBuffer->GetSize();
    }
 
private:
    friend class cSampleCodecFactory;
    cSampleCodec(ddl::codec::Codec&& oDecoder,
                 adtf::ucom::object_ptr_locked<adtf::streaming::ISampleBuffer>&& pBuffer):
        m_oCodec(std::move(oDecoder)),
        m_pBuffer(std::move(pBuffer)),
        m_oFirstElement(tCodecIndex(), *this)
    {
        cSampleDecoderBase::ResetFirst();
    }
    const ddl::codec::StaticDecoder* getDecoder() const override;
    ddl::codec::Codec* getCodec() override;
    ddl::codec::Codec m_oCodec;
    adtf::ucom::object_ptr_locked<adtf::streaming::ISampleBuffer> m_pBuffer;
    tElement m_oFirstElement;
};
 
 
class cSampleCodecFactory : public adtf_ddl_access::cCodecFactoryLegacy
{
public:
    cSampleCodecFactory();
 
    cSampleCodecFactory(const char* strStructName,
                        const char* strMediaDescription,
                        ddl::tDataRepresentation eDefaultDataRepresentation = ddl::tDataRepresentation::Deserialized);
    cSampleCodecFactory(const ddl::dd::StructType& oStruct,
                        const ddl::dd::DataDefinition& oParentDD,
                        ddl::tDataRepresentation eDefaultDataRepresentation = ddl::tDataRepresentation::Deserialized);
 
    cSampleCodecFactory(const std::pair<std::string, std::string>& oMDDescription,
                        ddl::tDataRepresentation eDefaultDataRepresentation = ddl::tDataRepresentation::Deserialized);
    cSampleCodecFactory(const ddl::DDStructure& oTypeDefinition,
                        ddl::tDataRepresentation eDefaultDataRepresentation = ddl::tDataRepresentation::Deserialized);
    cSampleCodecFactory(const streaming::ant::IStreamType& oStreamType);
    cSampleCodecFactory(const ucom::ant::iobject_ptr<const streaming::ant::IStreamType>& pStreamType);
    cSampleCodecFactory(const cSampleCodecFactory&);
    cSampleCodecFactory(cSampleCodecFactory&&);
    cSampleCodecFactory& operator=(const cSampleCodecFactory&);
    cSampleCodecFactory& operator=(cSampleCodecFactory&&);
 
    #ifndef NO_ADTF_MEDIA_DESCRIPTION_LEGACY
    using adtf_ddl_access::cCodecFactoryLegacy::Resolve;
    #endif //NO_ADTF_MEDIA_DESCRIPTION_LEGACY
    tResult IsValid() const;
    cStaticSampleDecoder MakeStaticDecoderFor(const adtf::streaming::ISample& oSample,
                                              ddl::tDataRepresentation eDataRepresentation) const;
    cStaticSampleCodec MakeStaticCodecFor(adtf::streaming::ISample& oSample,
                                          ddl::tDataRepresentation eDataRepresentation) const;
    cSampleDecoder MakeDecoderFor(const adtf::streaming::ISample& oSample,
                                  ddl::tDataRepresentation eDataRepresentation) const;
    cSampleCodec MakeCodecFor(adtf::streaming::ISample& oSample,
                              ddl::tDataRepresentation eDataRepresentation) const;
    typedef ddl::codec::FactoryElement<sample_codec_factory_access<const cSampleCodecFactory>> tElement;
    tElement GetElement(const tCodecIndex& oCodecIndex) const;
    tElement GetElement(const std::string& strElementFullName) const;
    typedef ddl::codec::ChildElements<sample_codec_factory_access<const cSampleCodecFactory>>
        tElements;
    const tElements& GetElements() const;
    size_t GetElementChildCount(const tCodecIndex& oCodecIndex) const;
    std::string GetElementFullName(const tCodecIndex& oCodecIndex) const;
    std::string GetElementName(const tCodecIndex& oCodecIndex) const;
    const std::string& GetElementBaseName(const tCodecIndex& oCodecIndex) const;
    size_t GetStaticBufferSize(ddl::tDataRepresentation eRep = ddl::tDataRepresentation::Deserialized) const;
 
    ddl::tDataRepresentation GetDefaultDataRepresentation() const;
 
public: // convenience methods
    inline cStaticSampleDecoder MakeStaticDecoderFor(const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample,
                                                     ddl::tDataRepresentation eDataRepresentation) const
    {
        return MakeStaticDecoderFor(*pSample.Get(), eDataRepresentation);
    }
    inline cSampleDecoder MakeDecoderFor(const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample,
                                         ddl::tDataRepresentation eDataRepresentation) const
    {
        return MakeDecoderFor(*pSample.Get(), eDataRepresentation);
    }
    inline cStaticSampleCodec MakeStaticCodecFor(const adtf::ucom::iobject_ptr<adtf::streaming::ISample>& pSample,
                                                 ddl::tDataRepresentation eDataRepresentation) const
    {
        return MakeStaticCodecFor(*pSample.Get(), eDataRepresentation);
    }
    inline cSampleCodec MakeCodecFor(const adtf::ucom::iobject_ptr<adtf::streaming::ISample>& pSample,
                                     ddl::tDataRepresentation eDataRepresentation) const
    {
        return MakeCodecFor(*pSample.Get(), eDataRepresentation);
    }
    inline cStaticSampleDecoder MakeStaticDecoderFor(const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) const
    {
        return MakeStaticDecoderFor(*pSample.Get(), m_eDefaultDataRepresentation);
    }
    inline cSampleDecoder MakeDecoderFor(const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) const
    {
        return MakeDecoderFor(*pSample.Get(), m_eDefaultDataRepresentation);
    }
    inline cStaticSampleCodec MakeStaticCodecFor(const adtf::ucom::iobject_ptr<adtf::streaming::ISample>& pSample) const
    {
        return MakeStaticCodecFor(*pSample.Get(), m_eDefaultDataRepresentation);
    }
    inline cSampleCodec MakeCodecFor(const adtf::ucom::iobject_ptr<adtf::streaming::ISample>& pSample) const
    {
        return MakeCodecFor(*pSample.Get(), m_eDefaultDataRepresentation);
    }
    inline cStaticSampleDecoder MakeStaticDecoderFor(const adtf::streaming::ISample& oSample) const
    {
        return MakeStaticDecoderFor(oSample, m_eDefaultDataRepresentation);
    }
    inline cSampleDecoder MakeDecoderFor(const adtf::streaming::ISample& oSample) const
    {
        return MakeDecoderFor(oSample, m_eDefaultDataRepresentation);
    }
    inline cStaticSampleCodec MakeStaticCodecFor(adtf::streaming::ISample& oSample) const
    {
        return MakeStaticCodecFor(oSample, m_eDefaultDataRepresentation);
    }
    inline cSampleCodec MakeCodecFor(adtf::streaming::ISample& oSample) const
    {
        return MakeCodecFor(oSample, m_eDefaultDataRepresentation);
    }
    void Resolve(tCodecIndex& oCodecIndex) const;
 
private:
    const ddl::codec::CodecFactory* getFactory() const override;
    ddl::tDataRepresentation m_eDefaultDataRepresentation = ddl::tDataRepresentation::Deserialized;
    ddl::codec::CodecFactory m_oFactory;
    tElement m_oFirstElement;
};
 
template<typename ElementsType>
using element_callback = std::function<void(std::conditional_t<std::is_const<ElementsType>::value,
                                                               const typename ElementsType::element_type,
                                                               typename ElementsType::element_type>&)>;
template<typename ElementsType>
using element_control_callback = std::function<bool(std::conditional_t<std::is_const<ElementsType>::value,
                                                               const typename ElementsType::element_type,
                                                               typename ElementsType::element_type>&)>;
 
template<typename ElementsType>
using array_element_callback = std::function<void(std::conditional_t<std::is_const<ElementsType>::value,
                                                                     const typename ElementsType::element_type,
                                                                     typename ElementsType::element_type>&,
                                                  size_t)>;
template<typename ElementsType>
using array_element_control_callback = std::function<bool(std::conditional_t<std::is_const<ElementsType>::value,
                                                                             const typename ElementsType::element_type,
                                                                             typename ElementsType::element_type>&,
                                                          size_t)>;
 
template<typename ElementsType>
void for_each_leaf_element(ElementsType& oElements, const element_callback<ElementsType>& fnCallback)
{
    for (auto& oCurrentElement : oElements)
    {
        if (oCurrentElement.hasChildren())
        {
            if (oCurrentElement.isArray())
            {
                for (size_t szArrayPos = 0; szArrayPos < oCurrentElement.getArraySize(); ++szArrayPos)
                {
                    auto oArrayElement = oCurrentElement.getArrayElement(szArrayPos);
                    auto& children = oArrayElement.getChildElements();
                    for_each_leaf_element(children, fnCallback);
                }
            }
            else
            {
                auto& children = oCurrentElement.getChildElements();
                for_each_leaf_element(children, fnCallback);
            }
        }
        else
        {
            if (oCurrentElement.isArray())
            {
                for (size_t szArrayPos = 0; szArrayPos < oCurrentElement.getArraySize(); ++szArrayPos)
                {
                    auto oArrayElement = oCurrentElement.getArrayElement(szArrayPos);
                    fnCallback(oArrayElement);
                }
            }
            else
            {
                fnCallback(oCurrentElement);
            }
        }
    }
}
template<typename T>
std::vector<tCodecIndex> get_codec_indices(const T& oDecoderOrFactory)
{
    std::vector<tCodecIndex> oIndices;
    for_each_leaf_element(oDecoderOrFactory.GetElements(),
        [&oIndices](const auto& oElement) {
                              oIndices.push_back(oElement.getIndex());
        });
    return oIndices;
}
 
template<typename ElementsType>
void for_each_element(ElementsType& oElements, const element_callback<ElementsType>& fnCallback)
{
    for (auto& oCurrentElement : oElements)
    {
        fnCallback(oCurrentElement);
        if (oCurrentElement.hasChildren())
        {
            for_each_element(oCurrentElement.getChildElements(), fnCallback);
        }
    }
}
 
template<typename ElementsType>
void for_each_element_infix(
    ElementsType& oElements,
    const element_callback<ElementsType>& fnLeafCallback,
    const element_control_callback<ElementsType>& fnEnterMemberCallback,
    const element_callback<ElementsType>& fnLeaveMemberCallback,
    const array_element_control_callback<ElementsType>& fnEnterArrayMemberCallback,
    const array_element_callback<ElementsType>& fnLeaveArrayMemberCallback
 )
{
    for (auto& oCurrentElement : oElements)
    {
        if (fnEnterMemberCallback(oCurrentElement))
        {
            if (oCurrentElement.hasChildren())
            {
                if (oCurrentElement.isArray())
                {
                    for (size_t szArrayPos = 0; szArrayPos < oCurrentElement.getArraySize(); ++szArrayPos)
                    {
                        auto oArrayElement = oCurrentElement.getArrayElement(szArrayPos);
                        if (fnEnterArrayMemberCallback(oArrayElement, szArrayPos))
                        {
                            auto& children = oArrayElement.getChildElements();
                            for_each_element_infix(children, fnLeafCallback, fnEnterMemberCallback,
                                                   fnLeaveMemberCallback, fnEnterArrayMemberCallback,
                                                   fnLeaveArrayMemberCallback);
                            fnLeaveArrayMemberCallback(oArrayElement, szArrayPos);
                        }
                    }
                }
                else
                {
                    auto& children = oCurrentElement.getChildElements();
                    for_each_element_infix(children, fnLeafCallback, fnEnterMemberCallback, fnLeaveMemberCallback,
                                           fnEnterArrayMemberCallback, fnLeaveArrayMemberCallback);
                }
            }
            else
            {
                if (oCurrentElement.isArray())
                {
                    for (size_t szArrayPos = 0; szArrayPos < oCurrentElement.getArraySize(); ++szArrayPos)
                    {
                        auto oArrayElement = oCurrentElement.getArrayElement(szArrayPos);
                        if (fnEnterArrayMemberCallback(oArrayElement, szArrayPos))
                        {
                            fnLeafCallback(oArrayElement);
                            fnLeaveArrayMemberCallback(oArrayElement, szArrayPos);
                        }
                    }
                }
                else
                {
                    fnLeafCallback(oCurrentElement);
                }
            }
            fnLeaveMemberCallback(oCurrentElement);
        }
    }
}
 
template<typename T>
adtf_util::cVariant get_value_as_variant(const T& oDecoder, const tCodecIndex& oCodecIndex)
{
    switch (oCodecIndex.getType())
    {
        case ddl::codec::ElementType::cet_bool:
            return oDecoder.template GetElementValue<bool>(oCodecIndex);
        case ddl::codec::ElementType::cet_int8:
            return oDecoder.template GetElementValue<tInt8>(oCodecIndex);
        case ddl::codec::ElementType::cet_uint8:
            return oDecoder.template GetElementValue<tUInt8>(oCodecIndex);
        case ddl::codec::ElementType::cet_int16:
            return oDecoder.template GetElementValue<tInt16>(oCodecIndex);
        case ddl::codec::ElementType::cet_uint16:
            return oDecoder.template GetElementValue<tUInt16>(oCodecIndex);
        case ddl::codec::ElementType::cet_int32:
            return oDecoder.template GetElementValue<tInt32>(oCodecIndex);
        case ddl::codec::ElementType::cet_uint32:
            return oDecoder.template GetElementValue<tUInt32>(oCodecIndex);
        case ddl::codec::ElementType::cet_int64:
            return oDecoder.template GetElementValue<tInt64>(oCodecIndex);
        case ddl::codec::ElementType::cet_uint64:
            return oDecoder.template GetElementValue<tUInt64>(oCodecIndex);
        case ddl::codec::ElementType::cet_float:
            return oDecoder.template GetElementValue<tFloat32>(oCodecIndex);
        case ddl::codec::ElementType::cet_double:
            return oDecoder.template GetElementValue<tFloat64>(oCodecIndex);
        default:
            break;
    }
    return adtf_util::cVariant();
}
 
} //namespace osborn
 
namespace quiet
{
 
template<typename ElementsType>
using element_callback = std::function<void(std::conditional_t<std::is_const<ElementsType>::value,
                                                               const typename ElementsType::element_type,
                                                               typename ElementsType::element_type>&,
                                            const ddl::dd::datamodel::StructType::Element&)>;
template<typename ElementsType>
using element_control_callback = std::function<bool(std::conditional_t<std::is_const<ElementsType>::value,
                                                               const typename ElementsType::element_type,
                                                               typename ElementsType::element_type>&,
                                                    const ddl::dd::datamodel::StructType::Element&)>;
 
template<typename ElementsType>
using array_element_callback = std::function<void(std::conditional_t<std::is_const<ElementsType>::value,
                                                                     const typename ElementsType::element_type,
                                                                     typename ElementsType::element_type>&,
                                                  size_t,
                                                  const ddl::dd::datamodel::StructType::Element&)>;
template<typename ElementsType>
using array_element_control_callback = std::function<bool(std::conditional_t<std::is_const<ElementsType>::value,
                                                                             const typename ElementsType::element_type,
                                                                             typename ElementsType::element_type>&,
                                                          size_t,
                                                          const ddl::dd::datamodel::StructType::Element&)>;
 
template<typename ElementsType>
void for_each_element_infix(
    ElementsType& oElements,
    const ddl::dd::datamodel::StructType::Elements& oModelElements,
    const ddl::dd::datamodel::DataDefinition& oDataDefinition,
    const element_callback<ElementsType>& fnLeafCallback,
    const element_control_callback<ElementsType>& fnEnterMemberCallback,
    const element_callback<ElementsType>& fnLeaveMemberCallback,
    const array_element_control_callback<ElementsType>& fnEnterArrayMemberCallback,
    const array_element_callback<ElementsType>& fnLeaveArrayMemberCallback
 );
 
namespace detail
{
 
template<typename ElementsType>
void for_each_element_infix(
    std::conditional_t<std::is_const<ElementsType>::value,
                       const typename ElementsType::element_type,
                       typename ElementsType::element_type>& oCurrentElement,
    const ddl::dd::datamodel::StructType::Element& oModelElement,
    const ddl::dd::datamodel::DataDefinition& oDataDefinition,
    const element_callback<ElementsType>& fnLeafCallback,
    const element_control_callback<ElementsType>& fnEnterMemberCallback,
    const element_callback<ElementsType>& fnLeaveMemberCallback,
    const array_element_control_callback<ElementsType>& fnEnterArrayMemberCallback,
    const array_element_callback<ElementsType>& fnLeaveArrayMemberCallback
 )
{
    if (fnEnterMemberCallback(oCurrentElement, oModelElement))
    {
        if (oCurrentElement.hasChildren())
        {
            const auto& oChildModelElements = oDataDefinition.getStructTypes().get(oModelElement.getTypeName())->getElements();
 
            if (oCurrentElement.isArray())
            {
                for (size_t szArrayPos = 0; szArrayPos < oCurrentElement.getArraySize(); ++szArrayPos)
                {
                    auto oArrayElement = oCurrentElement.getArrayElement(szArrayPos);
                    if (fnEnterArrayMemberCallback(oArrayElement, szArrayPos, oModelElement))
                    {
                        quiet::for_each_element_infix<ElementsType>(oArrayElement.getChildElements(), oChildModelElements, oDataDefinition,
                                                                    fnLeafCallback, fnEnterMemberCallback,
                                                                    fnLeaveMemberCallback, fnEnterArrayMemberCallback,
                                                                    fnLeaveArrayMemberCallback);
 
                        fnLeaveArrayMemberCallback(oArrayElement, szArrayPos, oModelElement);
                    }
                }
            }
            else
            {
                quiet::for_each_element_infix<ElementsType>(oCurrentElement.getChildElements(), oChildModelElements, oDataDefinition,
                                                            fnLeafCallback, fnEnterMemberCallback, fnLeaveMemberCallback,
                                                            fnEnterArrayMemberCallback, fnLeaveArrayMemberCallback);
            }
        }
        else
        {
            if (oCurrentElement.isArray())
            {
                for (size_t szArrayPos = 0; szArrayPos < oCurrentElement.getArraySize(); ++szArrayPos)
                {
                    auto oArrayElement = oCurrentElement.getArrayElement(szArrayPos);
                    if (fnEnterArrayMemberCallback(oArrayElement, szArrayPos, oModelElement))
                    {
                        fnLeafCallback(oArrayElement, oModelElement);
                        fnLeaveArrayMemberCallback(oArrayElement, szArrayPos, oModelElement);
                    }
                }
            }
            else
            {
                fnLeafCallback(oCurrentElement, oModelElement);
            }
        }
        fnLeaveMemberCallback(oCurrentElement, oModelElement);
    }
}
 
}
 
template<typename ElementsType>
void for_each_element_infix(
    ElementsType& oElements,
    const ddl::dd::datamodel::StructType::Elements& oModelElements,
    const ddl::dd::datamodel::DataDefinition& oDataDefinition,
    const element_callback<ElementsType>& fnLeafCallback,
    const element_control_callback<ElementsType>& fnEnterMemberCallback,
    const element_callback<ElementsType>& fnLeaveMemberCallback,
    const array_element_control_callback<ElementsType>& fnEnterArrayMemberCallback,
    const array_element_callback<ElementsType>& fnLeaveArrayMemberCallback
 )
{
    if (oElements.size() != oModelElements.getSize())
    {
        THROW_ERROR_DESC(ERR_INVALID_ARG, "The amount of the model elements does not match the amount of the codec elements.");
    }
 
    auto itModelElement = oModelElements.begin();
 
    for (auto& oCurrentElement : oElements)
    {
        detail::for_each_element_infix<ElementsType>(oCurrentElement, *itModelElement->get(), oDataDefinition,
                                                     fnLeafCallback, fnEnterMemberCallback,
                                                     fnLeaveMemberCallback, fnEnterArrayMemberCallback,
                                                     fnLeaveArrayMemberCallback);
        ++itModelElement;
    }
}
 
}
 
 
using osborn::cStaticSampleDecoder;
using osborn::cStaticSampleCodec;
using osborn::cSampleDecoder;
using osborn::cSampleCodec;
using osborn::cSampleCodecFactory;
 
using osborn::for_each_leaf_element;
using osborn::for_each_element;
using osborn::get_value_as_variant;
using osborn::get_codec_indices;
using osborn::for_each_element_infix;
using quiet::for_each_element_infix;
 
} //namespace mediadescription
} //namespace adtf