ParametrizedObject.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_PARAMETRIZED_OBJECT_H
#define GRAIL_PARAMETRIZED_OBJECT_H
 
#include "TypedObjectParameter.hh"
#include "../../MemoryPool.hh"
 
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace grail
{
namespace planner
{
    class ParametrizedObject
    {
    public:
        virtual ~ParametrizedObject() = default;
 
        //REVIEW: dox comments
        void MergeParameters(const ParametrizedObject& other);
 
        std::size_t GetParametersSize() const;
 
        bool Contains(const std::string& paramName) const;
 
        template <typename ParameterType>
        void SetParameter(const std::string& paramName, const ParameterType& paramValue)
        {
            parameters[paramName] = &memory->template Emplace<TypedObjectParameter<ParameterType>>(paramValue);
        }
 
        template <typename ParameterType>
        ParameterType GetParameterValue(const std::string& paramName) const
        {
            auto param = GetParameter(paramName);
            if(param != nullptr)
            {
                return param->GetValue<ParameterType>();
            }
            return ParameterType();
        }
 
        bool CollectionContains(const std::string& collectionName, unsigned int objectIndex) const;
 
        void AddCollection(const std::string& collectionName);
        std::set<unsigned int>* GetCollection(const std::string& name);
        const std::set<unsigned int>* GetCollection(const std::string& name) const;
 
        bool HasEqualParams(const ParametrizedObject& other) const;
        void SerializeSnapshot(std::map<std::string, std::string>& nameValues) const;
        void SetSerializeSnapshotFunction(
            std::function<void(const ParametrizedObject& object,
                               std::map<std::string, std::string>& nameValues)> function);
 
        ParametrizedObject& operator =(const ParametrizedObject& other);
        ParametrizedObject& operator=(ParametrizedObject&& other) = default;
 
    protected:
        ParametrizedObject(MemoryPool* memory);
        ParametrizedObject(const ParametrizedObject& other);
        ParametrizedObject(ParametrizedObject&& other) = default;
 
        std::map<std::string, ObjectParameter*> parameters{};
        std::map<std::string, std::set<unsigned int>> indexCollections{};
        MemoryPool* memory;
 
    private:
        const ObjectParameter* GetParameter(const std::string& paramName) const;
        ObjectParameter* GetParameter(const std::string& paramName);
        std::function<void(const ParametrizedObject& object, std::map<std::string, std::string>&)>
        serializeSnapshotFunction = nullptr;
    };
}
}
 
#endif //GRAIL_PARAMETRIZED_OBJECT_H