Merge pull request #1336 from fnc12/feature/modules-support

sqlite_orm as a C++ named module
fnc12 · Feb 6, 2025 · cfc1095 · cfc1095
2 parents d9c828d + 1d473c6
commit cfc1095
Show file tree

Hide file tree

Showing 118 changed files with 913 additions and 147 deletions.
diff --git a/.clang-format b/.clang-format
@@ -118,7 +118,7 @@ SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
 Standard:        Cpp11
-AttributeMacros: [SQLITE_ORM_CPP_LIKELY, SQLITE_ORM_CPP_UNLIKELY]
+AttributeMacros: [SQLITE_ORM_CPP_LIKELY, SQLITE_ORM_CPP_UNLIKELY, SQLITE_ORM_EXPORT]
 StatementMacros: 
   - __pragma
   - _Pragma

diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -11,10 +11,14 @@ set(PACKAGE_VERSION ${sqlite_orm_VERSION})
 project("sqlite_orm" VERSION ${PACKAGE_VERSION})
 
 # Handling C++ standard version to use
+option(SQLITE_ORM_ENABLE_CXX_23 "Enable C++ 23" OFF)
 option(SQLITE_ORM_ENABLE_CXX_20 "Enable C++ 20" OFF)
 option(SQLITE_ORM_ENABLE_CXX_17 "Enable C++ 17" OFF)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
-if(SQLITE_ORM_ENABLE_CXX_20)
+if(SQLITE_ORM_ENABLE_CXX_23)
+    set(CMAKE_CXX_STANDARD 23)
+    message(STATUS "SQLITE_ORM: Build with C++23 features")
+elseif(SQLITE_ORM_ENABLE_CXX_20)
     set(CMAKE_CXX_STANDARD 20)
     message(STATUS "SQLITE_ORM: Build with C++20 features")
 elseif(SQLITE_ORM_ENABLE_CXX_17)

diff --git a/appveyor.yml b/appveyor.yml
@@ -20,6 +20,11 @@ configuration:
 environment:
   appveyor_yml_disable_ps_linux: true
   matrix:
+    - job_name: Visual Studio 2022, x64, C++23
+      appveyor_build_worker_image: Visual Studio 2022
+      platform: x64
+      SQLITE_ORM_CXX_STANDARD: "-DSQLITE_ORM_ENABLE_CXX_23=ON"
+
     - job_name: clang, C++14
       appveyor_build_worker_image: Ubuntu
       CC: clang

diff --git a/dev/alias.h b/dev/alias.h
@@ -1,12 +1,14 @@
 #pragma once
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <type_traits>  //  std::enable_if, std::is_same
 #include <utility>  //  std::make_index_sequence, std::move
 #include <string>  //  std::string
 #include <sstream>  //  std::stringstream
 #if (SQLITE_VERSION_NUMBER >= 3008003) && defined(SQLITE_ORM_WITH_CTE)
 #include <array>
 #endif
+#endif
 
 #include "functional/cxx_type_traits_polyfill.h"
 #include "functional/mpl/conditional.h"
@@ -185,7 +187,9 @@ namespace sqlite_orm {
         inline constexpr bool is_builtin_numeric_column_alias_v<column_alias<C...>> = ((C >= '0' && C <= '9') && ...);
 #endif
     }
+}
 
+SQLITE_ORM_EXPORT namespace sqlite_orm {
     /**
      *  Using a column pointer, create a column reference to an aliased table column.
      *  

diff --git a/dev/alias_traits.h b/dev/alias_traits.h
@@ -1,20 +1,24 @@
 #pragma once
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <type_traits>  //  std::is_base_of, std::is_same
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
 #include <concepts>
 #endif
+#endif
 
 #include "functional/cxx_type_traits_polyfill.h"
 #include "type_traits.h"
 #include "table_reference.h"
 
-namespace sqlite_orm {
+SQLITE_ORM_EXPORT namespace sqlite_orm {
 
     /** @short Base class for a custom table alias, column alias or expression alias.
      */
     struct alias_tag {};
+}
 
+namespace sqlite_orm {
     namespace internal {
 
         template<class A>
@@ -65,7 +69,9 @@ namespace sqlite_orm {
         template<class A>
         using is_cte_moniker = polyfill::bool_constant<is_cte_moniker_v<A>>;
     }
+}
 
+SQLITE_ORM_EXPORT namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     template<class A>
     concept orm_alias = std::derived_from<A, alias_tag>;

diff --git a/dev/arg_values.h b/dev/arg_values.h
@@ -4,7 +4,7 @@
 
 #include "row_extractor.h"
 
-namespace sqlite_orm {
+SQLITE_ORM_EXPORT namespace sqlite_orm {
 
     /** @short Wrapper around a dynamically typed value object.
      */

diff --git a/dev/arithmetic_tag.h b/dev/arithmetic_tag.h
@@ -1,10 +1,12 @@
 #pragma once
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <type_traits>  // std::is_integral
+#endif
 
 #include "functional/mpl/conditional.h"
 
-namespace sqlite_orm {
+SQLITE_ORM_EXPORT namespace sqlite_orm {
 
     /**
      *  Helper classes used by statement_binder and row_extractor.

diff --git a/dev/ast/excluded.h b/dev/ast/excluded.h
@@ -1,6 +1,8 @@
 #pragma once
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <utility>  //  std::move
+#endif
 
 namespace sqlite_orm {
     namespace internal {
@@ -12,7 +14,9 @@ namespace sqlite_orm {
             expression_type expression;
         };
     }
+}
 
+SQLITE_ORM_EXPORT namespace sqlite_orm {
     template<class T>
     internal::excluded_t<T> excluded(T expression) {
         return {std::move(expression)};

diff --git a/dev/ast/exists.h b/dev/ast/exists.h
@@ -1,6 +1,8 @@
 #pragma once
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <utility>  //  std::move
+#endif
 
 #include "../tags.h"
 
@@ -17,7 +19,9 @@ namespace sqlite_orm {
             exists_t(expression_type expression_) : expression(std::move(expression_)) {}
         };
     }
+}
 
+SQLITE_ORM_EXPORT namespace sqlite_orm {
     /**
      *  EXISTS(condition).
      *  Example: storage.select(columns(&Agent::code, &Agent::name, &Agent::workingArea, &Agent::comission),

diff --git a/dev/ast/group_by.h b/dev/ast/group_by.h
@@ -1,8 +1,10 @@
 #pragma once
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <tuple>  //  std::tuple, std::make_tuple
 #include <type_traits>  //  std::true_type, std::false_type
 #include <utility>  //  std::forward, std::move
+#endif
 
 #include "../functional/cxx_type_traits_polyfill.h"
 
@@ -37,7 +39,9 @@ namespace sqlite_orm {
         using is_group_by = polyfill::disjunction<polyfill::is_specialization_of<T, group_by_t>,
                                                   polyfill::is_specialization_of<T, group_by_with_having>>;
     }
+}
 
+SQLITE_ORM_EXPORT namespace sqlite_orm {
     /**
      *  GROUP BY column.
      *  Example: storage.get_all<Employee>(group_by(&Employee::name))

diff --git a/dev/ast/into.h b/dev/ast/into.h
@@ -13,7 +13,9 @@ namespace sqlite_orm {
         template<class T>
         using is_into = polyfill::is_specialization_of<T, into_t>;
     }
+}
 
+SQLITE_ORM_EXPORT namespace sqlite_orm {
     template<class T>
     internal::into_t<T> into() {
         return {};

diff --git a/dev/ast/match.h b/dev/ast/match.h
@@ -1,6 +1,8 @@
 #pragma once
 
-#include <utility>  // std::move
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
+#include <utility>
+#endif
 
 namespace sqlite_orm {
     namespace internal {
@@ -11,11 +13,11 @@ namespace sqlite_orm {
             using argument_type = X;
 
             argument_type argument;
-
-            match_t(argument_type argument) : argument(std::move(argument)) {}
         };
     }
+}
 
+SQLITE_ORM_EXPORT namespace sqlite_orm {
     template<class T, class X>
     internal::match_t<T, X> match(X argument) {
         return {std::move(argument)};

diff --git a/dev/ast/rank.h b/dev/ast/rank.h
@@ -4,7 +4,9 @@ namespace sqlite_orm {
     namespace internal {
         struct rank_t {};
     }
+}
 
+SQLITE_ORM_EXPORT namespace sqlite_orm {
     inline internal::rank_t rank() {
         return {};
     }

diff --git a/dev/ast/set.h b/dev/ast/set.h
@@ -1,10 +1,12 @@
 #pragma once
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <tuple>  //  std::tuple, std::tuple_size
 #include <string>  //  std::string
 #include <vector>  //  std::vector
 #include <sstream>  //  std::stringstream
 #include <type_traits>  //  std::false_type, std::true_type
+#endif
 
 #include "../tuple_helper/tuple_traits.h"
 #include "../table_name_collector.h"
@@ -85,7 +87,9 @@ namespace sqlite_orm {
         template<class C>
         struct is_dynamic_set<dynamic_set_t<C>> : std::true_type {};
     }
+}
 
+SQLITE_ORM_EXPORT namespace sqlite_orm {
     /**
      *  SET keyword used in UPDATE ... SET queries.
      *  Args must have `assign_t` type. E.g. set(assign(&User::id, 5)) or set(c(&User::id) = 5)

diff --git a/dev/ast/special_keywords.h b/dev/ast/special_keywords.h
@@ -6,7 +6,9 @@ namespace sqlite_orm {
         struct current_date_t {};
         struct current_timestamp_t {};
     }
+}
 
+SQLITE_ORM_EXPORT namespace sqlite_orm {
     inline internal::current_time_t current_time() {
         return {};
     }

diff --git a/dev/ast/upsert_clause.h b/dev/ast/upsert_clause.h
@@ -1,9 +1,11 @@
 #pragma once
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #if SQLITE_VERSION_NUMBER >= 3024000
 #include <tuple>  //  std::tuple
 #include <utility>  //  std::forward, std::move
 #endif
+#endif
 
 #include "../functional/cxx_type_traits_polyfill.h"
 
@@ -51,7 +53,9 @@ namespace sqlite_orm {
         template<class T>
         using is_upsert_clause = polyfill::bool_constant<is_upsert_clause_v<T>>;
     }
+}
 
+SQLITE_ORM_EXPORT namespace sqlite_orm {
 #if SQLITE_VERSION_NUMBER >= 3024000
     /**
      *  ON CONFLICT upsert clause builder function.

diff --git a/dev/ast/where.h b/dev/ast/where.h
@@ -1,7 +1,9 @@
 #pragma once
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <type_traits>  //  std::false_type, std::true_type
 #include <utility>  //  std::move
+#endif
 
 #include "../functional/cxx_type_traits_polyfill.h"
 #include "../serialize_result_type.h"
@@ -35,7 +37,9 @@ namespace sqlite_orm {
         template<class T>
         struct is_where : polyfill::bool_constant<is_where_v<T>> {};
     }
+}
 
+SQLITE_ORM_EXPORT namespace sqlite_orm {
     /**
      *  WHERE clause. Use it to add WHERE conditions wherever you like.
      *  C is expression type. Can be any expression like: is_equal_t, is_null_t, exists_t etc

diff --git a/dev/ast_iterator.h b/dev/ast_iterator.h
@@ -1,7 +1,9 @@
 #pragma once
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <vector>  //  std::vector
 #include <functional>  //  std::reference_wrapper
+#endif
 
 #include "tuple_helper/tuple_iteration.h"
 #include "type_traits.h"

diff --git a/dev/backup.h b/dev/backup.h
@@ -1,10 +1,12 @@
 #pragma once
 
 #include <sqlite3.h>
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <system_error>  //  std::system_error
 #include <string>  //  std::string
 #include <memory>
 #include <utility>  //  std::move, std::exchange
+#endif
 
 #include "error_code.h"
 #include "connection_holder.h"

diff --git a/dev/carray.h b/dev/carray.h
@@ -6,6 +6,7 @@
  *  Hence we make it only available for compilers supporting inline variables.
  */
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #if SQLITE_VERSION_NUMBER >= 3020000
 #ifdef SQLITE_ORM_INLINE_VARIABLES_SUPPORTED
 #include <utility>  //  std::move
@@ -14,12 +15,13 @@
 #endif
 #endif
 #endif
+#endif
 
 #include "pointer_value.h"
 
 #if SQLITE_VERSION_NUMBER >= 3020000
 #ifdef SQLITE_ORM_INLINE_VARIABLES_SUPPORTED
-namespace sqlite_orm {
+SQLITE_ORM_EXPORT namespace sqlite_orm {
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     inline constexpr orm_pointer_type auto carray_pointer_tag = "carray"_pointer_type;

diff --git a/dev/column_expression.h b/dev/column_expression.h
@@ -1,8 +1,10 @@
 #pragma once
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <type_traits>  //  std::enable_if, std::is_same, std::decay, std::is_arithmetic
 #include <tuple>  //  std::tuple
 #include <functional>  //  std::reference_wrapper
+#endif
 
 #include "functional/cxx_type_traits_polyfill.h"
 #include "tuple_helper/tuple_transformer.h"

diff --git a/dev/column_names_getter.h b/dev/column_names_getter.h
@@ -1,11 +1,13 @@
 #pragma once
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <type_traits>  //  std::is_base_of
 #include <string>  //  std::string
 #include <vector>  //  std::vector
 #include <functional>  //  std::reference_wrapper
 #include <system_error>
 #include <utility>  //  std::move
+#endif
 
 #include "tuple_helper/tuple_traits.h"
 #include "tuple_helper/tuple_iteration.h"

diff --git a/dev/column_pointer.h b/dev/column_pointer.h
@@ -1,7 +1,9 @@
 #pragma once
 
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <type_traits>  //  std::enable_if, std::is_convertible
 #include <utility>  // std::move
+#endif
 
 #include "functional/cxx_core_features.h"
 #include "functional/cxx_type_traits_polyfill.h"
@@ -40,7 +42,9 @@ namespace sqlite_orm {
         struct alias_holder;
 #endif
     }
+}
 
+SQLITE_ORM_EXPORT namespace sqlite_orm {
     /**
      *  Explicitly refer to a column, used in contexts
      *  where the automatic object mapping deduction needs to be overridden.