mapper_base_types.h

Go to the documentation of this file.

 
#ifndef _MAPPER_BASE_HEADER
#define _MAPPER_BASE_HEADER
 
#include <ddl/codec/codec_factory.h>
#include <ddl/mapping/mapper_interfaces.h>
 
#include <type_traits>
 
namespace ddl {
namespace mapping {

template <typename T>
class MapperElementBase : public T {
public:
    MapperElementBase(std::string name, Properties properties)
        : _name(std::move(name)), _properties(std::move(properties))
    {
    }

    ~MapperElementBase() override = default;

    const std::string& getName() const override
    {
        return _name;
    }

    const Properties& getProperties() const override
    {
        return _properties;
    }

    const Property& getProperty(const std::string& property_name) const
    {
        const auto found = _properties.find(property_name);
        if (found != _properties.end()) {
            return found->second;
        }
        else {
            throw std::runtime_error("Property with name " + property_name + " was not found");
        }
    }
 
private:
    std::string _name;
    Properties _properties;
};

template <typename SourceType>
class SourceFactoryImplementation : public SourceFactory {
public:
    std::string getType() const override
    {
        return SourceType::getType();
    }
    Properties getDefaultProperties() const override
    {
        return SourceType::getDefaultProperties();
    }
    std::shared_ptr<Source> make(std::string name, Properties properties) const
    {
        return std::make_shared<SourceType>(std::move(name), std::move(properties));
    }
};

template <typename TargetType>
class TargetFactoryImplementation : public TargetFactory {
public:
    std::string getType() const override
    {
        return TargetType::getType();
    }
    Properties getDefaultProperties() const override
    {
        return TargetType::getDefaultProperties();
    }
    std::shared_ptr<Target> make(std::string name, Properties properties) const override
    {
        return std::make_shared<TargetType>(std::move(name), std::move(properties));
    }
};

template <typename FunctionType>
class FunctionFactoryImplementation : public FunctionFactory {
public:
    std::string getType() const override
    {
        return FunctionType::getType();
    }
    Properties getDefaultProperties() const override
    {
        return FunctionType::getDefaultProperties();
    }
    std::shared_ptr<Function> make(std::string name, Properties properties) const override
    {
        return std::make_shared<FunctionType>(std::move(name), std::move(properties));
    }
};

class ConstantValueFactory {
public:
    ConstantValueFactory() = delete;
 
public:
    static std::shared_ptr<const PlainSourceValue> make(const std::string& value);
};
 
} // namespace mapping
} // namespace ddl
#endif // _MAPPER_BASE_HEADER