Permanent memory space for a user-defined function

dev/function.h

@@ -1,15 +1,13 @@
 #pragma once
 
-#include <sqlite3.h>
 #include <type_traits>  //  std::is_member_function_pointer, std::remove_const, std::decay, std::is_same, std::false_type, std::true_type
-#include <string>  //  std::string
 #include <tuple>  //  std::tuple, std::tuple_size, std::tuple_element
-#include <functional>  //  std::function
 #include <algorithm>  //  std::min
 #include <utility>  //  std::move, std::forward
 
 #include "functional/cxx_universal.h"
 #include "functional/cxx_type_traits_polyfill.h"
+#include "tags.h"
 
 namespace sqlite_orm {
 
@@ -21,48 +19,6 @@ namespace sqlite_orm {
     class pointer_binding;
 
     namespace internal {
-
-        struct udf_proxy_base {
-            using func_call_fn_t = void (*)(void* udfHandle,
-                                            sqlite3_context* context,
-                                            int argsCount,
-                                            sqlite3_value** values);
-            using final_call_fn_t = void (*)(void* udfHandle, sqlite3_context* context);
-
-            std::string name;
-            int argumentsCount = 0;
-            std::function<void*()> create;
-            xdestroy_fn_t destroy = nullptr;
-            func_call_fn_t func = nullptr;
-            final_call_fn_t finalAggregateCall = nullptr;
-
-            udf_proxy_base(std::string name,
-                           int argumentsCount,
-                           std::function<void*()> create,
-                           xdestroy_fn_t destroy,
-                           func_call_fn_t run) :
-                name(std::move(name)),
-                argumentsCount(argumentsCount), create(std::move(create)), destroy(destroy), func(run) {}
-
-            udf_proxy_base(std::string name,
-                           int argumentsCount,
-                           std::function<void*()> create,
-                           xdestroy_fn_t destroy,
-                           func_call_fn_t step,
-                           final_call_fn_t finalCall) :
-                name(std::move(name)),
-                argumentsCount(argumentsCount), create(std::move(create)), destroy(destroy), func(step),
-                finalAggregateCall(finalCall) {}
-        };
-
-        struct scalar_udf_proxy : udf_proxy_base {
-            using udf_proxy_base::udf_proxy_base;
-        };
-
-        struct aggregate_udf_proxy : udf_proxy_base {
-            using udf_proxy_base::udf_proxy_base;
-        };
-
         template<class F>
         using scalar_call_function_t = decltype(&F::operator());
 
@@ -131,6 +87,10 @@ namespace sqlite_orm {
             args_tuple args;
         };
 
+        template<class T>
+        SQLITE_ORM_INLINE_VAR constexpr bool
+            is_operator_argument_v<T, std::enable_if_t<polyfill::is_specialization_of_v<T, function_call>>> = true;
+
         template<class T>
         struct unpacked_arg {
             using type = T;
@@ -244,6 +204,10 @@ namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /** @short Specifies that a type is a user-defined scalar function.
+     *  
+     *  `UDF` must meet the following requirements:
+     *  - `UDF::name()` static function
+     *  - `UDF::operator()()` call operator
      */
     template<class UDF>
     concept orm_scalar_udf = requires {
@@ -252,6 +216,11 @@ namespace sqlite_orm {
     };
 
     /** @short Specifies that a type is a user-defined aggregate function.
+     *  
+     *  `UDF` must meet the following requirements:
+     *  - `UDF::name()` static function
+     *  - `UDF::step()` member function
+     *  - `UDF::fin()` member function
      */
     template<class UDF>
     concept orm_aggregate_udf = requires {

dev/functional/config.h

@@ -6,6 +6,12 @@
 #include <version>
 #endif
 
+#ifdef SQLITE_ORM_CONSTEXPR_LAMBDAS_SUPPORTED
+#define SQLITE_ORM_CONSTEXPR_LAMBDA_CPP17 constexpr
+#else
+#define SQLITE_ORM_CONSTEXPR_LAMBDA_CPP17
+#endif
+
 #ifdef SQLITE_ORM_INLINE_VARIABLES_SUPPORTED
 #define SQLITE_ORM_INLINE_VAR inline
 #else
@@ -24,6 +30,14 @@
 #define SQLITE_ORM_NOUNIQUEADDRESS
 #endif
 
+#if SQLITE_ORM_HAS_CPP_ATTRIBUTE(likely) >= 201803L
+#define SQLITE_ORM_CPP_LIKELY [[likely]]
+#define SQLITE_ORM_CPP_UNLIKELY [[unlikely]]
+#else
+#define SQLITE_ORM_CPP_LIKELY
+#define SQLITE_ORM_CPP_UNLIKELY
+#endif
+
 #ifdef SQLITE_ORM_CONSTEVAL_SUPPORTED
 #define SQLITE_ORM_CONSTEVAL consteval
 #else

dev/functional/cxx_core_features.h

@@ -37,6 +37,10 @@
 #define SQLITE_ORM_FOLD_EXPRESSIONS_SUPPORTED
 #endif
 
+#if __cpp_constexpr >= 201603L
+#define SQLITE_ORM_CONSTEXPR_LAMBDAS_SUPPORTED
+#endif
+
 #if __cpp_if_constexpr >= 201606L
 #define SQLITE_ORM_IF_CONSTEXPR_SUPPORTED
 #endif

dev/functional/cxx_functional_polyfill.h

@@ -5,9 +5,7 @@
 #endif
 #include <utility>  //  std::forward
 
-#if __cpp_lib_invoke < 201411L
 #include "cxx_type_traits_polyfill.h"
-#endif
 #include "../member_traits/member_traits.h"
 
 namespace sqlite_orm {

dev/functional/cxx_tuple_polyfill.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <tuple>  //  std::apply; std::tuple_size
+#if __cpp_lib_apply < 201603L
+#include <utility>  //  std::forward, std::index_sequence, std::make_index_sequence
+#endif
+
+#include "../functional/cxx_universal.h"  //  ::size_t
+#include "../functional/cxx_functional_polyfill.h"  //  std::invoke
+
+namespace sqlite_orm {
+    namespace internal {
+        namespace polyfill {
+#if __cpp_lib_apply >= 201603L
+            using std::apply;
+#else
+            template<class Callable, class Tpl, size_t... Idx>
+            decltype(auto) apply(Callable&& callable, Tpl&& tpl, std::index_sequence<Idx...>) {
+                return polyfill::invoke(std::forward<Callable>(callable), std::get<Idx>(std::forward<Tpl>(tpl))...);
+            }
+
+            template<class Callable, class Tpl>
+            decltype(auto) apply(Callable&& callable, Tpl&& tpl) {
+                constexpr size_t size = std::tuple_size<std::remove_reference_t<Tpl>>::value;
+                return apply(std::forward<Callable>(callable),
+                             std::forward<Tpl>(tpl),
+                             std::make_index_sequence<size>{});
+            }
+#endif
+        }
+    }
+
+    namespace polyfill = internal::polyfill;
+}