function_dispatcher.h

#ifndef _FUNCTION_DISPATCHER_H_
#define _FUNCTION_DISPATCHER_H_

#include <functional>
#include <map>
#include <string>
#include <utility>
#include <vector>

template <typename Treturntype, typename... Targs>
class Dispatcher {
 public:
  static Dispatcher* instance() {
    static Dispatcher dispatcher;
    return &dispatcher;
  }

  void register_function(const std::string& key, std::function<Treturntype(Targs...)> new_function) {
    if (!this->check(key)) {    
      registry[key] = std::move(new_function);
    } else {
      throw std::runtime_error("Duplicate key: " + key +
                               ", already registered. Verify key choice to "
                               "ensure function has not already been added");
    }
  }

  Treturntype dispatch(const std::string& key, Targs... args) {
    if (!this->check(key)) {
      throw std::runtime_error("Invalid key: " + key + ", not found in the function dispatcher");
    } else {
      return registry.at(key)(std::forward<Targs>(args)...);
    }
  }

  bool check(const std::string& key) const {
    bool status = false;
    for (const auto& keyvalue : registry)
      if (keyvalue.first == key) status = true;
    return status;
  }
  
  std::vector<std::string> list() const {
    std::vector<std::string> dispatcher_items;
    for (const auto& keyvalue : registry)
      dispatcher_items.push_back(keyvalue.first);
    return dispatcher_items;
  }

 private:
  Dispatcher() = default;

  std::map<std::string, std::function<Treturntype(Targs...)>> registry; 
};

template <typename Treturntype, typename... Targs>
class DispatchRegister {
 public:
  explicit DispatchRegister(
      const std::string& key,
      std::function<Treturntype(Targs...)> new_function) {
    // register the class factory function
    Dispatcher<Treturntype, Targs...>::instance()->register_function(
        key, std::move(new_function));
  }
};

#endif  // _FUNCTION_DISPATCHER_H_