Merge pull request #1376 from fnc12/code_quality

Another code quality iteration.

Author: trueqbit

.clang-format

@@ -122,4 +122,5 @@ StatementMacros:
  - QT_REQUIRE_VERSION
 TabWidth: 4
 UseTab: Never
+LineEnding: LF
 ...

dev/column_result_proxy.h

@@ -1,41 +1,41 @@
-#pragma once
-
-#include "type_traits.h"
-#include "table_reference.h"
-
-namespace sqlite_orm {
- namespace internal {
-
+#pragma once
+
+#include "type_traits.h"
+#include "table_reference.h"
+
+namespace sqlite_orm {
+ namespace internal {
+
  /*
  * Holder for the type of an unmapped aggregate/structure/object to be constructed ad-hoc from column results.
  * `T` must be constructible using direct-list-initialization.
- */
- template<class T, class ColResults>
- struct structure {
- using type = T;
- };
- }
-}
-
-namespace sqlite_orm {
- namespace internal {
-
- template<class T, class SFINAE = void>
- struct column_result_proxy : std::remove_const<T> {};
-
+ */
+ template<class T, class ColResults>
+ struct structure {
+ using type = T;
+ };
+ }
+}
+
+namespace sqlite_orm {
+ namespace internal {
+
+ template<class T, class SFINAE = void>
+ struct column_result_proxy : std::remove_const<T> {};
+
  /*
  * Unwrap `table_reference`
- */
- template<class P>
- struct column_result_proxy<P, match_if<is_table_reference, P>> : decay_table_ref<P> {};
-
+ */
+ template<class P>
+ struct column_result_proxy<P, match_if<is_table_reference, P>> : decay_table_ref<P> {};
+
  /*
  * Pass through `structure`
- */
- template<class P>
- struct column_result_proxy<P, match_specialization_of<P, structure>> : P {};
-
- template<class T>
- using column_result_proxy_t = typename column_result_proxy<T>::type;
- }
-}
+ */
+ template<class P>
+ struct column_result_proxy<P, match_specialization_of<P, structure>> : P {};
+
+ template<class T>
+ using column_result_proxy_t = typename column_result_proxy<T>::type;
+ }
+}

dev/implementations/table_definitions.h

@@ -4,10 +4,12 @@
  */
 #pragma once
 
-#include <type_traits> // std::decay_t
+#include <type_traits> // std::remove_reference
 #include <utility> // std::move
 #include <algorithm> // std::find_if, std::ranges::find
 
+#include "../tuple_helper/tuple_filter.h"
+#include "../type_traits.h"
 #include "../type_printer.h"
 #include "../schema/column.h"
 #include "../schema/table.h"
@@ -20,7 +22,7 @@ namespace sqlite_orm {
  std::vector<table_xinfo> res;
  res.reserve(filter_tuple_sequence_t<elements_type, is_column>::size());
  this->for_each_column([&res](auto& column) {
- using field_type = field_type_t<std::decay_t<decltype(column)>>;
+ using field_type = field_type_t<std::remove_reference_t<decltype(column)>>;
  std::string dft;
  if(auto d = column.default_value()) {
  dft = std::move(*d);

dev/journal_mode.h

@@ -1,10 +1,9 @@
 #pragma once
 
-#include <iterator> // std::back_inserter
-#include <string> // std::string
-#include <memory> // std::unique_ptr
 #include <array> // std::array
-#include <algorithm> // std::transform
+#include <string> // std::string
+#include <utility> // std::pair
+#include <algorithm> // std::ranges::transform
 #include <cctype> // std::toupper
 
 #include "serialize_result_type.h"
@@ -35,36 +34,49 @@ namespace sqlite_orm {
 
  namespace internal {
 
- inline const serialize_result_type& to_string(journal_mode value) {
- static const std::array<serialize_result_type, 6> res = {
+ inline const serialize_result_type& journal_mode_to_string(journal_mode value) {
+#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
+ static constexpr std::array<serialize_result_type, 6> idx2str = {
+#else
+ static const std::array<serialize_result_type, 6> idx2str = {
+#endif
  "DELETE",
  "TRUNCATE",
  "PERSIST",
  "MEMORY",
  "WAL",
  "OFF",
  };
- return res.at(static_cast<int>(value));
+ return idx2str.at(static_cast<int>(value));
  }
 
- inline std::pair<bool, journal_mode> journal_mode_from_string(const std::string& string) {
- std::string upperString;
- std::transform(string.begin(), string.end(), std::back_inserter(upperString), [](char c) {
- return static_cast<char>(std::toupper(static_cast<int>(c)));
- });
- static const std::array<journal_mode, 6> allValues = {{
+ inline std::pair<bool, journal_mode> journal_mode_from_string(std::string string) {
+ static constexpr std::array<journal_mode, 6> journalModes = {{
  journal_mode::DELETE,
  journal_mode::TRUNCATE,
  journal_mode::PERSIST,
  journal_mode::MEMORY,
  journal_mode::WAL,
  journal_mode::OFF,
  }};
- for(auto journalMode: allValues) {
- if(to_string(journalMode) == upperString) {
+#if __cpp_lib_ranges >= 201911L
+ std::ranges::transform(string, string.begin(), [](unsigned char c) noexcept {
+ return std::toupper(c);
+ });
+ if(auto found = std::ranges::find(journalModes, string, journal_mode_to_string);
+ found != journalModes.end()) SQLITE_ORM_CPP_LIKELY {
+ return {true, *found};
+ }
+#else
+ std::transform(string.begin(), string.end(), string.begin(), [](unsigned char c) noexcept {
+ return std::toupper(c);
+ });
+ for(auto journalMode: journalModes) {
+ if(journal_mode_to_string(journalMode) == string) {
  return {true, journalMode};
  }
  }
+#endif
  return {false, journal_mode::OFF};
  }
  }

dev/locking_mode.h

@@ -3,7 +3,8 @@
 #include <array> // std::array
 #include <string> // std::string
 #include <utility> // std::pair
-#include <iterator> // std::back_inserter
+#include <algorithm> // std::ranges::transform
+#include <cctype> // std::toupper
 
 #include "serialize_result_type.h"
 
@@ -14,28 +15,42 @@ namespace sqlite_orm {
  };
 
  namespace internal {
- inline const serialize_result_type& to_string(locking_mode value) {
- static const std::array<serialize_result_type, 2> res = {
+ inline const serialize_result_type& locking_mode_to_string(locking_mode value) {
+#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
+ static constexpr std::array<serialize_result_type, 2> idx2str = {
+#else
+ static const std::array<serialize_result_type, 2> idx2str = {
+#endif
  "NORMAL",
  "EXCLUSIVE",
  };
- return res.at(static_cast<int>(value));
+ return idx2str.at(static_cast<int>(value));
  }
 
- inline std::pair<bool, locking_mode> locking_mode_from_string(const std::string& string) {
- std::string upperString;
- std::transform(string.begin(), string.end(), std::back_inserter(upperString), [](char c) {
- return static_cast<char>(std::toupper(static_cast<int>(c)));
- });
- static const std::array<locking_mode, 2> allValues = {{
+ inline std::pair<bool, locking_mode> locking_mode_from_string(std::string string) {
+ static constexpr std::array<locking_mode, 2> lockingModes = {{
  locking_mode::NORMAL,
  locking_mode::EXCLUSIVE,
  }};
- for(auto lockingMode: allValues) {
- if(to_string(lockingMode) == upperString) {
+
+#if __cpp_lib_ranges >= 201911L
+ std::ranges::transform(string, string.begin(), [](unsigned char c) noexcept {
+ return std::toupper(c);
+ });
+ if(auto found = std::ranges::find(lockingModes, string, locking_mode_to_string);
+ found != lockingModes.end()) SQLITE_ORM_CPP_LIKELY {
+ return {true, *found};
+ }
+#else
+ std::transform(string.begin(), string.end(), string.begin(), [](unsigned char c) noexcept {
+ return std::toupper(c);
+ });
+ for(auto lockingMode: lockingModes) {
+ if(locking_mode_to_string(lockingMode) == string) {
  return {true, lockingMode};
  }
  }
+#endif
  return {false, locking_mode::NORMAL};
  }
  }

dev/pragma.h

@@ -77,9 +77,9 @@ namespace sqlite_orm {
  }
 
  void journal_mode(sqlite_orm::journal_mode value) {
- this->_journal_mode = -1;
+ this->journal_mode_ = -1;
  this->set_pragma("journal_mode", value);
- this->_journal_mode = static_cast<decltype(this->_journal_mode)>(value);
+ this->journal_mode_ = static_cast<decltype(this->journal_mode_)>(value);
  }
 
  /**
@@ -101,9 +101,9 @@ namespace sqlite_orm {
  }
 
  void synchronous(int value) {
- this->_synchronous = -1;
+ this->synchronous_ = -1;
  this->set_pragma("synchronous", value);
- this->_synchronous = value;
+ this->synchronous_ = value;
  }
 
  int user_version() {
@@ -222,8 +222,8 @@ namespace sqlite_orm {
  private:
  friend struct storage_base;
 
- int _synchronous = -1;
- signed char _journal_mode = -1; // if != -1 stores static_cast<sqlite_orm::journal_mode>(journal_mode)
+ int synchronous_ = -1;
+ signed char journal_mode_ = -1; // if != -1 stores static_cast<sqlite_orm::journal_mode>(journal_mode)
  get_connection_t get_connection;
 
  template<class T>
@@ -245,15 +245,15 @@ namespace sqlite_orm {
  this->set_pragma_impl(ss.str(), db);
  }
 
- void set_pragma(const std::string& name, const sqlite_orm::journal_mode& value, sqlite3* db = nullptr) {
+ void set_pragma(const std::string& name, sqlite_orm::journal_mode value, sqlite3* db = nullptr) {
  std::stringstream ss;
- ss << "PRAGMA " << name << " = " << to_string(value);
+ ss << "PRAGMA " << name << " = " << journal_mode_to_string(value);
  this->set_pragma_impl(ss.str(), db);
  }
 
- void set_pragma(const std::string& name, const sqlite_orm::locking_mode& value, sqlite3* db = nullptr) {
+ void set_pragma(const std::string& name, sqlite_orm::locking_mode value, sqlite3* db = nullptr) {
  std::stringstream ss;
- ss << "PRAGMA " << name << " = " << to_string(value);
+ ss << "PRAGMA " << name << " = " << locking_mode_to_string(value);
  this->set_pragma_impl(ss.str(), db);
  }