dd.h

Go to the documentation of this file.

 
#ifndef DD_DD_H_INCLUDED
#define DD_DD_H_INCLUDED
 
#include <ddl/dd/datamodel/datamodel_datadefinition.h>
#include <ddl/dd/dd_common_types.h>
#include <ddl/dd/infomodel/dd_infomodel_type.h>
#include <ddl/dd/dd_struct_access.h>
 
#include <string>
 
namespace ddl {
 
// forward declarations
class DDMerge;
 
namespace dd {

using Header = datamodel::Header;
using BaseUnit = datamodel::BaseUnit;
using UnitPrefix = datamodel::UnitPrefix;
using Unit = datamodel::Unit;
using DataType = datamodel::DataType;
using EnumType = datamodel::EnumType;
using StructType = datamodel::StructType;
using StreamMetaType = datamodel::StreamMetaType;
using Stream = datamodel::Stream;

class DataDefinition final : datamodel::ModelObserver<Header>,
                             datamodel::ModelObserver<BaseUnit>,
                             datamodel::ModelObserver<UnitPrefix>,
                             datamodel::ModelObserver<Unit>,
                             datamodel::ModelObserver<DataType>,
                             datamodel::ModelObserver<EnumType>,
                             datamodel::ModelObserver<StructType>,
                             datamodel::ModelObserver<StreamMetaType>,
                             datamodel::ModelObserver<Stream> {
public:
    DataDefinition();
    DataDefinition(Version ddl_version);
    DataDefinition(const DataDefinition& other);
    DataDefinition(DataDefinition&& other);
    DataDefinition& operator=(const DataDefinition& other);
    DataDefinition& operator=(DataDefinition&& other);
    DataDefinition(const std::shared_ptr<datamodel::DataDefinition>& datamodel);
    virtual ~DataDefinition();

    void setModel(const std::shared_ptr<datamodel::DataDefinition>& datamodel);
    std::shared_ptr<const datamodel::DataDefinition> getModel() const;
 
public:
    using BaseUnits = datamodel::DataDefinition::BaseUnits;
    using UnitPrefixes = datamodel::DataDefinition::UnitPrefixes;
    using Units = datamodel::DataDefinition::Units;
    using DataTypes = datamodel::DataDefinition::DataTypes;
    using EnumTypes = datamodel::DataDefinition::EnumTypes;
    using StructTypes = datamodel::DataDefinition::StructTypes;
    using StreamMetaTypes = datamodel::DataDefinition::StreamMetaTypes;
    using Streams = datamodel::DataDefinition::Streams;

    void setVersion(const Version& ddl_version);
    Version getVersion() const;

    void setHeader(const Header& header);
    const Header& getHeader() const;
    Header& getHeader();

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

    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;

    const StreamMetaTypes& getStreamMetaTypes() const;
    StreamMetaTypes& getStreamMetaTypes();

    const Streams& getStreams() const;
    Streams& getStreams();

    bool isValid(ValidationLevel level = ValidationLevel::valid) const;
    void validate(bool force_revalidation = false);
    std::vector<ddl::dd::Problem> getValidationProtocol() const;

    void calculatePositions(const std::string& type_name = {},
                            TypeOfType type_of_type = TypeOfType::invalid_type,
                            bool force_recalculation = false);
    StructTypeAccess getStructTypeAccess(const std::string& type_name) const;
 
    // merge/add
    void add(const BaseUnit& base_unit, const DataDefinition& source_dd);
    void add(const UnitPrefix& unit_prefix, const DataDefinition& source_dd);
    void add(const Unit& unit, const DataDefinition& source_dd);
    void add(const DataType& data_type, const DataDefinition& source_dd);
    void add(const EnumType& enum_type, const DataDefinition& source_dd);
    void add(const StructType& struct_type, const DataDefinition& source_dd);
    void add(const StreamMetaType& stream_meta_type, const DataDefinition& source_dd);
    void add(const Stream& stream, const DataDefinition& source_dd);
    void add(const DataDefinition& source_dd);
 
private:
    friend class ddl::DDMerge;
    std::shared_ptr<datamodel::DataDefinition> _datamodel;
    void attachToModel();
    void detachFromModel();
    void modelChanged(datamodel::ModelEventCode event_code,
                      datamodel::Header& changed_subject,
                      const std::string& additional_info) override;
    void modelChanged(datamodel::ModelEventCode event_code,
                      datamodel::BaseUnit& changed_subject,
                      const std::string& additional_info) override;
    void modelChanged(datamodel::ModelEventCode event_code,
                      datamodel::UnitPrefix& changed_subject,
                      const std::string& additional_info) override;
    void modelChanged(datamodel::ModelEventCode event_code,
                      datamodel::Unit& changed_subject,
                      const std::string& additional_info) override;
    void modelChanged(datamodel::ModelEventCode event_code,
                      datamodel::DataType& changed_subject,
                      const std::string& additional_info) override;
    void modelChanged(datamodel::ModelEventCode event_code,
                      datamodel::EnumType& changed_subject,
                      const std::string& additional_info) override;
    void modelChanged(datamodel::ModelEventCode event_code,
                      datamodel::StructType& changed_subject,
                      const std::string& additional_info) override;
    void modelChanged(datamodel::ModelEventCode event_code,
                      datamodel::StreamMetaType& changed_subject,
                      const std::string& additional_info) override;
    void modelChanged(datamodel::ModelEventCode event_code,
                      datamodel::Stream& changed_subject,
                      const std::string& additional_info) override;
 
    Version _last_known_ddl_version;
    // this member variable must stay there for ABI compatibility!
    // NOLINTNEXTLINE(clang-diagnostic-unused-private-field)
    ValidationLevel _dummy_validation_level = ValidationLevel::dont_know;
    std::unordered_map<std::string, std::string> _recursion_detection_stream_meta_types;
    std::unordered_map<std::string, std::string> _recursion_detection_struct;
};

bool addTypeByName(const std::string& type_name,
                   const DataDefinition& source_dd,
                   DataDefinition& destination_dd);
bool addStreamTypeByName(const std::string& stream_type_name,
                         const DataDefinition& source_dd,
                         DataDefinition& destination_dd);
bool addUnitByName(const std::string& unit_name,
                   const DataDefinition& source_dd,
                   DataDefinition& destination_dd);

std::vector<std::string> transformValidationProblemList(
    const std::vector<ddl::dd::Problem>& problems);

using DataDescription = dd::DataDefinition;
 
} // namespace dd
using dd::DataDefinition;
using dd::DataDescription;
} // namespace ddl
 
#endif // DD_DD_H_INCLUDED