mapping_engine.h

Go to the documentation of this file.

 
#ifndef _MAPPING_ENGINE_HEADER
#define _MAPPING_ENGINE_HEADER
 
#include <ddl/mapping/mapper.h>
#include <ddl/mapping/mapping_configuration.h>
#include <ddl/mapping/functions/engine_function.h>
 
#include <optional>
#include <string_view>
 
namespace ddl {
namespace mapping {

class MapperFactories {
public:
    void add(std::shared_ptr<const SourceFactory> source_factory);
    void add(std::shared_ptr<const TargetFactory> target_factory);
    void add(std::shared_ptr<const FunctionFactory> function_factory);
    std::shared_ptr<Source> makeSource(const std::string& type,
                                       std::string name,
                                       Properties properties) const;
    std::shared_ptr<Target> makeTarget(const std::string& type,
                                       std::string name,
                                       Properties properties) const;
    std::shared_ptr<Function> makeFunction(const std::string& type,
                                           std::string name,
                                           Properties properties) const;

    const std::unordered_map<std::string, std::shared_ptr<const SourceFactory>>&
    getSourceFactories() const;
    const std::unordered_map<std::string, std::shared_ptr<const TargetFactory>>&
    getTargetFactories() const;
    const std::unordered_map<std::string, std::shared_ptr<const FunctionFactory>>&
    getFunctionFactories() const;
 
private:
    std::unordered_map<std::string, std::shared_ptr<const SourceFactory>> _source_factories;
    std::unordered_map<std::string, std::shared_ptr<const TargetFactory>> _target_factories;
    std::unordered_map<std::string, std::shared_ptr<const FunctionFactory>> _function_factories;
};

MapperFactories getDefaultMapperFactories();

class Engine {
public:
    Engine(MapperFactories mapper_factories);
    void create(const MappingConfiguration& configuration);
    void create(const std::string& mapping_file);
    void create(const MappingConfiguration& configuration, ddl::DataDefinition dd);
    void create(const std::string& mapping_file, const std::string& dd_file);

    static constexpr auto property_time_strategy = "time_strategy";
 
protected:
    virtual void addSource(std::shared_ptr<Source> /*source*/, std::shared_ptr<Updateable> /*trigger_update*/){};
    virtual void addTarget(std::shared_ptr<Target> /*target*/){};

    struct TargetTimeTrigger {
        std::chrono::nanoseconds _duration;
        std::shared_ptr<Target> _target;
        std::shared_ptr<AssignmentTrigger> _trigger;
        std::unordered_map<std::string, std::string> _additional_properties;
    };

    virtual void addTimeTrigger(TargetTimeTrigger /*time_trigger*/){};

    struct TargetSourceTrigger {
        std::shared_ptr<Source> _source;
        std::shared_ptr<Target> _target;
        std::shared_ptr<AssignmentTrigger> _trigger;
        std::unordered_map<std::string, std::string> _additional_properties;
    };

    virtual void addSourceTrigger(TargetSourceTrigger /*source_trigger*/){};

    struct TargetDataTrigger {
        std::string strValueName;
        std::string strOp;
        std::string strValue;
        std::shared_ptr<Source> _source;
        std::shared_ptr<Target> _target;
        std::shared_ptr<AssignmentTrigger> _trigger;
        std::unordered_map<std::string, std::string> _additional_properties;
    };

    virtual void addDataTrigger(TargetDataTrigger /*data_trigger*/){};
 
protected:
    std::unique_ptr<Mapper> _mapper;
    MapperFactories _factories;
    std::optional<ddl::DataDefinition> _global_dd;
};

class DefaultEngine final : public Engine {
public:
    DefaultEngine();
    DefaultEngine(MapperFactories factories);
    
    class ISourceTrigger {
    public:
        virtual ~ISourceTrigger() = default;
        virtual bool update(std::chrono::nanoseconds time,
                            std::shared_ptr<const Memory> memory) = 0;
    };

    class ITimeTrigger {
    public:
        virtual ~ITimeTrigger() = default;
        virtual bool update(std::chrono::nanoseconds time) = 0;
    };

    class ITargetTrigger {
    public: 
        virtual ~ITargetTrigger() = default;
        virtual std::shared_ptr<Memory> getMemory(size_t data_size) = 0;
        virtual void update(std::chrono::nanoseconds target_time) = 0;
    };

    std::shared_ptr<ISourceTrigger> getSourceTrigger(const std::string_view& source_name);
    std::shared_ptr<ITimeTrigger> getTimeTrigger();

    void registerForTarget(const std::string_view& target_name,
                           std::shared_ptr<ITargetTrigger> target_trigger);
    void reset();
 
private:
    void addSource(std::shared_ptr<Source> source, std::shared_ptr<Updateable> trigger_updateable) override;
    void addTarget(std::shared_ptr<Target> target) override;
    void addTimeTrigger(TargetTimeTrigger time_trigger) override;
    void addSourceTrigger(TargetSourceTrigger source_trigger) override;
    void addDataTrigger(TargetDataTrigger data_trigger) override;
 
private:
    std::shared_ptr<ITimeTrigger> _time_trigger;
    std::unordered_map<std::string, std::shared_ptr<ISourceTrigger>> _source_triggers;
    std::unordered_map<std::string, std::shared_ptr<AssignmentTrigger>> _target_triggers;
};
 
} // namespace mapping
} // namespace ddl
#endif // _MAPPING_ENGINE_HEADER