AlgorithmSequence.h

#pragma once
 
#include "Algorithm.h"
 
namespace iguana {
 
  class AlgorithmSequence : public Algorithm
  {
 
      DEFINE_IGUANA_ALGORITHM(AlgorithmSequence, seq)
 
    public:
 
      void Start(hipo::banklist& banks) override;
      void Run(hipo::banklist& banks) const override;
      void Stop() override;
 
      void Add(std::string const& class_name, std::string const& instance_name = "");
 
      template <class ALGORITHM>
      void Add(std::string_view instance_name = "")
      {
        if(instance_name == "")
          Add(std::make_unique<ALGORITHM>());
        else
          Add(std::make_unique<ALGORITHM>(instance_name));
      }
 
      void Add(algo_t&& algo);
 
      template <class ALGORITHM>
      ALGORITHM* Get(std::string const& instance_name)
      {
        if(auto it{m_algo_names.find(instance_name)}; it != m_algo_names.end())
          return dynamic_cast<ALGORITHM*>(m_sequence[it->second].get());
        m_log->Error("cannot find algorithm '{}' in sequence", instance_name);
        throw std::runtime_error("cannot Get algorithm");
      }
 
      template <typename OPTION_TYPE>
      void SetOption(std::string const& algo_name, std::string const& key, const OPTION_TYPE val)
      {
        Get<Algorithm>(algo_name)->SetOption(key, val);
      }
 
      void SetName(std::string_view name);
 
      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);
 
    private:
 
      std::vector<algo_t> m_sequence;
 
      std::unordered_map<std::string, std::vector<algo_t>::size_type> m_algo_names;
  };
}