aron_conversions.cpp

Go to the documentation of this file.

#include "aron_conversions.h"
 
#include <RobotAPI/libraries/aron/converter/datatype/DatatypeConverterVisitor.h>
#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
 
namespace armarx::armem
{
    std::map<armarx::eStateType, armarx::skills::arondto::Statechart::StateType>
        toAronStateTypeMap = {
            {eNormalState,
             (armarx::skills::arondto::Statechart::StateType)
                 armarx::skills::arondto::Statechart::StateType::NORMAL},
            {eFinalState,
             (armarx::skills::arondto::Statechart::StateType)
                 armarx::skills::arondto::Statechart::StateType::FINAL},
            {eRemoteState,
             (armarx::skills::arondto::Statechart::StateType)
                 armarx::skills::arondto::Statechart::StateType::REMOTE},
            {eDynamicRemoteState,
             (armarx::skills::arondto::Statechart::StateType)
                 armarx::skills::arondto::Statechart::StateType::DYNAMIC_REMOTE},
            {eUndefined,
             (armarx::skills::arondto::Statechart::StateType)
                 armarx::skills::arondto::Statechart::StateType::UNDEFINED},
    };
 
    std::map<armarx::skills::arondto::Statechart::StateType, armarx::eStateType>
        fromAronStateTypeMap = {
            {(armarx::skills::arondto::Statechart::StateType)
                 armarx::skills::arondto::Statechart::StateType::NORMAL,
             eNormalState},
            {(armarx::skills::arondto::Statechart::StateType)
                 armarx::skills::arondto::Statechart::StateType::FINAL,
             eFinalState},
            {(armarx::skills::arondto::Statechart::StateType)
                 armarx::skills::arondto::Statechart::StateType::REMOTE,
             eRemoteState},
            {(armarx::skills::arondto::Statechart::StateType)
                 armarx::skills::arondto::Statechart::StateType::DYNAMIC_REMOTE,
             eDynamicRemoteState},
            {(armarx::skills::arondto::Statechart::StateType)
                 armarx::skills::arondto::Statechart::StateType::UNDEFINED,
             eUndefined},
    };
 
    void
    fromAron(const skills::arondto::Statechart::StateType& dto, eStateType& bo)
    {
        if (fromAronStateTypeMap.find(dto) != fromAronStateTypeMap.end())
        {
            bo = fromAronStateTypeMap[dto];
        }
        else
        {
            bo = eStateType::eUndefined;
        }
    }
 
    void
    toAron(skills::arondto::Statechart::StateType& dto, const eStateType& bo)
    {
        if (toAronStateTypeMap.find(bo) != toAronStateTypeMap.end())
        {
            dto.value = toAronStateTypeMap[bo].value;
        }
        else
        {
            dto.value = skills::arondto::Statechart::StateType::UNDEFINED;
        }
    }
 
    void
    fromAron(const skills::arondto::Statechart::ParameterMap& dto, StateParameterMap& bo)
    {
        // todo: implement
        //        for (auto const& [key, val] : dto.parameters)
        //        {
        // fromAron(val, ...)
        //            bo.insert(key, val);
        //        }
    }
 
    void
    toAron(skills::arondto::Statechart::ParameterMap& dto, const StateParameterMap& bo)
    {
        for (auto const& [key, val] : bo)
        {
            dto.parameters[key] = val->value->toString();
        }
    }
 
    void
    fromAron(const skills::arondto::Statechart::Transition& dto,
             ProfilerStatechartTransitionWithParameters& bo)
    {
        bo.processId = dto.processId;
        bo.sourceStateIdentifier = dto.sourceStateIdentifier;
        bo.targetStateIdentifier = dto.targetStateIdentifier;
        bo.eventName = dto.eventName;
        fromAron(dto.targetStateType, bo.targetStateType);
        fromAron(dto.inputParameters, bo.inputParameters);
        fromAron(dto.localParameters, bo.localParameters);
        fromAron(dto.outputParameters, bo.outputParameters);
    }
 
    void
    toAron(skills::arondto::Statechart::Transition& dto,
           const ProfilerStatechartTransitionWithParameters& bo)
    {
        dto.processId = bo.processId;
        dto.sourceStateIdentifier = bo.sourceStateIdentifier;
        dto.targetStateIdentifier = bo.targetStateIdentifier;
        dto.eventName = bo.eventName;
        toAron(dto.targetStateType, bo.targetStateType);
        toAron(dto.inputParameters, bo.inputParameters);
        toAron(dto.localParameters, bo.localParameters);
        toAron(dto.outputParameters, bo.outputParameters);
    }
 
    void
    fromAron(const armarx::skills::arondto::ProviderID& dto, skills::ProviderID& bo)
    {
        bo.providerName = dto.providerName;
    }
 
    void
    toAron(armarx::skills::arondto::ProviderID& dto, const skills::ProviderID& bo)
    {
        dto.providerName = bo.providerName;
    }
 
    void
    fromAron(const armarx::skills::arondto::SkillID& dto, skills::SkillID& bo)
    {
        bo.skillName = dto.skillName;
        bo.providerId = skills::ProviderID{.providerName = ""};
        fromAron(dto.providerId, *bo.providerId);
    }
 
    void
    toAron(armarx::skills::arondto::SkillID& dto, const skills::SkillID& bo)
    {
        dto.skillName = bo.skillName;
        dto.providerId.resetHard();
        if (bo.providerId.has_value())
        {
            toAron(dto.providerId, *bo.providerId);
        }
    }
 
    void
    fromAron(const armarx::skills::arondto::SkillDescription& dto, skills::SkillDescription& bo)
    {
        fromAron(dto.skillId, bo.skillId);
        bo.description = dto.description;
        bo.timeout = dto.timeout;
        bo.rootProfileDefaults = dto.rootProfileParameterization;
        if (dto.parametersType)
        {
            throw armarx::LocalException("Not implemented yet");
        }
    }
 
    void
    toAron(armarx::skills::arondto::SkillDescription& dto, const skills::SkillDescription& bo)
    {
        toAron(dto.skillId, bo.skillId);
        dto.description = bo.description;
        dto.timeout = bo.timeout;
        dto.rootProfileParameterization = bo.rootProfileDefaults;
        if (bo.parametersType)
        {
            aron::type::converter::AronDatatypeConverterVisitor c;
            aron::type::visit(c, bo.parametersType);
 
            dto.parametersType = aron::data::Dict::DynamicCastAndCheck(c.latest);
        }
    }
 
    void
    fromAron(const armarx::skills::arondto::SkillExecutionRequest& dto,
             skills::SkillExecutionRequest& bo)
    {
        fromAron(dto.skillId, bo.skillId);
        bo.executorName = dto.executorName;
        bo.parameters = dto.parameters;
    }
 
    void
    toAron(armarx::skills::arondto::SkillExecutionRequest& dto,
           const skills::SkillExecutionRequest& bo)
    {
        toAron(dto.skillId, bo.skillId);
        dto.executorName = bo.executorName;
        dto.parameters = bo.parameters;
    }
 
    void
    fromAron(const armarx::skills::arondto::SkillStatusUpdate& dto, skills::SkillStatusUpdate& bo)
    {
        static std::map<std::string, skills::SkillStatus> map{
            {"Constructing", skills::SkillStatus::Constructing},
            {"Initializing", skills::SkillStatus::Initializing},
            {"Preparing", skills::SkillStatus::Preparing},
            {"Running", skills::SkillStatus::Running},
            {"Failed", skills::SkillStatus::Failed},
            {"Aborted", skills::SkillStatus::Aborted},
            {"Succeeded", skills::SkillStatus::Succeeded}};
 
        fromAron(dto.skillId, bo.executionId.skillId);
        bo.executionId.executionStartedTime = dto.executionStartedTimestamp;
        bo.executionId.executorName = dto.executorName;
        bo.parameters = dto.parameters;
        bo.result = dto.result;
        bo.status = map.at(dto.status);
    }
 
    void
    toAron(armarx::skills::arondto::SkillStatusUpdate& dto, const skills::SkillStatusUpdate& bo)
    {
        static std::map<skills::SkillStatus, std::string> map{
            {skills::SkillStatus::Constructing, "Constructing"},
            {skills::SkillStatus::Initializing, "Initializing"},
            {skills::SkillStatus::Preparing, "Preparing"},
            {skills::SkillStatus::Running, "Running"},
            {skills::SkillStatus::Failed, "Failed"},
            {skills::SkillStatus::Aborted, "Aborted"},
            {skills::SkillStatus::Succeeded, "Succeeded"}};
 
        toAron(dto.skillId, bo.executionId.skillId);
        dto.executorName = bo.executionId.executorName;
        dto.executionStartedTimestamp = bo.executionId.executionStartedTime;
        dto.parameters = bo.parameters;
        dto.result = bo.result;
        dto.status = map.at(bo.status);
    }
} // namespace armarx::armem