datamodel_types.h

Go to the documentation of this file.

 
#ifndef DD_DATA_MODEL_TYPES_H_INCLUDED
#define DD_DATA_MODEL_TYPES_H_INCLUDED
 
#include <ddl/dd/datamodel/datamodel_base.h>
#include <ddl/dd/datamodel/datamodel_keyvalue.h>
#include <ddl/dd/dd_common_types.h>
#include <ddl/utilities/access_list.h>
#include <ddl/utilities/access_map.h>
#include <ddl/utilities/infomodel_base.h>
 
#include <string>
#include <vector>
 
namespace ddl {
 
namespace dd {
 
namespace datamodel {

class TypeBase {
public:
    TypeBase() = default;
    TypeBase(const TypeBase&) = default;
    TypeBase(TypeBase&&) = default;
    TypeBase& operator=(const TypeBase&) = default;
    TypeBase& operator=(TypeBase&&) = default;
    TypeBase(std::string name);
    virtual ~TypeBase() = default;

    virtual TypeOfType getTypeOfType() const = 0;
    virtual void setName(const std::string& name);
    const std::string& getName() const;
 
protected:
    std::string _name;
};

class DataType : public TypeBase,
                 public ModelSubject<DataType>,
                 public utility::TypeAccessMapSubject<DataType>,
                 public InfoMap {
public:
    DataType(){};
    DataType(const DataType&) = default;
    DataType(DataType&&) = default;
    DataType& operator=(const DataType&) = default;
    DataType& operator=(DataType&&) = default;
    DataType(std::string name,
             size_t bit_size,
             std::string description = {},
             OptionalSize array_size = {},
             std::string unit_name = {},
             std::string minimum_value = {},
             std::string maximum_value = {},
             OptionalSize default_type_alignment = {});

    DataType(const std::initializer_list<std::string>& initializer);
    virtual ~DataType() = default;
    bool operator==(const DataType& other) const;
    bool operator!=(const DataType& other) const;

    TypeOfType getTypeOfType() const override;
    void setName(const std::string& name) override;

    size_t getBitSize() const;
    void setBitSize(size_t size);

    OptionalSize getArraySize() const;
    void setArraySize(OptionalSize array_size);

    const std::string& getUnitName() const;
    void setUnitName(const std::string& unit_name);

    const std::string& getMin() const;
    void setMin(const std::string& minimum_value);

    const std::string& getMax() const;
    void setMax(const std::string& maximum_value);

    const std::string& getDescription() const;
    void setDescription(const std::string& description);

    const OptionalSize& getDefaultAlignment() const;
 
private:
    void notify(const std::string& additional_info);
    size_t _bit_size = 0;
    std::string _description = {};
    OptionalSize _array_size = {};
    std::string _unit_name = {};
    std::string _minimum_value = {};
    std::string _maximum_value = {};
    OptionalSize _default_type_alignment = {};
};

class EnumType : public TypeBase,
                 public ModelSubject<EnumType>,
                 public utility::TypeAccessMapSubject<EnumType>,
                 public InfoMap {
public: // types
    using Element = KeyValuePair;
    using Elements = utility::TypeAccessMap<Element, EnumType>;
    friend Elements;
 
public:
    EnumType() = delete;
    EnumType(EnumType&&);
    EnumType& operator=(EnumType&&);
    EnumType(const EnumType& other);
    EnumType& operator=(const EnumType& other);
    EnumType(const std::string& name,
             const std::string& data_type_name,
             const std::vector<Element>& elements = {});
    virtual ~EnumType() = default;
    bool operator==(const EnumType& other) const;
    bool operator!=(const EnumType& other) const;

    const Elements& getElements() const;
    Elements& getElements();

    TypeOfType getTypeOfType() const override;
    void setName(const std::string& name) override;

    const std::string& getDataTypeName() const;
    void setDataTypeName(const std::string& data_type_name);
 
private:
    void notify(ModelEventCode code,
                utility::TypeAccessMapEventCode forward_code,
                const std::string& additional_info);
    bool validateContains(const Elements::access_type& element_name) const;
    void notifyChangedMapContent(utility::TypeAccessMapEventCode code,
                                 Elements::access_type& element,
                                 const std::string& additional_info);
 
    std::string _data_type_name = {};
    Elements _elements;
};

class StructType : public TypeBase,
                   public ModelSubject<StructType>,
                   public utility::TypeAccessMapSubject<StructType>,
                   public InfoMap {
public:
    StructType() = delete;
    StructType(StructType&& other);
    StructType& operator=(StructType&& other);
    StructType(const StructType& other);
    StructType& operator=(const StructType& other);
    virtual ~StructType() = default;

    class SerializedInfo {
    public:
        SerializedInfo(){};
        SerializedInfo(const SerializedInfo&) = default;
        SerializedInfo(SerializedInfo&&) = default;
        SerializedInfo& operator=(const SerializedInfo&) = default;
        SerializedInfo& operator=(SerializedInfo&&) = default;
        virtual ~SerializedInfo() = default;

        SerializedInfo(OptionalSize byte_pos,
                       ByteOrder byte_order = ByteOrderDefault::getPlatformDefault(),
                       OptionalSize bit_pos = {},
                       OptionalSize num_bits = {});
        SerializedInfo(const std::initializer_list<size_t>& intializer);
        bool operator==(const SerializedInfo& other) const;

        OptionalSize getBytePos() const;
        void setBytePos(OptionalSize byte_pos, bool prevent_notification = false);

        OptionalSize getBitPos() const;
        void setBitPos(OptionalSize bit_pos, bool prevent_notification = false);

        OptionalSize getNumBits() const;
        void setNumBits(OptionalSize num_bits);

        ByteOrder getByteOrder() const;
        void setByteOrder(ByteOrder byte_order);
 
    protected:
        virtual void notifyChangeSerialized(const std::string&){};
 
    private:
        OptionalSize _byte_pos = {};
        OptionalSize _bit_pos = {};
        OptionalSize _num_bits = {};
        ByteOrder _byte_order = e_le;
    };

    class DeserializedInfo {
    public:
        DeserializedInfo(){};
        DeserializedInfo(const DeserializedInfo&) = default;
        DeserializedInfo(DeserializedInfo&&) = default;
        DeserializedInfo& operator=(const DeserializedInfo&) = default;
        DeserializedInfo& operator=(DeserializedInfo&&) = default;
        virtual ~DeserializedInfo() = default;

        DeserializedInfo(size_t alignment);
        DeserializedInfo(const std::initializer_list<size_t>& intializer);

        bool operator==(const DeserializedInfo& other) const;

        virtual size_t getAlignment() const;
        void setAlignment(size_t alignment);
 
    protected:
        virtual void notifyChangeDeserialized(const std::string&){};
 
    private:
        size_t _alignment = Alignment::e_invalid;
    };

    class Element : public SerializedInfo,
                    public DeserializedInfo,
                    public utility::TypeAccessListSubject<Element>,
                    public InfoMap {
    public:
        Element();
        Element(const Element& other);
        Element(Element&& other);
        Element& operator=(const Element& other);
        Element& operator=(Element&& other) noexcept;

        Element(std::string name,
                std::string type_name,
                DeserializedInfo deserialized_info,
                SerializedInfo serialized_info,
                dd::ArraySize array_size = {},
                std::string description = {},
                std::string comment = {},
                std::string unit_name = {},
                std::string value = {},
                std::string minimum_value = {},
                std::string maximum_value = {},
                std::string default_value = {},
                std::string scale = {},
                std::string offset = {});

        Element(std::string name,
                std::string type_name,
                DeserializedInfo deserialized_info,
                SerializedInfo serialized_info,
                dd::ArraySize array_size,
                std::string description,
                std::string comment,
                std::string unit_name,
                std::string value,
                std::string minimum_value,
                std::string maximum_value,
                std::string default_value,
                std::string scale,
                std::string offset,
                std::string valid_element_count);

        bool operator==(const Element& other) const;
        bool operator!=(const Element& other) const;

        const std::string& getName() const;
        void setName(const std::string& name);

        const std::string& getTypeName() const;
        void setTypeName(const std::string& type_name);

        const std::string& getDescription() const;
        void setDescription(const std::string& description);

        const std::string& getComment() const;
        void setComment(const std::string& comment);

        const ArraySize& getArraySize() const;
        void setArraySize(const ArraySize& array_size);

        const std::string& getValidElementCount() const;
        void setValidElementCount(const std::string& valid_element_count);

        const std::string& getUnitName() const;
        void setUnitName(const std::string& unit_name);

        const std::string& getValue() const;
        void setValue(const std::string& value);

        const std::string& getMin() const;
        void setMin(const std::string& minimum_value);

        const std::string& getMax() const;
        void setMax(const std::string& maximum_value);

        const std::string& getDefault() const;
        void setDefault(const std::string& default_value);

        const std::string& getScale() const;
        void setScale(const std::string& scale);

        const std::string& getOffset() const;
        void setOffset(const std::string& offset);
 
    private:
        void notifyChangeSerialized(const std::string& additional_info) override;
        void notifyChangeDeserialized(const std::string& additional_info) override;
 
    private:
        std::string _name;
        std::string _type_name;
        std::string _description;
        std::string _unit_name;
        std::string _comment;
        ArraySize _array_size = 1;
        std::string _value;
        std::string _minimum_value;
        std::string _maximum_value;
        std::string _default_value;
        std::string _scale;
        std::string _offset;
    };

    StructType(const std::string& name,
               const std::string& struct_version = "1",
               OptionalSize alignment = {},
               const std::string& comment = {},
               dd::Version ddl_version = dd::Version(0, 0),
               const std::vector<Element>& elements = {});
    bool operator==(const StructType& other) const;
    bool operator!=(const StructType& other) const;

    TypeOfType getTypeOfType() const override;
    void setName(const std::string& name) override;

    OptionalSize getAlignment() const;
    void setAlignment(OptionalSize alignment);

    const std::string& getComment() const;
    void setComment(const std::string& comment);

    const std::string& getVersion() const;
    void setVersion(const std::string& struct_version);

    Version getLanguageVersion() const;
    void setLanguageVersion(const Version& ddl_version);
 
public:
    using Elements = utility::TypeAccessList<Element, StructType>;
    friend Elements;

    const Elements& getElements() const;
    Elements& getElements();
 
private:
    void notify(ModelEventCode code,
                utility::TypeAccessMapEventCode map_code,
                const std::string& additional_info);
    bool validateContains(const Elements::access_type& element_name) const;
    void notifyChangedListContent(utility::TypeAccessListEventCode code,
                                  Elements::access_type& element,
                                  const std::string& additional_info);
    [[deprecated]]
    const Elements::container_named_type* getNamedItemList() const;
    [[deprecated]]
    Elements::container_named_type* getNamedItemList();
 
    const Elements::container_named_type* getNamedItemViewList() const;
    Elements::container_named_type* getNamedItemViewList();
 
    std::string _struct_version;
    dd::Version _ddl_version;
    std::string _comment;
    OptionalSize _alignment = Alignment::e1;
    Elements _elements;
};

class StreamMetaType : public TypeBase,
                       public ModelSubject<StreamMetaType>,
                       public utility::TypeAccessMapSubject<StreamMetaType>,
                       public InfoMap {
public: // types
    using Property = KeyValuePair;
    using Properties = utility::TypeAccessMap<Property, StreamMetaType>;
    friend Properties;
 
public:
    StreamMetaType() = delete;
    StreamMetaType(StreamMetaType&&);
    StreamMetaType& operator=(StreamMetaType&&);
    StreamMetaType(const StreamMetaType& other);
    StreamMetaType& operator=(const StreamMetaType& other);
    StreamMetaType(std::string name,
                   std::string version,
                   std::string parent = {},
                   const std::vector<Property>& properties = {});
    virtual ~StreamMetaType() = default;
    bool operator==(const StreamMetaType& other) const;
    bool operator!=(const StreamMetaType& other) const;

    const Properties& getProperties() const;
    Properties& getProperties();

    TypeOfType getTypeOfType() const override;
    void setName(const std::string& name) override;

    const std::string& getParent() const;
    void setParent(const std::string& parent);

    const std::string& getVersion() const;
    void setVersion(const std::string& version);
 
private:
    void notify(ModelEventCode code,
                utility::TypeAccessMapEventCode forward_code,
                const std::string& additional_info);
    bool validateContains(const Properties::access_type& prop) const;
    void notifyChangedMapContent(utility::TypeAccessMapEventCode code,
                                 Properties::access_type& element,
                                 const std::string& additional_info);
 
    std::string _version = {};
    std::string _parent = {};
    Properties _properties;
};

struct ElementType {
    TypeOfType _type_of_type = invalid_type;
    std::shared_ptr<datamodel::DataType> _data_type = {};
    std::shared_ptr<datamodel::EnumType> _enum_type = {};
    std::shared_ptr<datamodel::StructType> _struct_type = {};
};
 
} // namespace datamodel
} // namespace dd
} // namespace ddl
 
namespace ddl::dd::utility::detail
{
    template<> struct TypeValidationInfo<ddl::dd::datamodel::DataType> {
        static constexpr auto _other_types = "enumtype, structtype or streammetatype";
        static std::string getDifference(const ddl::dd::datamodel::DataType& left, const ddl::dd::datamodel::DataType& right);
    };

    template<> struct TypeValidationInfo<ddl::dd::datamodel::EnumType> {
        static constexpr auto _other_types = "datatype, streammetatype or structtype";
        static std::string getDifference(const ddl::dd::datamodel::EnumType& left, const ddl::dd::datamodel::EnumType& right);
    };

    template<> struct TypeValidationInfo<ddl::dd::datamodel::StructType> {
        static constexpr auto _other_types = "datatype, enumtype or streammetatype";
        static std::string getDifference(const ddl::dd::datamodel::StructType& left, const ddl::dd::datamodel::StructType& right);
    };

    template<> struct TypeValidationInfo<ddl::dd::datamodel::StructType::Element> {
        static constexpr auto _other_types = "";
        static std::string getDifference(const ddl::dd::datamodel::StructType::Element& left, const ddl::dd::datamodel::StructType::Element& right);
    };
}
 
#endif // DD_DATA_MODEL_TYPES_H_INCLUDED