SkillStatusUpdate.cpp

Go to the documentation of this file.

#include "SkillStatusUpdate.h"
#include <optional>
#include <ArmarXCore/core/logging/Logging.h>
 
#include <RobotAPI/libraries/skills/core/error/Exception.h>
 
namespace armarx
{
    namespace skills
    {
        SkillStatus
        toSkillStatus(const ActiveOrTerminatedSkillStatus& d)
        {
            switch (d)
            {
                case ActiveOrTerminatedSkillStatus::Running:
                    return SkillStatus::Running;
                case ActiveOrTerminatedSkillStatus::Failed:
                    return SkillStatus::Failed;
                case ActiveOrTerminatedSkillStatus::Succeeded:
                    return SkillStatus::Succeeded;
                case ActiveOrTerminatedSkillStatus::Aborted:
                    return SkillStatus::Aborted;
            }
            throw error::SkillException(__PRETTY_FUNCTION__, "Should not happen!");
        }
 
        SkillStatus
        toSkillStatus(const TerminatedSkillStatus& d)
        {
            switch (d)
            {
                case TerminatedSkillStatus::Failed:
                    return SkillStatus::Failed;
                case TerminatedSkillStatus::Succeeded:
                    return SkillStatus::Succeeded;
                case TerminatedSkillStatus::Aborted:
                    return SkillStatus::Aborted;
            }
            throw error::SkillException(__PRETTY_FUNCTION__, "Should not happen!");
        }
 
        TerminatedSkillStatus
        mergeSkillStatuseses(const TerminatedSkillStatus t1, const TerminatedSkillStatus t2)
        {
            // if both are equal
            if (t1 == t2)
            {
                return t1;
            }
 
            // if one is failed (most unspecific result)
            if (t1 == TerminatedSkillStatus::Failed or t2 == TerminatedSkillStatus::Failed)
            {
                return TerminatedSkillStatus::Failed;
            }
 
            // else one must be aborted and the other one must be succeeded
            return TerminatedSkillStatus::Aborted;
        }
 
        ActiveOrTerminatedSkillStatus
        mergeSkillStatuseses(const ActiveOrTerminatedSkillStatus t1,
                             const ActiveOrTerminatedSkillStatus t2)
        {
            // if both are equal
            if (t1 == t2)
            {
                return t1;
            }
 
            // if one is failed (most unspecific result)
            if (t1 == ActiveOrTerminatedSkillStatus::Failed or
                t2 == ActiveOrTerminatedSkillStatus::Failed)
            {
                return ActiveOrTerminatedSkillStatus::Failed;
            }
 
            // if none is failed and one is aborted (second most unspecific result)
            if (t1 == ActiveOrTerminatedSkillStatus::Aborted or
                t2 == ActiveOrTerminatedSkillStatus::Aborted)
            {
                return ActiveOrTerminatedSkillStatus::Aborted;
            }
 
            // else one must be running and the other one must be succeeded
            return ActiveOrTerminatedSkillStatus::Running;
        }
 
        void
        toIce(core::dto::Execution::Status& ret, const SkillStatus& status)
        {
            switch (status)
            {
                case SkillStatus::Constructing:
                    ret = core::dto::Execution::Status::Constructing;
                    return;
                case SkillStatus::Initializing:
                    ret = core::dto::Execution::Status::Initializing;
                    return;
                case SkillStatus::Preparing:
                    ret = core::dto::Execution::Status::Preparing;
                    return;
                case SkillStatus::Running:
                    ret = core::dto::Execution::Status::Running;
                    return;
                case SkillStatus::Failed:
                    ret = core::dto::Execution::Status::Failed;
                    return;
                case SkillStatus::Succeeded:
                    ret = core::dto::Execution::Status::Succeeded;
                    return;
                case SkillStatus::Aborted:
                    ret = core::dto::Execution::Status::Aborted;
                    return;
            }
            throw error::SkillException(__PRETTY_FUNCTION__, "Should not happen!");
        }
 
        void
        toIce(core::dto::Execution::Status& ret, const ActiveOrTerminatedSkillStatus& status)
        {
            switch (status)
            {
                case ActiveOrTerminatedSkillStatus::Running:
                    ret = core::dto::Execution::Status::Running;
                    return;
                case ActiveOrTerminatedSkillStatus::Failed:
                    ret = core::dto::Execution::Status::Failed;
                    return;
                case ActiveOrTerminatedSkillStatus::Succeeded:
                    ret = core::dto::Execution::Status::Succeeded;
                    return;
                case ActiveOrTerminatedSkillStatus::Aborted:
                    ret = core::dto::Execution::Status::Aborted;
                    return;
            }
            throw error::SkillException(__PRETTY_FUNCTION__, "Should not happen!");
        }
 
        void
        toIce(core::dto::Execution::Status& ret, const TerminatedSkillStatus& status)
        {
            switch (status)
            {
                case TerminatedSkillStatus::Failed:
                    ret = core::dto::Execution::Status::Failed;
                    return;
                case TerminatedSkillStatus::Succeeded:
                    ret = core::dto::Execution::Status::Succeeded;
                    return;
                case TerminatedSkillStatus::Aborted:
                    ret = core::dto::Execution::Status::Aborted;
                    return;
            }
            throw error::SkillException(__PRETTY_FUNCTION__, "Should not happen!");
        }
 
        void
        fromIce(const core::dto::Execution::Status& status, TerminatedSkillStatus& ret)
        {
            switch (status)
            {
                case core::dto::Execution::Status::Constructing:
                    [[fallthrough]];
                case core::dto::Execution::Status::Initializing:
                    [[fallthrough]];
                case core::dto::Execution::Status::Preparing:
                    [[fallthrough]];
                case core::dto::Execution::Status::Running:
                    break;
                case core::dto::Execution::Status::Failed:
                    ret = TerminatedSkillStatus::Failed;
                    return;
                case core::dto::Execution::Status::Succeeded:
                    ret = TerminatedSkillStatus::Succeeded;
                    return;
                case core::dto::Execution::Status::Aborted:
                    ret = TerminatedSkillStatus::Aborted;
                    return;
            }
            throw error::SkillException(
                __PRETTY_FUNCTION__,
                "You entered an invalid execution status type to convert to a terminating status.");
        }
 
        void
        fromIce(const core::dto::Execution::Status& status, ActiveOrTerminatedSkillStatus& ret)
        {
            switch (status)
            {
                case core::dto::Execution::Status::Constructing:
                    [[fallthrough]];
                case core::dto::Execution::Status::Initializing:
                    [[fallthrough]];
                case core::dto::Execution::Status::Preparing:
                    break;
                case core::dto::Execution::Status::Running:
                    ret = ActiveOrTerminatedSkillStatus::Running;
                    return;
                case core::dto::Execution::Status::Failed:
                    ret = ActiveOrTerminatedSkillStatus::Failed;
                    return;
                case core::dto::Execution::Status::Succeeded:
                    ret = ActiveOrTerminatedSkillStatus::Succeeded;
                    return;
                case core::dto::Execution::Status::Aborted:
                    ret = ActiveOrTerminatedSkillStatus::Aborted;
                    return;
            }
            throw error::SkillException(
                __PRETTY_FUNCTION__,
                "You entered an invalid execution status type to convert to a terminating status.");
        }
 
        void
        fromIce(const core::dto::Execution::Status& status, SkillStatus& ret)
        {
            switch (status)
            {
                case core::dto::Execution::Status::Constructing:
                    ret = SkillStatus::Constructing;
                    return;
                case core::dto::Execution::Status::Initializing:
                    ret = SkillStatus::Initializing;
                    return;
                case core::dto::Execution::Status::Preparing:
                    ret = SkillStatus::Preparing;
                    return;
                case core::dto::Execution::Status::Running:
                    ret = SkillStatus::Running;
                    return;
                case core::dto::Execution::Status::Failed:
                    ret = SkillStatus::Failed;
                    return;
                case core::dto::Execution::Status::Succeeded:
                    ret = SkillStatus::Succeeded;
                    return;
                case core::dto::Execution::Status::Aborted:
                    ret = SkillStatus::Aborted;
                    return;
            }
            throw error::SkillException(__PRETTY_FUNCTION__, "Should not happen!");
        }
 
        manager::dto::SkillStatusUpdate
        SkillStatusUpdateBase::toManagerIce() const
        {
            manager::dto::SkillStatusUpdate ret;
            ret.executionId.skillId = executionId.skillId.toManagerIce();
            ret.executionId.executorName = executionId.executorName;
            armarx::core::time::toIce(ret.executionId.executionStartedTime,
                                      executionId.executionStartedTime);
            ret.parameters = aron::data::Dict::ToAronDictDTO(parameters);
            ret.callbackInterface = callbackInterface;
            ret.result = aron::data::Dict::ToAronDictDTO(result);
            return ret;
        }
 
        provider::dto::SkillStatusUpdate
        SkillStatusUpdateBase::toProviderIce() const
        {
            provider::dto::SkillStatusUpdate ret;
            ret.executionId.skillId = executionId.skillId.toProviderIce();
            ret.executionId.executorName = executionId.executorName;
            armarx::core::time::toIce(ret.executionId.executionStartedTime,
                                      executionId.executionStartedTime);
            ret.parameters = aron::data::Dict::ToAronDictDTO(parameters);
            ret.callbackInterface = callbackInterface;
            ret.result = aron::data::Dict::ToAronDictDTO(result);
            return ret;
        }
 
        manager::dto::SkillStatusUpdate
        TerminatedSkillStatusUpdate::toManagerIce() const
        {
            manager::dto::SkillStatusUpdate ret = SkillStatusUpdateBase::toManagerIce();
            skills::toIce(ret.status, status);
            return ret;
        }
 
        provider::dto::SkillStatusUpdate
        TerminatedSkillStatusUpdate::toProviderIce() const
        {
            provider::dto::SkillStatusUpdate ret = SkillStatusUpdateBase::toProviderIce();
            skills::toIce(ret.status, status);
            return ret;
        }
 
        manager::dto::SkillStatusUpdate
        SkillStatusUpdate::toManagerIce() const
        {
            manager::dto::SkillStatusUpdate ret = SkillStatusUpdateBase::toManagerIce();
            skills::toIce(ret.status, status);
            return ret;
        }
 
        provider::dto::SkillStatusUpdate
        SkillStatusUpdate::toProviderIce() const
        {
            provider::dto::SkillStatusUpdate ret = SkillStatusUpdateBase::toProviderIce();
            skills::toIce(ret.status, status);
            return ret;
        }
 
        manager::dto::SkillStatusUpdate
        ActiveOrTerminatedSkillStatusUpdate::toManagerIce() const
        {
            manager::dto::SkillStatusUpdate ret = SkillStatusUpdateBase::toManagerIce();
            skills::toIce(ret.status, status);
            return ret;
        }
 
        provider::dto::SkillStatusUpdate
        ActiveOrTerminatedSkillStatusUpdate::toProviderIce() const
        {
            provider::dto::SkillStatusUpdate ret = SkillStatusUpdateBase::toProviderIce();
            skills::toIce(ret.status, status);
            return ret;
        }
 
        template <class BoT, class DtoT>
        static void
        setResultFromIce(BoT& bo, const DtoT& dto)
        {
            if (dto.result)
            {
                bo.result = aron::make_dict(dto.result);
            }
        }
 
        TerminatedSkillStatusUpdate
        TerminatedSkillStatusUpdate::FromIce(const manager::dto::SkillStatusUpdate& update)
        {
            TerminatedSkillStatusUpdate ret{
                {.executionId = skills::SkillExecutionID::FromIce(update.executionId),
                 .parameters = armarx::aron::data::Dict::FromAronDictDTO(update.parameters),
                 .callbackInterface = update.callbackInterface}};
            skills::fromIce(update.status, ret.status);
            setResultFromIce(ret, update);
            return ret;
        }
 
        TerminatedSkillStatusUpdate
        TerminatedSkillStatusUpdate::FromIce(const provider::dto::SkillStatusUpdate& update,
                                             const std::optional<skills::ProviderID>& providerId)
        {
            TerminatedSkillStatusUpdate ret{
                {.executionId = skills::SkillExecutionID::FromIce(update.executionId, providerId),
                 .parameters = armarx::aron::data::Dict::FromAronDictDTO(update.parameters),
                 .callbackInterface = update.callbackInterface}};
            skills::fromIce(update.status, ret.status);
            setResultFromIce(ret, update);
            return ret;
        }
 
        SkillStatusUpdate
        SkillStatusUpdate::FromIce(const manager::dto::SkillStatusUpdate& update)
        {
            SkillStatusUpdate ret{{
                .executionId = skills::SkillExecutionID::FromIce(update.executionId),
                .parameters = armarx::aron::data::Dict::FromAronDictDTO(update.parameters),
                .callbackInterface = update.callbackInterface,
            }};
            skills::fromIce(update.status, ret.status);
            setResultFromIce(ret, update);
            return ret;
        }
 
        SkillStatusUpdate
        SkillStatusUpdate::FromIce(const provider::dto::SkillStatusUpdate& update,
                                   const std::optional<skills::ProviderID>& providerId)
        {
            SkillStatusUpdate ret{
                {.executionId = skills::SkillExecutionID::FromIce(update.executionId, providerId),
                 .parameters = armarx::aron::data::Dict::FromAronDictDTO(update.parameters),
                 .callbackInterface = update.callbackInterface,
                 .result = armarx::aron::data::Dict::FromAronDictDTO(update.result)}};
            skills::fromIce(update.status, ret.status);
            setResultFromIce(ret, update);
            return ret;
        }
 
        ActiveOrTerminatedSkillStatusUpdate
        ActiveOrTerminatedSkillStatusUpdate::FromIce(const manager::dto::SkillStatusUpdate& update)
        {
            ActiveOrTerminatedSkillStatusUpdate ret{
                {.executionId = skills::SkillExecutionID::FromIce(update.executionId),
                 .parameters = armarx::aron::data::Dict::FromAronDictDTO(update.parameters),
                 .callbackInterface = update.callbackInterface}};
            skills::fromIce(update.status, ret.status);
            setResultFromIce(ret, update);
            return ret;
        }
 
        ActiveOrTerminatedSkillStatusUpdate
        ActiveOrTerminatedSkillStatusUpdate::FromIce(
            const provider::dto::SkillStatusUpdate& update,
            const std::optional<skills::ProviderID>& providerId)
        {
            ActiveOrTerminatedSkillStatusUpdate ret{
                {.executionId = skills::SkillExecutionID::FromIce(update.executionId, providerId),
                 .parameters = armarx::aron::data::Dict::FromAronDictDTO(update.parameters),
                 .callbackInterface = update.callbackInterface}};
            skills::fromIce(update.status, ret.status);
            setResultFromIce(ret, update);
            return ret;
        }
 
        bool
        SkillStatusUpdate::operator<(const SkillStatusUpdate& o) const
        {
            if (!hasBeenConstructed() and o.hasBeenConstructed())
            {
                return true;
            }
            if (!hasBeenInitialized() and o.hasBeenInitialized())
            {
                return true;
            }
            if (!hasBeenPrepared() and o.hasBeenPrepared())
            {
                return true;
            }
            if (!hasBeenRunning() and o.hasBeenRunning())
            {
                return true;
            }
            if (!hasBeenTerminated() and o.hasBeenTerminated())
            {
                return true;
            }
            return false;
        }
 
        bool
        SkillStatusUpdate::operator<=(const SkillStatusUpdate& o) const
        {
            if (status == o.status)
            {
                return true;
            }
            return *this < o;
        }
 
        bool
        SkillStatusUpdate::hasBeenConstructed() const
        {
            return status != SkillStatus::Constructing;
        }
 
        bool
        SkillStatusUpdate::hasBeenInitialized() const
        {
            return status != SkillStatus::Initializing && hasBeenConstructed();
        }
 
        bool
        SkillStatusUpdate::hasBeenPrepared() const
        {
            return status != SkillStatus::Preparing && hasBeenInitialized();
        }
 
        bool
        SkillStatusUpdate::hasBeenRunning() const
        {
            return status != SkillStatus::Running || hasBeenPrepared();
        }
 
        bool
        SkillStatusUpdate::hasBeenTerminated() const
        {
            return status == SkillStatus::Succeeded || status == SkillStatus::Failed ||
                   status == SkillStatus::Aborted;
        }
 
        bool
        SkillStatusUpdate::hasBeenSucceeded() const
        {
            return status == SkillStatus::Succeeded;
        }
 
        bool
        ActiveOrTerminatedSkillStatusUpdate::hasBeenTerminated() const
        {
            return status == ActiveOrTerminatedSkillStatus::Succeeded ||
                   status == ActiveOrTerminatedSkillStatus::Failed ||
                   status == ActiveOrTerminatedSkillStatus::Aborted;
        }
 
        bool
        ActiveOrTerminatedSkillStatusUpdate::hasBeenSucceeded() const
        {
            return status == ActiveOrTerminatedSkillStatus::Succeeded;
        }
 
        bool
        TerminatedSkillStatusUpdate::hasBeenTerminated() const
        {
            return true;
        }
 
        bool
        TerminatedSkillStatusUpdate::hasBeenSucceeded() const
        {
            return status == TerminatedSkillStatus::Succeeded;
        }
 
        bool
        skillExecutionFailed(
            const std::optional<armarx::skills::TerminatedSkillStatusUpdate>& update)
        {
            if (not update.has_value())
            {
                ARMARX_VERBOSE << "No skill termination update available.";
                return true;
            }
 
            if (not update->hasBeenSucceeded())
            {
                ARMARX_VERBOSE << "Skill execution failed.";
                return true;
            }
 
            return false;
        }
 
        bool
        skillExecutionSucceeded(
            const std::optional<armarx::skills::TerminatedSkillStatusUpdate>& update)
        {
            if (not update.has_value())
            {
                ARMARX_VERBOSE << "No skill termination update available.";
                return false;
            }
 
            if (not update->hasBeenSucceeded())
            {
                ARMARX_VERBOSE << "Skill execution failed.";
                return false;
            }
 
            return true;
        }
    } // namespace skills
} // namespace armarx