AlgorithmSequence.h

#pragma once
 
#include "Algorithm.h"
 
namespace iguana {

  class AlgorithmSequence : public Algorithm
  {
 
      DEFINE_IGUANA_ALGORITHM(AlgorithmSequence, seq)
 
    private: // hooks
      void StartHook(hipo::banklist& banks) override;
      bool RunHook(hipo::banklist& banks) const override;
      void StopHook() override;
 
    public:

      void Add(std::string const& algo_class_name, std::string const& algo_instance_name = "");

      template <class ALGORITHM>
      void Add(std::string_view algo_instance_name = "")
      {
        if(algo_instance_name == "")
          Add(std::make_unique<ALGORITHM>());
        else
          Add(std::make_unique<ALGORITHM>(algo_instance_name));
      }

      void Add(algo_t&& algo);

      template <class ALGORITHM = Algorithm>
      ALGORITHM* Get(std::string const& algo_instance_name)
      {
        if(auto it{m_algo_names.find(algo_instance_name)}; it != m_algo_names.end())
          return dynamic_cast<ALGORITHM*>(m_sequence[it->second].get());
        m_log->Error("cannot find algorithm '{}' in sequence", algo_instance_name);
        throw std::runtime_error("cannot Get algorithm");
      }

      template <typename OPTION_TYPE>
      void SetOption(std::string const& algo_instance_name, std::string const& key, const OPTION_TYPE val)
      {
        Get<Algorithm>(algo_instance_name)->SetOption(key, val);
      }

      void SetLogLevel(std::string const& algo_instance_name, std::string const& lev)
      {
        Get<Algorithm>(algo_instance_name)->SetLogLevel(lev);
      }

      void SetName(std::string_view name);

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

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

      void PrintSequence(Logger::Level level = Logger::info) const;

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

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

      void ForEachAlgorithm(std::function<void(algo_t&)> func);

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

      hipo::banklist::size_type GetCreatedBankIndex(
          hipo::banklist& banks,
          std::string const& algo_instance_name) const noexcept(false);
 
    private:

      std::vector<algo_t> m_sequence;

      std::unordered_map<std::string, std::vector<algo_t>::size_type> m_algo_names;
  };
}