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/dd/ddelement_ref.h>
#include <ddl/utilities/std_to_string.h>
 
#include <type_traits>
 
namespace ddl {

class DDElement;
class DDElementRef;

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);

    DDElementRef createElement(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);

    DDElementRef createElement(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);

    DDElementRef createElement(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);

    DDElementRef createElement(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>
    DDElementRef createElement(const std::string& element_name,
                               size_t array_size = 1,
                               const std::string& special_type_name = {})
    {
        if (special_type_name.empty()) {
            return createElement(element_name, DataType<PREDEF_DATA_TYPE>(), array_size);
        }
        else {
            return createElement(
                element_name, DataType<PREDEF_DATA_TYPE>(special_type_name), array_size);
        }
    }

    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;
    }

    template <typename PREDEF_DATA_TYPE>
    DDElementRef createElement(const std::string& element_name,
                               size_t array_size,
                               size_t alignment,
                               const std::string& special_type_name = {})
    {
        if (special_type_name.empty()) {
            return createElement(element_name, DataType<PREDEF_DATA_TYPE>(), array_size, alignment);
        }
        else {
            return createElement(
                element_name, DataType<PREDEF_DATA_TYPE>(special_type_name), array_size, alignment);
        }
    }

    DDStructure& addElement(const std::string& element_name,
                            const DDEnum& enum_type,
                            size_t array_size,
                            const std::string& constant_value = {});

    DDElementRef createElement(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 = {});

    DDElementRef createElement(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 = {});

    DDElementRef createElement(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);

    DDElementRef createElement(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);

    DDElementRef createElement(const std::string& element_name,
                               const DDStructure& struct_type,
                               size_t array_size,
                               size_t alignment);
    DDStructure& addElement(const DDElement& element);

    DDElementRef createElement(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);

    DDElementRef getElement(const std::string& element_name);
 
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 ddl
 
#endif // DDSTRUCTURE_H_INCLUDED