Deduce argument size and types from lambda signature

This commit adds an ability to use lambda in a more traditional scenario with a lambda and a predefined number of arguments.

This commit reuses `add_callback` function to extend its functionality. It reuses existing methods and should provide backward compatibility with the existing use cases.

Author: Stat1cV01D

.gitignore

@@ -1,4 +1,5 @@
 .coveralls.yml
+.cache/
 .vscode
 .vs
 

include/inja/environment.hpp

@@ -7,14 +7,17 @@
 #include <sstream>
 #include <string>
 #include <string_view>
+#include <tuple>
+#include <type_traits>
 
-#include "json.hpp"
 #include "config.hpp"
 #include "function_storage.hpp"
+#include "json.hpp"
 #include "parser.hpp"
 #include "renderer.hpp"
 #include "template.hpp"
 #include "throw.hpp"
+#include "utils.hpp"
 
 namespace inja {
 
@@ -25,6 +28,30 @@ class Environment {
   FunctionStorage function_storage;
   TemplateStorage template_storage;
 
+  template <class Arg>
+  static Arg get_callback_argument(const Arguments &args, size_t index) {
+    if constexpr (std::is_lvalue_reference_v<Arg>) {
+      return args[index]->get_ref<const 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)](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;
@@ -179,10 +206,41 @@ 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) {
+    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());
+    constexpr size_t num_args = std::tuple_size_v<typename Sig::ArgsTuple>;
+
+    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>{});
+    }
   }
 
   /*!

include/inja/utils.hpp

@@ -31,6 +31,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);

test/test-functions.cpp

@@ -230,6 +230,8 @@ TEST_CASE("assignments") {
   CHECK(env.render("{% set v1 = \"a\" %}{% set v2 = \"b\" %}{% set var = v1 + v2 %}{{ var }}", data) == "ab");
 }
 
+void dummy_callback() {}
+
 TEST_CASE("callbacks") {
   inja::Environment env;
   inja::json data;
@@ -246,25 +248,24 @@ TEST_CASE("callbacks") {
   });
 
   std::string greet = "Hello";
-  env.add_callback("double-greetings", 0, [greet](inja::Arguments) { return greet + " " + greet + "!"; });
+  env.add_callback("double-greetings",
+                   [greet] { return greet + " " + greet + "!"; });
 
   env.add_callback("multiply", 2, [](inja::Arguments args) {
     double number1 = args.at(0)->get<double>();
     auto number2 = args.at(1)->get<double>();
     return number1 * number2;
   });
 
-  env.add_callback("multiply", 3, [](inja::Arguments args) {
-    double number1 = args.at(0)->get<double>();
-    double number2 = args.at(1)->get<double>();
-    double number3 = args.at(2)->get<double>();
-    return number1 * number2 * number3;
-  });
+  env.add_callback("multiply",
+                   [](double number1, double number2, double number3) {
+                     return number1 * number2 * number3;
+                   });
 
-  env.add_callback("length", 1, [](inja::Arguments args) {
-    auto number1 = args.at(0)->get<std::string>();
-    return number1.length();
-  });
+  env.add_callback("length",
+                   [](const std::string &number1) { return number1.length(); });
+
+  env.add_callback("dummy", dummy_callback);
 
   env.add_void_callback("log", 1, [](inja::Arguments) {
 
@@ -275,6 +276,7 @@ TEST_CASE("callbacks") {
   CHECK(env.render("{{ double(age) }}", data) == "56");
   CHECK(env.render("{{ half(age) }}", data) == "14");
   CHECK(env.render("{{ log(age) }}", data) == "");
+  CHECK(env.render("{{ dummy() }}", data) == "");
   CHECK(env.render("{{ double-greetings }}", data) == "Hello Hello!");
   CHECK(env.render("{{ double-greetings() }}", data) == "Hello Hello!");
   CHECK(env.render("{{ multiply(4, 5) }}", data) == "20.0");