ddstructure_generator.h

Go to the documentation of this file.

 
#ifndef DDSTRUCTURE_GENERATOR_H_INCLUDED
#define DDSTRUCTURE_GENERATOR_H_INCLUDED
 
#include <ddl/dd/dd.h>
#include <ddl/dd/ddstructure.h>
#include <ddl/utilities/std_to_string.h>
 
#include <type_traits>
 
namespace ddl {

namespace detail {
 
template <typename T>
struct ArrayMember {
    using value_type = T;
    static constexpr size_t array_size = 1;
};
 
// if zero-sized array as placeholder for dynamic arrays
template <typename T>
struct ArrayMember<T[]> {
    using value_type = T;
    static constexpr size_t array_size = 0;
};
 
// if std::array
template <typename ValueType, size_t value_array_size>
struct ArrayMember<std::array<ValueType, value_array_size>> {
    using value_type = ValueType;
    static constexpr size_t array_size = value_array_size;
};
 
// if bounded array
template <typename ValueType, size_t value_array_size>
struct ArrayMember<ValueType[value_array_size]> {
    using value_type = ValueType;
    static constexpr size_t array_size = value_array_size;
};
 
template <typename T>
struct MemberTypeCheck {
    using member_type = typename std::remove_pointer<T>::type;
    using value_type = typename ArrayMember<member_type>::value_type;
    static constexpr size_t array_size = ArrayMember<member_type>::array_size;
};
 
template <typename T, typename MemberType>
size_t getOffsetOfMember(MemberType T::*member)
{
    T* start = 0;
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 6011)
#endif
    return reinterpret_cast<size_t>(&(start->*member));
#ifdef _MSC_VER
#pragma warning(pop)
#endif
}
 
} // namespace detail

template <typename T, bool align_with_padding = true>
class DDStructureGenerator {
    static_assert(std::is_trivially_copyable<T>::value,
                  "You can only use structs with plain old datatypes and complex members. Do not "
                  "use pointers!");
 
public:
    explicit DDStructureGenerator(const std::string& name, uint32_t struct_version = 1)
        : _structure(name, struct_version, alignof(T))
    {
    }

    template <typename MemberType>
    DDElementRef createElement(const std::string& name, MemberType T::*member_offset)
    {
        using ValueType = typename detail::MemberTypeCheck<MemberType>::value_type;
 
        static_assert(!std::is_enum<ValueType>::value,
                      "For elements with enum type you must specify the DDEnum before! "
                      "Use createElement(name, member_offset, dd_enum);");
        static_assert(std::is_arithmetic<ValueType>::value,
                      "For elements with complex structure types you must specify the used "
                      "DDStructure before! Use createElement(name, member_offset, dd_structure);");
        static_assert(detail::MemberTypeCheck<MemberType>::array_size != 0,
                      "For dynamic arrays the array_size must be specified! Use "
                      "createElement(name, member_offset, array_size_name);");
 
        PaddingAlignmentGuard padding_alignment_guard(*this);
        return createElement(
            name,
            *evaluateAlignment(name, detail::getOffsetOfMember(member_offset), alignof(MemberType)),
            DataType<ValueType>(),
            detail::MemberTypeCheck<MemberType>::array_size);
    }

    template <typename MemberType>
    DDElementRef createElement(const std::string& name,
                               MemberType T::*member_offset,
                               const std::string& valid_element_count_or_array_size_name)
    {
        using ValueType = typename detail::MemberTypeCheck<MemberType>::value_type;
 
        static_assert(!std::is_enum<ValueType>::value,
                      "For elements with enum type you must specify the DDEnum before! "
                      "Use createElement(name, member_offset, dd_enum);");
        static_assert(std::is_arithmetic<ValueType>::value,
                      "For elements with complex structure types you must specify the used "
                      "DDStructure before! Use createElement(name, member_offset, dd_structure);");
 
        PaddingAlignmentGuard padding_alignment_guard(*this);
        using ValueType = typename detail::MemberTypeCheck<MemberType>::value_type;
        return createArrayElement(
            name,
            *evaluateAlignment(name, detail::getOffsetOfMember(member_offset), alignof(MemberType)),
            DataType<ValueType>(),
            detail::MemberTypeCheck<MemberType>::array_size,
            valid_element_count_or_array_size_name);
    }

    template <typename MemberType>
    DDStructureGenerator& addElement(const std::string& name, MemberType T::*member_offset)
    {
        createElement(name, member_offset);
        return *this;
    }

    template <typename MemberType>
    DDStructureGenerator& addElement(const std::string& name,
                                     MemberType T::*member_offset,
                                     const std::string& valid_element_count_or_array_size_name)
    {
        createElement(name, member_offset, valid_element_count_or_array_size_name);
        return *this;
    }

    template <typename MemberType>
    DDElementRef createElement(const std::string& name,
                               MemberType T::*member_offset,
                               const DDEnum& enum_type)
    {
        static_assert(
            detail::MemberTypeCheck<MemberType>::array_size != 0,
            "For dynamic arrays the array_size must be specified! Use createElement(name, "
            "member_offset, array_size_name);");
 
        PaddingAlignmentGuard padding_alignment_guard(*this);
        return createElement(
            name,
            *evaluateAlignment(name, detail::getOffsetOfMember(member_offset), alignof(MemberType)),
            enum_type,
            detail::MemberTypeCheck<MemberType>::array_size);
    }

    template <typename MemberType>
    DDElement createElement(const std::string& name,
                            MemberType T::*member_offset,
                            const DDEnum& enum_type,
                            const std::string& valid_element_count_or_array_size_name)
    {
        PaddingAlignmentGuard padding_alignment_guard(*this);
        return createArrayElement(
            name,
            *evaluateAlignment(name, detail::getOffsetOfMember(member_offset), alignof(MemberType)),
            enum_type,
            detail::MemberTypeCheck<MemberType>::array_size,
            valid_element_count_or_array_size_name);
    }

    template <typename MemberType>
    DDStructureGenerator& addElement(const std::string& name,
                                     MemberType T::*member_offset,
                                     const DDEnum& enum_type)
    {
        createElement(name, member_offset, enum_type);
        return *this;
    }

    template <typename MemberType>
    DDStructureGenerator& addElement(const std::string& name,
                                     MemberType T::*member_offset,
                                     const DDEnum& enum_type,
                                     const std::string& valid_element_count_or_array_size_name)
    {
        createElement(name, member_offset, enum_type, valid_element_count_or_array_size_name);
        return *this;
    }

    template <typename MemberType>
    DDElementRef createElement(const std::string& name,
                               MemberType T::*member_offset,
                               const DDStructure& struct_type)
    {
        static_assert(detail::MemberTypeCheck<MemberType>::array_size != 0,
                      "For dynamic arrays the array_size must be specified! Use addElement(name, "
                      "member_offset, array_size_name);");
 
        PaddingAlignmentGuard padding_alignment_guard(*this);
        return createElement(
            name,
            *evaluateAlignment(name, detail::getOffsetOfMember(member_offset), alignof(MemberType)),
            struct_type,
            detail::MemberTypeCheck<MemberType>::array_size);
    }

    template <typename MemberType>
    DDElementRef createElement(const std::string& name,
                               MemberType T::*member_offset,
                               const DDStructure& struct_type,
                               const std::string& valid_element_count_or_array_size_name)
    {
        PaddingAlignmentGuard padding_alignment_guard(*this);
        return createElement(
            name,
            *evaluateAlignment(name, detail::getOffsetOfMember(member_offset), alignof(MemberType)),
            struct_type,
            detail::MemberTypeCheck<MemberType>::array_size,
            valid_element_count_or_array_size_name);
    }

    template <typename MemberType>
    DDStructureGenerator& addElement(const std::string& name,
                                     MemberType T::*member_offset,
                                     const DDStructure& struct_type)
    {
        createElement(name, member_offset, struct_type);
        return *this;
    }

    template <typename MemberType>
    DDStructureGenerator& addElement(const std::string& name,
                                     MemberType T::*member_offset,
                                     const DDStructure& struct_type,
                                     const std::string& valid_element_count_or_array_size_name)
    {
        createElement(name, member_offset, struct_type).setValidElementCount(valid_element_count_or_array_size_name);
        return *this;
    }

    std::string getStructDescription() const
    {
        validate();
        return _structure.getStructDescription();
    }

    std::string getStructName() const
    {
        return _structure.getStructName();
    }

    const dd::DataDefinition& getDD() const
    {
        validate();
        return _structure.getDD();
    }

    const dd::StructType& getStructType() const
    {
        validate();
        return _structure.getStructType();
    }

    const DDStructure& getStructure() const
    {
        validate();
        return _structure;
    }

    size_t getSize() const
    {
        return _structure.getSize();
    }

    size_t getAlignment() const
    {
        return _structure.getAlignment();
    }

    operator const DDStructure&() const
    {
        return getStructure();
    }

    void setStructInfo(const std::string& comment)
    {
        _structure.setStructInfo(comment);
    }

    void setElementInfo(const std::string& element_name,
                        const std::string& description = {},
                        const std::string& comment = {},
                        const std::string& value = {},
                        const std::string& minimum_value = {},
                        const std::string& maximum_value = {},
                        const std::string& default_value = {},
                        const std::string& scale = {},
                        const std::string& offset = {})
    {
        _structure.setElementInfo(element_name,
                                  description,
                                  comment,
                                  value,
                                  minimum_value,
                                  maximum_value,
                                  default_value,
                                  scale,
                                  offset);
    }

    void setElementUnit(const std::string& element_name, const DDUnit& unit)
    {
        _structure.setElementUnit(element_name, unit);
    }

    void setElementUnit(const std::string& element_name, const dd::BaseUnit& base_unit)
    {
        _structure.setElementUnit(element_name, base_unit);
    }

    DDElementRef getElement(const std::string& element_name)
    {
        return _structure.getElement(element_name);
    }
 
private:
    void pushAlignment()
    {
        if constexpr (align_with_padding) {
            const auto current_struct_size = _structure.getSize();
            if (sizeof(T) > current_struct_size) {
                _structure.addElement<uint8_t>(
                    "__padding_final", sizeof(T) - current_struct_size, 1);
                _padded_final = true;
            }
        }
    }
 
    void popAlignment()
    {
        if constexpr (align_with_padding) {
            if (_padded_final) {
                _structure.popLastElement();
                _padded_final = false;
            }
        }
    }
 
    struct PaddingAlignmentGuard {
        PaddingAlignmentGuard(DDStructureGenerator& padded_structure)
            : _padded_structure(padded_structure)
        {
            padded_structure.popAlignment();
        }
 
        ~PaddingAlignmentGuard()
        {
            _padded_structure.pushAlignment();
        }
 
    private:
        DDStructureGenerator& _padded_structure;
    };
 
    void validate() const
    {
        if constexpr (!align_with_padding) {
            if (_structure.getSize() != sizeof(T)) {
                throw ddl::dd::Error(
                    "DDStructureGenerator::validate",
                    "The generated struct '" + _structure.getStructName() +
                        "' does not have the expected size of (" + std::to_string(sizeof(T)) +
                        ") - The evaluated a size is (" + std::to_string(_structure.getSize()) +
                        "). Check if there are missing or misordered elements. ");
            }
        }
    }
 
    dd::OptionalSize evaluateAlignment(const std::string& element_name,
                                       size_t member_offset,
                                       size_t member_type_alignment)
    {
        // obtain the unaligned size
        const auto struct_access = _structure.getDD().getStructTypeAccess(getStructName());
        const auto current_struct_offset = struct_access.getStaticUnalignedStructSize();
 
        if (member_offset < current_struct_offset) {
            throw ddl::dd::Error(
                "evaluateAlignment",
                {std::to_string(member_offset)},
                "The evaluated struct size of '" + getStructName() + "' is already (" +
                    std::to_string(current_struct_offset) + ") - Trying to add a member at (" +
                    std::to_string(member_offset) +
                    ") at a address prior the last element. Check misordered addElement calls.");
        }
 
        // evaluate difference between last added element and current offset
        const auto difference = member_offset - current_struct_offset;
 
        // find the minimum alignment to begin alignment discovery
        // this is the data_type alignment or the struct alignment
        const size_t minimum_alignment =
            member_type_alignment > alignof(T) ? alignof(T) : member_type_alignment;
 
        const auto valid_alignment_range = {1u, 2u, 4u, 8u, 16u, 32u, 64u};
 
        // find a valid alignment in the range of member_type_alignment and struct_alignment
        for (const size_t alignment: valid_alignment_range) {
            // maximum alignment is the alignment of the struct
            if (alignment <= alignof(T)) {
                if (alignment >= minimum_alignment) {
                    if ((alignment > difference) && ((member_offset % alignment) == 0)) {
                        // we do not add padding bytes between if it fits with alignment
                        return alignment;
                    }
                }
            }
            else {
                break;
            }
        }
 
        // if difference is below minimum alignment and we could not reach the position
        // the struct has been packed by the user to another alignment then the struct alignment
        if (difference < minimum_alignment) {
            for (const size_t alignment: valid_alignment_range) {
                if (alignment < minimum_alignment) {
                    if ((alignment > difference) && ((member_offset % alignment) == 0)) {
                        // we do not add padding bytes between if it fits with alignment
                        return alignment;
                    }
                }
                else {
                    break;
                }
            }
        }
 
        // we could not reach the position with alignments, so we
        // align with padding if switch on
        if constexpr (align_with_padding) {
            if (difference != 0) {
                _structure.addElement<uint8_t>("__padding_" + element_name, difference, 1);
            }
            // We need to return alignment 1 to use the very next position
            return 1;
        }
        else {
            throw ddl::dd::Error(
                "evaluateAlignment",
                {std::to_string(member_offset)},
                "For the generated struct '" + getStructName() +
                    "' it is not possible to find a valid member alignment to reach offset (" +
                    std::to_string(member_offset) + ") from position (" +
                    std::to_string(current_struct_offset) + ")");
        }
    }
 
    template <typename DDMemberType>
    DDElementRef createElement(const std::string& name,
                               size_t alignment,
                               const DDMemberType& used_type,
                               size_t array_size)
    {
        return _structure.createElement(name, used_type, array_size, alignment);
    }
 
    template <typename DDMemberType>
    DDElementRef createArrayElement(const std::string& name,
                                    size_t alignment,
                                    const DDMemberType& used_type,
                                    size_t array_size,
                                    const std::string& corresponding_element_name)
    {
        if (array_size == 0) {
            // this is a zerobased array so we add a dynamic array!
            return _structure.createElement(DDElement(name,
                                                      used_type,
                                                      DDElement::Deserialized(alignment),
                                                      {},
                                                      dd::ArraySize(corresponding_element_name)));
        }
        else {
            auto element = _structure.createElement(name, used_type, array_size, alignment);
            element.setValidElementCount(corresponding_element_name);
            return element;
        }
    }
 
    DDStructure _structure;
    bool _padded_final = false;
};
 
} // namespace ddl
 
#endif // DDSTRUCTURE_GENERATOR_H_INCLUDED