type_reflection_legacy.h

Go to the documentation of this file.

#pragma once
#include <adtf_utils.h>
#include <type_traits>
#include <memory>
#include <vector>
#include <string>
#include <utility>
 
#include <adtf_base_deprecated.h>
 
namespace adtf
{
namespace mediadescription
{
namespace flash
{
namespace detail
{
 
template <typename Type>
struct arithmetic_type_name;
 
#define DDL_DEFINE_ARITHMETIC_TYPE_NAME(__type, __name) \
template <> \
struct arithmetic_type_name<__type> \
{ \
    static constexpr const char* name = __name; \
};
 
DDL_DEFINE_ARITHMETIC_TYPE_NAME(tBool, "tBool")
DDL_DEFINE_ARITHMETIC_TYPE_NAME(tChar, "tChar")
DDL_DEFINE_ARITHMETIC_TYPE_NAME(tUInt8, "tUInt8")
DDL_DEFINE_ARITHMETIC_TYPE_NAME(tUInt16, "tUInt16")
DDL_DEFINE_ARITHMETIC_TYPE_NAME(tUInt32, "tUInt32")
DDL_DEFINE_ARITHMETIC_TYPE_NAME(tUInt64, "tUInt64")
DDL_DEFINE_ARITHMETIC_TYPE_NAME(tInt8, "tInt8")
DDL_DEFINE_ARITHMETIC_TYPE_NAME(tInt16, "tInt16")
DDL_DEFINE_ARITHMETIC_TYPE_NAME(tInt32, "tInt32")
DDL_DEFINE_ARITHMETIC_TYPE_NAME(tInt64, "tInt64")
DDL_DEFINE_ARITHMETIC_TYPE_NAME(tFloat32, "tFloat32")
DDL_DEFINE_ARITHMETIC_TYPE_NAME(tFloat64, "tFloat64")
 
template<typename T, typename Enable = void>
struct array_count
{
    static constexpr size_t value = 1;
};
 
template<typename T>
struct array_count<T, typename std::enable_if<std::is_array<T>::value>::type>
{
    static constexpr size_t value = sizeof(T) / sizeof(typename std::remove_pointer<typename std::decay<T>::type>::type);
};
 
inline bool is_little_endian()
{
    union
    {
        uint16_t nNumber;
        uint8_t aBytes[2];
    } sTest;
    sTest.nNumber = 0x1;
    return sTest.aBytes[0] == 1;
}
 
template <typename T, typename MemberType>
size_t member_pointer_to_offset(MemberType T::* pMember)
{
    T* pStart = 0;
    return reinterpret_cast<size_t>(&(pStart->*pMember));
}
 
} // namespace detail

class cType
{
    public:
        virtual ~cType();

        virtual std::string GetName() const = 0;

        virtual size_t GetSize() const = 0;

        virtual size_t GetAlignment() const = 0;
};

template <typename Type>
struct arithmetic_type: public cType
{
    arithmetic_type()
    {
        static_assert(std::is_arithmetic<Type>::value, "Type is not an arithmetic type");
    }
 
    std::string GetName() const override
    {
        return detail::arithmetic_type_name<Type>::name;
    }
 
    size_t GetSize() const override
    {
        return sizeof(Type);
    }
 
    size_t GetAlignment() const override
    {
        return alignof(Type);
    }
};

class cEnumerationType: public cType
{
    public:
        struct tValue
        {
            std::string strName;
            int64_t nAssignedValue;
        };
 
    public:
        cEnumerationType(const std::string& strName, const std::shared_ptr<cType>& pUnderlyingType);
        cEnumerationType(const cEnumerationType& oOther);
        ~cEnumerationType() override = default;
        std::string GetName() const override;
        size_t GetSize() const override;
        size_t GetAlignment() const override;

        const std::shared_ptr<cType>& GetUnderlyingType() const;

        const std::vector<tValue>& GetValues() const;
 
    protected:
        void Add(tValue&& sNewValue);
 
    private:
        std::string m_strName;
        std::shared_ptr<cType> m_pUnderlyingType;
        std::vector<tValue> m_oValues;
};

template <typename Type, typename Enable = void>
class enumeration: public cEnumerationType
{
    public:
        enumeration(const std::string& strName):
            cEnumerationType(strName,
                             std::make_shared<arithmetic_type<typename std::underlying_type<Type>::type>>())
        {
        }

        enumeration& Add(const std::string& strName, Type eValue)
        {
            cEnumerationType::Add({strName, static_cast<int64_t>(eValue)});
            return *this;
        }
};

template <typename UnderlyingType>
class enumeration<UnderlyingType,
                  typename std::enable_if<std::is_arithmetic<UnderlyingType>::value>::type>: public cEnumerationType
{
    public:
        enumeration(const std::string& strName):
            cEnumerationType(strName,
                             std::make_shared<arithmetic_type<UnderlyingType>>())
        {
        }

        enumeration& Add(const std::string& strName, int64_t nValue)
        {
            cEnumerationType::Add({strName, nValue});
            return *this;
        }
};

class cStructureType: public cType
{
    public:
        struct member
        {
            size_t nOffset; 
            size_t nSerializedOffset; 
            bool nSerializedLittleEndian; 
            size_t nSize; 
            size_t nArrayCount; 
            std::string strName; 
            std::shared_ptr<cType> pTypeDefinition; 
        };
 
    public:
        cStructureType(const std::string& strName,
                       size_t nSize,
                       size_t nAlignment);
        cStructureType(const cStructureType& oOther);
        ~cStructureType() override = default;
 
        std::string GetName() const override;
        size_t GetSize() const override;
        size_t GetAlignment() const override;

        const std::vector<member>& GetMembers() const;

        std::pair<std::string, std::string> GetAsStringPair() const;
        
        operator std::pair<std::string, std::string>() const
        {
            return GetAsStringPair();
        }
 
    protected:
        void Add(member&& sNewMember);
 
    private:
        std::string m_strName;
        size_t m_nSize;
        size_t m_nAlignment;
        std::vector<member> m_oMembers;
};

template <typename T = void>
class structure: public cStructureType
{
    static_assert(std::is_trivially_copyable<T>::value,
                  "You can only use structs without pointers or complex members.");
 
    public:
        structure(const std::string& strName):
            cStructureType(strName, sizeof(T), alignof(T))
        {            
        }

        template <typename MemberType>
        structure& Add(const std::string& strName,
                       MemberType T::* pMemberOffset)
        {
            cStructureType::Add({detail::member_pointer_to_offset(pMemberOffset),
                                 m_nCurrentSerializedOffset,
                                 detail::is_little_endian(),
                                 sizeof(MemberType),
                                 detail::array_count<MemberType>::value,
                                 strName,
                                 std::make_shared<arithmetic_type<typename std::remove_pointer<typename std::decay<MemberType>::type>::type>>()});
            m_nCurrentSerializedOffset += sizeof(MemberType);
            return *this;
        }

        template <typename MemberType>
        structure& Add(const std::string& strName, MemberType T::* pMemberOffset, const cEnumerationType& oTypeDefinition)
        {
            cStructureType::Add({detail::member_pointer_to_offset(pMemberOffset),
                                 m_nCurrentSerializedOffset,
                                 detail::is_little_endian(),
                                 sizeof(typename std::underlying_type<MemberType>::type),
                                 detail::array_count<MemberType>::value,
                                 strName,
                                 std::make_shared<cEnumerationType>(oTypeDefinition)});
            m_nCurrentSerializedOffset += sizeof(typename std::underlying_type<MemberType>::type);
            return *this;
        }

        template <typename MemberType>
        structure& Add(const std::string& strName, MemberType T::* pMemberOffset, const cStructureType& oTypeDefinition)
        {
            cStructureType::Add({detail::member_pointer_to_offset(pMemberOffset),
                                 m_nCurrentSerializedOffset,
                                 detail::is_little_endian(),
                                 sizeof(MemberType),
                                 detail::array_count<MemberType>::value,
                                 strName,
                                 std::make_shared<cStructureType>(oTypeDefinition)});
            m_nCurrentSerializedOffset += sizeof(MemberType);
            return *this;
        }
 
    private:
        size_t m_nCurrentSerializedOffset = 0;
};

template <>
class structure<void>: public cStructureType
{
    public:
        ADTF3_DEPRECATED("Use ddl::dd::DDStructure instead.")
        structure(const std::string& strName, size_t nAlignment = 0);
 
        size_t GetSize() const override;
        size_t GetAlignment() const override;

        template <typename ArithmeticType>
        typename std::enable_if<std::is_arithmetic<ArithmeticType>::value, structure>::type&
        Add(const std::string& strName,
            size_t nArrayCount = 1,
            size_t nAlignment = 0,
            int32_t nBytePosition = -1,
            bool bLittleEndian = true)
        {
            Add(strName, nArrayCount, nAlignment, nBytePosition, bLittleEndian, std::make_shared<arithmetic_type<ArithmeticType>>());
            return *this;
        }

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

        structure& Add(const std::string& strName,
                       const cStructureType& oTypeDefinition,
                       size_t nArrayCount = 1,
                       size_t nAlignment = 0,
                       int32_t nBytePosition = -1,
                       bool bLittleEndian = true);
 
    private:
        void Add(const std::string& strName,
                 size_t nArrayCount,
                 size_t nAlignment,
                 int32_t nBytePosition,
                 bool bLittleEndian,
                 const std::shared_ptr<cType>& oTypeDefinition);
 
        size_t Align(size_t nOffset, size_t nAlignment) const;
        void AlignOffset(size_t nAlignment);
 
    private:
        size_t m_nCurrentOffset = 0;
        size_t m_nCurrentSerializedOffset = 0;
        size_t m_nMaxAlignment = 1;
};
 
}
 
using flash::cType;
}
}