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/RCDBReader.h"
#include "iguana/services/YAMLReader.h"
#include <iguana/services/GlobalParam.h>
 
namespace iguana {

  // ALGORITHM TOOLS

  namespace tools {
    hipo::banklist::size_type GetBankIndex(
        hipo::banklist& banks,
        std::string const& bank_name,
        unsigned int const& variant = 0) noexcept(false);
  }

  // BASE CLASS ALGORITHM

  /* 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("")
      {}
      virtual ~Algorithm() {}

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

      void Start();

      virtual bool 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);

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

      hipo::banklist::size_type GetCreatedBankIndex(hipo::banklist& banks) const noexcept(false);

      std::vector<std::string> GetCreatedBankNames() const noexcept(false);

      std::string GetCreatedBankName() const noexcept(false);

      hipo::bank GetCreatedBank(std::string const& bank_name = "") const noexcept(false);

      hipo::schema GetCreatedBankSchema(std::string const& bank_name = "") const noexcept(false);

      unsigned int GetCreatedBankVariant() const;

      std::unique_ptr<RCDBReader>& GetRCDBReader();
 
    protected: // methods

      void ParseYAMLConfig();

      void StartRCDBReader();

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

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

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

      void ShowBank(hipo::bank const& 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;

      void ThrowSinceRenamed(std::string const& new_name, std::string const& version) const noexcept(false);
 
    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;

      unsigned int m_created_bank_variant{0};

      std::unique_ptr<RCDBReader> m_rcdb;
 
    private: // members

      std::unique_ptr<YAMLReader> m_yaml_config;

      std::unordered_map<std::string, option_t> m_option_cache;
  };

  // ALGORITHM FACTORY

  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& algo_name, algo_creator_t creator, std::vector<std::string> const new_banks = {}) noexcept;

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

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

      static std::optional<std::vector<std::string>> GetCreatedBanks(std::string const& algo_name) noexcept(false);
 
    private:

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

      static std::unordered_map<std::string, std::vector<std::string>> s_bank_to_algos;

      static std::unordered_map<std::string, std::vector<std::string>> s_algo_to_banks;
  };
}