MHO_OperatorBuilderManager.hh

Go to the documentation of this file.

#ifndef MHO_OperatorBuilderManager_HH__
#define MHO_OperatorBuilderManager_HH__
 
#include "MHO_ContainerStore.hh"
#include "MHO_JSONHeaderWrapper.hh"
#include "MHO_Message.hh"
#include "MHO_OperatorBuilder.hh"
#include "MHO_OperatorToolbox.hh"
#include "MHO_FringeData.hh"
#include "MHO_ParameterStore.hh"
 
namespace hops
{
 
class MHO_OperatorBuilderManager
{
    public:
        MHO_OperatorBuilderManager(MHO_OperatorToolbox* toolbox, 
                                   MHO_FringeData* fdata, 
                                   mho_json control_format):
            fOperatorToolbox(toolbox),
            fFringeData(fdata),
            fContainerStore(fdata->GetContainerStore() ),
            fParameterStore(fdata->GetParameterStore() )
        {
            fFormat = control_format;
        };
 
        virtual ~MHO_OperatorBuilderManager()
        {
            for(std::size_t i = 0; i < fAllBuilders.size(); i++)
            {
                delete fAllBuilders[i];
            }
            fAllBuilders.clear();
            fNameToBuilderMap.clear();
            fCategoryToBuilderMap.clear();
        }
 
        void SetControlStatements(mho_json* statements) { fControl = statements; };
 
        void CreateDefaultBuilders();
 
        void BuildOperatorCategory(const char* cat)
        {
            std::string scat(cat);
            BuildOperatorCategory(scat);
        };
 
        void BuildOperatorCategory(const std::string& cat);
 
        std::size_t GetNBuildersInCategory(std::string cat);
 
        template< typename XBuilderType > void AddBuilderType(const std::string& builder_name, const std::string& format_key)
        {
            auto format_it = fFormat.find(format_key);
            if(format_it != fFormat.end())
            {
                auto it = fNameToBuilderMap.find(builder_name);
                if(it == fNameToBuilderMap.end()) //not found, so make one
                {
                    auto builder = new XBuilderType(fOperatorToolbox, fFringeData);
                    builder->SetFormat(fFormat[format_key]);
 
                    //the builder's operator category comes from the format specification
                    std::string category = "unknown"; //default's to unknown
                    if(format_it->contains("operator_category"))
                    {
                        category = (*format_it)["operator_category"].get< std::string >();
                    }
                    fAllBuilders.push_back(builder);
                    fNameToBuilderMap.emplace(builder_name, builder);
                    fCategoryToBuilderMap.emplace(category, builder);
                }
            }
            else
            {
                msg_error("initialization", "cannot add builder for operator with format key: " << format_key << eom);
            }
        };
 
    private:
        void CreateNullFormatBuilders();
 
        template< typename XBuilderType > void AddBuilderTypeWithFormat(const std::string& builder_name, const mho_json& format)
        {
            auto it = fNameToBuilderMap.find(builder_name);
            if(it == fNameToBuilderMap.end()) //not found, so make one
            {
                // auto builder = new XBuilderType(fOperatorToolbox, fContainerStore, fParameterStore);
                auto builder = new XBuilderType(fOperatorToolbox, fFringeData);
                builder->SetFormat(format);
 
                //the builder's operator category comes from the format specification
                std::string category = "unknown"; //default's to unknown
                if(format.contains("operator_category"))
                {
                    category = format["operator_category"].get< std::string >();
                }
                fAllBuilders.push_back(builder);
                fNameToBuilderMap.emplace(builder_name, builder);
                fCategoryToBuilderMap.emplace(category, builder);
            }
        };
 
        //internal data
        mho_json fFormat;   //control file statement formats
        mho_json* fControl; //control file statements
 
        //constructed operators all get stashed here
        MHO_OperatorToolbox* fOperatorToolbox;
 
        //data container and parameter stores
        MHO_FringeData* fFringeData;
        MHO_ContainerStore* fContainerStore;
        MHO_ParameterStore* fParameterStore;
 
        //container to store all of the builders, for memory management
        std::vector< MHO_OperatorBuilder* > fAllBuilders;
 
        //name -> builder map for lookup by name
        std::map< std::string, MHO_OperatorBuilder* > fNameToBuilderMap;
 
        //operator category -> builder multimap for lookup by category
        std::multimap< std::string, MHO_OperatorBuilder* > fCategoryToBuilderMap;
};
 
} // namespace hops
 
#endif