Renamed public-facing connection control member variable

Author: trueqbit

dev/storage.h

@@ -81,54 +81,37 @@ namespace sqlite_orm {
             polyfill::void_t<indirectly_test_preparable<decltype(std::declval<S>().prepare(std::declval<E>()))>>> =
             true;
 
+        template<class Opt, class OptionsTpl>
+        decltype(auto) storage_opt_or_default(OptionsTpl& options) {
 #ifdef SQLITE_ORM_CTAD_SUPPORTED
-        template<class PropsTpl>
-        on_open on_open_spec_or_default(PropsTpl& properties) {
-            if constexpr (tuple_has_type<PropsTpl, on_open>::value) {
-                return std::move(std::get<on_open>(properties));
+            if constexpr (tuple_has_type<OptionsTpl, Opt>::value) {
+                return std::move(std::get<Opt>(options));
             } else {
-                return {};
+                return Opt{};
             }
-        }
-
-        template<class PropsTpl>
-        connection_control connection_control_or_default(PropsTpl& properties) {
-            if constexpr (tuple_has_type<PropsTpl, connection_control>::value) {
-                return std::move(std::get<connection_control>(properties));
-            } else {
-                return {};
-            }
-        }
 #else
-        template<class PropsTpl>
-        on_open on_open_spec_or_default(PropsTpl&) {
-            return {};
-        }
-
-        template<class PropsTpl>
-        connection_control connection_control_or_default(PropsTpl&) {
-            return {};
-        }
+            return Opt{};
 #endif
+        }
 
         /**
          *  Storage class itself. Create an instanse to use it as an interfacto to sqlite db by calling `make_storage`
          *  function.
          */
         template<class... DBO>
         struct storage_t : storage_base {
-            using self = storage_t;
+            using self_type = storage_t;
             using db_objects_type = db_objects_tuple<DBO...>;
 
             /**
              *  @param filename database filename.
              *  @param dbObjects db_objects_tuple
              */
-            template<class PropsTpl>
-            storage_t(std::string filename, db_objects_type dbObjects, PropsTpl properties) :
+            template<class OptionsTpl>
+            storage_t(std::string filename, db_objects_type dbObjects, OptionsTpl options) :
                 storage_base{std::move(filename),
-                             on_open_spec_or_default(properties),
-                             connection_control_or_default(properties),
+                             storage_opt_or_default<connection_control>(options),
+                             storage_opt_or_default<on_open_spec>(options),
                              foreign_keys_count(dbObjects)},
                 db_objects{std::move(dbObjects)} {}
 
@@ -149,7 +132,7 @@ namespace sqlite_orm {
              *
              *  Hence, friend was replaced by `obtain_db_objects()` and `pick_const_impl()`.
              */
-            friend const db_objects_type& obtain_db_objects(const self& storage) noexcept {
+            friend const db_objects_type& obtain_db_objects(const self_type& storage) noexcept {
                 return storage.db_objects;
             }
 
@@ -281,7 +264,7 @@ namespace sqlite_orm {
 
           public:
             template<class T, class O = mapped_type_proxy_t<T>, class... Args>
-            mapped_view<O, self, Args...> iterate(Args&&... args) {
+            mapped_view<O, self_type, Args...> iterate(Args&&... args) {
                 this->assert_mapped_type<O>();
 
                 auto con = this->get_connection();
@@ -816,7 +799,7 @@ namespace sqlite_orm {
                      std::enable_if_t<!is_prepared_statement<Ex>::value && !is_mapped<db_objects_type, Ex>::value,
                                       bool> = true>
             std::string dump(E&& expression, bool parametrized = false) const {
-                static_assert(is_preparable_v<self, Ex>, "Expression must be a high-level statement");
+                static_assert(is_preparable_v<self_type, Ex>, "Expression must be a high-level statement");
 
                 decltype(auto) e2 = static_if<is_select<Ex>::value>(
                     [](auto expression) -> auto {
@@ -1739,18 +1722,15 @@ namespace sqlite_orm {
         };  // struct storage_t
 
 #ifdef SQLITE_ORM_CTAD_SUPPORTED
-        template<typename T>
-        using storage_prop_tag_t = typename T::storage_prop_tag;
-
         template<class Elements>
-        using prop_index_sequence = filter_tuple_sequence_t<Elements, check_if_names<storage_prop_tag_t>::template fn>;
+        using dbo_index_sequence = filter_tuple_sequence_t<Elements, check_if_lacks<storage_opt_tag_t>::template fn>;
 
         template<class Elements>
-        using dbo_index_sequence = filter_tuple_sequence_t<Elements, check_if_lacks<storage_prop_tag_t>::template fn>;
+        using opt_index_sequence = filter_tuple_sequence_t<Elements, check_if_names<storage_opt_tag_t>::template fn>;
 
-        template<class... DBO, class PropsTpl>
-        storage_t<DBO...> make_storage(std::string filename, std::tuple<DBO...> dbObjects, PropsTpl properties) {
-            return {std::move(filename), std::move(dbObjects), std::move(properties)};
+        template<class... DBO, class OptionsTpl>
+        storage_t<DBO...> make_storage(std::string filename, std::tuple<DBO...> dbObjects, OptionsTpl options) {
+            return {std::move(filename), std::move(dbObjects), std::move(options)};
         }
 #endif
     }
@@ -1762,13 +1742,14 @@ SQLITE_ORM_EXPORT namespace sqlite_orm {
      *  Factory function for a storage, from a database file and a bunch of database object definitions.
      */
     template<class... Spec>
-    auto make_storage(std::string filename, Spec... arguments) {
+    auto make_storage(std::string filename, Spec... specifications) {
         using namespace ::sqlite_orm::internal;
 
-        std::tuple args{std::forward<Spec>(arguments)...};
-        return make_storage(std::move(filename),
-                            create_from_tuple<std::tuple>(std::move(args), dbo_index_sequence<decltype(args)>{}),
-                            create_from_tuple<std::tuple>(std::move(args), prop_index_sequence<decltype(args)>{}));
+        std::tuple specTuple{std::forward<Spec>(specifications)...};
+        return internal::make_storage(
+            std::move(filename),
+            create_from_tuple<std::tuple>(std::move(specTuple), dbo_index_sequence<decltype(specTuple)>{}),
+            create_from_tuple<std::tuple>(std::move(specTuple), opt_index_sequence<decltype(specTuple)>{}));
     }
 #else
     template<class... DBO>

dev/storage_base.h

@@ -14,7 +14,7 @@
 #include <list>  //  std::list
 #include <memory>  //  std::make_unique, std::unique_ptr
 #include <map>  //  std::map
-#include <type_traits>  //  std::is_same
+#include <type_traits>  //  std::is_same, std::is_aggregate
 #include <algorithm>  //  std::find_if, std::ranges::find
 #endif
 
@@ -34,25 +34,7 @@
 #include "udf_proxy.h"
 #include "serializing_util.h"
 #include "table_info.h"
-
-SQLITE_ORM_EXPORT namespace sqlite_orm {
-    struct on_open {
-        using storage_prop_tag = int;
-
-#ifndef SQLITE_ORM_AGGREGATE_PAREN_INIT_SUPPORTED
-        on_open() = default;
-        on_open(std::function<void(sqlite3*)> onOpen) : onOpen{std::move(onOpen)} {}
-#endif
-
-        std::function<void(sqlite3*)> onOpen;
-    };
-
-    struct connection_control {
-        using storage_prop_tag = int;
-
-        bool openForever = false;
-    };
-}
+#include "storage_options.h"
 
 namespace sqlite_orm {
     namespace internal {
@@ -682,10 +664,10 @@ namespace sqlite_orm {
 
           protected:
             storage_base(std::string filename,
-                         sqlite_orm::on_open onOpenSpec,
                          connection_control connectionCtrl,
+                         on_open_spec onOpenSpec,
                          int foreignKeysCount) :
-                on_open{std::move(onOpenSpec.onOpen)}, isOpenedForever{connectionCtrl.openForever},
+                on_open{std::move(onOpenSpec.onOpen)}, isOpenedForever{connectionCtrl.open_forever},
                 pragma(std::bind(&storage_base::get_connection, this)),
                 limit(std::bind(&storage_base::get_connection, this)),
                 inMemory(filename.empty() || filename == ":memory:"),
@@ -1020,8 +1002,8 @@ namespace sqlite_orm {
                     });
 #endif
                     if (dbColumnInfoIt != dbTableInfo.end()) {
-                        auto& dbColumnInfo = *dbColumnInfoIt;
-                        auto columnsAreEqual =
+                        table_xinfo& dbColumnInfo = *dbColumnInfoIt;
+                        bool columnsAreEqual =
                             dbColumnInfo.name == storageColumnInfo.name &&
                             dbColumnInfo.notnull == storageColumnInfo.notnull &&
                             (!dbColumnInfo.dflt_value.empty()) == (!storageColumnInfo.dflt_value.empty()) &&
@@ -1032,8 +1014,7 @@ namespace sqlite_orm {
                             break;
                         }
                         dbTableInfo.erase(dbColumnInfoIt);
-                        storageTableInfo.erase(storageTableInfo.begin() +
-                                               static_cast<ptrdiff_t>(storageColumnInfoIndex));
+                        storageTableInfo.erase(storageTableInfo.begin() + storageColumnInfoIndex);
                         --storageColumnInfoIndex;
                     } else {
                         columnsToAdd.push_back(&storageColumnInfo);

dev/storage_options.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <sqlite3.h>
+#ifdef SQLITE_ORM_IMPORT_STD_MODULE
+#include <version>
+#else
+#include <type_traits>  //  std::is_aggregate
+#include <utility>  //  std::move
+#include <functional>  //  std::function
+#endif
+
+namespace sqlite_orm {
+    namespace internal {
+        template<typename T>
+        using storage_opt_tag_t = typename T::storage_opt_tag;
+
+        struct on_open_spec {
+            using storage_opt_tag = int;
+
+            std::function<void(sqlite3*)> onOpen;
+        };
+    }
+}
+
+SQLITE_ORM_EXPORT namespace sqlite_orm {
+    /** 
+     *  Database connection control options to be passed to `make_storage()`.
+     */
+    struct connection_control {
+        /// Whether to open the database once and for all.
+        /// Required if using a 'storage' instance from multiple threads.
+        bool open_forever = false;
+
+        using storage_opt_tag = int;
+    };
+#if __cpp_lib_is_aggregate >= 201703L
+    // design choice: must be an aggregate that can be constructed using designated initializers
+    static_assert(std::is_aggregate_v<connection_control>);
+#endif
+
+#ifdef SQLITE_ORM_CTAD_SUPPORTED
+    /** 
+     *  Callback function to be passed to `make_storage()`.
+     *  The provided function is called immdediately after the database connection has been established and set up.
+     */
+    inline internal::on_open_spec on_open(std::function<void(sqlite3*)> onOpen) {
+        return {std::move(onOpen)};
+    }
+#endif
+}