SkillManagerWrapper.h

Go to the documentation of this file.

#pragma once
 
#include <mutex>
#include <vector>
 
#include <QObject>
 
#include "RobotAPI/libraries/skills/core/ProviderID.h"
#include "RobotAPI/libraries/skills/core/SkillDescription.h"
#include "RobotAPI/libraries/skills/core/SkillExecutionID.h"
#include "RobotAPI/libraries/skills/core/SkillID.h"
#include "RobotAPI/libraries/skills/core/SkillStatusUpdate.h"
#include <RobotAPI/interface/skills/SkillManagerInterface.h>
 
namespace armarx::skills::gui
{
    using StatusMap = std::map<skills::SkillExecutionID, skills::SkillStatusUpdate>;
    using SkillMap =
        std::map<skills::ProviderID, std::map<skills::SkillID, skills::SkillDescription>>;
 
    using Parameters = aron::data::DictPtr;
    using SkillParameterMap =
        std::map<skills::SkillID, std::vector<Parameters>>;
 
    class SkillManagerWrapper : public QObject
    {
        Q_OBJECT
    public:
        SkillManagerWrapper(skills::manager::dti::SkillManagerInterfacePrx& _memory,
                            QObject* parent = nullptr) :
            QObject(parent), memory(_memory)
        {
        }
 
        // We can instantiate the proxy without memory, if it's not connected yet.
        SkillManagerWrapper(QObject* parent = nullptr) : QObject(parent)
        {
        }
 
        /**
         * @brief Updates the memory pointer. This should be called whenever the GUI connects/reconnects.
         */
        void connectMemory(skills::manager::dti::SkillManagerInterfacePrx const& updatedMemory);
 
        // Basic functions to work with. These will produce Ice calls!
        /**
         * @brief Attempts to start an execution with given parameters. If an Ice exception is encountered, a message will be logged and the method will abort.
         * @param skillId The skill to execute.
         * @param params The parameters to execute with.
         */
        void startExecutionWithParams(skills::SkillID& skillId, aron::data::DictPtr const params);
 
        /**
         * @brief Attempts to stop an execution. If this doesn't succeed, it will retry.
         * @param executionId The ExecutionID to abort.
         * @param max_retries The amount of times to retry, if aborting fails.
         */
        void stopExecution(skills::SkillExecutionID const& executionId,
                           const unsigned int max_retries = 0);
 
        static const std::optional<skills::ProviderID> findFirstProvider(SkillMap const& map,
                                                                         SkillID const& skillId);
 
        /**
         * @brief Returns the latest skills snapshot.
         * @return The map representing all currently known skills.
         */
        SkillMap getSkills();
 
        /**
         * @brief Returns the latest skills snapshot.
         * @return The map representing all currently known skills.
         */
        SkillMap getSkillsFiltered();
 
        /**
         * @brief Returns the latest status snapshot.
         * @return The map containing status updates for all execution ids.
         */
        StatusMap getExecutions();
 
        struct Snapshot
        {
            StatusMap statuses;
            SkillMap skills;
 
            // default constructor (construct empty)
            Snapshot() : statuses({}), skills({})
            {
            }
        };
 
    signals:
        void disableAutoUpdate();
        void connectionUpdate(std::string const& message, std::string const& error);
        void updateAvailable(Snapshot update);
        void searchAccepted();
 
    public slots:
        /**
         * @brief Disconnects the interface from memory.
         */
        void disconnectMemory();
 
        /**
         * @brief Applies the search word to the update filter.
         * @param search The search word.
         */
        void acceptSearchRequest(std::string const& search);
 
        /**
         * @brief Stops all available (and running) executions.
         */
        void stopAllExecutions();
 
        /**
         * @brief Requests this wrapper to overwrite its own state from memory.
         */
        void updateFromMemory();
 
        // == Skill Parameters State ==
 
        std::vector<Parameters> getParameterHistoryForSkill(const skills::SkillID& sid);
        void addParametersToHistory(const skills::SkillID& sid, const Parameters& params);
        std::optional<Parameters> getLatestParametersForSkill(const skills::SkillID& sid);
 
    private:
        mutable std::mutex mutex_memory;
        mutable std::mutex mutex_snapshot;
 
        armarx::skills::manager::dti::SkillManagerInterfacePrx memory;
        std::string currentSkillSearch = "";
 
        // Store a list of all execution parameters for each skill 
        SkillParameterMap skillParameterExecutionHistory;
        SkillParameterMap lostParameterHistory;
 
        Snapshot snapshot;
 
        /**
         * @brief Fetches and returns the latest skills update from memory.
         * @return The map representing all skills in memory. Empty, if error occurred.
         */
        SkillMap fetchSkillsFromMemory();
 
        /**
         * @brief Fetches and returns the latest status update from memory.
         * @return The map containing status updates for all execution ids. Empty, if error occurred.
         */
        StatusMap fetchExecutionsFromMemory();
 
        /**
         * @brief Returns the given snapshot, matching the search.
         * @param update The snapshot to modify.
         */
        Snapshot filterUpdate(Snapshot update);
 
        // config
        // TODO: perhaps use proper config file for the gui
 
        // should we do an ice call to use the latest information when requesting an execution?
        static constexpr bool UPDATE_ON_EXECUTION_REQUEST = true;
 
        // ---
    };
} // namespace armarx::skills::gui