Revert the usage of TBB's iterator pair taking overloads.

This reverts the range based overload usage introduced in @6b2bf495.

Old TBB versions do not provide the range overloads.

contractor/contractor.hpp

@@ -192,7 +192,7 @@ class Contractor
         // FIXME not sure if we need this
         edges.shrink_to_fit();
 
-        tbb::parallel_sort(edges);
+        tbb::parallel_sort(edges.begin(), edges.end());
         NodeID edge = 0;
         for (NodeID i = 0; i < edges.size();)
         {
@@ -416,7 +416,7 @@ class Contractor
                 contractor_graph.reset();
 
                 // create new graph
-                tbb::parallel_sort(new_edge_set);
+                tbb::parallel_sort(new_edge_set.begin(), new_edge_set.end());
                 contractor_graph =
                     std::make_shared<ContractorGraph>(remaining_nodes.size(), new_edge_set);
 
@@ -468,7 +468,8 @@ class Contractor
                 [&](const ThreadDataContainer::EnumerableThreadData::range_type &range)
                 {
                     for (auto &data : range)
-                        tbb::parallel_sort(data->inserted_edges);
+                        tbb::parallel_sort(data->inserted_edges.begin(),
+                                           data->inserted_edges.end());
                 });
             tbb::parallel_for(
                 tbb::blocked_range<int>(first_independent_node, last, DeleteGrainSize),
@@ -867,7 +868,7 @@ class Contractor
             }
         }
         // eliminate duplicate entries ( forward + backward edges )
-        tbb::parallel_sort(neighbours);
+        tbb::parallel_sort(neighbours.begin(), neighbours.end());
         neighbours.resize(std::unique(neighbours.begin(), neighbours.end()) - neighbours.begin());
 
         for (const auto i : osrm::irange<std::size_t>(0, neighbours.size()))
@@ -896,7 +897,7 @@ class Contractor
             node_data[u].depth = (std::max)(node_data[node].depth + 1, node_data[u].depth);
         }
         // eliminate duplicate entries ( forward + backward edges )
-        tbb::parallel_sort(neighbours);
+        tbb::parallel_sort(neighbours.begin(), neighbours.end());
         neighbours.resize(std::unique(neighbours.begin(), neighbours.end()) - neighbours.begin());
 
         // re-evaluate priorities of neighboring nodes
@@ -939,7 +940,7 @@ class Contractor
             neighbours.push_back(target);
         }
 
-        tbb::parallel_sort(neighbours);
+        tbb::parallel_sort(neighbours.begin(), neighbours.end());
         neighbours.resize(std::unique(neighbours.begin(), neighbours.end()) - neighbours.begin());
 
         // examine all neighbours that are at most 2 hops away

contractor/processing_chain.cpp

@@ -183,7 +183,7 @@ void Prepare::FindComponents(unsigned max_edge_id,
         }
     }
 
-    tbb::parallel_sort(edges);
+    tbb::parallel_sort(edges.begin(), edges.end());
     auto new_end = std::unique(edges.begin(), edges.end());
     edges.resize(new_end - edges.begin());
 

data_structures/node_based_graph.hpp

@@ -90,7 +90,7 @@ NodeBasedDynamicGraphFromEdges(int number_of_nodes, const std::vector<NodeBasedE
         }
     );
 
-    tbb::parallel_sort(edges_list);
+    tbb::parallel_sort(edges_list.begin(), edges_list.end());
 
     auto graph = std::make_shared<NodeBasedDynamicGraph>(
         static_cast<NodeBasedDynamicGraph::NodeIterator>(number_of_nodes), edges_list);

data_structures/static_rtree.hpp

@@ -392,7 +392,7 @@ class StaticRTree
         leaf_node_file.write((char *)&m_element_count, sizeof(uint64_t));
 
         // sort the hilbert-value representatives
-        tbb::parallel_sort(input_wrapper_vector);
+        tbb::parallel_sort(input_wrapper_vector.begin(), input_wrapper_vector.end());
         std::vector<TreeNode> tree_nodes_in_level;
 
         // pack M elements into leaf node and write to leaf file

tools/components.cpp

@@ -92,8 +92,7 @@ std::size_t LoadGraph(const char* path,
     std::vector<NodeID> barrier_node_list;
 
     auto number_of_nodes = loadNodesFromFile(input_stream, barrier_node_list,
-                                             traffic_light_node_list,
+                                             traffic_light_node_list, coordinate_list);
-                                             coordinate_list);
 
     loadEdgesFromFile(input_stream, edge_list);
 
@@ -133,8 +132,7 @@ int main(int argc, char *argv[])
         // enable logging
         if (argc < 3)
         {
-            SimpleLogger().Write(logWARNING) << "usage:\n" << argv[0]
+            SimpleLogger().Write(logWARNING) << "usage:\n" << argv[0] << " <osrm>";
-                                             << " <osrm>";
             return -1;
         }
 
@@ -143,7 +141,7 @@ int main(int argc, char *argv[])
         std::vector<TarjanEdge> graph_edge_list;
         auto number_of_nodes = LoadGraph(argv[1], coordinate_list, graph_edge_list);
 
-        tbb::parallel_sort(graph_edge_list);
+        tbb::parallel_sort(graph_edge_list.begin(), graph_edge_list.end());
         const auto graph = std::make_shared<TarjanGraph>(number_of_nodes, graph_edge_list);
         graph_edge_list.clear();
         graph_edge_list.shrink_to_fit();
@@ -216,8 +214,9 @@ int main(int argc, char *argv[])
                     BOOST_ASSERT(source != SPECIAL_NODEID);
                     BOOST_ASSERT(target != SPECIAL_NODEID);
 
-                    const unsigned size_of_containing_component = std::min(
+                    const unsigned size_of_containing_component =
-                        tarjan->get_component_size(tarjan->get_component_id(source)), tarjan->get_component_size(tarjan->get_component_id(target)));
+                        std::min(tarjan->get_component_size(tarjan->get_component_id(source)),
+                                 tarjan->get_component_size(tarjan->get_component_id(target)));
 
                     // edges that end on bollard nodes may actually be in two distinct components
                     if (size_of_containing_component < 1000)

util/graph_loader.hpp

@@ -141,7 +141,8 @@ NodeID loadEdgesFromFile(std::istream &input_stream, std::vector<NodeBasedEdge>
 
 #ifndef NDEBUG
     SimpleLogger().Write() << "Validating loaded edges...";
-    tbb::parallel_sort(edge_list, [](const NodeBasedEdge &lhs, const NodeBasedEdge &rhs)
+    tbb::parallel_sort(edge_list.begin(), edge_list.end(),
+                       [](const NodeBasedEdge &lhs, const NodeBasedEdge &rhs)
                        {
                            return (lhs.source < rhs.source) ||
                                   (lhs.source == rhs.source && lhs.target < rhs.target);