ParametrizedObject.h

#ifndef GRAIL_PARAMETRIZED_OBJECT_H
#define GRAIL_PARAMETRIZED_OBJECT_H
 
#include "TypedObjectParameter.h"
#include "../../MemoryPool.hh"
 
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace grail
{
    namespace planning
    {
        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