Algorithm.h

#pragma once
 
#include <mutex>
#include <optional>
#include <set>
 
#include <hipo4/bank.h>
 
 
#include "iguana/algorithms/AlgorithmBoilerplate.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
   */
  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("")
      {}
      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;
      }
 
      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,
          std::vector<std::string> schema_def,
          int group_id, // FIXME: generalize group_id and item_id setting
          int item_id) 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;
 
  };
 
 
  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;
  };
}