map_transformation.h

Go to the documentation of this file.

 
#ifndef HEADER_MAP_TRANSFORMATION_H
#define HEADER_MAP_TRANSFORMATION_H
 
#include <a_util/result.h>
#include <a_util/strings.h>
#include <a_util/xml.h>
 
namespace ddl {
namespace mapping {
 
class MapConfiguration;

class MapTransformationBase {
public:
    MapTransformationBase(MapConfiguration* config, const std::string& name);

    virtual ~MapTransformationBase();

    const std::string& getName() const;

    bool isValid() const;

    virtual bool isEqual(const MapTransformationBase& other) const = 0;

    virtual MapTransformationBase* clone() const = 0;

    virtual double evaluate(double value) const = 0;
 
private:
    static a_util::result::Result createFromDOM(MapConfiguration* config,
                                                const a_util::xml::DOMElement& dom_element,
                                                MapTransformationBase*& destination);

    static a_util::result::Result create(MapConfiguration* config,
                                         const std::string& name,
                                         const std::string& type,
                                         MapTransformationBase*& destination);

    a_util::result::Result writeToDOM(a_util::xml::DOMElement& dom_element) const;

    a_util::result::Result setTypeFromDDL();
 
protected:
    friend class MapConfiguration;
    MapConfiguration* _config;
    std::string _name;
    bool _is_valid;
};

class MapPolynomTransformation : public MapTransformationBase {
public:
    MapPolynomTransformation(MapConfiguration* config, const std::string& name);

    double getA() const;

    double getB() const;

    double getC() const;

    double getD() const;

    double getE() const;

    a_util::result::Result setCoefficients(const std::string coefs[5]);

    bool isEqual(const MapTransformationBase& other) const;

    double evaluate(double value) const;

    MapTransformationBase* clone() const;
 
private:
    a_util::result::Result loadFromDom(const a_util::xml::DOMElement& dom_element);

    a_util::result::Result writeToDOM(a_util::xml::DOMElement& dom_element) const;
 
private:
    friend class MapTransformationBase;
    double _a, _b, _c, _d, _e;
};

class MapEnumTableTransformation : public MapTransformationBase {
public: // types
#if defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wattributes"
#endif // defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))

    using ConversionMap = std::map<int64_t, int64_t>;
 
#if defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
 
public:
    MapEnumTableTransformation(MapConfiguration* config, const std::string& name);

    const std::string& getEnumFrom() const;

    const std::string& getEnumTo() const;

    a_util::result::Result setEnums(const std::string& enum_from, const std::string& enum_to);

    int64_t getDefault() const;

    std::string getDefaultStr() const;

    a_util::result::Result setDefault(const std::string& default_value);

    const ConversionMap& getConversions() const;

    const std::map<std::string, std::string>& getConversionsStr() const;

    a_util::result::Result addConversion(const std::string& from, const std::string& to);

    a_util::result::Result removeConversion(const std::string& from);

    bool isEqual(const MapTransformationBase& other) const;

    double evaluate(double value) const;

    MapTransformationBase* clone() const;
 
private:
    a_util::result::Result loadFromDom(const a_util::xml::DOMElement& dom_element);

    a_util::result::Result writeToDOM(a_util::xml::DOMElement& dom_element) const;

    a_util::result::Result convertValuesWithDDL();

    a_util::result::Result setEnumsStr(const std::string& enum_from, const std::string& enum_to);

    a_util::result::Result setDefaultStr(const std::string& default_value);

    a_util::result::Result addConversionStr(const std::string& from, const std::string& to);
 
private:
    friend class MapTransformationBase;
    std::string _enum_from;
    std::string _enum_to;
    std::string _default_value;
    typedef std::map<std::string, std::string> MapStrConversionList;
    MapStrConversionList _conversions;
    int64_t _default_int;
    ConversionMap _conversions_int;
};

typedef std::vector<MapTransformationBase*> MapTransformationList;
 
} // namespace mapping
} // namespace ddl
 
#endif // HEADER_MAP_TRANSFORMATION_H