datamodel_configuration_items.h

Go to the documentation of this file.

 
#ifndef MAPPING_CONFIGURATION_DATA_MODEL_ITEMS_HEADER
#define MAPPING_CONFIGURATION_DATA_MODEL_ITEMS_HEADER
 
#include <ddl/mapping/datamodel/datamodel_base.h>
#include <ddl/mapping/mapping_configuration_types.h>
#include <ddl/utilities/access_list.h>
#include <ddl/utilities/access_map.h>
#include <ddl/utilities/access_vector.h>
#include <ddl/utilities/infomodel_base.h>
 
#include <string>
 
namespace ddl {
namespace mapping {
namespace datamodel {

class Header : public ModelSubject<Header>, public InfoMap {
public:
    Header() = delete;
    Header(const Header& other);
    Header(Header&& other);
    Header(const Version& mapping_version,
           const std::string& author = {},
           const std::string& date_creation = {},
           const std::string& date_change = {},
           const std::string& description = {});
    ~Header();

    Header& operator=(const Header& other);
    Header& operator=(Header&& other);

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

    Version getMappingVersion() const;
    void setMappingVersion(const Version& mapping_version);

    const std::string& getAuthor() const;
    void setAuthor(const std::string& author);

    const std::string& getDateCreation() const;
    void setDateCreation(const std::string& date_creation);

    const std::string& getDateChange() const;
    void setDateChange(const std::string& date_change);

    const std::string& getDescription() const;
    void setDescription(const std::string& description);
 
private:
    // for internal use
    class HeaderImpl;
    std::unique_ptr<HeaderImpl> _impl;
};

class Property : public ddl::utility::TypeAccessMapSubject<Property>, public InfoMap {
public:
    Property() = delete;
    Property(const Property& other);
    Property(Property&& other);
    Property(const std::string& name, const std::string& value);
    ~Property();

    Property& operator=(const Property& other);
    Property& operator=(Property&& other);

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

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

    const std::string& getValue() const;
    void setValue(const std::string& value);
 
private:
    // for internal use
    class PropertyImpl;
    std::unique_ptr<PropertyImpl> _impl;
};

class Source : public ddl::utility::TypeAccessMapSubject<Source>, public InfoMap {
public:
    Source() = delete;
    Source(const Source& other);
    Source(Source&& other);
    Source(const std::string& name,
           const std::string& type,
           const std::vector<Property>& properties = {});
    ~Source();

    Source& operator=(const Source& other);
    Source& operator=(Source&& other);

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

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

    const std::string& getType() const;
    void setType(const std::string& type);

    using Properties = ddl::utility::TypeAccessMap<Property, Source>;
    friend Properties;

    const Properties& getProperties() const;
    Properties& getProperties();
 
private:
    // for internal use
    bool validateContains(const Properties::access_type& prop) const;
    void notifyChangedMapContent(ddl::utility::TypeAccessMapEventCode code,
                                 Properties::access_type& prop,
                                 const std::string& additional_info);
    class SourceImpl;
    std::unique_ptr<SourceImpl> _impl;
};

class Trigger : public ddl::utility::TypeAccessVectorSubject<Trigger>, public InfoMap {
public:
    enum class Type {
        source,
        data,
        period
    };

    struct Source {
        std::string source_name;
    };

    struct Data {
        std::string source_name;
        std::string source_value_name;
        std::string operation;
        std::string value;
    };

    struct Period {
        std::string time;
        std::string unit;
    };

    Trigger() = delete;
    Trigger(const Trigger& other);
    Trigger(Trigger&& other);
    Trigger(const Source& source);
    Trigger(const Data& data);
    Trigger(const Period& period);
    ~Trigger();

    Trigger& operator=(const Trigger& other);
    Trigger& operator=(Trigger&& other);

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

    Type getType() const;

    Source getSource() const;
    void setAsSource(const Source& source);

    Data getData() const;
    void setAsData(const Data& data);

    Period getPeriod() const;
    void setAsPeriod(const Period& period);

    static constexpr auto strategy_trigger = "trigger";
    static constexpr auto strategy_first_in_config = "first_in_config";
    static constexpr auto strategy_latest = "latest";
    static constexpr auto strategy_earliest = "earliest";

    const std::string& getTimeStrategy() const;
    void setTimeStrategy(const std::string& time_strategy);
 
private:
    // for internal use
    class TriggerImpl;
    std::unique_ptr<TriggerImpl> _impl;
};

bool operator==(const Trigger::Source& left, const Trigger::Source& right);
bool operator!=(const Trigger::Source& left, const Trigger::Source& right);
bool operator==(const Trigger::Data& left, const Trigger::Data& right);
bool operator!=(const Trigger::Data& left, const Trigger::Data& right);
bool operator==(const Trigger::Period& left, const Trigger::Period& right);
bool operator!=(const Trigger::Period& left, const Trigger::Period& right);

class ParameterValue : public ddl::utility::TypeAccessListSubject<ParameterValue>, public InfoMap {
public:
    enum class Type {
        source_value,
        const_value,
        internal_value
    };

    struct SourceValue {
        std::string name;
        std::string value_name;
    };

    struct ConstValue {
        std::string value;
    };

    struct InternalValue {
        std::string name;
        std::string value_name;
    };

    ParameterValue() = delete;
    ParameterValue(const ParameterValue& other);
    ParameterValue(ParameterValue&& other);
    ParameterValue(const std::string& name, const SourceValue& source_value);
    ParameterValue(const std::string& name, const ConstValue& const_value);

    ParameterValue(const std::string& name, const InternalValue& internal_value);
    ~ParameterValue();

    ParameterValue& operator=(const ParameterValue& other);
    ParameterValue& operator=(ParameterValue&& other);

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

    Type getType() const;

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

    SourceValue getSourceValue() const;
    void setAsSourceValue(const SourceValue& source_value);

    ConstValue getConstValue() const;
    void setAsConstValue(const ConstValue& const_value);

    InternalValue getInternalValue() const;
    void setAsInternalValue(const InternalValue& internal_value);
 
private:
    // for internal use
    class ParameterValueImpl;
    std::unique_ptr<ParameterValueImpl> _impl;
};

bool operator==(const ParameterValue::SourceValue& left, const ParameterValue::SourceValue& right);
bool operator!=(const ParameterValue::SourceValue& left, const ParameterValue::SourceValue& right);
bool operator==(const ParameterValue::ConstValue& left, const ParameterValue::ConstValue& right);
bool operator!=(const ParameterValue::ConstValue& left, const ParameterValue::ConstValue& right);

bool operator==(const ParameterValue::InternalValue& left,
                const ParameterValue::InternalValue& right);
bool operator!=(const ParameterValue::InternalValue& left,
                const ParameterValue::InternalValue& right);

class Assignment : public ddl::utility::TypeAccessListSubject<Assignment>, public InfoMap {
public:
    enum class Type {
        source_value,
        const_value,
        function_call
    };

    using SourceValue = ParameterValue::SourceValue;
    using ConstValue = ParameterValue::ConstValue;
    struct FunctionCall {
        std::string function_name;
    };

    Assignment() = delete;
    Assignment(const Assignment& other);
    Assignment(Assignment&& other);
    Assignment(const std::string& to_target_value_name, const SourceValue& from_source_value);
    Assignment(const std::string& to_target_value_name, const ConstValue& from_const_value);
    Assignment(const std::string& to_target_value_name,
               const FunctionCall& from_module_call,
               const std::vector<ParameterValue>& parameter_values = {});
    ~Assignment();

    Assignment& operator=(const Assignment& other);
    Assignment& operator=(Assignment&& other);

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

    Type getType() const;

    const std::string& getTo() const;
    const std::string& getName() const;
    void setTo(const std::string& to);

    SourceValue getSourceValue() const;
    void setAsSourceValue(const SourceValue& source_value);

    ConstValue getConstValue() const;
    void setAsConstValue(const ConstValue& const_value);

    FunctionCall getFunctionCall() const;
    void setAsFunctionCall(const FunctionCall& function_call);
    void setAsFunctionCall(const FunctionCall& module_call,
                           const std::vector<ParameterValue>& parameter_values);

    using ParameterValues = ddl::utility::TypeAccessList<ParameterValue, Assignment>;
    friend ParameterValues;

    const ParameterValues& getParameterValues() const;
    ParameterValues& getParameterValues();
 
private:
    // for internal use
    void notify(ddl::utility::TypeAccessListEventCode code_forward,
                const std::string& additional_info);
 
    bool validateContains(const ParameterValues::access_type& prop) const;
    void notifyChangedListContent(ddl::utility::TypeAccessListEventCode code,
                                  ParameterValues::access_type& parameter_value,
                                  const std::string& additional_info);
 
    class AssignmentImpl;
    std::unique_ptr<AssignmentImpl> _impl;
};

bool operator==(const Assignment::FunctionCall& left, const Assignment::FunctionCall& right);
bool operator!=(const Assignment::FunctionCall& left, const Assignment::FunctionCall& right);

class Target : public ddl::utility::TypeAccessMapSubject<Target>, public InfoMap {
public:
    Target() = delete;
    Target(const Target& other);
    Target(Target&& other);
    Target(const std::string& name,
           const std::string& type,
           const std::vector<Property>& properties = {});
    ~Target();

    Target& operator=(const Target& other);
    Target& operator=(Target&& other);

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

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

    const std::string& getType() const;
    void setType(const std::string& type);

    using Properties = ddl::utility::TypeAccessMap<Property, Target>;
    friend Properties;

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

    using Triggers = ddl::utility::TypeAccessVector<Trigger, Target>;
    friend Triggers;

    const Triggers& getTriggers() const;
    Triggers& getTriggers();

    using Assignments = ddl::utility::TypeAccessList<Assignment, Target>;
    friend Assignments;

    const Assignments& getAssignments() const;
    Assignments& getAssignments();
 
private:
    // for internal use
    bool validateContains(const Properties::access_type& prop) const;
    void notifyChangedMapContent(ddl::utility::TypeAccessMapEventCode code,
                                 Properties::access_type& prop,
                                 const std::string& additional_info);
    bool validateContains(const Triggers::access_type& prop) const;
    void notifyChangedVectorContent(ddl::utility::TypeAccessVectorEventCode code,
                                    Triggers::access_type& trigger,
                                    const std::string& additional_info);
 
    bool validateContains(const Assignments::access_type& prop) const;
    void notifyChangedListContent(ddl::utility::TypeAccessListEventCode code,
                                  Assignments::access_type& assignment,
                                  const std::string& additional_info);
    class TargetImpl;
    std::unique_ptr<TargetImpl> _impl;
};

class Function : public ddl::utility::TypeAccessMapSubject<Function>, public InfoMap {
public:
    Function() = delete;
    Function(const Function& other);
    Function(Function&& other);
    Function(const std::string& name,
             const std::string& type,
             const std::vector<Property>& properties = {});
    ~Function();

    Function& operator=(const Function& other);
    Function& operator=(Function&& other);

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

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

    const std::string& getType() const;
    void setType(const std::string& type);

    using Properties = ddl::utility::TypeAccessMap<Property, Function>;
    friend Properties;

    const Properties& getProperties() const;
    Properties& getProperties();
 
private:
    // for internal use
    bool validateContains(const Properties::access_type& prop) const;
    void notifyChangedMapContent(ddl::utility::TypeAccessMapEventCode code,
                                 Properties::access_type& prop,
                                 const std::string& additional_info);
    class FunctionImpl;
    std::unique_ptr<FunctionImpl> _impl;
};
 
} // namespace datamodel
} // namespace mapping
} // namespace ddl
 
#endif // MAPPING_CONFIGURATION_DATA_MODEL_ITEMS_HEADER