Replace ()-initialization with {}-initialization in the SQLite3 connector code.

MeanSquaredError · rbock · commit fdbfbc345ec9 · 2023-08-19T07:30:13.000Z
diff --git a/include/sqlpp11/sqlite3/bind_result.h b/include/sqlpp11/sqlite3/bind_result.h
@@ -104,7 +104,7 @@ namespace sqlpp
 
     public:
       bind_result_t() = default;
-      bind_result_t(const std::shared_ptr<detail::prepared_statement_handle_t>& handle) : _handle(handle)
+      bind_result_t(const std::shared_ptr<detail::prepared_statement_handle_t>& handle) : _handle{handle}
       {
         if (_handle and _handle->debug)
           std::cerr << "Sqlite3 debug: Constructing bind result, using handle at " << _handle.get() << std::endl;
@@ -230,7 +230,7 @@ namespace sqlpp
         if (detail::check_date_digits(date_string))
         {
           const auto ymd = ::date::year(std::atoi(date_string)) / atoi(date_string + 5) / atoi(date_string + 8);
-          *value = ::sqlpp::chrono::day_point(ymd);
+          *value = ::sqlpp::chrono::day_point{ymd};
         }
         else
         {
@@ -261,7 +261,7 @@ namespace sqlpp
         {
           const auto ymd =
               ::date::year(std::atoi(date_time_string)) / atoi(date_time_string + 5) / atoi(date_time_string + 8);
-          *value = ::sqlpp::chrono::day_point(ymd);
+          *value = ::sqlpp::chrono::day_point{ymd};
         }
         else
         {
@@ -275,8 +275,8 @@ namespace sqlpp
         const auto time_string = date_time_string + 11; // YYYY-MM-DDT
         if (detail::check_time_digits(time_string))
         {
-          *value += ::std::chrono::hours(std::atoi(time_string + 0)) +
-                    std::chrono::minutes(std::atoi(time_string + 3)) + std::chrono::seconds(std::atoi(time_string + 6));
+          *value += ::std::chrono::hours{std::atoi(time_string + 0)} +
+                    std::chrono::minutes{std::atoi(time_string + 3)} + std::chrono::seconds{std::atoi(time_string + 6)};
         }
         else
         {
@@ -285,7 +285,7 @@ namespace sqlpp
         const auto ms_string = time_string + 9; // hh:mm:ss.
         if (detail::check_ms_digits(ms_string) and ms_string[4] == '\0')
         {
-          *value += ::std::chrono::milliseconds(std::atoi(ms_string));
+          *value += ::std::chrono::milliseconds{std::atoi(ms_string)};
         }
         else
         {
@@ -308,7 +308,7 @@ namespace sqlpp
           case SQLITE_DONE:
             return false;
           default:
-            throw sqlpp::exception("Sqlite3 error: Unexpected return value for sqlite3_step()");
+            throw sqlpp::exception{"Sqlite3 error: Unexpected return value for sqlite3_step()"};
         }
       }
     };
diff --git a/include/sqlpp11/sqlite3/connection.h b/include/sqlpp11/sqlite3/connection.h
@@ -72,16 +72,16 @@ namespace sqlpp
         if (handle->config->debug)
           std::cerr << "Sqlite3 debug: Preparing: '" << statement << "'" << std::endl;
 
-        detail::prepared_statement_handle_t result(nullptr, handle->config->debug);
+        detail::prepared_statement_handle_t result{nullptr, handle->config->debug};
 
         auto rc = sqlite3_prepare_v2(handle->native_handle(), statement.c_str(), static_cast<int>(statement.size()),
                                      &result.sqlite_statement, nullptr);
 
         if (rc != SQLITE_OK)
         {
-          throw sqlpp::exception(
+          throw sqlpp::exception{
               "Sqlite3 error: Could not prepare statement: " + std::string(sqlite3_errmsg(handle->native_handle())) +
-              " (statement was >>" + (rc == SQLITE_TOOBIG ? statement.substr(0, 128) + "..." : statement) + "<<\n");
+              " (statement was >>" + (rc == SQLITE_TOOBIG ? statement.substr(0, 128) + "..." : statement) + "<<\n"};
         }
 
         return result;
@@ -99,8 +99,8 @@ namespace sqlpp
           default:
             if (handle->config->debug)
               std::cerr << "Sqlite3 debug: sqlite3_step return code: " << rc << std::endl;
-            throw sqlpp::exception("Sqlite3 error: Could not execute statement: " +
-                                   std::string(sqlite3_errmsg(handle->native_handle())));
+            throw sqlpp::exception{"Sqlite3 error: Could not execute statement: " +
+                                   std::string(sqlite3_errmsg(handle->native_handle()))};
         }
       }
     }  // namespace detail
@@ -110,7 +110,7 @@ namespace sqlpp
 
     struct context_t
     {
-      context_t(const connection_base& db) : _db(db), _count(1)
+      context_t(const connection_base& db) : _db{db}, _count{1}
       {
       }
 
@@ -153,16 +153,16 @@ namespace sqlpp
         active
       };
 
-      transaction_status_type _transaction_status = transaction_status_type::none;
+      transaction_status_type _transaction_status{transaction_status_type::none};
 
       // direct execution
       bind_result_t select_impl(const std::string& statement)
       {
-        std::unique_ptr<detail::prepared_statement_handle_t> prepared(
-            new detail::prepared_statement_handle_t(prepare_statement(_handle, statement)));
+        std::unique_ptr<detail::prepared_statement_handle_t> prepared{
+            new detail::prepared_statement_handle_t(prepare_statement(_handle, statement))};
         if (!prepared)
         {
-          throw sqlpp::exception("Sqlite3 error: Could not store result set");
+          throw sqlpp::exception{"Sqlite3 error: Could not store result set"};
         }
 
         return {std::move(prepared)};
@@ -193,8 +193,8 @@ namespace sqlpp
       // prepared execution
       prepared_statement_t prepare_impl(const std::string& statement)
       {
-        return {std::unique_ptr<detail::prepared_statement_handle_t>(
-            new detail::prepared_statement_handle_t(prepare_statement(_handle, statement)))};
+        return {std::unique_ptr<detail::prepared_statement_handle_t>{
+            new detail::prepared_statement_handle_t(prepare_statement(_handle, statement))}};
       }
 
       bind_result_t run_prepared_select_impl(prepared_statement_t& prepared_statement)
@@ -263,15 +263,15 @@ namespace sqlpp
       template <typename Select>
       bind_result_t select(const Select& s)
       {
-        _context_t context(*this);
+        _context_t context{*this};
         serialize(s, context);
         return select_impl(context.str());
       }
 
       template <typename Select>
       _prepared_statement_t prepare_select(Select& s)
       {
-        _context_t context(*this);
+        _context_t context{*this};
         serialize(s, context);
         return prepare_impl(context.str());
       }
@@ -288,15 +288,15 @@ namespace sqlpp
       template <typename Insert>
       size_t insert(const Insert& i)
       {
-        _context_t context(*this);
+        _context_t context{*this};
         serialize(i, context);
         return insert_impl(context.str());
       }
 
       template <typename Insert>
       _prepared_statement_t prepare_insert(Insert& i)
       {
-        _context_t context(*this);
+        _context_t context{*this};
         serialize(i, context);
         return prepare_impl(context.str());
       }
@@ -313,15 +313,15 @@ namespace sqlpp
       template <typename Update>
       size_t update(const Update& u)
       {
-        _context_t context(*this);
+        _context_t context{*this};
         serialize(u, context);
         return update_impl(context.str());
       }
 
       template <typename Update>
       _prepared_statement_t prepare_update(Update& u)
       {
-        _context_t context(*this);
+        _context_t context{*this};
         serialize(u, context);
         return prepare_impl(context.str());
       }
@@ -338,15 +338,15 @@ namespace sqlpp
       template <typename Remove>
       size_t remove(const Remove& r)
       {
-        _context_t context(*this);
+        _context_t context{*this};
         serialize(r, context);
         return remove_impl(context.str());
       }
 
       template <typename Remove>
       _prepared_statement_t prepare_remove(Remove& r)
       {
-        _context_t context(*this);
+        _context_t context{*this};
         serialize(r, context);
         return prepare_impl(context.str());
       }
@@ -372,15 +372,15 @@ namespace sqlpp
           typename Enable = typename std::enable_if<not std::is_convertible<Execute, std::string>::value, void>::type>
       size_t execute(const Execute& x)
       {
-        _context_t context(*this);
+        _context_t context{*this};
         serialize(x, context);
         return execute(context.str());
       }
 
       template <typename Execute>
       _prepared_statement_t prepare_execute(Execute& x)
       {
-        _context_t context(*this);
+        _context_t context{*this};
         serialize(x, context);
         return prepare_impl(context.str());
       }
@@ -472,7 +472,7 @@ namespace sqlpp
       {
         if (_transaction_status == transaction_status_type::active)
         {
-          throw sqlpp::exception("Sqlite3 error: Cannot have more than one open transaction per connection");
+          throw sqlpp::exception{"Sqlite3 error: Cannot have more than one open transaction per connection"};
         }
 
         _transaction_status = transaction_status_type::maybe;
@@ -486,7 +486,7 @@ namespace sqlpp
       {
         if (_transaction_status == transaction_status_type::none)
         {
-          throw sqlpp::exception("Sqlite3 error: Cannot commit a finished or failed transaction");
+          throw sqlpp::exception{"Sqlite3 error: Cannot commit a finished or failed transaction"};
         }
         _transaction_status = transaction_status_type::maybe;
         auto prepared = prepare_statement(_handle, "COMMIT");
@@ -500,7 +500,7 @@ namespace sqlpp
       {
         if (_transaction_status == transaction_status_type::none)
         {
-          throw sqlpp::exception("Sqlite3 error: Cannot rollback a finished or failed transaction");
+          throw sqlpp::exception{"Sqlite3 error: Cannot rollback a finished or failed transaction"};
         }
         if (report)
         {
diff --git a/include/sqlpp11/sqlite3/connection_config.h b/include/sqlpp11/sqlite3/connection_config.h
@@ -35,7 +35,7 @@ namespace sqlpp
   {
     struct connection_config
     {
-      connection_config() : path_to_database(), flags(0), vfs(), debug(false),password("")
+      connection_config() : path_to_database{}, flags{0}, vfs{}, debug{false},password{}
       {
       }
       connection_config(const connection_config&) = default;
@@ -44,7 +44,7 @@ namespace sqlpp
       connection_config& operator=(connection_config&&) = default;
 
       connection_config(std::string path, int fl = 0, std::string vf = "", bool dbg = false,std::string password="")
-          : path_to_database(std::move(path)), flags(fl), vfs(std::move(vf)), debug(dbg),password(password)
+          : path_to_database{std::move(path)}, flags{fl}, vfs{std::move(vf)}, debug{dbg},password{password}
       {
       }
 
diff --git a/include/sqlpp11/sqlite3/detail/connection_handle.h b/include/sqlpp11/sqlite3/detail/connection_handle.h
@@ -53,8 +53,8 @@ namespace sqlpp
         std::unique_ptr<::sqlite3, int (*)(::sqlite3*)> sqlite;
 
         connection_handle(const std::shared_ptr<const connection_config>& conf) :
-          config(conf),
-          sqlite(nullptr, sqlite3_close)
+          config{conf},
+          sqlite{nullptr, sqlite3_close}
         {
 #ifdef SQLPP_DYNAMIC_LOADING
           init_sqlite("");
@@ -67,7 +67,7 @@ namespace sqlpp
           {
             const std::string msg = sqlite3_errmsg(sqlite_ptr);
             sqlite3_close(sqlite_ptr);
-            throw sqlpp::exception("Sqlite3 error: Can't open database: " + msg);
+            throw sqlpp::exception{"Sqlite3 error: Can't open database: " + msg};
           }
 
           sqlite.reset(sqlite_ptr);
@@ -80,7 +80,7 @@ namespace sqlpp
             {
               const std::string msg = sqlite3_errmsg(native_handle());
               sqlite3_close(native_handle());
-              throw sqlpp::exception("Sqlite3 error: Can't set password to database: " + msg);
+              throw sqlpp::exception{"Sqlite3 error: Can't set password to database: " + msg};
             }
           }
 #endif
diff --git a/include/sqlpp11/sqlite3/detail/prepared_statement_handle.h b/include/sqlpp11/sqlite3/detail/prepared_statement_handle.h
@@ -48,14 +48,14 @@ namespace sqlpp
         sqlite3_stmt* sqlite_statement;
         bool debug;
 
-        prepared_statement_handle_t(sqlite3_stmt* statement, bool debug_) : sqlite_statement(statement), debug(debug_)
+        prepared_statement_handle_t(sqlite3_stmt* statement, bool debug_) : sqlite_statement{statement}, debug{debug_}
         {
         }
 
         prepared_statement_handle_t(const prepared_statement_handle_t&) = delete;
         prepared_statement_handle_t(prepared_statement_handle_t&& rhs) :
-          sqlite_statement(rhs.sqlite_statement),
-          debug(rhs.debug)
+          sqlite_statement{rhs.sqlite_statement},
+          debug{rhs.debug}
         {
           rhs.sqlite_statement = nullptr;
         }
diff --git a/include/sqlpp11/sqlite3/prepared_statement.h b/include/sqlpp11/sqlite3/prepared_statement.h
@@ -60,14 +60,14 @@ namespace sqlpp
           case SQLITE_OK:
             return;
           case SQLITE_RANGE:
-            throw sqlpp::exception("Sqlite3 error: " + std::string(type) + " bind value out of range");
+            throw sqlpp::exception{"Sqlite3 error: " + std::string(type) + " bind value out of range"};
           case SQLITE_NOMEM:
-            throw sqlpp::exception("Sqlite3 error: " + std::string(type) + " bind out of memory");
+            throw sqlpp::exception{"Sqlite3 error: " + std::string(type) + " bind out of memory"};
           case SQLITE_TOOBIG:
-            throw sqlpp::exception("Sqlite3 error: " + std::string(type) + " bind too big");
+            throw sqlpp::exception{"Sqlite3 error: " + std::string(type) + " bind too big"};
           default:
-            throw sqlpp::exception("Sqlite3 error: " + std::string(type) +
-                                   " bind returned unexpected value: " + std::to_string(result));
+            throw sqlpp::exception{"Sqlite3 error: " + std::string(type) +
+                                   " bind returned unexpected value: " + std::to_string(result)};
         }
       }
     }  // namespace detail

Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ namespace sqlpp`
`104`	`104`
`105`	`105`	`public:`
`106`	`106`	`bind_result_t() = default;`
`107`		`- bind_result_t(const std::shared_ptr<detail::prepared_statement_handle_t>& handle) : _handle(handle)`
	`107`	`+ bind_result_t(const std::shared_ptr<detail::prepared_statement_handle_t>& handle) : _handle{handle}`
`108`	`108`	`{`
`109`	`109`	`if (_handle and _handle->debug)`
`110`	`110`	`std::cerr << "Sqlite3 debug: Constructing bind result, using handle at " << _handle.get() << std::endl;`
`@@ -230,7 +230,7 @@ namespace sqlpp`
`230`	`230`	`if (detail::check_date_digits(date_string))`
`231`	`231`	`{`
`232`	`232`	`const auto ymd = ::date::year(std::atoi(date_string)) / atoi(date_string + 5) / atoi(date_string + 8);`
`233`		`- *value = ::sqlpp::chrono::day_point(ymd);`
	`233`	`+ *value = ::sqlpp::chrono::day_point{ymd};`
`234`	`234`	`}`
`235`	`235`	`else`
`236`	`236`	`{`
`@@ -261,7 +261,7 @@ namespace sqlpp`
`261`	`261`	`{`
`262`	`262`	`const auto ymd =`
`263`	`263`	`::date::year(std::atoi(date_time_string)) / atoi(date_time_string + 5) / atoi(date_time_string + 8);`
`264`		`- *value = ::sqlpp::chrono::day_point(ymd);`
	`264`	`+ *value = ::sqlpp::chrono::day_point{ymd};`
`265`	`265`	`}`
`266`	`266`	`else`
`267`	`267`	`{`
`@@ -275,8 +275,8 @@ namespace sqlpp`
`275`	`275`	`const auto time_string = date_time_string + 11; // YYYY-MM-DDT`
`276`	`276`	`if (detail::check_time_digits(time_string))`
`277`	`277`	`{`
`278`		`- *value += ::std::chrono::hours(std::atoi(time_string + 0)) +`
`279`		`- std::chrono::minutes(std::atoi(time_string + 3)) + std::chrono::seconds(std::atoi(time_string + 6));`
	`278`	`+ *value += ::std::chrono::hours{std::atoi(time_string + 0)} +`
	`279`	`+ std::chrono::minutes{std::atoi(time_string + 3)} + std::chrono::seconds{std::atoi(time_string + 6)};`
`280`	`280`	`}`
`281`	`281`	`else`
`282`	`282`	`{`
`@@ -285,7 +285,7 @@ namespace sqlpp`
`285`	`285`	`const auto ms_string = time_string + 9; // hh:mm:ss.`
`286`	`286`	`if (detail::check_ms_digits(ms_string) and ms_string[4] == '\0')`
`287`	`287`	`{`
`288`		`- *value += ::std::chrono::milliseconds(std::atoi(ms_string));`
	`288`	`+ *value += ::std::chrono::milliseconds{std::atoi(ms_string)};`
`289`	`289`	`}`
`290`	`290`	`else`
`291`	`291`	`{`
`@@ -308,7 +308,7 @@ namespace sqlpp`
`308`	`308`	`case SQLITE_DONE:`
`309`	`309`	`return false;`
`310`	`310`	`default:`
`311`		`- throw sqlpp::exception("Sqlite3 error: Unexpected return value for sqlite3_step()");`
	`311`	`+ throw sqlpp::exception{"Sqlite3 error: Unexpected return value for sqlite3_step()"};`
`312`	`312`	`}`
`313`	`313`	`}`
`314`	`314`	`};`
Original file line number	Diff line number	Diff line change
`@@ -72,16 +72,16 @@ namespace sqlpp`
`72`	`72`	`if (handle->config->debug)`
`73`	`73`	`std::cerr << "Sqlite3 debug: Preparing: '" << statement << "'" << std::endl;`
`74`	`74`
`75`		`- detail::prepared_statement_handle_t result(nullptr, handle->config->debug);`
	`75`	`+ detail::prepared_statement_handle_t result{nullptr, handle->config->debug};`
`76`	`76`
`77`	`77`	`auto rc = sqlite3_prepare_v2(handle->native_handle(), statement.c_str(), static_cast<int>(statement.size()),`
`78`	`78`	`&result.sqlite_statement, nullptr);`
`79`	`79`
`80`	`80`	`if (rc != SQLITE_OK)`
`81`	`81`	`{`
`82`		`- throw sqlpp::exception(`
	`82`	`+ throw sqlpp::exception{`
`83`	`83`	`"Sqlite3 error: Could not prepare statement: " + std::string(sqlite3_errmsg(handle->native_handle())) +`
`84`		`- " (statement was >>" + (rc == SQLITE_TOOBIG ? statement.substr(0, 128) + "..." : statement) + "<<\n");`
	`84`	`+ " (statement was >>" + (rc == SQLITE_TOOBIG ? statement.substr(0, 128) + "..." : statement) + "<<\n"};`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`return result;`
`@@ -99,8 +99,8 @@ namespace sqlpp`
`99`	`99`	`default:`
`100`	`100`	`if (handle->config->debug)`
`101`	`101`	`std::cerr << "Sqlite3 debug: sqlite3_step return code: " << rc << std::endl;`
`102`		`- throw sqlpp::exception("Sqlite3 error: Could not execute statement: " +`
`103`		`- std::string(sqlite3_errmsg(handle->native_handle())));`
	`102`	`+ throw sqlpp::exception{"Sqlite3 error: Could not execute statement: " +`
	`103`	`+ std::string(sqlite3_errmsg(handle->native_handle()))};`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`	`} // namespace detail`
`@@ -110,7 +110,7 @@ namespace sqlpp`
`110`	`110`
`111`	`111`	`struct context_t`
`112`	`112`	`{`
`113`		`- context_t(const connection_base& db) : _db(db), _count(1)`
	`113`	`+ context_t(const connection_base& db) : _db{db}, _count{1}`
`114`	`114`	`{`
`115`	`115`	`}`
`116`	`116`
`@@ -153,16 +153,16 @@ namespace sqlpp`
`153`	`153`	`active`
`154`	`154`	`};`
`155`	`155`
`156`		`- transaction_status_type _transaction_status = transaction_status_type::none;`
	`156`	`+ transaction_status_type _transaction_status{transaction_status_type::none};`
`157`	`157`
`158`	`158`	`// direct execution`
`159`	`159`	`bind_result_t select_impl(const std::string& statement)`
`160`	`160`	`{`
`161`		`- std::unique_ptr<detail::prepared_statement_handle_t> prepared(`
`162`		`- new detail::prepared_statement_handle_t(prepare_statement(_handle, statement)));`
	`161`	`+ std::unique_ptr<detail::prepared_statement_handle_t> prepared{`
	`162`	`+ new detail::prepared_statement_handle_t(prepare_statement(_handle, statement))};`
`163`	`163`	`if (!prepared)`
`164`	`164`	`{`
`165`		`- throw sqlpp::exception("Sqlite3 error: Could not store result set");`
	`165`	`+ throw sqlpp::exception{"Sqlite3 error: Could not store result set"};`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`return {std::move(prepared)};`
`@@ -193,8 +193,8 @@ namespace sqlpp`
`193`	`193`	`// prepared execution`
`194`	`194`	`prepared_statement_t prepare_impl(const std::string& statement)`
`195`	`195`	`{`
`196`		`- return {std::unique_ptr<detail::prepared_statement_handle_t>(`
`197`		`- new detail::prepared_statement_handle_t(prepare_statement(_handle, statement)))};`
	`196`	`+ return {std::unique_ptr<detail::prepared_statement_handle_t>{`
	`197`	`+ new detail::prepared_statement_handle_t(prepare_statement(_handle, statement))}};`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`bind_result_t run_prepared_select_impl(prepared_statement_t& prepared_statement)`
`@@ -263,15 +263,15 @@ namespace sqlpp`
`263`	`263`	`template <typename Select>`
`264`	`264`	`bind_result_t select(const Select& s)`
`265`	`265`	`{`
`266`		`- _context_t context(*this);`
	`266`	`+ _context_t context{*this};`
`267`	`267`	`serialize(s, context);`
`268`	`268`	`return select_impl(context.str());`
`269`	`269`	`}`
`270`	`270`
`271`	`271`	`template <typename Select>`
`272`	`272`	`_prepared_statement_t prepare_select(Select& s)`
`273`	`273`	`{`
`274`		`- _context_t context(*this);`
	`274`	`+ _context_t context{*this};`
`275`	`275`	`serialize(s, context);`
`276`	`276`	`return prepare_impl(context.str());`
`277`	`277`	`}`
`@@ -288,15 +288,15 @@ namespace sqlpp`
`288`	`288`	`template <typename Insert>`
`289`	`289`	`size_t insert(const Insert& i)`
`290`	`290`	`{`
`291`		`- _context_t context(*this);`
	`291`	`+ _context_t context{*this};`
`292`	`292`	`serialize(i, context);`
`293`	`293`	`return insert_impl(context.str());`
`294`	`294`	`}`
`295`	`295`
`296`	`296`	`template <typename Insert>`
`297`	`297`	`_prepared_statement_t prepare_insert(Insert& i)`
`298`	`298`	`{`
`299`		`- _context_t context(*this);`
	`299`	`+ _context_t context{*this};`
`300`	`300`	`serialize(i, context);`
`301`	`301`	`return prepare_impl(context.str());`
`302`	`302`	`}`
`@@ -313,15 +313,15 @@ namespace sqlpp`
`313`	`313`	`template <typename Update>`
`314`	`314`	`size_t update(const Update& u)`
`315`	`315`	`{`
`316`		`- _context_t context(*this);`
	`316`	`+ _context_t context{*this};`
`317`	`317`	`serialize(u, context);`
`318`	`318`	`return update_impl(context.str());`
`319`	`319`	`}`
`320`	`320`
`321`	`321`	`template <typename Update>`
`322`	`322`	`_prepared_statement_t prepare_update(Update& u)`
`323`	`323`	`{`
`324`		`- _context_t context(*this);`
	`324`	`+ _context_t context{*this};`
`325`	`325`	`serialize(u, context);`
`326`	`326`	`return prepare_impl(context.str());`
`327`	`327`	`}`
`@@ -338,15 +338,15 @@ namespace sqlpp`
`338`	`338`	`template <typename Remove>`
`339`	`339`	`size_t remove(const Remove& r)`
`340`	`340`	`{`
`341`		`- _context_t context(*this);`
	`341`	`+ _context_t context{*this};`
`342`	`342`	`serialize(r, context);`
`343`	`343`	`return remove_impl(context.str());`
`344`	`344`	`}`
`345`	`345`
`346`	`346`	`template <typename Remove>`
`347`	`347`	`_prepared_statement_t prepare_remove(Remove& r)`
`348`	`348`	`{`
`349`		`- _context_t context(*this);`
	`349`	`+ _context_t context{*this};`
`350`	`350`	`serialize(r, context);`
`351`	`351`	`return prepare_impl(context.str());`
`352`	`352`	`}`
`@@ -372,15 +372,15 @@ namespace sqlpp`
`372`	`372`	`typename Enable = typename std::enable_if<not std::is_convertible<Execute, std::string>::value, void>::type>`
`373`	`373`	`size_t execute(const Execute& x)`
`374`	`374`	`{`
`375`		`- _context_t context(*this);`
	`375`	`+ _context_t context{*this};`
`376`	`376`	`serialize(x, context);`
`377`	`377`	`return execute(context.str());`
`378`	`378`	`}`
`379`	`379`
`380`	`380`	`template <typename Execute>`
`381`	`381`	`_prepared_statement_t prepare_execute(Execute& x)`
`382`	`382`	`{`
`383`		`- _context_t context(*this);`
	`383`	`+ _context_t context{*this};`
`384`	`384`	`serialize(x, context);`
`385`	`385`	`return prepare_impl(context.str());`
`386`	`386`	`}`
`@@ -472,7 +472,7 @@ namespace sqlpp`
`472`	`472`	`{`
`473`	`473`	`if (_transaction_status == transaction_status_type::active)`
`474`	`474`	`{`
`475`		`- throw sqlpp::exception("Sqlite3 error: Cannot have more than one open transaction per connection");`
	`475`	`+ throw sqlpp::exception{"Sqlite3 error: Cannot have more than one open transaction per connection"};`
`476`	`476`	`}`
`477`	`477`
`478`	`478`	`_transaction_status = transaction_status_type::maybe;`
`@@ -486,7 +486,7 @@ namespace sqlpp`
`486`	`486`	`{`
`487`	`487`	`if (_transaction_status == transaction_status_type::none)`
`488`	`488`	`{`
`489`		`- throw sqlpp::exception("Sqlite3 error: Cannot commit a finished or failed transaction");`
	`489`	`+ throw sqlpp::exception{"Sqlite3 error: Cannot commit a finished or failed transaction"};`
`490`	`490`	`}`
`491`	`491`	`_transaction_status = transaction_status_type::maybe;`
`492`	`492`	`auto prepared = prepare_statement(_handle, "COMMIT");`
`@@ -500,7 +500,7 @@ namespace sqlpp`
`500`	`500`	`{`
`501`	`501`	`if (_transaction_status == transaction_status_type::none)`
`502`	`502`	`{`
`503`		`- throw sqlpp::exception("Sqlite3 error: Cannot rollback a finished or failed transaction");`
	`503`	`+ throw sqlpp::exception{"Sqlite3 error: Cannot rollback a finished or failed transaction"};`
`504`	`504`	`}`
`505`	`505`	`if (report)`
`506`	`506`	`{`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ namespace sqlpp`
`35`	`35`	`{`
`36`	`36`	`struct connection_config`
`37`	`37`	`{`
`38`		`- connection_config() : path_to_database(), flags(0), vfs(), debug(false),password("")`
	`38`	`+ connection_config() : path_to_database{}, flags{0}, vfs{}, debug{false},password{}`
`39`	`39`	`{`
`40`	`40`	`}`
`41`	`41`	`connection_config(const connection_config&) = default;`
`@@ -44,7 +44,7 @@ namespace sqlpp`
`44`	`44`	`connection_config& operator=(connection_config&&) = default;`
`45`	`45`
`46`	`46`	`connection_config(std::string path, int fl = 0, std::string vf = "", bool dbg = false,std::string password="")`
`47`		`- : path_to_database(std::move(path)), flags(fl), vfs(std::move(vf)), debug(dbg),password(password)`
	`47`	`+ : path_to_database{std::move(path)}, flags{fl}, vfs{std::move(vf)}, debug{dbg},password{password}`
`48`	`48`	`{`
`49`	`49`	`}`
`50`	`50`
Original file line number	Diff line number	Diff line change
`@@ -53,8 +53,8 @@ namespace sqlpp`
`53`	`53`	`std::unique_ptr<::sqlite3, int ()(::sqlite3)> sqlite;`
`54`	`54`
`55`	`55`	`connection_handle(const std::shared_ptr<const connection_config>& conf) :`
`56`		`- config(conf),`
`57`		`- sqlite(nullptr, sqlite3_close)`
	`56`	`+ config{conf},`
	`57`	`+ sqlite{nullptr, sqlite3_close}`
`58`	`58`	`{`
`59`	`59`	`#ifdef SQLPP_DYNAMIC_LOADING`
`60`	`60`	`init_sqlite("");`
`@@ -67,7 +67,7 @@ namespace sqlpp`
`67`	`67`	`{`
`68`	`68`	`const std::string msg = sqlite3_errmsg(sqlite_ptr);`
`69`	`69`	`sqlite3_close(sqlite_ptr);`
`70`		`- throw sqlpp::exception("Sqlite3 error: Can't open database: " + msg);`
	`70`	`+ throw sqlpp::exception{"Sqlite3 error: Can't open database: " + msg};`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`sqlite.reset(sqlite_ptr);`
`@@ -80,7 +80,7 @@ namespace sqlpp`
`80`	`80`	`{`
`81`	`81`	`const std::string msg = sqlite3_errmsg(native_handle());`
`82`	`82`	`sqlite3_close(native_handle());`
`83`		`- throw sqlpp::exception("Sqlite3 error: Can't set password to database: " + msg);`
	`83`	`+ throw sqlpp::exception{"Sqlite3 error: Can't set password to database: " + msg};`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -48,14 +48,14 @@ namespace sqlpp`
`48`	`48`	`sqlite3_stmt* sqlite_statement;`
`49`	`49`	`bool debug;`
`50`	`50`
`51`		`- prepared_statement_handle_t(sqlite3_stmt* statement, bool debug_) : sqlite_statement(statement), debug(debug_)`
	`51`	`+ prepared_statement_handle_t(sqlite3_stmt* statement, bool debug_) : sqlite_statement{statement}, debug{debug_}`
`52`	`52`	`{`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`prepared_statement_handle_t(const prepared_statement_handle_t&) = delete;`
`56`	`56`	`prepared_statement_handle_t(prepared_statement_handle_t&& rhs) :`
`57`		`- sqlite_statement(rhs.sqlite_statement),`
`58`		`- debug(rhs.debug)`
	`57`	`+ sqlite_statement{rhs.sqlite_statement},`
	`58`	`+ debug{rhs.debug}`
`59`	`59`	`{`
`60`	`60`	`rhs.sqlite_statement = nullptr;`
`61`	`61`	`}`