replace boost::unordered by std::unordered

but in T3, Mesh_3, TDS_3, P3[TM]3

Author: sloriot

Alpha_shapes_3/examples/Alpha_shapes_3/visible_alpha_shape_facets_to_OFF.cpp

@@ -8,8 +8,8 @@
 #include <fstream>
 #include <vector>
 
-#include <boost/unordered_set.hpp>
-#include <boost/unordered_map.hpp>
+#include <unordered_set>
+#include <unordered_map>
 
 typedef CGAL::Exact_predicates_inexact_constructions_kernel Gt;
 
@@ -48,7 +48,7 @@ int main()
 
 // collect alpha-shape facets accessible from the infinity
   // marks the cells that are in the same component as the infinite vertex by flooding
-  boost::unordered_set< Alpha_shape_3::Cell_handle > marked_cells;
+  std::unordered_set< Alpha_shape_3::Cell_handle > marked_cells;
   std::vector< Alpha_shape_3::Cell_handle > queue;
   queue.push_back( as.infinite_cell() );
 
@@ -86,7 +86,7 @@ int main()
 
 // dump into OFF format
   // assign an id per vertex
-  boost::unordered_map< Alpha_shape_3::Vertex_handle, std::size_t> vids;
+  std::unordered_map< Alpha_shape_3::Vertex_handle, std::size_t> vids;
   points.clear();
 
   for(Alpha_shape_3::Facet f : filtered_regular_facets)

Arrangement_on_surface_2/include/CGAL/Surface_sweep_2/Arr_overlay_ss_visitor.h

@@ -24,9 +24,10 @@
 
 #include <boost/variant.hpp>
 #include <boost/optional.hpp>
-#include <boost/unordered_map.hpp>
 #include <boost/variant/apply_visitor.hpp>
 
+#include <unordered_map>
+
 #include <CGAL/Arr_tags.h>
 #include <CGAL/Surface_sweep_2/Arr_construction_ss_visitor.h>
 #include <CGAL/Unique_hash_map.h>
@@ -114,7 +115,7 @@ class Arr_overlay_ss_visitor :
                                                         Halfedge_map;
 
   typedef std::pair<Cell_handle_red, Cell_handle_blue>  Handle_info;
-  typedef boost::unordered_map<Vertex_handle, Handle_info, Handle_hash_function>
+  typedef std::unordered_map<Vertex_handle, Handle_info, Handle_hash_function>
                                                         Vertex_map;
 
   // Side categoties:

BGL/examples/BGL_LCC/copy_lcc.cpp

@@ -11,7 +11,7 @@
 #include <iostream>
 #include <fstream>
 #include <iterator>
-#include <boost/unordered_map.hpp>
+#include <unordered_map>
 
 typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
 
@@ -50,8 +50,8 @@ int main(int argc, char* argv[])
     typedef boost::graph_traits<Source>::vertex_descriptor   tm_vertex_descriptor;
     typedef boost::graph_traits<Source>::halfedge_descriptor tm_halfedge_descriptor;
 
-    boost::unordered_map<source_vertex_descriptor, tm_vertex_descriptor> v2v;
-    boost::unordered_map<source_halfedge_descriptor, tm_halfedge_descriptor> h2h;
+    std::unordered_map<source_vertex_descriptor, tm_vertex_descriptor> v2v;
+    std::unordered_map<source_halfedge_descriptor, tm_halfedge_descriptor> h2h;
 
     CGAL::copy_face_graph(T1, S, CGAL::parameters::vertex_to_vertex_output_iterator(std::inserter(v2v, v2v.end()))
                                                   .halfedge_to_halfedge_output_iterator(std::inserter(h2h, h2h.end())));

BGL/examples/BGL_graphcut/face_selection_borders_regularization_example.cpp

@@ -23,7 +23,7 @@ int main(int argc, char** argv)
   Mesh mesh;
   CGAL::IO::read_OFF (in, mesh);
 
-  boost::unordered_map<Face_index, bool> is_selected_map;
+  std::unordered_map<Face_index, bool> is_selected_map;
 
   // randomly select 1/3 of faces
   std::size_t nb_selected_before = 0;

BGL/examples/BGL_polyhedron_3/copy_polyhedron.cpp

@@ -16,7 +16,7 @@
 #include <fstream>
 #include <iterator>
 
-#include <boost/unordered_map.hpp>
+#include <unordered_map>
 
 
 typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
@@ -56,9 +56,9 @@ int main(int argc, char* argv[])
     typedef boost::graph_traits<Target2>::face_descriptor     tm_face_descriptor;
 
     // Use an unordered_map to keep track of elements.
-    boost::unordered_map<sm_vertex_descriptor, tm_vertex_descriptor>     v2v;
-    boost::unordered_map<sm_halfedge_descriptor, tm_halfedge_descriptor> h2h;
-    boost::unordered_map<sm_face_descriptor, tm_face_descriptor>         f2f;
+    std::unordered_map<sm_vertex_descriptor, tm_vertex_descriptor>     v2v;
+    std::unordered_map<sm_halfedge_descriptor, tm_halfedge_descriptor> h2h;
+    std::unordered_map<sm_face_descriptor, tm_face_descriptor>         f2f;
 
     CGAL::copy_face_graph(S, T2, CGAL::parameters::vertex_to_vertex_output_iterator(std::inserter(v2v, v2v.end()))
                                  .halfedge_to_halfedge_output_iterator(std::inserter(h2h, h2h.end()))
@@ -83,9 +83,9 @@ int main(int argc, char* argv[])
     typedef boost::graph_traits<Source>::face_descriptor   tm_face_descriptor;
 
 
-    boost::unordered_map<source_vertex_descriptor, tm_vertex_descriptor> v2v;
-    boost::unordered_map<source_halfedge_descriptor, tm_halfedge_descriptor> h2h;
-    boost::unordered_map<source_face_descriptor, tm_face_descriptor> f2f;
+    std::unordered_map<source_vertex_descriptor, tm_vertex_descriptor> v2v;
+    std::unordered_map<source_halfedge_descriptor, tm_halfedge_descriptor> h2h;
+    std::unordered_map<source_face_descriptor, tm_face_descriptor> f2f;
     CGAL::copy_face_graph(T1, S, CGAL::parameters::vertex_to_vertex_map(boost::make_assoc_property_map(v2v))
                           .halfedge_to_halfedge_output_iterator(std::inserter(h2h, h2h.end()))
                           .face_to_face_map(boost::make_assoc_property_map(f2f)));

BGL/include/CGAL/boost/graph/Face_filtered_graph.h

@@ -26,8 +26,8 @@
 #include <boost/graph/graph_traits.hpp>
 #include <boost/iterator/filter_iterator.hpp>
 #include <boost/range/has_range_iterator.hpp>
-#include <boost/unordered_set.hpp>
 
+#include <unordered_set>
 #include <bitset>
 #include <utility>
 #include <vector>
@@ -486,8 +486,8 @@ struct Face_filtered_graph
     selected_halfedges.reset();
 
     typedef typename boost::property_traits<FacePatchIndexMap>::value_type Patch_index;
-    boost::unordered_set<Patch_index> pids(boost::begin(selected_face_patch_indices),
-                                           boost::end(selected_face_patch_indices));
+    std::unordered_set<Patch_index> pids(boost::begin(selected_face_patch_indices),
+                                         boost::end(selected_face_patch_indices));
 
     for(face_descriptor fd : faces(_graph) )
     {
@@ -625,8 +625,8 @@ struct Face_filtered_graph
     // In that case, we will find a non-visited halfedge that has for target a vertex
     // that is already visited.
 
-    boost::unordered_set<vertex_descriptor> vertices_visited;
-    boost::unordered_set<halfedge_descriptor> halfedges_handled;
+    std::unordered_set<vertex_descriptor> vertices_visited;
+    std::unordered_set<halfedge_descriptor> halfedges_handled;
 
     for(halfedge_descriptor hd : halfedges(*this))
     {

BGL/include/CGAL/boost/graph/Seam_mesh.h

@@ -21,8 +21,8 @@
 #include <CGAL/Unique_hash_map.h>
 
 #include <boost/iterator/iterator_facade.hpp>
-#include <boost/unordered_set.hpp>
 
+#include <unordered_set>
 #include <fstream>
 #include <functional>
 #include <iostream>

BGL/include/CGAL/boost/graph/copy_face_graph.h

@@ -23,10 +23,11 @@
 #include <CGAL/Named_function_parameters.h>
 #include <CGAL/boost/graph/named_params_helper.h>
 #include <CGAL/property_map.h>
-#include <boost/unordered_map.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/iterator/function_output_iterator.hpp>
 
+#include <unordered_map>
+
 namespace CGAL {
 
 namespace internal {

BGL/include/CGAL/boost/graph/selection.h

@@ -14,7 +14,6 @@
 
 #include <boost/graph/graph_traits.hpp>
 #include <CGAL/boost/graph/iterator.h>
-#include <boost/unordered_set.hpp>
 
 #include <CGAL/boost/graph/Dual.h>
 #include <boost/graph/filtered_graph.hpp>
@@ -23,6 +22,8 @@
 #include <CGAL/boost/graph/alpha_expansion_graphcut.h>
 #include <CGAL/squared_distance_3.h>
 
+#include <unordered_set>
+
 namespace CGAL {
 
 
@@ -1037,7 +1038,7 @@ void expand_face_selection_for_removal(const FaceRange& faces_to_be_deleted,
   typedef typename boost::graph_traits<TriangleMesh>::face_descriptor face_descriptor;
   typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;
 
-  boost::unordered_set<vertex_descriptor> vertices_queue;
+  std::unordered_set<vertex_descriptor> vertices_queue;
 
   // collect vertices belonging to at least a triangle that will be removed
   for(face_descriptor fd : faces_to_be_deleted)
@@ -1130,8 +1131,8 @@ int euler_characteristic_of_selection(const FaceRange& face_selection,
   typedef typename boost::graph_traits<PolygonMesh>::face_descriptor face_descriptor;
   typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
   typedef typename boost::graph_traits<PolygonMesh>::edge_descriptor edge_descriptor;
-  boost::unordered_set<vertex_descriptor> sel_vertices;
-  boost::unordered_set<edge_descriptor> sel_edges;
+  std::unordered_set<vertex_descriptor> sel_vertices;
+  std::unordered_set<edge_descriptor> sel_edges;
   for(face_descriptor f : face_selection)
   {
     for(halfedge_descriptor h : halfedges_around_face(halfedge(f, pm), pm))

BGL/test/BGL/test_Face_filtered_graph.cpp

@@ -6,16 +6,16 @@
 #include "test_Prefix.h"
 
 #include <boost/numeric/conversion/cast.hpp>
-#include <boost/unordered_set.hpp>
-#include <boost/unordered_map.hpp>
 
+#include <unordered_map>
+#include <unordered_set>
 #include <fstream>
 #include <map>
 #include <memory>
 #include <utility>
 #include <cassert>
 
-typedef boost::unordered_set<std::size_t> id_map;
+typedef std::unordered_set<std::size_t> id_map;
 
 namespace PMP = CGAL::Polygon_mesh_processing;
 
@@ -25,7 +25,7 @@ void test_halfedge_around_vertex_iterator(const  Graph& g)
   typedef typename boost::graph_traits<Graph>::face_descriptor g_face_descriptor;
   typedef CGAL::Face_filtered_graph<Graph> Adapter;
   CGAL_GRAPH_TRAITS_MEMBERS(Adapter);
-  boost::unordered_map<g_face_descriptor, std::size_t> map(num_faces(g));
+  std::unordered_map<g_face_descriptor, std::size_t> map(num_faces(g));
   PMP::connected_components(g, boost::make_assoc_property_map(map));
 
   Adapter fg(g, 0, boost::make_assoc_property_map(map));
@@ -526,7 +526,7 @@ int main()
     *sm, fccmap, CGAL::parameters::edge_is_constrained_map(Constraint<SM, SM::Property_map<boost::graph_traits<SM>::vertex_descriptor,
                                                            SM::Point> >(*sm, positions)));
 
-  boost::unordered_set<long unsigned int> pids;
+  std::unordered_set<long unsigned int> pids;
   pids.insert(0);
   pids.insert(2);
   SM_Adapter sm_adapter(*sm, pids, fccmap);