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::getEnumType().template getInfo<ddl::dd::TypeInfo>()->getTypeByteSize();
    }
 
    size_t GetAlignment() const
    {
        return base_type::getEnumType().template getInfo<ddl::dd::TypeInfo>()->getTypeAlignment();
    }
 
    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;
 
}
}