Selector.hh

#ifndef GRAIL_SELECTOR_H
#define GRAIL_SELECTOR_H
 
#include "../GrailEvaluators/Evaluator.hh"
#include "Blueprint.hh"
#include "../GrailData/DebugInfo/UtilityReasonerSnapshot.h"
#include "../GrailData/UtilityModel/UtilitySelectorModel.h"
 
#include <limits>
#include <random>
#include <vector>
#include <functional>
 
namespace grail
{
    namespace utility
    {
        static const std::string MAX = "Max";
        static const std::string ROULETTE = "Roulette";
 
        template <typename ContextType>
        struct Option
        {
            ContextType context{};
            std::shared_ptr<Evaluator<ContextType>> evaluator{};
            std::string evaluatedObjectName{};
            std::string evaluatedObjectMetadata{};
            int rank{};
        };
 
 
        struct SelectionResult
        {
            SelectionResult(bool isDebugging = false)
            {
                if(isDebugging)
                {
                    snapshot = std::make_unique<UtilityReasonerSnapshot>();
                }
            }
 
            UtilityEvaluatorSnapshot* FetchNextEvaluatorSnapshot(const std::string& evaluatedObjectName, 
                const std::string& evaluatedObjectMetadata, int rank)
            {
                if(snapshot != nullptr)
                {
                    snapshot->evaluatorSnapshots.emplace_back(evaluatedObjectName, evaluatedObjectMetadata, rank);
                    return &snapshot->evaluatorSnapshots.back();
                }
                return nullptr;
            }
 
            bool IsValid() const
            {
                return optionIndex != std::numeric_limits<std::size_t>::max();
            }
 
            std::unique_ptr<UtilityReasonerSnapshot> snapshot{nullptr};
            std::size_t optionIndex = std::numeric_limits<std::size_t>::max();
        };
 
        namespace selector
        {
            template <typename ContextType>
            void SelectMaxUtility(const std::vector<Option<ContextType>>& options,
                                  SelectionResult& result,
                                  std::function<bool(const std::size_t&)> validator)
            {
 
                float bestWeight = std::numeric_limits<float>::min();
                int bestRank = std::numeric_limits<int>::min();
 
                for (std::size_t i = 0; i < options.size(); ++i)
                {
                    if (!validator(i))
                        continue;
 
                    auto& option = options[i];
 
                    int rank = option.rank;
                    float weight = option.evaluator->EvaluateContext(option.context,
                                                                     result.FetchNextEvaluatorSnapshot(option.evaluatedObjectName, 
                                                                         option.evaluatedObjectMetadata, rank));
 
                    if (rank > bestRank || (rank == bestRank && weight > bestWeight))
                    {
                        bestRank = rank;
                        bestWeight = weight;
                        result.optionIndex = i;
                    }
                }
            }
 
            template <typename ContextType>
            void GetBestOption(SelectionMethod selectionMethod,
                               const std::vector<Option<ContextType>>& options,
                               SelectionResult& result,
                               std::function<bool(const std::size_t&)> validator = [](const std::size_t&) -> bool { return true; })
            {
                switch (selectionMethod)
                {
                case SelectionMethod::MAX:
                    SelectMaxUtility<ContextType>(options, result, validator);
                    break;
                default:
                    break; //TODO: crash?
                    //REVIEW: resolve todo above
                }
            }
        }
    }
}
#endif  //GRAIL_SELECTOR_H