map_configuration.h

Go to the documentation of this file.

 
#ifndef HEADER_MAP_CONFIGURATION_H
#define HEADER_MAP_CONFIGURATION_H
 
#include <ddl/dd/dd.h>
#include <ddl/mapping/legacy/configuration/map_assignment.h>
#include <ddl/mapping/legacy/configuration/map_header.h>
#include <ddl/mapping/legacy/configuration/map_source.h>
#include <ddl/mapping/legacy/configuration/map_target.h>
#include <ddl/mapping/legacy/configuration/map_transformation.h>
#include <ddl/mapping/legacy/configuration/map_trigger.h>
 
#include <vector>
 
namespace ddl {
namespace mapping {
 
typedef std::vector<std::string> MapErrorList;
class MapConfiguration {
public: // methods
    enum MapConfigFlags {
        // replace the existing configuration
        mc_load_mapping = 0x1 << 0,
 
        // merge any new configuration into the current one
        // (error on conflicting configuration)
        mc_merge_mapping = 0x1 << 1
    };

    MapConfiguration();

    MapConfiguration(const ddl::dd::DataDefinition& ddl);
 
private:
    MapConfiguration(
        const std::shared_ptr<const ddl::dd::datamodel::DataDefinition>& ddl_datamodel);
 
public:
    ~MapConfiguration();

    MapConfiguration(const MapConfiguration& other);

    MapConfiguration& operator=(const MapConfiguration& other);

    MapConfiguration(MapConfiguration&& other);

    MapConfiguration& operator=(MapConfiguration&& other);

    a_util::result::Result setDD(const ddl::dd::DataDefinition& dd);

    a_util::result::Result resetDD();

    a_util::result::Result setDDWithoutConsistency(const ddl::dd::DataDefinition& ddl);

    a_util::result::Result modifyDD(const ddl::dd::DataDefinition& ddl);

    std::shared_ptr<const ddl::dd::datamodel::DataDefinition> getDD() const;

    void reset();

    a_util::result::Result loadFromFile(const std::string& file_path,
                                        uint32_t flags = mc_load_mapping);

    a_util::result::Result loadFromDOM(a_util::xml::DOM& dom, uint32_t flags = mc_load_mapping);

    a_util::result::Result loadFromDOMWithoutDDLConsistency(a_util::xml::DOM& dom,
                                                            uint32_t flags = mc_load_mapping);

    a_util::result::Result loadPartiallyFromFile(const std::string& file_path,
                                                 uint32_t flags = mc_load_mapping);

    a_util::result::Result loadPartiallyFromDOM(a_util::xml::DOM& dom,
                                                uint32_t flags = mc_load_mapping);

    a_util::result::Result writeToFile(const std::string& file_path);

    a_util::result::Result writeToDOM(a_util::xml::DOM& dom);

    const MapHeader& getHeader() const;

    a_util::result::Result setHeaderDescription(const std::string& desc);

    a_util::result::Result setHeaderDDPaths(const std::string& ddl_path);

    const std::string& getHeaderDDPaths() const;

    const MapTransformationList& getTransformationList() const;

    const MapTransformationBase* getTransformation(const std::string& transformation_name) const;

    MapTransformationBase* getTransformation(const std::string& transformation_name);

    a_util::result::Result addTransformation(const std::string& transformation_name,
                                             const std::string& transformation_type);

    a_util::result::Result removeTransformation(const std::string& transformation_name);

    const MapSource* getSource(const std::string& source_name) const;

    MapSource* getSource(const std::string& source_name);

    const MapSourceList& getSourceList() const;

    a_util::result::Result addSource(const std::string& name, const std::string& type);

    a_util::result::Result removeSource(const std::string& name);

    const MapTarget* getTarget(const std::string& target_name) const;

    MapTarget* getTarget(const std::string& target_name);

    a_util::result::Result addTarget(const std::string& name, const std::string& type);

    a_util::result::Result removeTarget(const std::string& name);

    const MapTargetList& getTargetList() const;

    const MapErrorList& getErrorList() const;

    a_util::result::Result resetErrors();

    void appendError(const std::string& error_string) const;

    bool isConsistencyChecked();

    bool isConsistent();

    a_util::result::Result checkDDLConsistency();
 
private:
    void swap(MapConfiguration& other);

    void repairConfigReferences(MapConfiguration& config);

    static a_util::result::Result loadMappingFromDOM(a_util::xml::DOM& dom,
                                                     MapConfiguration& tmp_config);

    a_util::result::Result addTarget(const MapTarget& target);

    a_util::result::Result addSource(const MapSource& source);

    a_util::result::Result checkMappingConsistency();

    a_util::result::Result merge(const MapConfiguration& other);

    const ddl::dd::StructElementAccess findTypeObject(const std::string& struct_name,
                                                      const std::string& path) const;

    a_util::result::Result checkSignalName(const std::string& name) const;

    a_util::result::Result checkSignalType(const std::string& type) const;

    a_util::result::Result checkAssignmentReferences(const MapAssignment& assignment) const;

    a_util::result::Result checkAssignmentType(const std::string& signal_name,
                                               const ddl::dd::datamodel::StructType& signal_struct,
                                               const MapAssignment& assignment) const;

    a_util::result::Result checkTriggerType(const MapTriggerBase* trigger) const;
 
private:
    friend class MapSource;
    friend class MapTarget;
    friend class MapTriggerBase;
    friend class MapDataTrigger;
    MapHeader _header;
    MapSourceList _sources;
    MapTargetList _targets;
    MapTransformationList _transforms;
    // mutable because its not part of the object state
    mutable MapErrorList _errors;
    std::shared_ptr<const ddl::dd::datamodel::DataDefinition> _ddl_ref;
    bool _checked_for_consistency;
    bool _is_consistent;
};
 
} // namespace mapping
} // namespace ddl
 
#endif // HEADER_MAP_CONFIGURATION_H