MHO_OperatorBuilderManager.hh

Go to the documentation of this file.

#ifndef MHO_OperatorBuilderManager_HH__
#define MHO_OperatorBuilderManager_HH__
 
#include <memory>
 
#include "MHO_ContainerStore.hh"
#include "MHO_FringeData.hh"
#include "MHO_JSONHeaderWrapper.hh"
#include "MHO_Message.hh"
#include "MHO_OperatorBuilder.hh"
#include "MHO_OperatorToolbox.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() {}
 
        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
                {
                    std::unique_ptr< XBuilderType > 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 >();
                    }
                    auto* raw = builder.get();
                    fAllBuilders.push_back(std::move(builder));
                    fNameToBuilderMap.emplace(builder_name, raw);
                    fCategoryToBuilderMap.emplace(category, raw);
                }
            }
            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
            {
                std::unique_ptr< XBuilderType > 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 >();
                }
                auto* raw = builder.get();
                fAllBuilders.push_back(std::move(builder));
                fNameToBuilderMap.emplace(builder_name, raw);
                fCategoryToBuilderMap.emplace(category, raw);
            }
        };
 
        //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;
 
        // owned storage - unique_ptrs are the sole owners
        std::vector< std::unique_ptr< MHO_OperatorBuilder > > fAllBuilders;
 
        //name -> builder map for lookup by name (non-owning)
        std::map< std::string, MHO_OperatorBuilder* > fNameToBuilderMap;
 
        //operator category -> builder multimap for lookup by category (non-owning)
        std::multimap< std::string, MHO_OperatorBuilder* > fCategoryToBuilderMap;
};
 
} // namespace hops
 
#endif