MHO_OperatorBuilder.hh

Go to the documentation of this file.

#ifndef MHO_OperatorBuilder_HH__
#define MHO_OperatorBuilder_HH__
 
#include <string>
#include <utility>
#include <vector>
 
#include "MHO_ContainerStore.hh"
#include "MHO_FringeData.hh"
#include "MHO_JSONHeaderWrapper.hh"
#include "MHO_Message.hh"
#include "MHO_Operator.hh"
#include "MHO_OperatorToolbox.hh"
#include "MHO_ParameterStore.hh"
 
namespace hops
{
 
class MHO_OperatorBuilder
{
 
    public:
        MHO_OperatorBuilder(MHO_OperatorToolbox* toolbox, MHO_FringeData* fdata)
            : fOperatorToolbox(toolbox), fFringeData(fdata), fContainerStore(fdata->GetContainerStore()),
              fParameterStore(fdata->GetParameterStore()){};
 
        MHO_OperatorBuilder(MHO_OperatorToolbox* toolbox, MHO_ContainerStore* cstore = nullptr,
                            MHO_ParameterStore* pstore = nullptr)
            : fOperatorToolbox(toolbox), fFringeData(nullptr), //ptr to fringe data object not provided
              fContainerStore(cstore), fParameterStore(pstore){};
 
        virtual ~MHO_OperatorBuilder(){}; //delegate memory management to toolbox
 
        void SetToolbox(MHO_OperatorToolbox* toolbox) { fOperatorToolbox = toolbox; }
 
        void SetFringeData(MHO_FringeData* fdata) { fFringeData = fdata; }
 
        void SetParameterStore(MHO_ParameterStore* pstore) { fParameterStore = pstore; }
 
        void SetContainerStore(MHO_ContainerStore* cstore) { fContainerStore = cstore; }
 
        //json config for this operator (parsed from the control file and format directives)
        void SetFormat(const mho_json& format) { fFormat = format; } //operator format
 
        void SetConditions(const mho_json& cond) { fConditions = cond; } //conditional statements
 
        void SetAttributes(const mho_json& attr) { fAttributes = attr; } //configuration parameters
 
        virtual bool Build() = 0;
 
    protected:
        virtual bool IsConfigurationOk()
        {
            TODO_FIXME_MSG("TODO FIXME -- improve checks on operator attributes in IsConfigurationOk)")
            bool ok = true;
            //for compound statements, check that the fields are present
            if(fFormat["statement_type"] == "operator")
            {
                if(fFormat.contains("type") && fFormat["type"].get< std::string >() == "compound")
                {
 
                    for(auto it = fFormat["fields"].begin(); it != fFormat["fields"].end(); it++)
                    {
                        if(!fAttributes["value"].contains(*it))
                        {
                            msg_error("initialization", "missing attribute called " << *it << " in parameters of operator: "
                                                                                    << fFormat["name"].get< std::string >()
                                                                                    << ", will not build " << eom);
                            return false;
                        }
                    }
                }
            }
 
            return ok;
        }
 
        //constructed operator gets stashed here
        MHO_OperatorToolbox* fOperatorToolbox;
 
        //fringe data object (holds both container/parameter store, along with plot data)
        MHO_FringeData* fFringeData;
 
        //data container and parameters stores
        MHO_ContainerStore* fContainerStore;
        MHO_ParameterStore* fParameterStore;
 
        // Returns all station identifiers named in the 'if station X' condition tokens.
        // Handles OR/AND compound conditions by collecting every 'station <X>' pair.
        // Returns {"??"} (wildcard) when no station keyword is present.
        std::vector< std::string > ExtractAllStationIdentifiers() const
        {
            std::vector< std::string > ids;
            if(fConditions.is_null() || !fConditions.contains("value"))
            {
                return {"??"};
            }
            auto tokens = fConditions["value"].get< std::vector< std::string > >();
            for(auto it = tokens.begin(); it != tokens.end(); ++it)
            {
                if(*it == "station")
                {
                    ++it;
                    if(it != tokens.end())
                    {
                        ids.push_back(*it);
                    }
                }
            }
            return ids.empty() ? std::vector< std::string >{"??"} : ids;
        }
 
        // Checks whether a single station identifier (from condition tokens) matches
        // a specific station role (reference or remote).  Handles 1-char mk4 ids,
        // 2-char station codes, and wildcards (?/??).
        // role should be "ref" or "rem".
        bool StationMatchesRole(const std::string& station_id, const std::string& role) const
        {
            if(fParameterStore == nullptr)
            {
                return true;
            }
 
            std::string role_mk4 = fParameterStore->GetAs< std::string >(std::string("/") + role + "_station/mk4id");
            std::string role_code = fParameterStore->GetAs< std::string >(std::string("/") + role + "_station/site_id");
 
            if(station_id == "??" || station_id == "?")
            {
                return true;
            }
            if(station_id.size() == 1)
            {
                return (station_id == role_mk4);
            }
            // 2-char or longer - compare against 2-char station code
            return (station_id == role_code);
        }
 
        // Checks whether a single station identifier (from condition tokens) matches
        // either the reference or remote station of the current baseline.
        // Handles 1-char mk4 ids, 2-char station codes, and wildcards (?/??).
        bool StationMatchesCurrentBaseline(const std::string& station_id) const
        {
            return StationMatchesRole(station_id, "ref") || StationMatchesRole(station_id, "rem");
        }
 
        // Filters the station identifiers extracted from the condition to only those
        // that actually match the current baseline's ref/rem stations.  This prevents
        // a condition like "if station X or station Y" from producing an operator
        // bound to both X and Y when only X is on the current baseline.
        // Returns {"??"} when no station keyword is present (apply to all).
        std::vector< std::string > GetMatchingStationIdentifiers() const
        {
            auto all_ids = ExtractAllStationIdentifiers();
            std::vector< std::string > matching;
            for(const auto& id : all_ids)
            {
                if(StationMatchesCurrentBaseline(id))
                {
                    matching.push_back(id);
                }
            }
            return matching.empty() ? std::vector< std::string >{"??"} : matching;
        }
 
        //provided for the configuration of the operator that is to be built
        mho_json fFormat;     //optional
        mho_json fConditions; //optional
        mho_json fAttributes; //required
};
 
} // namespace hops
 
#endif