Algorithm.h

#pragma once
 
#include <mutex>
#include <optional>
#include <set>
 
#include <hipo4/bank.h>
 
#include "AlgorithmBoilerplate.h"
#include "iguana/bankdefs/BankDefs.h"
#include "iguana/services/YAMLReader.h"
#include <iguana/services/GlobalParam.h>
 
namespace iguana {

  /* NOTE: if you modify this, you also must modify:
   * - [ ] `PrintOptionValue`
   * - [ ] Template specializations in this class
   * - [ ] Template specializations in `YAMLReader` or `ConfigFileReader`, and `ConcurrentParam`
   * - [ ] Add new tests, if you added new types
   * - FIXME: adding `bool` type may be tricky, see https://github.com/JeffersonLab/iguana/issues/347
   */
  using option_t = std::variant<
      int,
      double,
      std::string,
      std::vector<int>,
      std::vector<double>,
      std::vector<std::string>>;

  class Algorithm : public Object
  {
 
    public:

      Algorithm(std::string_view name)
          : Object(name)
          , m_rows_only(false)
          , m_default_config_file("")
          , o_user_config_file("")
          , o_user_config_dir("")
      {}
      Algorithm(std::string_view name) {…}
      virtual ~Algorithm() {}

      virtual void Start(hipo::banklist& banks) = 0;

      void Start();

      virtual void Run(hipo::banklist& banks) const = 0;

      virtual void Stop() = 0;

      template <typename OPTION_TYPE>
      OPTION_TYPE SetOption(std::string const& key, const OPTION_TYPE val)
      {
        // FIXME: this template is not specialized, to be friendlier to python `cppyy` bindings
        if(key == "log") {
          if constexpr(std::disjunction<
                           std::is_same<OPTION_TYPE, std::string>,
                           std::is_same<OPTION_TYPE, char const*>,
                           std::is_same<OPTION_TYPE, Logger::Level>>::value)
            m_log->SetLevel(val);
          else
            m_log->Error("Option '{}' must be a string or a Logger::Level", key);
        }
        m_option_cache[key] = val;
        return val;
      }
      OPTION_TYPE SetOption(std::string const& key, const OPTION_TYPE val) {…}

      template <typename OPTION_TYPE>
      OPTION_TYPE GetOptionScalar(std::string const& key, YAMLReader::node_path_t node_path = {}) const;

      template <typename OPTION_TYPE>
      std::vector<OPTION_TYPE> GetOptionVector(std::string const& key, YAMLReader::node_path_t node_path = {}) const;

      template <typename OPTION_TYPE>
      std::set<OPTION_TYPE> GetOptionSet(std::string const& key, YAMLReader::node_path_t node_path = {}) const;

      void SetName(std::string_view name);

      std::unique_ptr<YAMLReader> const& GetConfig() const;

      void SetConfig(std::unique_ptr<YAMLReader>&& yaml_config);

      void SetConfigFile(std::string const& name);

      void SetConfigDirectory(std::string const& name);
 
    protected: // methods

      void ParseYAMLConfig();

      hipo::bank& GetBank(hipo::banklist& banks, hipo::banklist::size_type const idx, std::string const& expected_bank_name = "") const noexcept(false);

      hipo::banklist::size_type GetBankIndex(hipo::banklist& banks, std::string const& bank_name) const noexcept(false);

      hipo::schema CreateBank(
          hipo::banklist& banks,
          hipo::banklist::size_type& bank_idx,
          std::string const& bank_name) const noexcept(false);

      void ShowBanks(hipo::banklist& banks, std::string_view message = "", Logger::Level const level = Logger::trace) const;

      void ShowBank(hipo::bank& bank, std::string_view message = "", Logger::Level const level = Logger::trace) const;

      template <typename OPTION_TYPE>
      std::optional<OPTION_TYPE> GetCachedOption(std::string const& key) const;
 
    private: // methods

      void CompleteOptionNodePath(std::string const& key, YAMLReader::node_path_t& node_path) const;
 
      // PrintOptionValue: overloaded for different value types
      void PrintOptionValue(std::string const& key, int const& val, Logger::Level const level = Logger::debug, std::string_view prefix = "OPTION") const;
      void PrintOptionValue(std::string const& key, double const& val, Logger::Level const level = Logger::debug, std::string_view prefix = "OPTION") const;
      void PrintOptionValue(std::string const& key, std::string const& val, Logger::Level const level = Logger::debug, std::string_view prefix = "OPTION") const;
      void PrintOptionValue(std::string const& key, std::vector<int> const& val, Logger::Level const level = Logger::debug, std::string_view prefix = "OPTION") const;
      void PrintOptionValue(std::string const& key, std::vector<double> const& val, Logger::Level const level = Logger::debug, std::string_view prefix = "OPTION") const;
      void PrintOptionValue(std::string const& key, std::vector<std::string> const& val, Logger::Level const level = Logger::debug, std::string_view prefix = "OPTION") const;
 
    protected: // members

      std::string m_class_name;

      bool m_rows_only;

      std::string m_default_config_file;

      std::string o_user_config_file;

      std::string o_user_config_dir;

      mutable std::mutex m_mutex;
 
    private: // members

      std::unique_ptr<YAMLReader> m_yaml_config;

      std::unordered_map<std::string, option_t> m_option_cache;
 
  };
  class Algorithm : public Object {…};


  using algo_t = std::unique_ptr<Algorithm>;

  class AlgorithmFactory
  {
 
    public:

      using algo_creator_t = std::function<algo_t()>;
 
      AlgorithmFactory() = delete;

      static bool Register(std::string const& name, algo_creator_t creator, std::vector<std::string> const new_banks = {}) noexcept;

      static algo_t Create(std::string const& name) noexcept(false);

      static std::optional<std::vector<std::string>> QueryNewBank(std::string const& bank_name) noexcept;
 
    private:

      static std::unordered_map<std::string, algo_creator_t> s_creators;

      static std::unordered_map<std::string, std::vector<std::string>> s_created_banks;
  };
  class AlgorithmFactory {…};
}
namespace iguana {…}