Use std::make_shared/unique to reduce use of bare "new" operator

Author: joto

src/db-copy-mgr.hpp

@@ -41,7 +41,7 @@ class db_copy_mgr_t
                 m_processor->add_buffer(std::move(m_current));
             }
 
-            m_current.reset(new db_cmd_copy_delete_t<DELETER>{table});
+            m_current = std::make_unique<db_cmd_copy_delete_t<DELETER>>(table);
         }
     }
 

src/db-copy.cpp

@@ -124,7 +124,7 @@ db_copy_thread_t::thread_t::thread_t(std::string conninfo, shared &shared)
 void db_copy_thread_t::thread_t::operator()()
 {
     try {
-        m_conn.reset(new pg_conn_t{m_conninfo});
+        m_conn = std::make_unique<pg_conn_t>(m_conninfo);
 
         // Let commits happen faster by delaying when they actually occur.
         m_conn->exec("SET synchronous_commit = off");

src/flex-table.cpp

@@ -152,7 +152,7 @@ void table_connection_t::connect(std::string const &conninfo)
 {
     assert(!m_db_connection);
 
-    m_db_connection.reset(new pg_conn_t{conninfo});
+    m_db_connection = std::make_unique<pg_conn_t>(conninfo);
     m_db_connection->exec("SET synchronous_commit = off");
 }
 

src/input.cpp

@@ -74,7 +74,7 @@ class data_source_t
 {
 public:
     explicit data_source_t(osmium::io::File const &file)
-    : m_reader(new osmium::io::Reader{file})
+    : m_reader(std::make_unique<osmium::io::Reader>(file))
     {
         get_next_nonempty_buffer();
         m_last = check_input(m_last, *m_it);

src/middle-pgsql.cpp

@@ -782,16 +782,16 @@ static bool check_bucket_index(pg_conn_t *db_connection,
 middle_pgsql_t::middle_pgsql_t(std::shared_ptr<thread_pool_t> thread_pool,
                                options_t const *options)
 : middle_t(std::move(thread_pool)), m_options(options),
-  m_cache(new node_locations_t{static_cast<std::size_t>(options->cache) *
-                               1024UL * 1024UL}),
+  m_cache(std::make_unique<node_locations_t>(
+      static_cast<std::size_t>(options->cache) * 1024UL * 1024UL)),
   m_db_connection(m_options->database_options.conninfo()),
   m_copy_thread(
       std::make_shared<db_copy_thread_t>(options->database_options.conninfo())),
   m_db_copy(m_copy_thread)
 {
     if (!options->flat_node_file.empty()) {
-        m_persistent_cache.reset(new node_persistent_cache{
-            options->flat_node_file, options->droptemp});
+        m_persistent_cache = std::make_shared<node_persistent_cache>(
+            options->flat_node_file, options->droptemp);
     }
 
     log_debug("Mid: pgsql, cache={}", options->cache);

src/node-persistent-cache.cpp

@@ -40,7 +40,7 @@ node_persistent_cache::node_persistent_cache(std::string file_name,
             m_file_name, std::strerror(errno))};
     }
 
-    m_index.reset(new index_t{m_fd});
+    m_index = std::make_unique<index_t>(m_fd);
 }
 
 node_persistent_cache::~node_persistent_cache() noexcept

src/output-pgsql.cpp

@@ -437,11 +437,10 @@ output_pgsql_t::output_pgsql_t(
             std::abort(); // should never be here
         }
 
-        m_tables[i].reset(
-            new table_t{name, type, columns, m_options.hstore_columns,
-                        m_options.projection->target_srs(), m_options.append,
-                        m_options.hstore_mode, copy_thread,
-                        m_options.output_dbschema});
+        m_tables[i] = std::make_unique<table_t>(
+            name, type, columns, m_options.hstore_columns,
+            m_options.projection->target_srs(), m_options.append,
+            m_options.hstore_mode, copy_thread, m_options.output_dbschema);
     }
 }
 
@@ -458,8 +457,8 @@ output_pgsql_t::output_pgsql_t(
 {
     for (size_t i = 0; i < t_MAX; ++i) {
         //copy constructor will just connect to the already there table
-        m_tables[i].reset(
-            new table_t{*(other->m_tables[i].get()), copy_thread});
+        m_tables[i] =
+            std::make_unique<table_t>(*(other->m_tables[i].get()), copy_thread);
     }
 }
 

src/table.cpp

@@ -68,7 +68,7 @@ void table_t::sync() { m_copy.sync(); }
 
 void table_t::connect()
 {
-    m_sql_conn.reset(new pg_conn_t{m_conninfo});
+    m_sql_conn = std::make_unique<pg_conn_t>(m_conninfo);
     //let commits happen faster by delaying when they actually occur
     m_sql_conn->exec("SET synchronous_commit = off");
 }

tests/common-import.hpp

@@ -137,15 +137,7 @@ class import_t
         options.database_options = m_db.db_options();
 
         auto thread_pool = std::make_shared<thread_pool_t>(1U);
-        std::shared_ptr<middle_t> middle;
-
-        if (options.slim) {
-            middle = std::shared_ptr<middle_t>(
-                new middle_pgsql_t{thread_pool, &options});
-        } else {
-            middle = std::shared_ptr<middle_t>(
-                new middle_ram_t{thread_pool, &options});
-        }
+        auto middle = create_middle(thread_pool, options);
         middle->start();
 
         auto output = output_t::create_output(middle->get_query_instance(),

tests/test-middle.cpp

@@ -111,11 +111,7 @@ TEMPLATE_TEST_CASE("middle import", "", options_slim_default,
     }
 
     auto thread_pool = std::make_shared<thread_pool_t>(1U);
-    auto mid = options.slim ? std::shared_ptr<middle_t>(
-                                  new middle_pgsql_t{thread_pool, &options})
-                            : std::shared_ptr<middle_t>(
-                                  new middle_ram_t{thread_pool, &options});
-
+    auto mid = create_middle(thread_pool, options);
     mid->start();
 
     output_requirements requirements;