FluxioControlNode.cpp

Go to the documentation of this file.

#include "FluxioControlNode.h"
 
#include <experimental/memory>
#include <memory>
#include <optional>
#include <vector>
 
#include <ArmarXCore/core/logging/Logging.h>
 
#include "RobotAPI/libraries/aron/core/data/variant/container/List.h"
#include "RobotAPI/libraries/aron/core/data/variant/primitive/Float.h"
#include "RobotAPI/libraries/aron/core/data/variant/primitive/String.h"
#include "RobotAPI/libraries/skills/core/FluxioNode.h"
#include <RobotAPI/interface/skills/SkillManagerInterface.h>
#include <RobotAPI/libraries/skills/core/aron/FluxioParameter.aron.generated.h>
 
#include "FluxioParameter.h"
 
namespace armarx
{
    namespace skills
    {
        FluxioControlNodeType
        FluxioControlNodeTypeFromString(const std::string& type)
        {
            if (type == "SPLITTER")
            {
                return FluxioControlNodeType::SPLITTER;
            }
            else if (type == "AND_MERGER")
            {
                return FluxioControlNodeType::AND_MERGER;
            }
            else if (type == "LOOP_REPEAT")
            {
                return FluxioControlNodeType::LOOP_REPEAT;
            }
            else if (type == "LOOP_RETRY")
            {
                return FluxioControlNodeType::LOOP_RETRY;
            }
            else
            {
                ARMARX_WARNING << "Unknown control node type: " << type;
                return FluxioControlNodeType::UNKNOWN;
            }
        }
 
        std::optional<std::string>
        FluxioControlNodeTypeToString(const FluxioControlNodeType& type)
        {
            switch (type)
            {
                case FluxioControlNodeType::SPLITTER:
                    return "SPLITTER";
                case FluxioControlNodeType::AND_MERGER:
                    return "AND_MERGER";
                case FluxioControlNodeType::LOOP_REPEAT:
                    return "LOOP_REPEAT";
                case FluxioControlNodeType::LOOP_RETRY:
                    return "LOOP_RETRY";
                case FluxioControlNodeType::UNKNOWN:
                default:
                    ARMARX_WARNING << "Unknown control node type: " << static_cast<int>(type);
                    return std::nullopt;
            }
        }
 
        std::optional<manager::dto::FluxioNode>
        FluxioControlNode::toManagerIce() const
        {
            const auto& nt = FluxioNodeTypeToString(nodeType);
            if (!nt.has_value())
            {
                return std::nullopt;
            }
            const auto& ct = skills::FluxioControlNodeTypeToString(controlType);
            if (!nt.has_value())
            {
                return std::nullopt;
            }
 
            manager::dto::FluxioNode ret;
            ret.nodeId = nodeId;
            ret.nodeType = nt.value();
            ret.name = name;
            ret.xPos = xPos;
            ret.yPos = yPos;
            ret.controlType = ct.value();
 
            manager::dto::FluxioIdentificator slottedNodeIdentificator;
            if (slottedNode != nullptr)
            {
                slottedNodeIdentificator.id = slottedNode->nodeId;
                slottedNodeIdentificator.hint = slottedNode->name;
            }
 
            ret.slottedNodeId = slottedNodeIdentificator;
 
            manager::dto::FluxioParameterList params;
            for (const auto& [id, parameter] : parametersMap)
            {
                params.push_back(parameter.toManagerIce());
            }
            ret.parameters = params;
 
            manager::dto::FluxioIdentificator emptyId;
            emptyId.id = "";
            emptyId.hint = "";
 
            ret.parameterId = emptyId;
            ret.skillId = emptyId;
 
            return ret;
        }
 
        std::optional<manager::arondto::FluxioNode>
        FluxioControlNode::toAron() const
        {
            const auto& nt = FluxioNodeTypeToString(nodeType);
            if (!nt.has_value())
            {
                return std::nullopt;
            }
            const auto& ct = skills::FluxioControlNodeTypeToString(controlType);
            if (!nt.has_value())
            {
                return std::nullopt;
            }
 
            manager::arondto::FluxioNode ret;
            ret.nodeId = nodeId;
            ret.nodeType = nt.value();
            ret.name = name;
            ret.xPos = xPos;
            ret.yPos = yPos;
            ret.controlType = ct.value();
 
            manager::arondto::FluxioIdentificator slottedNodeIdentificator;
            if (slottedNode != nullptr)
            {
                slottedNodeIdentificator.id = slottedNode->nodeId;
                slottedNodeIdentificator.hint = slottedNode->name;
            }
 
            ret.slottedNodeId = slottedNodeIdentificator;
 
 
            std::vector<manager::arondto::FluxioParameter> params;
            for (const auto& [id, parameter] : parametersMap)
            {
                params.push_back(parameter.toAron());
            }
            ret.parameters = params;
 
            manager::arondto::FluxioIdentificator emptyId;
            emptyId.id = "";
            emptyId.hint = "";
 
            ret.parameterId = emptyId;
            ret.skillId = emptyId;
 
            return ret;
        }
 
        std::optional<FluxioControlNode>
        FluxioControlNode::FromIce(
            const manager::dto::FluxioNode& i,
            std::map<std::string, FluxioProfile>& profilesMap,
            std::map<std::string, aron::type::ObjectPtr>& typesMap,
            std::map<const std::string, const std::unique_ptr<FluxioNode>>& nodesMap)
        {
            FluxioControlNode ret;
 
            ret.nodeId = i.nodeId;
            ret.nodeType = FluxioNodeTypeFromString(i.nodeType);
            ret.name = i.name;
            ret.xPos = i.xPos;
            ret.yPos = i.yPos;
            ret.controlType = skills::FluxioControlNodeTypeFromString(i.controlType);
            const auto& slottedNodeIt = nodesMap.find(i.slottedNodeId.id);
            if (slottedNodeIt == nodesMap.end())
            {
                ARMARX_INFO << "Slotted node not found: " << i.slottedNodeId.id;
                ret.slottedNode = nullptr;
            }
            else
            {
                ret.slottedNode = std::experimental::make_observer(slottedNodeIt->second.get());
            }
 
            std::map<std::string, FluxioParameter> paramsMap;
            for (const auto& parameter : i.parameters)
            {
                const auto& param = FluxioParameter::FromIce(parameter, profilesMap, typesMap);
                paramsMap.insert({parameter.id, param});
            }
 
            ret.parametersMap = paramsMap;
 
            return ret;
        }
 
        std::optional<FluxioControlNode>
        FluxioControlNode::FromAron(
            const manager::arondto::FluxioNode& i,
            std::map<std::string, FluxioProfile>& profilesMap,
            std::map<std::string, aron::type::ObjectPtr>& typesMap,
            std::map<const std::string, const std::unique_ptr<FluxioNode>>& nodesMap)
        {
            FluxioControlNode ret;
 
            ret.nodeId = i.nodeId;
            ret.nodeType = FluxioNodeTypeFromString(i.nodeType);
            ret.name = i.name;
            ret.xPos = i.xPos;
            ret.yPos = i.yPos;
            ret.controlType = skills::FluxioControlNodeTypeFromString(i.controlType);
            const auto& slottedNodeIt = nodesMap.find(i.slottedNodeId.id);
            if (slottedNodeIt == nodesMap.end())
            {
                ARMARX_INFO << "Slotted node not found: " << i.slottedNodeId.id;
                ret.slottedNode = nullptr;
            }
            else
            {
                ret.slottedNode = std::experimental::make_observer(slottedNodeIt->second.get());
            }
 
            std::map<std::string, FluxioParameter> paramsMap;
            for (const auto& parameter : i.parameters)
            {
                const auto& param = FluxioParameter::FromAron(parameter, profilesMap, typesMap);
                paramsMap.insert({parameter.id, param});
            }
 
            ret.parametersMap = paramsMap;
 
            return ret;
        }
    } // namespace skills
} // namespace armarx