map_assignment.h

Go to the documentation of this file.

 
#ifndef HEADER_MAP_ASSIGNMENT_H
#define HEADER_MAP_ASSIGNMENT_H
 
#include <a_util/result.h>
#include <a_util/xml.h>
 
#include <string>
#include <vector>
 
namespace ddl {
namespace mapping {
typedef std::vector<std::string> MapErrorList;
class MapAssignment {
public:
    MapAssignment();

    MapAssignment(std::string to);

    bool isValid() const;

    const std::string& getFrom() const;

    const std::string& getSource() const;

    a_util::result::Result connect(const std::string& source_element_path);

    const std::string& getConstant() const;

    a_util::result::Result setConstant(const std::string& constant);

    const std::string& getFunction() const;

    a_util::result::Result setSimulationTimeFunction();

    a_util::result::Result setTriggerCounterFunction(const std::string& modulo);

    a_util::result::Result setReceivedFunction(const std::string& source);

    const std::string& getModulo() const;

    const std::string& getTo() const;

    const std::string& getTransformation() const;

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

    a_util::result::Result removeTransformation();
 
private:
    a_util::result::Result loadFromDOM(const a_util::xml::DOMElement& assignment,
                                       MapErrorList& errors);

    a_util::result::Result writeToDOM(a_util::xml::DOMElement& dom_element) const;
 
private:
    friend class MapConfiguration;
    friend class MapTarget;
    std::string _from;
    std::string _source;
    std::string _constant;
    std::string _function; // "simulation_time" -> no args, "trigger_counter" -> arg in modulo,
                           // "received" -> arg in from
    std::string _modulo;
    std::string _to;
    std::string _transform;
    bool _is_valid;
};

inline bool operator==(const MapAssignment& a, const MapAssignment& b)
{
    return a.getConstant() == b.getConstant() && a.getFrom() == b.getFrom() &&
           a.getSource() == b.getSource() && a.getTo() == b.getTo() &&
           a.getFunction() == b.getFunction() && a.getModulo() == b.getModulo() &&
           a.getTransformation() == b.getTransformation();
}

inline bool operator!=(const MapAssignment& a, const MapAssignment& b)
{
    return !(a == b);
}

typedef std::vector<MapAssignment> MapAssignmentList;
 
} // namespace mapping
} // namespace ddl
 
#endif // HEADER_MAP_ASSIGNMENT_H