Replace boost::shared_ptr with std::shared_ptr

Author: pnorman

expire-tiles.cpp

@@ -496,7 +496,7 @@ int expire_tiles::from_db(table_t* table, osmid_t osm_id) {
         return -1;
 
     //grab the geom for this id
-    boost::shared_ptr<table_t::wkt_reader> wkts = table->get_wkt_reader(osm_id);
+    std::shared_ptr<table_t::wkt_reader> wkts = table->get_wkt_reader(osm_id);
 
     //dirty the stuff
     const char* wkt = nullptr;

geometry-builder.hpp

@@ -27,8 +27,8 @@
 
 #include <vector>
 #include <string>
+#include <memory>
 #include <boost/noncopyable.hpp>
-#include <boost/shared_ptr.hpp>
 
 struct geometry_builder : public boost::noncopyable
 {
@@ -41,8 +41,8 @@ struct geometry_builder : public boost::noncopyable
     };
 
     // type to represent an optional return of WKT-encoded geometry
-    typedef boost::shared_ptr<geometry_builder::wkt_t> maybe_wkt_t;
-    typedef boost::shared_ptr<std::vector<geometry_builder::wkt_t> > maybe_wkts_t;
+    typedef std::shared_ptr<geometry_builder::wkt_t> maybe_wkt_t;
+    typedef std::shared_ptr<std::vector<geometry_builder::wkt_t> > maybe_wkts_t;
     typedef std::vector<geometry_builder::wkt_t>::const_iterator wkt_itr;
 
     geometry_builder();

geometry-processor.cpp

@@ -6,24 +6,24 @@
 #include "options.hpp"
 #include "reprojection.hpp"
 
-#include <boost/make_shared.hpp>
 #include <boost/format.hpp>
 #include <boost/optional.hpp>
 #include <stdexcept>
+#include <memory>
 
-boost::shared_ptr<geometry_processor> geometry_processor::create(const std::string &type,
+std::shared_ptr<geometry_processor> geometry_processor::create(const std::string &type,
                                                                  const options_t *options) {
-    boost::shared_ptr<geometry_processor> ptr;
+    std::shared_ptr<geometry_processor> ptr;
     int srid = options->projection->project_getprojinfo()->srs;
 
     if (type == "point") {
-        ptr = boost::make_shared<processor_point>(srid);
+        ptr = std::make_shared<processor_point>(srid);
     }
     else if (type == "line") {
-        ptr = boost::make_shared<processor_line>(srid);
+        ptr = std::make_shared<processor_line>(srid);
     }
     else if (type == "polygon") {
-        ptr = boost::make_shared<processor_polygon>(srid, options->enable_multi);
+        ptr = std::make_shared<processor_polygon>(srid, options->enable_multi);
     }
     else {
         throw std::runtime_error((boost::format("Unable to construct geometry processor "

geometry-processor.hpp

@@ -4,7 +4,7 @@
 #include <cstddef>
 #include <string>
 #include <vector>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "geometry-builder.hpp"
 #include "osmtypes.hpp"
 
@@ -14,7 +14,7 @@ struct options_t;
 
 struct geometry_processor {
     // factory method for creating various types of geometry processors either by name or by geometry column type
-    static boost::shared_ptr<geometry_processor> create(const std::string &type,
+    static std::shared_ptr<geometry_processor> create(const std::string &type,
                                                         const options_t *options);
 
     virtual ~geometry_processor();

middle-pgsql.cpp

@@ -1358,7 +1358,7 @@ middle_pgsql_t::~middle_pgsql_t() {
 
 }
 
-boost::shared_ptr<const middle_query_t> middle_pgsql_t::get_instance() const {
+std::shared_ptr<const middle_query_t> middle_pgsql_t::get_instance() const {
     middle_pgsql_t* mid = new middle_pgsql_t();
     mid->out_options = out_options;
     mid->append = out_options->append;
@@ -1388,7 +1388,7 @@ boost::shared_ptr<const middle_query_t> middle_pgsql_t::get_instance() const {
         }
     }
 
-    return boost::shared_ptr<const middle_query_t>(mid);
+    return std::shared_ptr<const middle_query_t>(mid);
 }
 
 size_t middle_pgsql_t::pending_count() const {

middle-pgsql.hpp

@@ -15,7 +15,6 @@
 #include "id-tracker.hpp"
 #include <memory>
 #include <vector>
-#include <boost/shared_ptr.hpp>
 
 struct middle_pgsql_t : public slim_middle_t {
     middle_pgsql_t();
@@ -82,7 +81,7 @@ struct middle_pgsql_t : public slim_middle_t {
         struct pg_conn *sql_conn;
     };
 
-    virtual boost::shared_ptr<const middle_query_t> get_instance() const;
+    virtual std::shared_ptr<const middle_query_t> get_instance() const;
 private:
 
     int connect(table_desc& table);
@@ -97,10 +96,10 @@ struct middle_pgsql_t : public slim_middle_t {
     bool append;
     bool mark_pending;
 
-    boost::shared_ptr<node_ram_cache> cache;
-    boost::shared_ptr<node_persistent_cache> persistent_cache;
+    std::shared_ptr<node_ram_cache> cache;
+    std::shared_ptr<node_persistent_cache> persistent_cache;
 
-    boost::shared_ptr<id_tracker> ways_pending_tracker, rels_pending_tracker;
+    std::shared_ptr<id_tracker> ways_pending_tracker, rels_pending_tracker;
 
     int build_indexes;
 };

middle-ram.cpp

@@ -218,7 +218,7 @@ void no_delete(const middle_ram_t * middle) {
 
 }
 
-boost::shared_ptr<const middle_query_t> middle_ram_t::get_instance() const {
+std::shared_ptr<const middle_query_t> middle_ram_t::get_instance() const {
     //shallow copy here because readonly access is thread safe
-    return boost::shared_ptr<const middle_query_t>(this, no_delete);
+    return std::shared_ptr<const middle_query_t>(this, no_delete);
 }

middle-ram.hpp

@@ -115,7 +115,7 @@ struct middle_ram_t : public middle_t {
 
     size_t pending_count() const;
 
-    virtual boost::shared_ptr<const middle_query_t> get_instance() const;
+    virtual std::shared_ptr<const middle_query_t> get_instance() const;
 private:
 
     void release_ways();

middle.cpp

@@ -2,13 +2,13 @@
 #include "middle-pgsql.hpp"
 #include "middle-ram.hpp"
 
-#include <boost/make_shared.hpp>
+#include <memory>
 
-boost::shared_ptr<middle_t> middle_t::create_middle(const bool slim)
+std::shared_ptr<middle_t> middle_t::create_middle(const bool slim)
 {
      if(slim)
-         return boost::make_shared<middle_pgsql_t>();
+         return std::make_shared<middle_pgsql_t>();
      else
-         return boost::make_shared<middle_ram_t>();
+         return std::make_shared<middle_ram_t>();
 }
 

middle.hpp

@@ -10,7 +10,7 @@
 #include "osmtypes.hpp"
 
 #include <cstddef>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 struct options_t;
 
@@ -31,11 +31,11 @@ struct middle_query_t {
 
     virtual idlist_t relations_using_way(osmid_t way_id) const = 0;
 
-    virtual boost::shared_ptr<const middle_query_t> get_instance() const = 0;
+    virtual std::shared_ptr<const middle_query_t> get_instance() const = 0;
 };
 
 struct middle_t : public middle_query_t {
-    static boost::shared_ptr<middle_t> create_middle(bool slim);
+    static std::shared_ptr<middle_t> create_middle(bool slim);
 
     virtual ~middle_t() {}
 

node-persistent-cache-reader.cpp

@@ -4,14 +4,14 @@
 #include <cstring>
 #include <sys/wait.h>
 #include <sys/time.h>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 #include "osmtypes.hpp"
 #include "options.hpp"
 #include "node-persistent-cache.hpp"
 #include "node-ram-cache.hpp"
 
-void test_get_node_list(boost::shared_ptr<node_persistent_cache> cache,
+void test_get_node_list(std::shared_ptr<node_persistent_cache> cache,
                         int itterations, int max_size, int process_number) {
     int i, j, node_cnt, node_cnt_total;
     nodelist_t nodes;
@@ -43,18 +43,18 @@ void test_get_node_list(boost::shared_ptr<node_persistent_cache> cache,
 }
 
 int main(int argc, char *argv[]) {
-	int i,p;
-	options_t options;
-	osmNode node;
-	nodelist_t nodes;
-	struct timeval start;
-	idlist_t osmids;
-	int node_cnt;
-	options.append = true;
-	options.flat_node_cache_enabled = true;
-	options.flat_node_file = argv[1];
-        boost::shared_ptr<node_ram_cache> ram_cache(new node_ram_cache(0, 10, options.scale));
-        boost::shared_ptr<node_persistent_cache> cache;
+    int i,p;
+    options_t options;
+    osmNode node;
+    nodelist_t nodes;
+    struct timeval start;
+    idlist_t osmids;
+    int node_cnt;
+    options.append = true;
+    options.flat_node_cache_enabled = true;
+    options.flat_node_file = argv[1];
+    auto ram_cache = std::make_shared<node_ram_cache>(0, 10, options.scale);
+    std::shared_ptr<node_persistent_cache> cache;
 
 
 	if (argc > 3) {

node-persistent-cache.cpp

@@ -483,7 +483,7 @@ void node_persistent_cache::set_read_mode()
 }
 
 node_persistent_cache::node_persistent_cache(const options_t *options, bool append,
-                                             bool ro, boost::shared_ptr<node_ram_cache> ptr)
+                                             bool ro, std::shared_ptr<node_ram_cache> ptr)
     : node_cache_fd(0), node_cache_fname(nullptr), append_mode(append), cacheHeader(),
       writeNodeBlock(), readNodeBlockCache(nullptr), read_mode(ro), ram_cache(ptr)
 {

node-persistent-cache.hpp

@@ -3,7 +3,7 @@
 
 #include "osmtypes.hpp"
 #include "node-ram-cache.hpp"
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 #include <vector>
 
@@ -52,7 +52,7 @@ inline bool operator<(osmid_t a, cache_index_entry const &b)
 struct node_persistent_cache : public boost::noncopyable
 {
     node_persistent_cache(const struct options_t *options, bool append,
-                          bool ro, boost::shared_ptr<node_ram_cache> ptr);
+                          bool ro, std::shared_ptr<node_ram_cache> ptr);
     ~node_persistent_cache();
 
     void set(osmid_t id, double lat, double lon);
@@ -89,7 +89,7 @@ struct node_persistent_cache : public boost::noncopyable
 
     bool read_mode;
 
-    boost::shared_ptr<node_ram_cache> ram_cache;
+    std::shared_ptr<node_ram_cache> ram_cache;
 };
 
 #endif

options.hpp

@@ -6,7 +6,7 @@
 
 #include <vector>
 #include <string>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include <boost/optional.hpp>
 
 /* Variants for generation of hstore column */
@@ -31,7 +31,7 @@ struct options_t {
     std::string conninfo; /* Connection info string */
     std::string prefix; /* prefix for table names */
     int scale; /* scale for converting coordinates to fixed point */
-    boost::shared_ptr<reprojection> projection; /* SRS of projection */
+    std::shared_ptr<reprojection> projection; /* SRS of projection */
     bool append; /* Append to existing data */
     bool slim; /* In slim mode */
     int cache; /* Memory usable for cache in MB */

osm2pgsql.cpp

@@ -79,10 +79,10 @@ int main(int argc, char *argv[])
                                 options.projection, options.append);
 
         //setup the middle
-        boost::shared_ptr<middle_t> middle = middle_t::create_middle(options.slim);
+        std::shared_ptr<middle_t> middle = middle_t::create_middle(options.slim);
 
         //setup the backend (output)
-        std::vector<boost::shared_ptr<output_t> > outputs = output_t::create_outputs(middle.get(), options);
+        std::vector<std::shared_ptr<output_t> > outputs = output_t::create_outputs(middle.get(), options);
 
         //let osmdata orchestrate between the middle and the outs
         osmdata_t osmdata(middle, outputs);