FluxioNode.cpp

Go to the documentation of this file.

#include "FluxioNode.h"
 
#include <experimental/memory>
 
#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/interface/skills/SkillManagerInterface.h>
#include <RobotAPI/libraries/skills/core/aron/FluxioIdentificator.aron.generated.h>
#include <RobotAPI/libraries/skills/core/aron/FluxioNode.aron.generated.h>
 
namespace armarx
{
    namespace skills
    {
        FluxioNodeType
        FluxioNodeTypeFromString(const std::string& type)
        {
            if (type == "PARAMETER")
            {
                return FluxioNodeType::PARAMETER;
            }
            else if (type == "CONTROL")
            {
                return FluxioNodeType::CONTROL;
            }
            else if (type == "SUBSKILL")
            {
                return FluxioNodeType::SUBSKILL;
            }
            else
            {
                ARMARX_WARNING << "Unknown node type: " << type;
                return FluxioNodeType::UNKNOWN;
            }
        }
 
        std::optional<std::string>
        FluxioNodeTypeToString(const FluxioNodeType& type)
        {
            switch (type)
            {
                case FluxioNodeType::PARAMETER:
                    return "PARAMETER";
                case FluxioNodeType::CONTROL:
                    return "CONTROL";
                case FluxioNodeType::SUBSKILL:
                    return "SUBSKILL";
                case FluxioNodeType::UNKNOWN:
                default:
                    ARMARX_WARNING << "Unknown node type: " << static_cast<int>(type);
                    return std::nullopt;
            }
        }
 
        std::optional<manager::dto::FluxioNode>
        FluxioNode::toManagerIce() const
        {
            manager::dto::FluxioNode ret;
 
            const auto& nt = FluxioNodeTypeToString(nodeType);
            if (!nt.has_value())
            {
                return std::nullopt;
            }
 
            ret.nodeType = nt.value();
            ret.nodeId = nodeId;
            ret.name = name;
            ret.xPos = xPos;
            ret.yPos = yPos;
            ret.controlType = "";
            ret.parameters = {};
 
            manager::dto::FluxioIdentificator emptyId;
            emptyId.id = "";
            emptyId.hint = "";
 
            ret.parameterId = emptyId;
            ret.skillId = emptyId;
 
            return ret;
        }
 
        std::optional<manager::arondto::FluxioNode>
        FluxioNode::toAron() const
        {
            manager::arondto::FluxioNode ret;
 
            const auto& nt = FluxioNodeTypeToString(nodeType);
            if (!nt.has_value())
            {
                return std::nullopt;
            }
 
            ret.nodeType = nt.value();
            ret.nodeId = nodeId;
            ret.name = name;
            ret.xPos = xPos;
            ret.yPos = yPos;
            ret.controlType = "";
            ret.parameters = {};
 
            manager::arondto::FluxioIdentificator emptyId;
            emptyId.id = "";
            emptyId.hint = "";
 
            ret.parameterId = emptyId;
            ret.skillId = emptyId;
 
            return ret;
        }
 
        manager::dto::FluxioIdentificator
        FluxioNode::toFluxioIdentificatorIce() const
        {
            manager::dto::FluxioIdentificator ret;
            ret.id = nodeId;
            ret.hint = name;
            return ret;
        }
 
        manager::arondto::FluxioIdentificator
        FluxioNode::toFluxioIdentificatorAron() const
        {
            manager::arondto::FluxioIdentificator ret;
            ret.id = nodeId;
            ret.hint = name;
            return ret;
        }
 
        std::experimental::observer_ptr<const FluxioNode>
        FluxioNode::FromFluxioIdentificatorIce(
            const manager::dto::FluxioIdentificator& i,
            const std::map<const std::string, const std::unique_ptr<FluxioNode>>& nodesMap)
        {
            const auto& nodeIt = nodesMap.find(i.id);
 
            if (nodeIt == nodesMap.end())
            {
                ARMARX_WARNING << "Node with id " << i.id << " not found";
                return nullptr;
            }
 
            return std::experimental::make_observer(nodeIt->second.get());
        }
 
        std::experimental::observer_ptr<const FluxioNode>
        FluxioNode::FromFluxioIdentificatorAron(
            const manager::arondto::FluxioIdentificator& i,
            const std::map<const std::string, const std::unique_ptr<FluxioNode>>& nodesMap)
        {
            const auto& nodeIt = nodesMap.find(i.id);
 
            if (nodeIt == nodesMap.end())
            {
                ARMARX_WARNING << "Node with id " << i.id << " not found";
                return nullptr;
            }
 
            return std::experimental::make_observer(nodeIt->second.get());
        }
 
        FluxioNode
        FluxioNode::FromIce(const manager::dto::FluxioNode& i)
        {
            FluxioNode ret;
 
            ret.nodeType = FluxioNodeTypeFromString(i.nodeType);
            ret.nodeId = i.nodeId;
            ret.xPos = i.xPos;
            ret.yPos = i.yPos;
 
            return ret;
        }
    } // namespace skills
} // namespace armarx