type_reflection.h

Go to the documentation of this file.

#pragma once
 
#ifdef USE_ADTF_MEDIA_DESCRIPTION_LEGACY
    #ifndef NO_ADTF_MEDIA_DESCRIPTION_LEGACY
        #include "legacy/type_reflection_legacy.h"
    #endif
#endif
 
// the typereflection is move to the DDL Library ... for structure<> use ddl::DDLStructure for structure<T> use
// DDLStructureT<T>
#include "ddl_usage.h"
#include <adtfucom3/exception_handling.h>
 
namespace adtf
{
namespace mediadescription
{
namespace osborn
{

template<typename Type>
class enumeration : public ddl::DDEnumGenerator<Type>
{
public:
    typedef ddl::DDEnumGenerator<Type> base_type;
    using base_type::addElement;
    enumeration(const std::string& strName): base_type(strName)
    {
    }

    size_t GetSize() const
    {
        return base_type::getTypeByteSize();
    }

    size_t GetAlignment() const
    {
        return base_type::getAlignment();
    }

    enumeration& Add(const std::string& strName, Type eValue)
    {
        addElement(strName, eValue);
        return *this;
    }
};

template<typename T = void>
class structure : public ddl::DDStructureGenerator<T, true>
{
    static_assert(std::is_trivially_copyable<T>::value,
                  "You can only use structs without pointers or complex members.");
 
public:
    typedef ddl::DDStructureGenerator<T, true> base_type;
    structure(const std::string& strName, uint32_t ui32StructVersion = 1): base_type(strName, ui32StructVersion)
    {
    }

    size_t GetSize() const
    {
        return base_type::getDD().getStructTypeAccess(base_type::getStructName()).getStaticStructSize();
    }

    size_t GetAlignment() const
    {
        return *base_type::getStructType().getAlignment();
    }

    template<typename MemberType>
    structure& Add(const std::string& strName, MemberType T::* pMemberOffset)
    {
        base_type::addElement(strName, pMemberOffset);
        return *this;
    }

    template<typename MemberType>
    structure& Add(const std::string& strName, MemberType T::* pMemberOffset, const ddl::DDEnum& oTypeDefinition)
    {
        base_type::addElement(strName, pMemberOffset, oTypeDefinition);
        return *this;
    }

    template<typename MemberType>
    structure& Add(const std::string& strName, MemberType T::* pMemberOffset, const ddl::DDStructure& oTypeDefinition)
    {
        base_type::addElement(strName, pMemberOffset, oTypeDefinition);
        return *this;
    }

    const ddl::DDStructure& GetStructure() const
    {
        return base_type::getStructure();
    }

    operator const ddl::DDStructure&() const
    {
        return GetStructure();
    }
};

template<>
class structure<void> : public ddl::DDStructure
{
public:
    structure(const std::string& strName);

    structure(const std::string& strName, size_t nAlignment);

    size_t GetSize() const;

    size_t GetAlignment() const;

    structure& Add(const std::string& strName,
                   const ddl::dd::DataType& oTypeDefinition,
                   size_t nArrayCount = 1,
                   size_t nAlignment = 0,
                   int32_t nBytePosition = -1,
                   bool bLittleEndian = true);

    template<typename ArithmeticType>
    structure& Add(const std::string& strName,
                   size_t nArrayCount = 1,
                   size_t nAlignment = 0,
                   int32_t nBytePosition = -1,
                   bool bLittleEndian = true)
    {
        return Add(strName, ddl::DataType<ArithmeticType>(), nArrayCount, nAlignment, nBytePosition, bLittleEndian);
    }

    structure& Add(const std::string& strName,
                   const ddl::DDEnum& oTypeDefinition,
                   size_t nArrayCount = 1,
                   size_t nAlignment = 0,
                   int32_t nBytePosition = -1,
                   bool bLittleEndian = true);

    structure& Add(const std::string& strName,
                   const ddl::DDStructure& oTypeDefinition,
                   size_t nArrayCount = 1,
                   size_t nAlignment = 0,
                   int32_t nBytePosition = -1,
                   bool bLittleEndian = true);

    const ddl::DDStructure& GetStructure() const
    {
        return *this;
    }
};
 
} // namespace osborn
 
using osborn::enumeration;
using osborn::structure;
 
} // namespace mediadescription
} // namespace adtf