FunctionRegistry.h

Go to the documentation of this file.

#pragma once
#include <functional>
#include <memory>
#include <misc/gen/string.h>
#include <string>
#include <typeindex>
#include <unordered_map>
#include <vector>
 
namespace sf
{
 
class _MISC_CLASS FunctionRegistry
{
  public:
    class _MISC_CLASS Base
    {
      public:
        virtual ~Base() = default;
 
        virtual std::type_index returnType() const = 0;
 
        virtual std::vector<std::type_index> argTypes() const = 0;
    };
 
    template<typename R, typename... Args>
    static bool isValid(const std::string& name)
    {
      return Registration<R, Args...>(name).isValid();
    }
 
    template<typename R, typename... Args>
    static R call(const std::string& name, Args... args)
    {
      auto func = Registration<R, Args...>(name);
      if (func.isValid())
        return func.call(args...);
      return {};
    }
 
    template<typename R, typename... Args>
    class Registration
    {
      public:
        class Holder final : public Base
        {
          public:
            explicit Holder(std::function<R(Args...)> f);
 
            std::type_index returnType() const override;
 
            std::vector<std::type_index> argTypes() const override;
 
            R invoke(Args... args) const;
 
          private:
            std::function<R(Args...)> func;
        };
 
        explicit Registration(const std::string& name);
 
        bool isValid() const noexcept;
 
        operator bool() const noexcept;
 
        R call(Args... args) const;
 
        R operator()(Args... args) const;
 
      private:
        bool link();
 
        unsigned _counter;
        std::string _key;
        std::shared_ptr<Base> _holder;
    };
 
    template<typename R, typename... Args, typename F>
    static void add(const std::string& name, F&& f, const std::string& desc = {});
 
    template<typename R, typename... Args>
    static bool contains(const std::string& name);
 
    template<class R, class... Args>
    static bool remove(const std::string& name);
 
    static void list(std::ostream& os);
 
  private:
    template<typename R, typename... Args>
    static std::string makeKey(const std::string& name);
 
    struct Entry
    {
        std::shared_ptr<Base> holder;
        std::string description;
    };
 
    static std::unordered_map<std::string, Entry>& registry();
 
    static unsigned& counter();
};
 
}// namespace sf
 
// Include all inlined functions and template implementations.
#include <misc/gen/FunctionRegistry.hpp>