FluxioEdge.cpp

Go to the documentation of this file.

#include "FluxioEdge.h"
 
#include <memory>
#include <optional>
 
#include <ArmarXCore/core/logging/Logging.h>
 
#include "RobotAPI/libraries/skills/core/FluxioControlNode.h"
#include <RobotAPI/libraries/skills/core/aron/FluxioEdge.aron.generated.h>
 
#include "FluxioNode.h"
#include "FluxioParameter.h"
#include "FluxioSubSkillNode.h"
 
namespace armarx
{
    namespace skills
    {
        bool
        FluxioEdge::isValid() const
        {
            return fromNodePtr != nullptr && fromParameterPtr != nullptr && toNodePtr != nullptr &&
                   toParameterPtr != nullptr;
        }
 
        std::optional<manager::dto::FluxioEdge>
        FluxioEdge::toManagerIce() const
        {
            if (fromNodePtr == nullptr || fromParameterPtr == nullptr || toNodePtr == nullptr ||
                toParameterPtr == nullptr)
            {
                ARMARX_WARNING << "Could not create FluxioEdge DTO";
                return std::nullopt;
            }
 
            manager::dto::FluxioEdge ret;
 
            ret.fromNodeId = fromNodePtr->toFluxioIdentificatorIce();
            ret.fromParameterId = fromParameterPtr->toFluxioIdentificatorIce();
            ret.toNodeId = toNodePtr->toFluxioIdentificatorIce();
            ret.toParameterId = toParameterPtr->toFluxioIdentificatorIce();
 
            return ret;
        }
 
        std::optional<manager::arondto::FluxioEdge>
        FluxioEdge::toAron() const
        {
            if (fromNodePtr == nullptr || fromParameterPtr == nullptr || toNodePtr == nullptr ||
                toParameterPtr == nullptr)
            {
                ARMARX_WARNING << "Could not create FluxioEdge DTO";
                return std::nullopt;
            }
 
            manager::arondto::FluxioEdge ret;
 
            ret.fromNodeId = fromNodePtr->toFluxioIdentificatorAron();
            ret.fromParameterId = fromParameterPtr->toFluxioIdentificatorAron();
            ret.toNodeId = toNodePtr->toFluxioIdentificatorAron();
            ret.toParameterId = toParameterPtr->toFluxioIdentificatorAron();
 
            return ret;
        }
 
        std::optional<FluxioEdge>
        FluxioEdge::FromIce(
            const manager::dto::FluxioEdge& i,
            const std::map<const std::string, const std::unique_ptr<FluxioNode>>& nodesMap,
            const std::map<std::string, FluxioParameter>& parametersMap)
        {
            const auto& fromNodePtr =
                FluxioNode::FromFluxioIdentificatorIce(i.fromNodeId, nodesMap);
            const auto& toNodePtr = FluxioNode::FromFluxioIdentificatorIce(i.toNodeId, nodesMap);
 
            if (fromNodePtr == nullptr || toNodePtr == nullptr)
            {
                ARMARX_WARNING << "Failed to convert node(s)";
                return std::nullopt;
            }
 
            std::experimental::observer_ptr<const skills::FluxioParameter> fromParameterPtr =
                nullptr;
            std::experimental::observer_ptr<const skills::FluxioParameter> toParameterPtr = nullptr;
 
            // Check if fromNode is a SubSkillNode
            if (fromNodePtr->nodeType == FluxioNodeType::SUBSKILL)
            {
                const auto& subSkillNodePtr = std::experimental::make_observer(
                    dynamic_cast<const FluxioSubSkillNode*>(fromNodePtr.get()));
                if (subSkillNodePtr == nullptr)
                {
                    ARMARX_WARNING << "Failed to cast node to sub skill node";
                    return std::nullopt;
                }
 
                if (subSkillNodePtr->skillPtr == nullptr)
                {
                    ARMARX_WARNING << "SkillPtr for SubSkillNode is not set";
                    return std::nullopt;
                }
 
                const auto& subSkillParams = subSkillNodePtr->skillPtr->parameters;
                fromParameterPtr =
                    FluxioParameter::FromFluxioIdentificatorIce(i.fromParameterId, subSkillParams);
            }
            else if (fromNodePtr->nodeType == FluxioNodeType::PARAMETER)
            {
                fromParameterPtr =
                    FluxioParameter::FromFluxioIdentificatorIce(i.fromParameterId, parametersMap);
            }
            else if (fromNodePtr->nodeType == FluxioNodeType::CONTROL)
            {
                const auto& controlNodePtr = std::experimental::make_observer(
                    dynamic_cast<const FluxioControlNode*>(fromNodePtr.get()));
                if (controlNodePtr == nullptr)
                {
                    ARMARX_WARNING << "Failed to cast node to control node";
                    return std::nullopt;
                }
 
                fromParameterPtr = FluxioParameter::FromFluxioIdentificatorIce(
                    i.fromParameterId, controlNodePtr->parametersMap);
            }
            else
            {
                ARMARX_WARNING << "Unknown from node type";
                return std::nullopt;
            }
 
            // Check if toNode is a SubSkillNode
            if (toNodePtr->nodeType == FluxioNodeType::SUBSKILL)
            {
                const auto& subSkillNodePtr = std::experimental::make_observer(
                    dynamic_cast<const FluxioSubSkillNode*>(toNodePtr.get()));
                if (subSkillNodePtr == nullptr)
                {
                    ARMARX_WARNING << "Failed to cast node to sub skill node";
                    return std::nullopt;
                }
 
                if (subSkillNodePtr->skillPtr == nullptr)
                {
                    ARMARX_WARNING << "SkillPtr for SubSkillNode is not set";
                    return std::nullopt;
                }
 
                const auto& subSkillParams = subSkillNodePtr->skillPtr->parameters;
                toParameterPtr =
                    FluxioParameter::FromFluxioIdentificatorIce(i.toParameterId, subSkillParams);
            }
            else if (toNodePtr->nodeType == FluxioNodeType::CONTROL)
            {
                const auto& controlNodePtr = std::experimental::make_observer(
                    dynamic_cast<const FluxioControlNode*>(toNodePtr.get()));
                if (controlNodePtr == nullptr)
                {
                    ARMARX_WARNING << "Failed to cast node to control node";
                    return std::nullopt;
                }
 
                toParameterPtr = FluxioParameter::FromFluxioIdentificatorIce(
                    i.toParameterId, controlNodePtr->parametersMap);
            }
            else if (toNodePtr->nodeType == FluxioNodeType::PARAMETER)
            {
                toParameterPtr =
                    FluxioParameter::FromFluxioIdentificatorIce(i.toParameterId, parametersMap);
            }
            else
            {
                ARMARX_WARNING << "Unknown to node type";
                return std::nullopt;
            }
 
            if (fromParameterPtr == nullptr || toParameterPtr == nullptr)
            {
                ARMARX_WARNING << "Failed to convert parameter(s)";
                return std::nullopt;
            }
 
            return FluxioEdge{.fromNodePtr = fromNodePtr,
                              .fromParameterPtr = fromParameterPtr,
                              .toNodePtr = toNodePtr,
                              .toParameterPtr = toParameterPtr};
        }
 
        std::optional<FluxioEdge>
        FluxioEdge::FromAron(
            const manager::arondto::FluxioEdge& i,
            const std::map<const std::string, const std::unique_ptr<FluxioNode>>& nodesMap,
            const std::map<std::string, FluxioParameter>& parametersMap)
        {
            const auto& fromNodePtr =
                FluxioNode::FromFluxioIdentificatorAron(i.fromNodeId, nodesMap);
            const auto& toNodePtr = FluxioNode::FromFluxioIdentificatorAron(i.toNodeId, nodesMap);
 
            if (fromNodePtr == nullptr || toNodePtr == nullptr)
            {
                ARMARX_WARNING << "Failed to convert node(s)";
                return std::nullopt;
            }
 
            std::experimental::observer_ptr<const skills::FluxioParameter> fromParameterPtr =
                nullptr;
            std::experimental::observer_ptr<const skills::FluxioParameter> toParameterPtr = nullptr;
 
            // Check if fromNode is a SubSkillNode
            if (fromNodePtr->nodeType == FluxioNodeType::SUBSKILL)
            {
                const auto& subSkillNodePtr = std::experimental::make_observer(
                    dynamic_cast<const FluxioSubSkillNode*>(fromNodePtr.get()));
                if (subSkillNodePtr == nullptr)
                {
                    ARMARX_WARNING << "Failed to cast node to sub skill node";
                    return std::nullopt;
                }
 
                if (subSkillNodePtr->skillPtr == nullptr)
                {
                    ARMARX_WARNING << "SkillPtr for SubSkillNode is not set";
                    return std::nullopt;
                }
 
                const auto& subSkillParams = subSkillNodePtr->skillPtr->parameters;
                fromParameterPtr =
                    FluxioParameter::FromFluxioIdentificatorAron(i.fromParameterId, subSkillParams);
            }
            else if (fromNodePtr->nodeType == FluxioNodeType::PARAMETER)
            {
                fromParameterPtr =
                    FluxioParameter::FromFluxioIdentificatorAron(i.fromParameterId, parametersMap);
            }
            else if (fromNodePtr->nodeType == FluxioNodeType::CONTROL)
            {
                const auto& controlNodePtr = std::experimental::make_observer(
                    dynamic_cast<const FluxioControlNode*>(fromNodePtr.get()));
                if (controlNodePtr == nullptr)
                {
                    ARMARX_WARNING << "Failed to cast node to control node";
                    return std::nullopt;
                }
 
                fromParameterPtr = FluxioParameter::FromFluxioIdentificatorAron(
                    i.fromParameterId, controlNodePtr->parametersMap);
            }
            else
            {
                ARMARX_WARNING << "Unknown from node type";
                return std::nullopt;
            }
 
            // Check if toNode is a SubSkillNode
            if (toNodePtr->nodeType == FluxioNodeType::SUBSKILL)
            {
                const auto& subSkillNodePtr = std::experimental::make_observer(
                    dynamic_cast<const FluxioSubSkillNode*>(toNodePtr.get()));
                if (subSkillNodePtr == nullptr)
                {
                    ARMARX_WARNING << "Failed to cast node to sub skill node";
                    return std::nullopt;
                }
 
                if (subSkillNodePtr->skillPtr == nullptr)
                {
                    ARMARX_WARNING << "SkillPtr for SubSkillNode is not set";
                    return std::nullopt;
                }
 
                const auto& subSkillParams = subSkillNodePtr->skillPtr->parameters;
                toParameterPtr =
                    FluxioParameter::FromFluxioIdentificatorAron(i.toParameterId, subSkillParams);
            }
            else if (toNodePtr->nodeType == FluxioNodeType::CONTROL)
            {
                const auto& controlNodePtr = std::experimental::make_observer(
                    dynamic_cast<const FluxioControlNode*>(toNodePtr.get()));
                if (controlNodePtr == nullptr)
                {
                    ARMARX_WARNING << "Failed to cast node to control node";
                    return std::nullopt;
                }
 
                toParameterPtr = FluxioParameter::FromFluxioIdentificatorAron(
                    i.toParameterId, controlNodePtr->parametersMap);
            }
            else if (toNodePtr->nodeType == FluxioNodeType::PARAMETER)
            {
                toParameterPtr =
                    FluxioParameter::FromFluxioIdentificatorAron(i.toParameterId, parametersMap);
            }
            else
            {
                ARMARX_WARNING << "Unknown to node type";
                return std::nullopt;
            }
 
            if (fromParameterPtr == nullptr || toParameterPtr == nullptr)
            {
                ARMARX_WARNING << "Failed to convert parameter(s)";
                return std::nullopt;
            }
 
            return FluxioEdge{.fromNodePtr = fromNodePtr,
                              .fromParameterPtr = fromParameterPtr,
                              .toNodePtr = toNodePtr,
                              .toParameterPtr = toParameterPtr};
        }
    } // namespace skills
} // namespace armarx