SkillStatusUpdate.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
 
#include <ArmarXCore/core/time/DateTime.h>
#include <ArmarXCore/core/time/ice_conversions.h>
 
#include <RobotAPI/interface/skills/SkillProviderInterface.h>
#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
 
#include "SkillExecutionID.h"
#include "SkillID.h"
#include "SkillParameterization.h"
 
namespace armarx
{
    namespace skills
    {
        enum class SkillStatus
        {
            Constructing = 0,
            Initializing = 1,
            Preparing = 2,
            Running = 4,
            Failed = 8,
            Succeeded = 16,
            Aborted = 32
        };
 
        enum class ActiveOrTerminatedSkillStatus
        {
            Running = 2,
            Failed = 4,
            Succeeded = 8,
            Aborted = 16
        };
 
        enum class TerminatedSkillStatus
        {
            Failed = 4,
            Succeeded = 8,
            Aborted = 16
        };
 
        SkillStatus toSkillStatus(const ActiveOrTerminatedSkillStatus&);
        SkillStatus toSkillStatus(const TerminatedSkillStatus&);
 
        void toIce(core::dto::Execution::Status& ret, const SkillStatus& status);
        void toIce(core::dto::Execution::Status& ret, const ActiveOrTerminatedSkillStatus& status);
        void toIce(core::dto::Execution::Status& ret, const TerminatedSkillStatus& status);
 
        void fromIce(const core::dto::Execution::Status& status, TerminatedSkillStatus& ret);
        void fromIce(const core::dto::Execution::Status& status,
                     ActiveOrTerminatedSkillStatus& ret);
        void fromIce(const core::dto::Execution::Status& status, SkillStatus& ret);
 
        TerminatedSkillStatus mergeSkillStatuseses(const TerminatedSkillStatus t1,
                                                   const TerminatedSkillStatus t2);
        ActiveOrTerminatedSkillStatus mergeSkillStatuseses(const ActiveOrTerminatedSkillStatus t1,
                                                           const ActiveOrTerminatedSkillStatus t2);
 
        struct SkillStatusUpdateBase
        {
            // header
            SkillExecutionID executionId;
            aron::data::DictPtr parameters;
            callback::dti::SkillProviderCallbackInterfacePrx callbackInterface;
 
            // data
            aron::data::DictPtr result = nullptr;
 
            manager::dto::SkillStatusUpdate toManagerIce() const;
 
            provider::dto::SkillStatusUpdate toProviderIce() const;
        };
 
        // Will be returned after the execution of a skill
        struct TerminatedSkillStatusUpdate : public SkillStatusUpdateBase
        {
            TerminatedSkillStatus status = TerminatedSkillStatus::Failed;
 
            bool
            hasBeenTerminated() const
            {
                return true;
            }
 
            bool
            hasBeenSucceeded() const
            {
              return status == TerminatedSkillStatus::Succeeded;
            }
 
            manager::dto::SkillStatusUpdate toManagerIce() const;
 
            provider::dto::SkillStatusUpdate toProviderIce() const;
 
            static TerminatedSkillStatusUpdate
            FromIce(const provider::dto::SkillStatusUpdate& update,
                    const std::optional<skills::ProviderID>& providerId = std::nullopt);
 
            static TerminatedSkillStatusUpdate
            FromIce(const manager::dto::SkillStatusUpdate& update);
        };
 
        // Will be returned from periodic skills which can still run
        struct ActiveOrTerminatedSkillStatusUpdate : public SkillStatusUpdateBase
        {
            ActiveOrTerminatedSkillStatus status = ActiveOrTerminatedSkillStatus::Failed;
 
            bool
            hasBeenTerminated() const
            {
                return status == ActiveOrTerminatedSkillStatus::Succeeded ||
                       status == ActiveOrTerminatedSkillStatus::Failed ||
                       status == ActiveOrTerminatedSkillStatus::Aborted;
            }
 
            bool
            hasBeenSucceeded() const
            {
              return status == ActiveOrTerminatedSkillStatus::Succeeded;
            }
 
            manager::dto::SkillStatusUpdate toManagerIce() const;
 
            provider::dto::SkillStatusUpdate toProviderIce() const;
 
            static ActiveOrTerminatedSkillStatusUpdate
            FromIce(const provider::dto::SkillStatusUpdate& update,
                    const std::optional<skills::ProviderID>& providerId = std::nullopt);
 
            static ActiveOrTerminatedSkillStatusUpdate
            FromIce(const manager::dto::SkillStatusUpdate& update);
        };
 
        // Will be used as status updates from skills to the callback interface
        struct SkillStatusUpdate : public SkillStatusUpdateBase
        {
            SkillStatus status = SkillStatus::Constructing;
 
            bool
            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
            operator<=(const SkillStatusUpdate& o) const
            {
                if (status == o.status)
                {
                    return true;
                }
                return *this < o;
            }
 
            bool
            hasBeenConstructed() const
            {
                return status != SkillStatus::Constructing;
            }
 
            bool
            hasBeenInitialized() const
            {
                return status != SkillStatus::Initializing && hasBeenConstructed();
            }
 
            bool
            hasBeenPrepared() const
            {
                return status != SkillStatus::Preparing && hasBeenInitialized();
            }
 
            bool
            hasBeenRunning() const
            {
                return status != SkillStatus::Running || hasBeenPrepared();
            }
 
            bool
            hasBeenTerminated() const
            {
                return status == SkillStatus::Succeeded || status == SkillStatus::Failed ||
                       status == SkillStatus::Aborted;
            }
 
            bool
            hasBeenSucceeded() const
            {
              return status == SkillStatus::Succeeded;
            }
 
            manager::dto::SkillStatusUpdate toManagerIce() const;
 
            provider::dto::SkillStatusUpdate toProviderIce() const;
 
            static SkillStatusUpdate
            FromIce(const provider::dto::SkillStatusUpdate& update,
                    const std::optional<skills::ProviderID>& providerId = std::nullopt);
 
            static SkillStatusUpdate FromIce(const manager::dto::SkillStatusUpdate& update);
        };
    } // namespace skills
} // namespace armarx