mapper_interfaces.h

Go to the documentation of this file.

 
#ifndef _MAPPING_INTERFACES_HEADER
#define _MAPPING_INTERFACES_HEADER
 
#include <chrono>
#include <functional>
#include <memory>
#include <stdexcept>
#include <unordered_map>
#include <variant>
#include <vector>
#include <optional>
#include <string>
 
namespace ddl {
namespace mapping {

using ValueVariant = std::variant<uint8_t,
                                  int8_t,
                                  uint16_t,
                                  int16_t,
                                  uint32_t,
                                  int32_t,
                                  uint64_t,
                                  int64_t,
                                  float,
                                  double,
                                  bool>;

template <typename T>
void getValueRef(const ValueVariant& value, T& value_reference)
{
    static_assert(std::is_arithmetic_v<T>,
                    "Only arithmetic types are supported to retrieve the value with getValue<T>");
    value_reference = std::visit([](auto&& variant_content) { return static_cast<T>(variant_content); }, value);
}

template <typename T>
T getValue(const ValueVariant& value)
{
    static_assert(std::is_arithmetic_v<T>,
                    "Only arithmetic types are supported to retrieve the value with getValue<T>");
    return std::visit([](auto&& variant_content) { return static_cast<T>(variant_content); }, value);
}

class SourceValue
{
public:
    virtual ~SourceValue() {};
};

class PlainSourceValue: public SourceValue {
public:
    virtual std::optional<ValueVariant> getValue() const = 0;

    template <typename T>
    void getValueRef(T& value_reference) const
    {
        if (const auto untyped_value = getValue())
        {
            ddl::mapping::getValueRef(*untyped_value, value_reference);
        }
    }
    
    template <typename T>
    void getValueOrDefaultRef(T& value_reference, T default_value) const
    {
        if (const auto untyped_value = getValue())
        {
            ddl::mapping::getValueRef(*untyped_value, value_reference);
        }
        else
        {
            value_reference = default_value;
        }
    }
    
    template <typename T>
    T getValueOrDefault(T default_value) const
    {
        T value;
        this->getValueOrDefaultRef<T>(value, default_value);
        return value;
    }

    template <typename T>
    T getValue() const
    {
        return this->getValueOrDefault(T{});
    }
};

class ArraySourceValue: public SourceValue {
public:
    virtual std::optional<ValueVariant> getValue(size_t array_pos) const = 0;

    virtual size_t getArraySize() const = 0;
};

class TargetValue {
public:
    virtual ~TargetValue(){};

    virtual void initialize(std::shared_ptr<const SourceValue> value_source) = 0;

    virtual void update() = 0;
};

class Property {
public:
    Property() = default;
    Property(const Property&) = default;
    Property(Property&&) = default;
    Property& operator=(const Property&) = default;
    Property& operator=(Property&&) = default;

    Property(std::string value, std::string type) : _value(std::move(value)), _type(std::move(type))
    {
    }

    template <
        typename T,
        std::enable_if_t<std::is_unsigned<T>::value && !std::is_same<T, bool>::value, bool> = true>
    Property(T value) : _value(std::to_string(value)), _type("unsigned")
    {
    }

    template <typename T,
              std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, bool> = true>
    Property(T value) : _value(std::to_string(value)), _type("signed")
    {
    }

    template <typename T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>
    Property(T value) : _value(std::to_string(value)), _type("float")
    {
    }

    template <typename T, std::enable_if_t<std::is_same<T, bool>::value, bool> = true>
    Property(T value) : _value((value ? "true" : "false")), _type("bool")
    {
    }

    Property(std::string_view string_value) : _value(std::string(string_value)), _type("string")
    {
    }

    const std::string& getValue() const
    {
        return _value;
    }
    
    const std::string& getType() const
    {
        return _type;
    }
 
private:
    std::string _value;
    std::string _type;
};

inline bool operator==(const Property& left, const Property& right)
{
    return left.getType() == right.getType() && left.getValue() == right.getValue();
}

using Properties = std::unordered_map<std::string, Property>;

inline Properties operator+(const Properties& properties_left, const Properties& properties_right)
{
    Properties result_properties(properties_left);
    for (const auto& current_right: properties_right) {
        result_properties.insert_or_assign(current_right.first, current_right.second);
    }
    return result_properties;
}

class MapperElement {
public:
    virtual ~MapperElement() = default;
    virtual const std::string& getName() const = 0;
    virtual const Properties& getProperties() const = 0;
};

class Updateable {
public:
    virtual void updateBegin(std::chrono::nanoseconds /* time */)
    {
    }

    virtual void updateEnd()
    {
    }

    virtual void reset()
    {
    }
};

class Source : public MapperElement {
public:
    virtual std::vector<std::string> getAllValues() const = 0;
    virtual std::shared_ptr<const SourceValue> getValue(
        const std::string& value_name) const = 0;
};

class Memory {
public:
    virtual ~Memory() = default;
    virtual const void* getPtr() const = 0;
    virtual void* getPtr() = 0;
    virtual size_t getSize() const = 0;
};

class MemorySource : public Source {
public:
    ~MemorySource() override = default;

    virtual size_t getExpectedDataSize() const = 0;
    virtual void updateMemory(std::shared_ptr<const Memory> memory) = 0;
};

class MapperFactory {
public:
    virtual ~MapperFactory() = default;
    virtual std::string getType() const = 0;
    virtual Properties getDefaultProperties() const = 0;
};

template<typename ElementType>
class SpecificMapperFactory: public MapperFactory
{
public:
    virtual std::shared_ptr<ElementType> make(std::string name, Properties properties) const = 0;
};

using SourceFactory = SpecificMapperFactory<Source>;

class Target : public MapperElement, public Updateable {
public:
    virtual std::vector<std::string> getAllValues() const = 0;
    virtual std::shared_ptr<TargetValue> getValue(const std::string& value_name) const = 0;
};

class MemoryTarget : public Target {
public:
    ~MemoryTarget() override = default;

    virtual size_t getExpectedDataSize() const = 0;
    virtual void updateMemory(std::shared_ptr<Memory> memory) = 0;
    void reset() override
    {
        updateMemory(nullptr);
    }
};

using TargetFactory = SpecificMapperFactory<Target>;

class Function : public MapperElement {
public:
    struct ParameterDescription {
        std::optional<std::string> default_value;
    };

    class Callable {
    public:
        virtual ~Callable() = default;
        virtual std::shared_ptr<const SourceValue> initialize(const std::unordered_map<std::string, std::shared_ptr<const SourceValue>>& parameters) = 0;
    };

    using Description = std::unordered_map<std::string, ParameterDescription>;
    virtual Description getDescription() const = 0;
    virtual std::shared_ptr<Callable> getCallable() const = 0;
};

using FunctionFactory = SpecificMapperFactory<Function>;

class TimeStrategy {
public:
    virtual bool updateTime(std::chrono::nanoseconds source_value_time,
                            uint64_t source_value_update_counter,
                            const std::shared_ptr<const SourceValue>& source_value) = 0;
    virtual std::optional<std::chrono::nanoseconds> getTime() const = 0;
};

class AssignmentTrigger {
public:
    virtual void update([[maybe_unused]]std::chrono::nanoseconds trigger_time) = 0;
};

class AssignmentTriggerSourceTime : public AssignmentTrigger {
public:
    virtual void update([[maybe_unused]] std::chrono::nanoseconds trigger_time,
                        [[maybe_unused]] TimeStrategy* time_strategy) = 0;
};
 
} // namespace mapping
} // namespace ddl
#endif // _MAPPING_INTERFACES_HEADER