FluxioParameter.cpp

Go to the documentation of this file.

#include "FluxioParameter.h"
#include <vector>
 
#include <ArmarXCore/core/logging/Logging.h>
 
#include "RobotAPI/libraries/aron/core/type/variant/Variant.h"
#include "RobotAPI/libraries/aron/core/type/variant/container/Object.h"
#include "RobotAPI/libraries/skills/core/FluxioProfile.h"
#include <RobotAPI/interface/skills/SkillManagerInterface.h>
#include <RobotAPI/libraries/skills/core/aron/FluxioParameter.aron.generated.h>
#include <RobotAPI/libraries/skills/core/aron/FluxioValue.aron.generated.h>
 
#include "FluxioValue.h"
 
namespace armarx
{
    namespace skills
    {
        manager::dto::FluxioParameter
        FluxioParameter::toManagerIce() const
        {
            manager::dto::FluxioParameter ret;
 
            ret.id = id;
            ret.name = name;
            ret.description = description;
            ret.type = typeIdentificator.toManagerIce();
            ret.required = required;
            ret.isInput = isInput;
 
            skills::manager::dto::FluxioValueList ret_values;
            for (const FluxioValue& value : values)
            {
                const auto& v = value.toManagerIce();
 
                if (!v.has_value())
                {
                    ARMARX_WARNING << "Value could not be converted.";
                    continue;
                }
 
                ret_values.push_back(v.value());
            }
            ret.values = ret_values;
 
            return ret;
        }
 
        manager::dto::FluxioIdentificator
        FluxioParameter::toFluxioIdentificatorIce() const
        {
            manager::dto::FluxioIdentificator ret;
            ret.id = id;
            ret.hint = name;
            return ret;
        }
 
        void
        FluxioParameter::updateFromIce(const manager::dto::FluxioParameter& i,
                                       std::map<std::string, FluxioProfile>& profilesMap,
                                       std::map<std::string, aron::type::ObjectPtr>& typesMap)
        {
            name = i.name;
            description = i.description;
            typeIdentificator = FluxioTypeIdentificator::FromIce(i.type);
            type = typesMap[typeIdentificator.skillId]->getMemberType(
                typeIdentificator.parameterId); // TODO: Error handling
            required = i.required;
            isInput = i.isInput;
            this->updateValuesFromIce(i.values, profilesMap);
        }
 
        void
        FluxioParameter::updateFromAron(const manager::arondto::FluxioParameter& i,
                                       std::map<std::string, FluxioProfile>& profilesMap,
                                       std::map<std::string, aron::type::ObjectPtr>& typesMap)
        {
            name = i.name;
            description = i.description;
            typeIdentificator = FluxioTypeIdentificator::FromAron(i.type);
            type = typesMap[typeIdentificator.skillId]->getMemberType(
                typeIdentificator.parameterId); // TODO: Error handling
            required = i.required;
            isInput = i.isInput;
            this->updateValuesFromAron(i.values, profilesMap);
        }
 
        void
        FluxioParameter::updateValuesFromIce(const manager::dto::FluxioValueList& i,
                                             std::map<std::string, FluxioProfile>& profilesMap)
        {
            values.clear(); // clear old values and create them anew
            for (const auto& value : i)
            {
                const auto& v = FluxioValue::FromIce(value, profilesMap);
 
                if (!v.has_value())
                {
                    // TODO: error handling
                    ARMARX_WARNING << "Value could not be converted.";
                    continue;
                }
 
                values.push_back(v.value());
            }
        }
 
        void
        FluxioParameter::updateValuesFromAron(const std::vector<manager::arondto::FluxioValue>& i,
                                             std::map<std::string, FluxioProfile>& profilesMap)
        {
            values.clear(); // clear old values and create them anew
            for (const auto& value : i)
            {
                const auto& v = FluxioValue::FromAron(value, profilesMap);
 
                if (!v.has_value())
                {
                    // TODO: error handling
                    ARMARX_WARNING << "Value could not be converted.";
                    continue;
                }
 
                values.push_back(v.value());
            }
        }
 
        std::experimental::observer_ptr<const FluxioParameter>
        FluxioParameter::FromFluxioIdentificatorIce(
            const manager::dto::FluxioIdentificator& i,
            const std::map<std::string, FluxioParameter>& parametersMap)
        {
            const auto& parameterIt = parametersMap.find(i.id);
 
            if (parameterIt == parametersMap.end())
            {
                ARMARX_WARNING << "Parameter with id " << i.id << " not found";
                return nullptr;
            }
 
            return std::experimental::make_observer(&parameterIt->second);
        }
 
        std::experimental::observer_ptr<const FluxioParameter>
        FluxioParameter::FromFluxioIdentificatorAron(
            const manager::arondto::FluxioIdentificator& i,
            const std::map<std::string, FluxioParameter>& parametersMap)
        {
            const auto& parameterIt = parametersMap.find(i.id);
 
            if (parameterIt == parametersMap.end())
            {
                ARMARX_WARNING << "Parameter with id " << i.id << " not found";
                return nullptr;
            }
 
            return std::experimental::make_observer(&parameterIt->second);
        }
 
        FluxioParameter
        FluxioParameter::FromIce(const manager::dto::FluxioParameter& i,
                                 std::map<std::string, FluxioProfile>& profilesMap,
                                 std::map<std::string, aron::type::ObjectPtr>& typesMap)
        {
            FluxioParameter ret;
 
            ret.id = i.id;
            ret.name = i.name;
            ret.description = i.description;
            ret.typeIdentificator = FluxioTypeIdentificator::FromIce(i.type);
            ret.type = typesMap[ret.typeIdentificator.skillId]->getMemberType(
                ret.typeIdentificator.parameterId); // TODO: Error handling
            ret.required = i.required;
            ret.isInput = i.isInput;
 
            for (const manager::dto::FluxioValue& value : i.values)
            {
                const auto& v = FluxioValue::FromIce(value, profilesMap);
 
                if (!v.has_value())
                {
                    ARMARX_WARNING << "Value could not be converted.";
                    continue;
                }
 
                ret.values.push_back(v.value());
            }
 
            return ret;
        }
 
        FluxioParameter
        FluxioParameter::FromAron(const manager::arondto::FluxioParameter& i,
                                 std::map<std::string, FluxioProfile>& profilesMap,
                                 std::map<std::string, aron::type::ObjectPtr>& typesMap)
        {
            FluxioParameter ret;
 
            ret.id = i.id;
            ret.name = i.name;
            ret.description = i.description;
            ret.typeIdentificator = FluxioTypeIdentificator::FromAron(i.type);
            ret.type = typesMap[ret.typeIdentificator.skillId]->getMemberType(
                ret.typeIdentificator.parameterId); // TODO: Error handling
            ret.required = i.required;
            ret.isInput = i.isInput;
 
            for (const manager::arondto::FluxioValue& value : i.values)
            {
                const auto& v = FluxioValue::FromAron(value, profilesMap);
 
                if (!v.has_value())
                {
                    ARMARX_WARNING << "Value could not be converted.";
                    continue;
                }
 
                ret.values.push_back(v.value());
            }
 
            return ret;
        }
 
        manager::arondto::FluxioParameter
        FluxioParameter::toAron() const
        {
            manager::arondto::FluxioParameter ret;
 
            ret.id = id;
            ret.name = name;
            ret.description = description;
            ret.type = typeIdentificator.toAron();
            ret.required = required;
            ret.isInput = isInput;
 
            std::vector<manager::arondto::FluxioValue> ret_values;
            for (const FluxioValue& value : values)
            {
                const auto& v = value.toAron();
 
                if (!v.has_value())
                {
                    ARMARX_WARNING << "Value could not be converted.";
                    continue;
                }
 
                ret_values.push_back(v.value());
            }
            ret.values = ret_values;
 
            return ret;
        }
 
        manager::arondto::FluxioIdentificator
        FluxioParameter::toFluxioIdentificatorAron() const
        {
            manager::arondto::FluxioIdentificator ret;
            ret.id = id;
            ret.hint = name;
            return ret;
        }
    } // namespace skills
} // namespace armarx