datamodel_datadefinition.h

Go to the documentation of this file.

 
#ifndef DD_DATA_MODEL_H_INCLUDED
#define DD_DATA_MODEL_H_INCLUDED
 
#include <ddl/datamodel/datamodel_base.h>
#include <ddl/datamodel/datamodel_header.h>
#include <ddl/datamodel/datamodel_streams.h>
#include <ddl/datamodel/datamodel_types.h>
#include <ddl/datamodel/datamodel_units.h>
#include <ddl/datamodel/infomodel_base.h>
#include <ddl/dd/dd_common_types.h>
#include <ddl/utilities/dd_access_map.h>
 
#include <string>
#include <vector>
 
namespace ddl {
 
namespace dd {
 
namespace datamodel {
 
class DataDefinition : public ModelSubject<Header>,
                       private ModelObserver<Header>,
                       public ModelSubject<BaseUnit>,
                       public ModelSubject<UnitPrefix>,
                       public ModelSubject<Unit>,
                       public ModelSubject<DataType>,
                       public ModelSubject<EnumType>,
                       public ModelSubject<StructType>,
                       public ModelSubject<StreamMetaType>,
                       public ModelSubject<Stream>,
                       public InfoMap {
public:
    DataDefinition();
    DataDefinition(const dd::Version& ddl_version);
 
    DataDefinition(DataDefinition&&);
    DataDefinition& operator=(DataDefinition&&);
 
    DataDefinition(const DataDefinition& other);
    DataDefinition& operator=(const DataDefinition& other);
 
    virtual ~DataDefinition() = default;
 
public:
    using BaseUnits = utility::TypeAccessMap<BaseUnit, DataDefinition>;
    using UnitPrefixes = utility::TypeAccessMap<UnitPrefix, DataDefinition>;
    using Units = utility::TypeAccessMap<Unit, DataDefinition>;
    using DataTypes = utility::TypeAccessMap<DataType, DataDefinition>;
    using EnumTypes = utility::TypeAccessMap<EnumType, DataDefinition>;
    using StructTypes = utility::TypeAccessMap<StructType, DataDefinition>;
    using StreamMetaTypes = utility::TypeAccessMap<StreamMetaType, DataDefinition>;
    using Streams = utility::TypeAccessMap<Stream, DataDefinition>;
    friend BaseUnits;
    friend UnitPrefixes;
    friend Units;
    friend DataTypes;
    friend EnumTypes;
    friend StructTypes;
    friend StreamMetaTypes;
    friend Streams;
 
    void setVersion(const dd::Version& ddl_version);
    Version getVersion() const;
 
    std::shared_ptr<const Header> getHeader() const;
    std::shared_ptr<Header> getHeader();
    void setHeader(const Header& header);
 
    const BaseUnits& getBaseUnits() const;
    BaseUnits& getBaseUnits();
 
    const UnitPrefixes& getUnitPrefixes() const;
    UnitPrefixes& getUnitPrefixes();
 
    const Units& getUnits() const;
    Units& getUnits();
 
    const DataTypes& getDataTypes() const;
    DataTypes& getDataTypes();
 
    const EnumTypes& getEnumTypes() const;
    EnumTypes& getEnumTypes();
 
    const StructTypes& getStructTypes() const;
    StructTypes& getStructTypes();
 
    const StreamMetaTypes& getStreamMetaTypes() const;
    StreamMetaTypes& getStreamMetaTypes();
 
    const Streams& getStreams() const;
    Streams& getStreams();
 
    bool containsType(const std::string& type_name) const;
    TypeOfType getTypeOfType(const std::string& type_name) const;
 
    bool containsUnit(const std::string& unit_name) const;
    TypeOfUnit getTypeOfUnit(const std::string& unit_name) const;
 
    bool isEmpty() const;
 
private:
    bool validateContains(const BaseUnits::access_type& base_unit) const;
    bool validateContains(const UnitPrefixes::access_type& unit_prefix) const;
    bool validateContains(const Units::access_type& unit) const;
    bool validateContains(const DataTypes::access_type& data_type) const;
    bool validateContains(const EnumTypes::access_type& enum_type) const;
    bool validateContains(const StructTypes::access_type& struct_type) const;
    bool validateContains(const StreamMetaTypes::access_type& stream_meta_type) const;
    bool validateContains(const Streams::access_type& stream) const;
 
    void notifyChangedMapContent(utility::TypeAccessMapEventCode code,
                                 BaseUnits::access_type& base_unit,
                                 const std::string& additional_info);
    void notifyChangedMapContent(utility::TypeAccessMapEventCode code,
                                 UnitPrefixes::access_type& unit_prefix,
                                 const std::string& additional_info);
    void notifyChangedMapContent(utility::TypeAccessMapEventCode code,
                                 Units::access_type& unit,
                                 const std::string& additional_info);
    void notifyChangedMapContent(utility::TypeAccessMapEventCode code,
                                 DataTypes::access_type& data_type,
                                 const std::string& additional_info);
    void notifyChangedMapContent(utility::TypeAccessMapEventCode code,
                                 EnumTypes::access_type& enum_type,
                                 const std::string& additional_info);
    void notifyChangedMapContent(utility::TypeAccessMapEventCode code,
                                 StructTypes::access_type& struct_type,
                                 const std::string& additional_info);
    void notifyChangedMapContent(utility::TypeAccessMapEventCode code,
                                 StreamMetaTypes::access_type& struct_type,
                                 const std::string& additional_info);
    void notifyChangedMapContent(utility::TypeAccessMapEventCode code,
                                 Streams::access_type& stream,
                                 const std::string& additional_info);
 
    void modelChanged(datamodel::ModelEventCode event_code,
                      datamodel::Header& changed_subject,
                      const std::string& additional_info) override;
 
    std::shared_ptr<Header> _header;
    BaseUnits _base_units;
    UnitPrefixes _unit_prefixes;
    Units _units;
    DataTypes _data_types;
    EnumTypes _enum_types;
    StructTypes _struct_types;
    StreamMetaTypes _stream_meta_types;
    Streams _streams;
    bool _empty_model;
};
 
} // namespace datamodel
} // namespace dd
} // namespace ddl
 
#endif // DD_DATA_MODEL_H_INCLUDED