Replace boost::ptr_vector<T> with std::vector<std::unique_ptr<T>>

tabe · tabe · commit fc92d51007ac · 2017-09-16T10:58:39.000+09:00
diff --git a/obsolete/include/mdds/mixed_type_matrix_storage.hpp b/obsolete/include/mdds/mixed_type_matrix_storage.hpp
@@ -30,7 +30,6 @@
 
 #include <cassert>
 
-#include <boost/ptr_container/ptr_vector.hpp>
 #include <boost/ptr_container/ptr_map.hpp>
 // Boost.Pool indirectly pulls in Boost.System, causing linking error
 // with Boost 1.50, because some (deprecated) symbols from System are
diff --git a/src/multi_type_vector_test_custom.cpp b/src/multi_type_vector_test_custom.cpp
@@ -35,11 +35,10 @@
 #include <mdds/multi_type_vector_custom_func3.hpp>
 
 #include <cassert>
+#include <memory>
 #include <sstream>
 #include <vector>
 
-#include <boost/ptr_container/ptr_vector.hpp>
-
 #define ARRAY_SIZE(x) sizeof(x)/sizeof(x[0])
 
 using namespace std;
@@ -91,16 +90,16 @@ struct date
 template<typename T>
 class cell_pool
 {
-    boost::ptr_vector<T> m_pool;
+    std::vector<std::unique_ptr<T>> m_pool;
 public:
     cell_pool() = default;
     cell_pool(const cell_pool&) = delete;
     cell_pool& operator=(const cell_pool&) = delete;
 
     T* construct()
     {
-        m_pool.push_back(new T);
-        return &m_pool.back();
+        m_pool.emplace_back(new T);
+        return m_pool.back().get();
     }
 
     void clear() { m_pool.clear(); }
diff --git a/src/multi_type_vector_test_default.cpp b/src/multi_type_vector_test_default.cpp
@@ -36,8 +36,6 @@
 #include <vector>
 #include <deque>
 
-#include <boost/ptr_container/ptr_vector.hpp>
-
 #define ARRAY_SIZE(x) sizeof(x)/sizeof(x[0])
 
 using namespace std;
diff --git a/src/multi_type_vector_test_perf.cpp b/src/multi_type_vector_test_perf.cpp
@@ -35,8 +35,6 @@
 #include <vector>
 #include <deque>
 
-#include <boost/ptr_container/ptr_vector.hpp>
-
 #define ARRAY_SIZE(x) sizeof(x)/sizeof(x[0])
 
 using namespace std;
diff --git a/src/point_quad_tree_test.cpp b/src/point_quad_tree_test.cpp
@@ -29,14 +29,13 @@
 #include "test_global.hpp"
 
 #include <algorithm>
+#include <memory>
 #include <vector>
 #include <sstream>
-#include <boost/ptr_container/ptr_vector.hpp>
 #include <boost/cstdint.hpp>
 
 using namespace std;
 using namespace mdds;
-using ::boost::ptr_vector;
 using ::boost::uint16_t;
 
 struct data_printer : public unary_function<string*, void>
@@ -144,13 +143,13 @@ void pqt_test_insertion_removal()
     assert(db.size() == 0);
 
     // Create all data instances.
-    ptr_vector<string> data_store;
+    vector<unique_ptr<string>> data_store;
     data_store.reserve(100);
     for (size_t i = 0; i < 100; ++i)
     {
         ostringstream os;
         os << "0x" << hex << i;
-        data_store.push_back(new string(os.str()));
+        data_store.emplace_back(new string(os.str()));
     }
 
     vector<db_type::node_data> expected;
@@ -162,7 +161,7 @@ void pqt_test_insertion_removal()
         {
             int32_t x = i*10 + 1, y = j*10 + 1;
             size_t index = i*10 + j;
-            const string* data_ptr = &data_store[index];
+            const string* data_ptr = data_store[index].get();
             cout << "inserting '" << *data_ptr << "' at (" << x << "," << y << ")" << endl;
             db.insert(x, y, data_ptr);
             expected.push_back(db_type::node_data(x, y, data_ptr));
diff --git a/src/rectangle_set_test.cpp b/src/rectangle_set_test.cpp
@@ -29,12 +29,12 @@
 #include "test_global.hpp"
 
 #include <iostream>
+#include <memory>
+#include <vector>
 #include <sstream>
-#include <boost/ptr_container/ptr_vector.hpp>
 
 using namespace std;
 using namespace mdds;
-using ::boost::ptr_vector;
 
 template<typename T>
 struct rm_pointer
@@ -654,22 +654,22 @@ void rect_test_perf_insertion_fixed_x()
     cout << "data count: " << data_count << endl;
 
     set_type db;
-    ptr_vector<range_type> data_store;
+    vector<unique_ptr<range_type>> data_store;
     data_store.reserve(data_count);
     {
         stack_printer __stack_printer2__("::rect_test_perf_insertion range instance creation");
         for (size_t i = 0; i < data_count; ++i)
         {
             ostringstream os;
             os << hex << i;
-            data_store.push_back(new range_type(0, 0, 10, i+1, os.str()));
+            data_store.emplace_back(new range_type(0, 0, 10, i+1, os.str()));
         }
     }
 
     {
         stack_printer __stack_printer2__("::rect_test_perf_insertion data insertion");
         for (size_t i = 0; i < data_count; ++i)
-            insert_range(db, data_store[i]);
+            insert_range(db, *data_store[i]);
     }
     assert(db.size() == data_count);
 
@@ -758,7 +758,7 @@ void rect_test_perf_insertion_fixed_x()
     {
         stack_printer __stack_printer__("::rect_test_perf_insertion 10000 removals");
         for (size_t i = 0; i < 10000; ++i)
-            db.remove(&data_store[i]);
+            db.remove(data_store[i].get());
     }
 
     {
@@ -778,22 +778,22 @@ void rect_test_perf_insertion_fixed_y()
     cout << "data count: " << data_count << endl;
 
     set_type db;
-    ptr_vector<range_type> data_store;
+    vector<unique_ptr<range_type>> data_store;
     data_store.reserve(data_count);
     {
         stack_printer __stack_printer2__("::rect_test_perf_insertion range instance creation");
         for (size_t i = 0; i < data_count; ++i)
         {
             ostringstream os;
             os << hex << i;
-            data_store.push_back(new range_type(0, 0, i+1, 10, os.str()));
+            data_store.emplace_back(new range_type(0, 0, i+1, 10, os.str()));
         }
     }
 
     {
         stack_printer __stack_printer2__("::rect_test_perf_insertion data insertion");
         for (size_t i = 0; i < data_count; ++i)
-            insert_range(db, data_store[i]);
+            insert_range(db, *data_store[i]);
     }
     assert(db.size() == data_count);
 
@@ -882,7 +882,7 @@ void rect_test_perf_insertion_fixed_y()
     {
         stack_printer __stack_printer__("::rect_test_perf_insertion 10000 removals");
         for (size_t i = 0; i < 10000; ++i)
-            db.remove(&data_store[i]);
+            db.remove(data_store[i].get());
     }
 
     {
diff --git a/src/segment_tree_test.cpp b/src/segment_tree_test.cpp
@@ -33,10 +33,10 @@
 #include <cstdlib>
 #include <cstdio>
 #include <iostream>
+#include <memory>
 #include <sstream>
 #include <string>
-
-#include <boost/ptr_container/ptr_vector.hpp>
+#include <vector>
 
 #define ARRAY_SIZE(x) sizeof(x)/sizeof(x[0])
 
@@ -635,20 +635,20 @@ void st_test_search_on_uneven_tree()
 
     for (key_type data_count = 10; data_count < 20; ++data_count)
     {
-        boost::ptr_vector<test_data> data_store;
+        vector<unique_ptr<test_data>> data_store;
         data_store.reserve(data_count);
         for (key_type i = 0; i < data_count; ++i)
         {
             ostringstream os;
             os << hex << showbase << i;
-            data_store.push_back(new test_data(os.str()));
+            data_store.emplace_back(new test_data(os.str()));
         }
         assert(data_store.size() == static_cast<size_t>(data_count));
 
         db_type db;
         for (key_type i = 0; i < data_count; ++i)
         {
-            test_data* p = &data_store[i];
+            test_data* p = data_store[i].get();
             db.insert(0, i+1, p);
         }
         assert(db.size() == static_cast<size_t>(data_count));
@@ -678,15 +678,15 @@ void st_test_perf_insertion()
     key_type data_count = 1000000;
 
     // First, create test data instances and store them into a vector.
-    boost::ptr_vector<test_data> data_store;
+    vector<unique_ptr<test_data>> data_store;
     {
         stack_printer __stack_printer2__("::st_test_perf_insertion:: data array creation");
         data_store.reserve(data_count);
         for (key_type i = 0; i < data_count; ++i)
         {
             ostringstream os;
             os << hex << i;
-            data_store.push_back(new test_data(os.str()));
+            data_store.emplace_back(new test_data(os.str()));
         }
     }
     assert(data_store.size() == data_count);
@@ -696,7 +696,7 @@ void st_test_perf_insertion()
         stack_printer __stack_printer2__("::st_test_perf_insertion:: data array insertion into segment tree");
         for (key_type i = 0; i < data_count; ++i)
         {
-            test_data* p = &data_store[i];
+            test_data* p = data_store[i].get();
             db.insert(0, i+1, p);
         }
     }
@@ -800,7 +800,7 @@ void st_test_perf_insertion()
         stack_printer __stack_printer2__("::st_test_perf_insertion:: 10000 segment removals");
         for (key_type i = 0; i < 10000; ++i)
         {
-            test_data* p = &data_store[i];
+            test_data* p = data_store[i].get();
             db.remove(p);
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -29,12 +29,12 @@`
`29`	`29`	`#include "test_global.hpp"`
`30`	`30`
`31`	`31`	`#include <iostream>`
	`32`	`+#include <memory>`
	`33`	`+#include <vector>`
`32`	`34`	`#include <sstream>`
`33`		`-#include <boost/ptr_container/ptr_vector.hpp>`
`34`	`35`
`35`	`36`	`using namespace std;`
`36`	`37`	`using namespace mdds;`
`37`		`-using ::boost::ptr_vector;`
`38`	`38`
`39`	`39`	`template<typename T>`
`40`	`40`	`struct rm_pointer`
`@@ -654,22 +654,22 @@ void rect_test_perf_insertion_fixed_x()`
`654`	`654`	`cout << "data count: " << data_count << endl;`
`655`	`655`
`656`	`656`	`set_type db;`
`657`		`- ptr_vector<range_type> data_store;`
	`657`	`+ vector<unique_ptr<range_type>> data_store;`
`658`	`658`	`data_store.reserve(data_count);`
`659`	`659`	`{`
`660`	`660`	`stack_printer __stack_printer2__("::rect_test_perf_insertion range instance creation");`
`661`	`661`	`for (size_t i = 0; i < data_count; ++i)`
`662`	`662`	`{`
`663`	`663`	`ostringstream os;`
`664`	`664`	`os << hex << i;`
`665`		`- data_store.push_back(new range_type(0, 0, 10, i+1, os.str()));`
	`665`	`+ data_store.emplace_back(new range_type(0, 0, 10, i+1, os.str()));`
`666`	`666`	`}`
`667`	`667`	`}`
`668`	`668`
`669`	`669`	`{`
`670`	`670`	`stack_printer __stack_printer2__("::rect_test_perf_insertion data insertion");`
`671`	`671`	`for (size_t i = 0; i < data_count; ++i)`
`672`		`- insert_range(db, data_store[i]);`
	`672`	`+ insert_range(db, *data_store[i]);`
`673`	`673`	`}`
`674`	`674`	`assert(db.size() == data_count);`
`675`	`675`
`@@ -758,7 +758,7 @@ void rect_test_perf_insertion_fixed_x()`
`758`	`758`	`{`
`759`	`759`	`stack_printer __stack_printer__("::rect_test_perf_insertion 10000 removals");`
`760`	`760`	`for (size_t i = 0; i < 10000; ++i)`
`761`		`- db.remove(&data_store[i]);`
	`761`	`+ db.remove(data_store[i].get());`
`762`	`762`	`}`
`763`	`763`
`764`	`764`	`{`
`@@ -778,22 +778,22 @@ void rect_test_perf_insertion_fixed_y()`
`778`	`778`	`cout << "data count: " << data_count << endl;`
`779`	`779`
`780`	`780`	`set_type db;`
`781`		`- ptr_vector<range_type> data_store;`
	`781`	`+ vector<unique_ptr<range_type>> data_store;`
`782`	`782`	`data_store.reserve(data_count);`
`783`	`783`	`{`
`784`	`784`	`stack_printer __stack_printer2__("::rect_test_perf_insertion range instance creation");`
`785`	`785`	`for (size_t i = 0; i < data_count; ++i)`
`786`	`786`	`{`
`787`	`787`	`ostringstream os;`
`788`	`788`	`os << hex << i;`
`789`		`- data_store.push_back(new range_type(0, 0, i+1, 10, os.str()));`
	`789`	`+ data_store.emplace_back(new range_type(0, 0, i+1, 10, os.str()));`
`790`	`790`	`}`
`791`	`791`	`}`
`792`	`792`
`793`	`793`	`{`
`794`	`794`	`stack_printer __stack_printer2__("::rect_test_perf_insertion data insertion");`
`795`	`795`	`for (size_t i = 0; i < data_count; ++i)`
`796`		`- insert_range(db, data_store[i]);`
	`796`	`+ insert_range(db, *data_store[i]);`
`797`	`797`	`}`
`798`	`798`	`assert(db.size() == data_count);`
`799`	`799`
`@@ -882,7 +882,7 @@ void rect_test_perf_insertion_fixed_y()`
`882`	`882`	`{`
`883`	`883`	`stack_printer __stack_printer__("::rect_test_perf_insertion 10000 removals");`
`884`	`884`	`for (size_t i = 0; i < 10000; ++i)`
`885`		`- db.remove(&data_store[i]);`
	`885`	`+ db.remove(data_store[i].get());`
`886`	`886`	`}`
`887`	`887`
`888`	`888`	`{`
Original file line number	Diff line number	Diff line change
`@@ -33,10 +33,10 @@`
`33`	`33`	`#include <cstdlib>`
`34`	`34`	`#include <cstdio>`
`35`	`35`	`#include <iostream>`
	`36`	`+#include <memory>`
`36`	`37`	`#include <sstream>`
`37`	`38`	`#include <string>`
`38`		`-`
`39`		`-#include <boost/ptr_container/ptr_vector.hpp>`
	`39`	`+#include <vector>`
`40`	`40`
`41`	`41`	`#define ARRAY_SIZE(x) sizeof(x)/sizeof(x[0])`
`42`	`42`
`@@ -635,20 +635,20 @@ void st_test_search_on_uneven_tree()`
`635`	`635`
`636`	`636`	`for (key_type data_count = 10; data_count < 20; ++data_count)`
`637`	`637`	`{`
`638`		`- boost::ptr_vector<test_data> data_store;`
	`638`	`+ vector<unique_ptr<test_data>> data_store;`
`639`	`639`	`data_store.reserve(data_count);`
`640`	`640`	`for (key_type i = 0; i < data_count; ++i)`
`641`	`641`	`{`
`642`	`642`	`ostringstream os;`
`643`	`643`	`os << hex << showbase << i;`
`644`		`- data_store.push_back(new test_data(os.str()));`
	`644`	`+ data_store.emplace_back(new test_data(os.str()));`
`645`	`645`	`}`
`646`	`646`	`assert(data_store.size() == static_cast<size_t>(data_count));`
`647`	`647`
`648`	`648`	`db_type db;`
`649`	`649`	`for (key_type i = 0; i < data_count; ++i)`
`650`	`650`	`{`
`651`		`- test_data* p = &data_store[i];`
	`651`	`+ test_data* p = data_store[i].get();`
`652`	`652`	`db.insert(0, i+1, p);`
`653`	`653`	`}`
`654`	`654`	`assert(db.size() == static_cast<size_t>(data_count));`
`@@ -678,15 +678,15 @@ void st_test_perf_insertion()`
`678`	`678`	`key_type data_count = 1000000;`
`679`	`679`
`680`	`680`	`// First, create test data instances and store them into a vector.`
`681`		`- boost::ptr_vector<test_data> data_store;`
	`681`	`+ vector<unique_ptr<test_data>> data_store;`
`682`	`682`	`{`
`683`	`683`	`stack_printer __stack_printer2__("::st_test_perf_insertion:: data array creation");`
`684`	`684`	`data_store.reserve(data_count);`
`685`	`685`	`for (key_type i = 0; i < data_count; ++i)`
`686`	`686`	`{`
`687`	`687`	`ostringstream os;`
`688`	`688`	`os << hex << i;`
`689`		`- data_store.push_back(new test_data(os.str()));`
	`689`	`+ data_store.emplace_back(new test_data(os.str()));`
`690`	`690`	`}`
`691`	`691`	`}`
`692`	`692`	`assert(data_store.size() == data_count);`
`@@ -696,7 +696,7 @@ void st_test_perf_insertion()`
`696`	`696`	`stack_printer __stack_printer2__("::st_test_perf_insertion:: data array insertion into segment tree");`
`697`	`697`	`for (key_type i = 0; i < data_count; ++i)`
`698`	`698`	`{`
`699`		`- test_data* p = &data_store[i];`
	`699`	`+ test_data* p = data_store[i].get();`
`700`	`700`	`db.insert(0, i+1, p);`
`701`	`701`	`}`
`702`	`702`	`}`
`@@ -800,7 +800,7 @@ void st_test_perf_insertion()`
`800`	`800`	`stack_printer __stack_printer2__("::st_test_perf_insertion:: 10000 segment removals");`
`801`	`801`	`for (key_type i = 0; i < 10000; ++i)`
`802`	`802`	`{`
`803`		`- test_data* p = &data_store[i];`
	`803`	`+ test_data* p = data_store[i].get();`
`804`	`804`	`db.remove(p);`
`805`	`805`	`}`
`806`	`806`	`}`