Use std::make_unique to make code cleaner

Now that we are using C++14, make_unique is available.

Author: joto

src/db-copy.cpp

@@ -105,15 +105,14 @@ void db_copy_thread_t::sync_and_wait()
 {
     std::promise<void> barrier;
     std::future<void> sync = barrier.get_future();
-    add_buffer(
-        std::unique_ptr<db_cmd_t>(new db_cmd_sync_t{std::move(barrier)}));
+    add_buffer(std::make_unique<db_cmd_sync_t>(std::move(barrier)));
     sync.wait();
 }
 
 void db_copy_thread_t::finish()
 {
     if (m_worker.joinable()) {
-        add_buffer(std::unique_ptr<db_cmd_t>(new db_cmd_finish_t{}));
+        add_buffer(std::make_unique<db_cmd_finish_t>());
         m_worker.join();
     }
 }

src/geom-transform.cpp

@@ -156,15 +156,15 @@ geom_transform_area_t::run(geom::osmium_builder_t *builder,
 std::unique_ptr<geom_transform_t> create_geom_transform(char const *type)
 {
     if (std::strcmp(type, "point") == 0) {
-        return std::unique_ptr<geom_transform_t>{new geom_transform_point_t{}};
+        return std::make_unique<geom_transform_point_t>();
     }
 
     if (std::strcmp(type, "line") == 0) {
-        return std::unique_ptr<geom_transform_t>{new geom_transform_line_t{}};
+        return std::make_unique<geom_transform_line_t>();
     }
 
     if (std::strcmp(type, "area") == 0) {
-        return std::unique_ptr<geom_transform_t>{new geom_transform_area_t{}};
+        return std::make_unique<geom_transform_area_t>();
     }
 
     throw std::runtime_error{

src/middle-pgsql.cpp

@@ -817,9 +817,8 @@ middle_pgsql_t::get_query_instance()
 {
     // NOTE: this is thread safe for use in pending async processing only because
     // during that process they are only read from
-    std::unique_ptr<middle_query_pgsql_t> mid{
-        new middle_query_pgsql_t{m_options->database_options.conninfo(),
-                                 m_cache, m_persistent_cache}};
+    auto mid = std::make_unique<middle_query_pgsql_t>(
+        m_options->database_options.conninfo(), m_cache, m_persistent_cache);
 
     // We use a connection per table to enable the use of COPY
     for (auto &table : m_tables) {

src/osm2pgsql.cpp

@@ -37,10 +37,10 @@ static void run(options_t const &options)
 
     middle->set_requirements(output->get_requirements());
 
-    auto dependency_manager = std::unique_ptr<dependency_manager_t>(
+    auto dependency_manager =
         options.with_forward_dependencies
-            ? new full_dependency_manager_t{middle}
-            : new dependency_manager_t{});
+            ? std::make_unique<full_dependency_manager_t>(middle)
+            : std::make_unique<dependency_manager_t>();
 
     osmdata_t osmdata{std::move(dependency_manager), middle, output, options};
 

src/tagtransform-c.cpp

@@ -96,8 +96,7 @@ c_tagtransform_t::c_tagtransform_t(options_t const *options,
 
 std::unique_ptr<tagtransform_t> c_tagtransform_t::clone() const
 {
-    return std::unique_ptr<tagtransform_t>(
-        new c_tagtransform_t{m_options, m_export_list});
+    return std::make_unique<c_tagtransform_t>(m_options, m_export_list);
 }
 
 bool c_tagtransform_t::check_key(std::vector<taginfo> const &infos,

src/tagtransform.cpp

@@ -25,7 +25,7 @@ tagtransform_t::make_tagtransform(options_t const *options,
 #ifdef HAVE_LUA
         log_debug("Using lua based tag transformations with script {}",
                   options->tag_transform_script);
-        return std::unique_ptr<tagtransform_t>(new lua_tagtransform_t{options});
+        return std::make_unique<lua_tagtransform_t>(options);
 #else
         throw std::runtime_error{"Error: Could not init lua tag transform, as "
                                  "lua support was not compiled into this "
@@ -34,8 +34,7 @@ tagtransform_t::make_tagtransform(options_t const *options,
     }
 
     log_debug("Using built-in tag transformations");
-    return std::unique_ptr<tagtransform_t>(
-        new c_tagtransform_t{options, exlist});
+    return std::make_unique<c_tagtransform_t>(options, exlist);
 }
 
 tagtransform_t::~tagtransform_t() = default;

tests/common-import.hpp

@@ -150,10 +150,10 @@ class import_t
 
         middle->set_requirements(output->get_requirements());
 
-        auto dependency_manager = std::unique_ptr<dependency_manager_t>(
+        auto dependency_manager =
             options.with_forward_dependencies
-                ? new full_dependency_manager_t{middle}
-                : new dependency_manager_t{});
+                ? std::make_unique<full_dependency_manager_t>(middle)
+                : std::make_unique<dependency_manager_t>();
 
         osmdata_t osmdata{std::move(dependency_manager), middle, output,
                           options};
@@ -187,8 +187,8 @@ class import_t
 
         middle->set_requirements(output->get_requirements());
 
-        auto dependency_manager = std::unique_ptr<dependency_manager_t>(
-            new full_dependency_manager_t{middle});
+        auto dependency_manager =
+            std::make_unique<full_dependency_manager_t>(middle);
 
         parse_file(options, std::move(dependency_manager), middle, output,
                    file);

tests/test-db-copy-thread.cpp

@@ -34,7 +34,7 @@ TEST_CASE("db_copy_thread_t with db_deleter_by_id_t")
 
     db_copy_thread_t t(db.conninfo());
     using cmd_copy_t = db_cmd_copy_delete_t<db_deleter_by_id_t>;
-    auto cmd = std::unique_ptr<cmd_copy_t>(new cmd_copy_t{table});
+    auto cmd = std::make_unique<cmd_copy_t>(table);
 
     SECTION("simple copy command")
     {
@@ -78,7 +78,7 @@ TEST_CASE("db_copy_thread_t with db_deleter_by_id_t")
         t.add_buffer(std::unique_ptr<db_cmd_t>(cmd.release()));
         t.sync_and_wait();
 
-        cmd = std::unique_ptr<cmd_copy_t>(new cmd_copy_t{table});
+        cmd = std::make_unique<cmd_copy_t>(table);
 
         SECTION("simple delete of existing rows")
         {
@@ -121,7 +121,7 @@ TEST_CASE("db_copy_thread_t with db_deleter_by_id_t")
         cmd->buffer += "542\n5543\n10133\n";
         t.add_buffer(std::unique_ptr<db_cmd_t>(cmd.release()));
 
-        cmd = std::unique_ptr<cmd_copy_t>(new cmd_copy_t{table});
+        cmd = std::make_unique<cmd_copy_t>(table);
         cmd->buffer += "12\n784\n523\n";
         t.add_buffer(std::unique_ptr<db_cmd_t>(cmd.release()));
 
@@ -137,7 +137,7 @@ TEST_CASE("db_copy_thread_t with db_deleter_by_id_t")
         cmd->buffer += "542\n5543\n10133\n";
         t.add_buffer(std::unique_ptr<db_cmd_t>(cmd.release()));
 
-        cmd = std::unique_ptr<cmd_copy_t>(new cmd_copy_t{table});
+        cmd = std::make_unique<cmd_copy_t>(table);
         cmd->add_deletable(542);
         cmd->buffer += "12\n";
         t.add_buffer(std::unique_ptr<db_cmd_t>(cmd.release()));
@@ -165,7 +165,7 @@ TEST_CASE("db_copy_thread_t with db_deleter_place_t")
 
     db_copy_thread_t t(db.conninfo());
     using cmd_copy_t = db_cmd_copy_delete_t<db_deleter_place_t>;
-    auto cmd = std::unique_ptr<cmd_copy_t>(new cmd_copy_t{table});
+    auto cmd = std::make_unique<cmd_copy_t>(table);
 
     SECTION("simple delete")
     {
@@ -177,7 +177,7 @@ TEST_CASE("db_copy_thread_t with db_deleter_place_t")
         t.add_buffer(std::unique_ptr<db_cmd_t>(cmd.release()));
         t.sync_and_wait();
 
-        cmd = std::unique_ptr<cmd_copy_t>(new cmd_copy_t{table});
+        cmd = std::make_unique<cmd_copy_t>(table);
 
         SECTION("full delete of existing rows")
         {

tests/test-parse-osmium.cpp

@@ -157,8 +157,8 @@ TEST_CASE("parse xml file")
     std::shared_ptr<output_t> output{new counting_output_t{options}};
 
     auto counts = std::make_shared<counts_t>();
-    auto dependency_manager = std::unique_ptr<dependency_manager_t>(
-        new counting_dependency_manager_t{counts});
+    auto dependency_manager =
+        std::make_unique<counting_dependency_manager_t>(counts);
 
     testing::parse_file(options, std::move(dependency_manager), middle,
                         {output}, "test_multipolygon.osm", false);
@@ -197,8 +197,8 @@ TEST_CASE("parse diff file")
     std::shared_ptr<output_t> output{new counting_output_t{options}};
 
     auto counts = std::make_shared<counts_t>();
-    auto dependency_manager = std::unique_ptr<dependency_manager_t>(
-        new counting_dependency_manager_t{counts});
+    auto dependency_manager =
+        std::make_unique<counting_dependency_manager_t>(counts);
 
     testing::parse_file(options, std::move(dependency_manager), middle,
                         {output}, "008-ch.osc.gz", false);
@@ -235,8 +235,8 @@ TEST_CASE("parse xml file with extra args")
     std::shared_ptr<output_t> output{new counting_output_t{options}};
 
     auto counts = std::make_shared<counts_t>();
-    auto dependency_manager = std::unique_ptr<dependency_manager_t>(
-        new counting_dependency_manager_t{counts});
+    auto dependency_manager =
+        std::make_unique<counting_dependency_manager_t>(counts);
 
     testing::parse_file(options, std::move(dependency_manager), middle,
                         {output}, "test_multipolygon.osm", false);
@@ -275,8 +275,8 @@ TEST_CASE("invalid location")
     std::shared_ptr<output_t> output{new counting_output_t{options}};
 
     auto counts = std::make_shared<counts_t>();
-    auto dependency_manager = std::unique_ptr<dependency_manager_t>(
-        new counting_dependency_manager_t{counts});
+    auto dependency_manager =
+        std::make_unique<counting_dependency_manager_t>(counts);
 
     testing::parse_file(options, std::move(dependency_manager), middle,
                         {output}, "test_invalid_location.osm", false);