FluxioExecutor.cpp

Go to the documentation of this file.

#include "FluxioExecutor.h"
 
#include <memory>
#include <mutex>
 
#include <ArmarXCore/core/logging/Logging.h>
 
#include "RobotAPI/libraries/aron/core/data/variant/Variant.h"
#include "RobotAPI/libraries/skills/core/FluxioProfile.h"
#include "RobotAPI/libraries/skills/core/FluxioValue.h"
 
#include "../SkillStatusUpdate.h"
 
namespace armarx::skills
{
    void
    FluxioExecutor::setStatus(skills::SkillStatus status, const std::string& nodeId)
    {
        const skills::FluxioSkillStatusUpdate update = {.timestamp = armarx::DateTime::Now(),
                                                        .executionId = this->id,
                                                        .subSkillNodeId = nodeId,
                                                        .status = status};
 
        std::scoped_lock statusLock(statusMutex, statusUpdatesMutex);
        this->status = update;
        this->statusUpdates.push_front(update);
    }
 
    armarx::aron::data::VariantPtr
    FluxioExecutor::getPossibleInputCopy(const std::string nodeId, const std::string parameterId)
    {
        std::scoped_lock l(possibleInputsMutex);
        const auto& dictIt = possibleInputs.find(nodeId);
        if (dictIt == possibleInputs.end())
        {
            ARMARX_WARNING << "No possible input found for node " << nodeId;
            return nullptr;
        }
        if (dictIt->second == nullptr || !dictIt->second->hasElement(parameterId))
        {
            ARMARX_WARNING << "No possible input found for parameter " << parameterId;
            return nullptr;
        }
        const auto& res = dictIt->second->getElement(parameterId);
        if (res == nullptr)
        {
            return nullptr;
        }
        return res->cloneAsVariant();
    }
 
    armarx::aron::data::DictPtr
    FluxioExecutor::getResultsCopy()
    {
        std::scoped_lock l(resultMutex);
        if (result == nullptr)
        {
            return nullptr;
        }
 
        return result->clone();
    }
 
    std::optional<std::vector<skills::FluxioSkillStatusUpdate>>
    FluxioExecutor::getStatusUpdate()
    {
        return std::nullopt;
    }
 
    std::optional<skills::FluxioSkillStatusUpdate>
    FluxioExecutor::getStatus() const
    {
        return status;
    }
 
    armarx::aron::data::VariantPtr
    FluxioExecutor::findParameterValue(
        const std::experimental::observer_ptr<const FluxioProfile> profilePtr,
        const FluxioParameter& parameter) const
    {
        std::experimental::observer_ptr<const FluxioProfile> idPtr = profilePtr;
        armarx::aron::data::VariantPtr value = nullptr;
        while (value == nullptr)
        {
            const auto& valueIt = std::find_if(parameter.values.begin(),
                                               parameter.values.end(),
                                               [idPtr](const FluxioValue& v)
                                               { return v.profilePtr->id == idPtr->id; });
            if (valueIt == parameter.values.end())
            {
                if (idPtr->parentPtr == nullptr)
                {
                    ARMARX_WARNING << "Value for parameter " << parameter.id
                                   << " not found in profile " << profilePtr->id;
                    return nullptr;
                }
                idPtr = idPtr->parentPtr;
            }
            else
            {
                value = valueIt->content;
            }
        }
        return value->cloneAsVariant();
    }
} // namespace armarx::skills