EvaluatorHelpers.h

#ifndef GRAIL_EVALUATOR_HELPERS_H
#define GRAIL_EVALUATOR_HELPERS_H
 
#include "../Curves/Curve.hh"
#include "../Aggregators/Aggregator.hh"
#include "../../GrailCore/Logger/LoggerManager.hh"
#include "../Aggregators/AverageAggregator.hh"
#include "../Aggregators/MaxAggregator.hh"
#include "../Aggregators/MinAggregator.hh"
#include "../Aggregators/ProductAggregator.hh"
#include "../Aggregators/SumAggregator.hh"
#include "../Curves/AllCurves.h"
#include "../../GrailData/UtilityModel/EvaluatorNodeModel.h"
#include "../../GrailData/UtilityModel/EvaluatorTreeModel.h"
#include "../../GrailData/UtilityModel/EvaluatorTreeReference.h"
#include "IConsiderationProvider.h"
 
#include <algorithm>
#include <sstream>
 
 
namespace grail
{
    namespace helpers
    {
        template<typename ContextType>
        std::shared_ptr<utility::Aggregator<ContextType>> ConstructAggregator(const std::vector<std::shared_ptr<utility::Evaluator<ContextType>>>& inputEvaluators,
            EvaluatorType evaluatorType)
 
        {
            switch (evaluatorType)
            {
                case EvaluatorType::AGGREGATOR_MIN:
                {
                    return std::make_shared<utility::MinAggregator<utility::EntityBlackboardPair>>(inputEvaluators);
                }
                case EvaluatorType::AGGREGATOR_MAX:
                {
                    return std::make_shared<utility::MaxAggregator<utility::EntityBlackboardPair>>(inputEvaluators);
                }
                case EvaluatorType::AGGREGATOR_AVERAGE:
                {
                    return std::make_shared<utility::AverageAggregator<utility::EntityBlackboardPair>>(inputEvaluators);
                }
                case EvaluatorType::AGGREGATOR_PRODUCT:
                {
                    return std::make_shared<utility::ProductAggregator<utility::EntityBlackboardPair>>(inputEvaluators);
                }
                case EvaluatorType::AGGREGATOR_SUM:
                {
                    return std::make_shared<utility::SumAggregator<utility::EntityBlackboardPair>>(inputEvaluators);
                }
                default:
                {
                    GRAIL_LOG(consts::DEFAULT_GRAIL_LOG_GROUP, grail::Severity::ERRORS, "Invalid aggregator type");
                    return nullptr;
                }
            }
        }
 
        template<typename ContextType>
        std::shared_ptr<curves::Curve<ContextType>> ConstructCurve(const std::shared_ptr<utility::Evaluator<ContextType>>& inputEvaluator,
            EvaluatorType evaluatorType, const std::vector<float>& curveParameters)
        {
            switch (evaluatorType)
            {
                case EvaluatorType::CURVE_LINEAR:
                {
                    return std::make_shared<curves::LinearFunction<utility::EntityBlackboardPair>>(inputEvaluator, curveParameters[0],
                        curveParameters[1]);
                }
                case EvaluatorType::CURVE_POWER:
                {
                    return std::make_shared<curves::PowerFunction<utility::EntityBlackboardPair>>(inputEvaluator, curveParameters[0],
                        curveParameters[1],
                        curveParameters[2]);
                }
                case EvaluatorType::CURVE_SIGMOID:
                {
                    return std::make_shared<curves::SigmoidFunction<utility::EntityBlackboardPair>>(inputEvaluator, curveParameters[0],
                        curveParameters[1],
                        curveParameters[2],
                        curveParameters[3]);
                }
                case EvaluatorType::CURVE_UNIT_STEP:
                {
                    return std::make_shared<curves::UnitStepFunction<utility::EntityBlackboardPair>>(inputEvaluator, curveParameters[0],
                        curveParameters[1],
                        curveParameters[2]);
                }
                case EvaluatorType::CURVE_EXPONENTIAL:
                {
                    return std::make_shared<curves::ExponentialFunction<utility::EntityBlackboardPair>>(inputEvaluator, curveParameters[0]);
                }
                case EvaluatorType::CURVE_CONSTANT:
                {
                    return std::make_shared<curves::ConstantFunction<utility::EntityBlackboardPair>>(inputEvaluator, curveParameters[0]);
                }
                case EvaluatorType::CURVE_LINEAR_INTERPOLATED:
                {
                    std::vector<Vector2> points{};
                    for (size_t i = 0; i < curveParameters.size(); i += 2)
                    {
                        points.emplace_back(curveParameters[i], curveParameters[i + 1]);
                    }
 
                    return std::make_shared<curves::LinearlyInterpolatedCurve<utility::EntityBlackboardPair>>(inputEvaluator, points);
                }
                case EvaluatorType::CURVE_BEZIER:
                {
                    std::vector<Vector2> points{};
                    std::vector<Vector2> tangents{};
 
                    for (size_t i = 0; i < curveParameters.size(); i += 4)
                    {
                        points.emplace_back(curveParameters[i], curveParameters[i + 1]);
                        tangents.emplace_back(curveParameters[i + 2], curveParameters[i + 3]);
                    }
 
                    return std::make_shared<curves::BezierSpline<utility::EntityBlackboardPair>>(inputEvaluator, points, tangents);
                }
                case EvaluatorType::CURVE_STAIRCASE:
                {
                    std::vector<grail::curves::StepData> stepData{};
                    for (size_t i = 0; i < curveParameters.size(); i += 2)
                    {
                        grail::curves::StepData data;
                        data.startPoint = curveParameters[i];
                        data.value = curveParameters[i + 1];
                        data.inclusiveStartPoint = true;
                        stepData.emplace_back(data);
                    }
 
                    return std::make_shared<curves::StaircaseFunction<utility::EntityBlackboardPair>>(inputEvaluator, stepData);
                }
                case EvaluatorType::CURVE_LOWER_BOUND:
                {
                    return std::make_shared<curves::LowerBound<utility::EntityBlackboardPair>>(inputEvaluator, curveParameters[0]);
                }
                case EvaluatorType::CURVE_UPPER_BOUND:
                {
                    return std::make_shared<curves::UpperBound<utility::EntityBlackboardPair>>(inputEvaluator, curveParameters[0]);
                }
                case EvaluatorType::CURVE_DOUBLE_SIDED_BOUND:
                {
                    return std::make_shared<curves::DoubleSidedBound<utility::EntityBlackboardPair>>(inputEvaluator, curveParameters[0], curveParameters[1]);
                }
                default:
                {
                    GRAIL_LOG(consts::DEFAULT_GRAIL_LOG_GROUP, grail::Severity::ERRORS, "Invalid curve data type");
                    return nullptr;
                }
            }
        }
 
 
        namespace internal
        {
            enum class EvaluatorTypeGroup
            {
                CONSIDERATION,
                CURVE,
                AGGREGATOR,
                SUBTREE_REFERENCE,
            };
 
            EvaluatorTypeGroup GetEvaluatorTypeGroup(EvaluatorType evaluatorType);
            EvaluatorNodeModel ResolveSubtreeDependencies(const EvaluatorNodeModel& inputModel,
                const std::vector<EvaluatorTreeModel>& savedSubtrees);
 
            template<typename ContextType>
            std::shared_ptr<utility::Evaluator<ContextType>> ConstructEvaluator(const EvaluatorNodeModel& resolvedModel,
                const std::shared_ptr<const IConsiderationProvider<ContextType>>& considerationProvider)
            {
                EvaluatorTypeGroup evaluatorTypeGroup = GetEvaluatorTypeGroup(resolvedModel.evaluatorTypeId);
                switch (evaluatorTypeGroup)
                {
                    case EvaluatorTypeGroup::CONSIDERATION:
                    {
                        if (resolvedModel.inputEvaluatorModels.size() != 0)
                        {
                            std::stringstream ss;
                            ss << "Invalid config for consideration " << resolvedModel.considerationModel.name <<
                                ": considerations don't accept inputs";
                            GRAIL_LOG(consts::DEFAULT_GRAIL_LOG_GROUP, grail::Severity::ERRORS, ss.str());
                            return nullptr;
                        }
                        return considerationProvider->GetConsiderationByName(resolvedModel.considerationModel.name);
                    }
                    case EvaluatorTypeGroup::AGGREGATOR:
                    {
                        std::vector<std::shared_ptr<utility::Evaluator<utility::EntityBlackboardPair>>> inputEvaluators;
                        std::transform(resolvedModel.inputEvaluatorModels.begin(), resolvedModel.inputEvaluatorModels.end(),
                            std::back_inserter(inputEvaluators),
                            [&considerationProvider](const EvaluatorNodeModel& model)
                            {
                                return ConstructEvaluator(model, considerationProvider);
                            });
                        return ConstructAggregator(inputEvaluators, resolvedModel.evaluatorTypeId);
                    }
                    case EvaluatorTypeGroup::CURVE:
                    {
                        if (resolvedModel.inputEvaluatorModels.size() != 1)
                        {
                            std::stringstream ss;
                            ss << "Invalid config for utility curve: " << resolvedModel.inputEvaluatorModels.size() <<
                                " curve inputs provided, expected 1";
                            GRAIL_LOG(consts::DEFAULT_GRAIL_LOG_GROUP, grail::Severity::ERRORS, ss.str());
                            return nullptr;
                        }
 
                        return ConstructCurve(ConstructEvaluator(resolvedModel.inputEvaluatorModels[0], considerationProvider),
                            resolvedModel.evaluatorTypeId, resolvedModel.curveDataModel.curveParameters);
                    }
                    default:
                    {
                        return nullptr;
                    }
                }
            }
        }
 
        template<typename ContextType>
        std::shared_ptr<utility::Evaluator<ContextType>> ConstructEvaluator(const EvaluatorNodeModel& inputModel,
            const std::vector<EvaluatorTreeModel>& evaluatorTreeModels,
            const std::shared_ptr<const IConsiderationProvider<ContextType>>& considerationProvider)
        {
            return internal::ConstructEvaluator(internal::ResolveSubtreeDependencies(inputModel, evaluatorTreeModels), considerationProvider);
        }
    }
}
 
#endif //GRAIL_EVALUATOR_HELPERS_H