Update single_include/inja.hpp

Author: Stat1cV01D

single_include/inja/inja.hpp

@@ -74,8 +74,6 @@ std::abort();                 \
 #include <string>
 #include <string_view>
 
-// #include "json.hpp"
-
 // #include "config.hpp"
 #ifndef INCLUDE_INJA_CONFIG_HPP_
 #define INCLUDE_INJA_CONFIG_HPP_
@@ -336,6 +334,29 @@ inline bool starts_with(std::string_view view, std::string_view prefix) {
 }
 } // namespace string_view
 
+namespace function_signature {
+template <class... Args> struct ArgsList {};
+template <class Func> struct Get {};
+template <class R, class... A> //
+struct Get<R (*)(A...)> {
+  using Ret = R;
+  using ArgsList = ArgsList<A...>;
+  using ArgsTuple = std::tuple<A...>;
+};
+template <class R, class C, class... A> //
+struct Get<R (C::*)(A...)> {
+  using Ret = R;
+  using ArgsList = ArgsList<A...>;
+  using ArgsTuple = std::tuple<A...>;
+};
+template <class R, class C, class... A> //
+struct Get<R (C::*)(A...) const> {
+  using Ret = R;
+  using ArgsList = ArgsList<A...>;
+  using ArgsTuple = std::tuple<A...>;
+};
+} // namespace function_signature
+
 inline SourceLocation get_source_location(std::string_view content, size_t pos) {
   // Get line and offset position (starts at 1:1)
   auto sliced = string_view::slice(content, 0, pos);
@@ -922,6 +943,8 @@ struct RenderConfig {
 
 // #include "function_storage.hpp"
 
+// #include "json.hpp"
+
 // #include "parser.hpp"
 #ifndef INCLUDE_INJA_PARSER_HPP_
 #define INCLUDE_INJA_PARSER_HPP_
@@ -2834,6 +2857,8 @@ class Renderer : public NodeVisitor {
 
 // #include "throw.hpp"
 
+// #include "utils.hpp"
+
 
 namespace inja {
 
@@ -2844,6 +2869,41 @@ class Environment {
   FunctionStorage function_storage;
   TemplateStorage template_storage;
 
+  template <class Arg>
+  static Arg get_callback_argument(const Arguments &args, size_t index) {
+    using BasicArg = std::remove_const_t<
+        std::remove_pointer_t<std::remove_reference_t<std::decay_t<Arg>>>>;
+
+    static constexpr bool check =
+        std::is_const_v<std::remove_reference_t<Arg>> ||
+        std::is_same_v<BasicArg, Arg>;
+    static_assert(check, "Arguments should be either const& or a value type");
+
+    if constexpr (std::is_same_v<BasicArg, json>) {
+      return *args[index];
+    } else if constexpr (std::is_lvalue_reference_v<Arg>) {
+      return args[index]->get_ref<Arg>();
+    } else {
+      return args[index]->get<Arg>();
+    }
+  }
+
+  template <class Ret, class Func, class... Args, size_t... Is>
+  void add_callback_closure(const std::string &name, Func func,
+                            function_signature::ArgsList<Args...> /*args*/,
+                            std::index_sequence<Is...> /*seq*/) {
+    add_callback(name, sizeof...(Args),
+                 [func = std::move(func)] //
+                 ([[maybe_unused]] const Arguments &args) -> json {
+                   if constexpr (std::is_same_v<Ret, void>) {
+                     func(get_callback_argument<Args>(args, Is)...);
+                     return {};
+                   } else {
+                     return func(get_callback_argument<Args>(args, Is)...);
+                   }
+                 });
+  }
+
 protected:
   LexerConfig lexer_config;
   ParserConfig parser_config;
@@ -2998,10 +3058,42 @@ class Environment {
   }
 
   /*!
-  @brief Adds a variadic callback
+  @brief Adds a callback
   */
-  void add_callback(const std::string& name, const CallbackFunction& callback) {
-    add_callback(name, -1, callback);
+  template <class Callback>
+  void add_callback(const std::string &name, Callback callback) {
+    static constexpr auto get_sig = [] {
+      if constexpr (std::is_class_v<Callback>) {
+        return function_signature::Get<decltype(&Callback::operator())> {};
+      } else {
+        return function_signature::Get<Callback>{};
+      }
+    };
+    using Sig = decltype(get_sig());
+    static constexpr size_t num_args =
+        std::tuple_size_v<typename Sig::ArgsTuple>;
+
+    static constexpr auto is_arguments_vector = [] {
+      if constexpr (num_args == 1) {
+        return std::is_same_v<
+            std::remove_cv_t<std::remove_reference_t<
+                std::tuple_element_t<0, typename Sig::ArgsTuple>>>,
+            Arguments>;
+      } else {
+        return false;
+      }
+    };
+
+    if constexpr (is_arguments_vector()) {
+      // If callback has the only argument of `Arguments` - fallback to adding a
+      // variadic callback
+      add_callback(name, -1, callback);
+    } else {
+      // If it has other arguments - use it in a closure
+      add_callback_closure<typename Sig::Ret>(
+          name, std::move(callback), typename Sig::ArgsList{},
+          std::make_index_sequence<num_args>{});
+    }
   }
 
   /*!