ddstructure.h

Go to the documentation of this file.

 
#ifndef DDSTRUCTURE_H_INCLUDED
#define DDSTRUCTURE_H_INCLUDED
 
#include <ddl/dd/dd.h>
#include <ddl/dd/ddelement.h>
#include <ddl/utilities/std_to_string.h>
 
#include <type_traits>
 
namespace ddl {
 
class DDElement;
 
class DDStructure {
public:
    DDStructure() = delete;
    DDStructure(DDStructure&& other);
    DDStructure(const DDStructure& other);
    DDStructure& operator=(DDStructure&& other);
    DDStructure& operator=(const DDStructure& other);
    ~DDStructure() = default;
    explicit DDStructure(const std::string& name,
                         const uint32_t struct_version = 1,
                         dd::OptionalSize alignment = {},
                         const std::string& comment = {},
                         const dd::Version& ddl_version = {});
    explicit DDStructure(const std::string& name,
                         const std::string& xml_string,
                         const dd::Version& ddl_xml_file_version_to_parse = dd::Version(0, 0));
    DDStructure& addElement(const std::string& element_name,
                            const dd::DataType& data_type,
                            size_t array_size = 1);
    DDStructure& addElement(const std::string& element_name,
                            const dd::DataType& data_type,
                            size_t array_size,
                            size_t alignment);
    DDStructure& addElement(const std::string& element_name,
                            const DDDataType& data_type,
                            size_t array_size = 1);
 
    DDStructure& addElement(const std::string& element_name,
                            const DDDataType& data_type,
                            size_t array_size,
                            size_t alignment);
    template <typename PREDEF_DATA_TYPE>
    DDStructure& addElement(const std::string& element_name,
                            size_t array_size = 1,
                            const std::string& special_type_name = {})
    {
        if (special_type_name.empty()) {
            addElement(element_name, DataType<PREDEF_DATA_TYPE>(), array_size);
        }
        else {
            addElement(element_name, DataType<PREDEF_DATA_TYPE>(special_type_name), array_size);
        }
        return *this;
    }
 
    template <typename PREDEF_DATA_TYPE>
    DDStructure& addElement(const std::string& element_name,
                            size_t array_size,
                            size_t alignment,
                            const std::string& special_type_name = {})
    {
        if (special_type_name.empty()) {
            addElement(element_name, DataType<PREDEF_DATA_TYPE>(), array_size, alignment);
        }
        else {
            addElement(
                element_name, DataType<PREDEF_DATA_TYPE>(special_type_name), array_size, alignment);
        }
        return *this;
    }
 
    DDStructure& addElement(const std::string& element_name,
                            const DDEnum& enum_type,
                            size_t array_size,
                            const std::string& constant_value = {});
 
    DDStructure& addElement(const std::string& element_name,
                            const DDEnum& enum_type,
                            size_t array_size,
                            size_t alignment,
                            const std::string& constant_value = {});
 
    DDStructure& addElement(const std::string& element_name,
                            const DDEnum& enum_type,
                            const std::string& constant_value = {});
 
    DDStructure& addElement(const std::string& element_name,
                            const DDStructure& struct_type,
                            size_t array_size = 1);
 
    DDStructure& addElement(const std::string& element_name,
                            const DDStructure& struct_type,
                            size_t array_size,
                            size_t alignment);
    DDStructure& addElement(const DDElement& element);
    DDStructure& addElements(const std::vector<DDElement>& elements);
 
    typedef dd::datamodel::StructType::Elements::const_iterator const_iterator;
 
    const_iterator cbegin() const
    {
        return _struct_type->getElements().cbegin();
    };
    const_iterator cend() const
    {
        return _struct_type->getElements().cend();
    }
    const_iterator begin() const
    {
        return _struct_type->getElements().begin();
    };
    const_iterator end() const
    {
        return _struct_type->getElements().end();
    }
    const dd::DataDefinition& getDD() const;
    const dd::StructType& getStructType() const;
 
    std::string getStructDescription() const;
    std::string getStructName() const;
 
    bool isCompatible(const DDStructure& other) const;
    bool isEqual(const DDStructure& other) const;
 
    size_t getSize() const;
 
    size_t getAlignment() const;
 
    void setStructInfo(const std::string& 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 = {});
    void setElementUnit(const std::string& element_name, const DDUnit& unit);
    void setElementUnit(const std::string& element_name, const dd::BaseUnit& base_unit);
 
private:
    template <typename T, bool align_with_padding>
    friend class DDStructureGenerator;
 
    void popLastElement();
 
    dd::DataDefinition _dd;
    std::shared_ptr<dd::StructType> _struct_type;
    dd::OptionalSize _initial_alignment = {};
};
 
namespace detail {
 
template <typename T, typename Enable = void>
struct arrayCount {
    static constexpr size_t value = 1;
};
 
template <typename T>
struct arrayCount<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);
};
 
template <typename T, typename MemberType>
size_t memberPointerToOffset(MemberType T::*member)
{
    T* start = 0;
    return reinterpret_cast<size_t>(&(start->*member));
}
 
} // 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>
    DDStructureGenerator& addElement(const std::string& name, MemberType T::*member_offset)
    {
        popAlignment();
        _structure
            .addElement<typename std::remove_pointer<typename std::decay<MemberType>::type>::type>(
                name,
                detail::arrayCount<MemberType>::value,
                *evaluateAlignment(
                    name, detail::memberPointerToOffset(member_offset), alignof(MemberType)));
        pushAlignment();
        return *this;
    }
 
    template <typename MemberType>
    DDStructureGenerator& addElement(const std::string& name,
                                     MemberType T::*member_offset,
                                     const DDEnum& enum_type)
    {
        popAlignment();
        _structure.addElement(name,
                              enum_type,
                              detail::arrayCount<MemberType>::value,
                              *evaluateAlignment(name,
                                                 detail::memberPointerToOffset(member_offset),
                                                 alignof(MemberType)));
        pushAlignment();
        return *this;
    }
    template <typename MemberType>
    DDStructureGenerator& addElement(const std::string& name,
                                     MemberType T::*member_offset,
                                     const DDStructure& struct_type)
    {
        popAlignment();
        _structure.addElement(name,
                              struct_type,
                              detail::arrayCount<MemberType>::value,
                              *evaluateAlignment(name,
                                                 detail::memberPointerToOffset(member_offset),
                                                 alignof(MemberType)));
        pushAlignment();
        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);
    }
 
private:
    void pushAlignment()
    {
        if (align_with_padding) {
            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 (align_with_padding) {
            if (_padded_final) {
                _structure.popLastElement();
                _padded_final = false;
            }
        }
    }
    void validate() const
    {
        constexpr auto padding_aligned = align_with_padding;
        if (!padding_aligned) {
            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 missed or misordered elements. ");
            }
        }
    }
 
    dd::OptionalSize evaluateAlignment(const std::string& element_name,
                                       size_t member_offset,
                                       size_t member_type_alignment)
    {
        // obtain the unaligned size
        auto struct_access = _structure.getDD().getStructTypeAccess(getStructName());
        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
        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
        size_t minimum_alignment = member_type_alignment;
        if (member_type_alignment > alignof(T)) {
            minimum_alignment = alignof(T);
        }
 
        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 (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 diffence 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 (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 (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;
        }
 
        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) + ")");
    }
 
    DDStructure _structure;
    bool _padded_final = false;
};
 
} // namespace ddl
 
#endif // DDSTRUCTURE_H_INCLUDED