aron_conversions.cpp

Go to the documentation of this file.

#include "aron_conversions.h"
 
#include <ArmarXCore/core/logging/Logging.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 const 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;
 
        // Use find() instead of at() so an unknown status string does not
        // throw std::out_of_range and crash the SkillMemory component on
        // corrupted data, version mismatches, or new enum values.
        if (auto it = map.find(dto.status); it != map.end())
        {
            bo.status = it->second;
        }
        else
        {
            ARMARX_WARNING << "Unknown skill status string '" << dto.status
                           << "' encountered in fromAron(SkillStatusUpdate). "
                              "Falling back to SkillStatus::Failed.";
            bo.status = skills::SkillStatus::Failed;
        }
    }
 
    void
    toAron(armarx::skills::arondto::SkillStatusUpdate& dto, const skills::SkillStatusUpdate& bo)
    {
        static const 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;
 
        // Use find() instead of at() so an unknown enum value (e.g. from a
        // future enum addition or memory corruption) does not throw and
        // crash the component.
        if (auto it = map.find(bo.status); it != map.end())
        {
            dto.status = it->second;
        }
        else
        {
            ARMARX_WARNING << "Unknown skills::SkillStatus enum value "
                           << static_cast<int>(bo.status)
                           << " in toAron(SkillStatusUpdate). "
                              "Falling back to status string \"Failed\".";
            dto.status = "Failed";
        }
    }
} // namespace armarx::armem