Features.h

Go to the documentation of this file.

#ifndef LINTEL_FEATURES_H
#define LINTEL_FEATURES_H
 
#include <cstdint>
#include <functional>
#include <magic_enum/magic_enum.hpp>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
// The DI container is only needed as an incomplete type here: ContainerBuilder
// is passed by reference and Container travels inside a shared_ptr. Forward
// declaring both keeps the container - and its heavier template machinery - out
// of every translation unit that only talks to Features.
namespace lintel {
namespace di {
  class Container;
  class ContainerBuilder;
}// namespace di
}// namespace lintel
 
namespace lintel {
class Features
{
public:
  using RegisterTypeFunc = std::function<void(lintel::di::ContainerBuilder &)>;
  using InitializeFunc = std::function<void(std::shared_ptr<lintel::di::Container>)>;
 
  template<typename T, std::enable_if_t<std::is_enum_v<T>> * = nullptr>
  void registerFeature(T x, const RegisterTypeFunc &registerTypeFunc, const InitializeFunc &initializeFunc)
  {
    std::string name = std::string(magic_enum::enum_name(x));
    m_features.push_back(name);
    m_registerTypeMap.insert({ name, registerTypeFunc });
    m_initializeMap.insert({ name, initializeFunc });
  };
 
  Features()
  {
    auto names = magic_enum::enum_names<Value>();
    for (const auto &iter : names) { m_features.emplace_back(iter); }
  }
 
  void initializeOf(const std::string &featureName, std::shared_ptr<lintel::di::Container> container)
  {
    auto found = m_initializeMap.find(featureName);
    if (found == m_initializeMap.end()) { return; }
    found->second(std::move(container));
  }
 
  void registerType(const std::string &featureName, lintel::di::ContainerBuilder &builder)
  {
    auto found = m_registerTypeMap.find(featureName);
    if (found == m_registerTypeMap.end()) { return; }
    found->second(builder);
  }
 
  std::vector<std::string> allOf() { return m_features; }
 
  enum Value : std::uint8_t {
    Base, 
    Http, 
    Property, 
    Cli 
  };
 
private:
  std::vector<std::string> m_features{};
  std::map<std::string, RegisterTypeFunc> m_registerTypeMap;
  std::map<std::string, InitializeFunc> m_initializeMap;
};
 
}// namespace lintel
#endif// LINTEL_FEATURES_H