Enable readability-container-contains clang-tidy check (#6909)

SiarheiFedartsou · web-flow · commit 9aaab7a53f5c · 2024-05-27T08:33:26.000+02:00
diff --git a/.clang-tidy b/.clang-tidy
@@ -82,7 +82,6 @@ Checks: >
     -readability-make-member-function-const,
     -readability-redundant-string-init,
     -readability-non-const-parameter,
-    -readability-container-contains,
     -readability-static-accessed-through-instance
     
 WarningsAsErrors: '*'
diff --git a/include/extractor/traffic_signals.hpp b/include/extractor/traffic_signals.hpp
@@ -17,18 +17,18 @@ struct TrafficSignals
 
     inline bool HasSignal(NodeID from, NodeID to) const
     {
-        return bidirectional_nodes.count(to) > 0 || unidirectional_segments.count({from, to}) > 0;
+        return bidirectional_nodes.contains(to) || unidirectional_segments.contains({from, to});
     }
 
     void Compress(NodeID from, NodeID via, NodeID to)
     {
         bidirectional_nodes.erase(via);
-        if (unidirectional_segments.count({via, to}))
+        if (unidirectional_segments.contains({via, to}))
         {
             unidirectional_segments.erase({via, to});
             unidirectional_segments.insert({from, to});
         }
-        if (unidirectional_segments.count({via, from}))
+        if (unidirectional_segments.contains({via, from}))
         {
             unidirectional_segments.erase({via, from});
             unidirectional_segments.insert({to, from});
diff --git a/src/engine/guidance/lane_processing.cpp b/src/engine/guidance/lane_processing.cpp
@@ -125,9 +125,9 @@ std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,
 
                 if (previous_is_straight)
                 {
-                    if (isLeftTurn(current_inst) || is_straight_left.count(&current) > 0)
+                    if (isLeftTurn(current_inst) || is_straight_left.contains(&current))
                         is_straight_left.insert(&previous);
-                    else if (isRightTurn(current_inst) || is_straight_right.count(&current) > 0)
+                    else if (isRightTurn(current_inst) || is_straight_right.contains(&current))
                         is_straight_right.insert(&previous);
                 }
 
@@ -190,9 +190,9 @@ std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,
                     //
                     // coming from right, going to left (in direction of way) -> handle as left turn
 
-                    if (is_straight_left.count(&current) > 0)
+                    if (is_straight_left.contains(&current))
                         anticipate_for_left_turn();
-                    else if (is_straight_right.count(&current) > 0)
+                    else if (is_straight_right.contains(&current))
                         anticipate_for_right_turn();
                     else // FIXME: right-sided driving
                         anticipate_for_right_turn();
diff --git a/src/engine/routing_algorithms/alternative_path_mld.cpp b/src/engine/routing_algorithms/alternative_path_mld.cpp
@@ -248,7 +248,7 @@ filterViaCandidatesByViaNotOnPath(const WeightedViaNodePackedPath &path, RandIt
     for (const auto &edge : path.path)
         nodes.insert(std::get<1>(edge));
 
-    const auto via_on_path = [&](const auto via) { return nodes.count(via.node) > 0; };
+    const auto via_on_path = [&](const auto via) { return nodes.contains(via.node); };
 
     return std::remove_if(first, last, via_on_path);
 }
@@ -308,7 +308,7 @@ RandIt filterPackedPathsByCellSharing(RandIt first,
         {
             const auto source_cell = get_cell(std::get<0>(edge));
             const auto target_cell = get_cell(std::get<1>(edge));
-            return cells.count(source_cell) < 1 && cells.count(target_cell) < 1;
+            return !cells.contains(source_cell) && !cells.contains(target_cell);
         };
 
         const auto different = std::count_if(begin(packed.path), end(packed.path), not_seen);
@@ -491,7 +491,7 @@ RandIt filterUnpackedPathsBySharing(RandIt first,
         {
             auto node_duration = facade.GetNodeDuration(node);
             total_duration += node_duration;
-            if (nodes.count(node) > 0)
+            if (nodes.contains(node))
             {
                 return duration + node_duration;
             }
diff --git a/src/engine/routing_algorithms/many_to_many_mld.cpp b/src/engine/routing_algorithms/many_to_many_mld.cpp
@@ -325,7 +325,7 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                            EdgeDuration initial_duration,
                            EdgeDistance initial_distance)
     {
-        if (target_nodes_index.count(node))
+        if (target_nodes_index.contains(node))
         {
             // Source and target on the same edge node. If target is not reachable directly via
             // the node (e.g destination is before source on oneway segment) we want to allow
diff --git a/src/engine/routing_algorithms/tile_turns.cpp b/src/engine/routing_algorithms/tile_turns.cpp
@@ -49,7 +49,7 @@ std::vector<TurnData> generateTurns(const datafacade &facade,
         {
             // operator[] will construct an empty vector at [edge.u] if there is no value.
             directed_graph[edge.u].push_back({edge.v, edge.forward_segment_id.id});
-            if (edge_based_node_info.count(edge.forward_segment_id.id) == 0)
+            if (!edge_based_node_info.contains(edge.forward_segment_id.id))
             {
                 edge_based_node_info[edge.forward_segment_id.id] = {true, get_geometry_id(edge)};
             }
@@ -64,7 +64,7 @@ std::vector<TurnData> generateTurns(const datafacade &facade,
         if (edge.reverse_segment_id.enabled)
         {
             directed_graph[edge.v].push_back({edge.u, edge.reverse_segment_id.id});
-            if (edge_based_node_info.count(edge.reverse_segment_id.id) == 0)
+            if (!edge_based_node_info.contains(edge.reverse_segment_id.id))
             {
                 edge_based_node_info[edge.reverse_segment_id.id] = {false, get_geometry_id(edge)};
             }
@@ -106,7 +106,7 @@ std::vector<TurnData> generateTurns(const datafacade &facade,
         {
             // If the target of this edge doesn't exist in our directed
             // graph, it's probably outside the tile, so we can skip it
-            if (directed_graph.count(approachedge.target_node) == 0)
+            if (!directed_graph.contains(approachedge.target_node))
                 continue;
 
             // For each of the outgoing edges from our target coordinate
diff --git a/src/extractor/edge_based_graph_factory.cpp b/src/extractor/edge_based_graph_factory.cpp
@@ -167,7 +167,7 @@ NBGToEBG EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const N
     m_edge_based_node_container.nodes[nbe_to_ebn_mapping[edge_id_1]].annotation_id =
         forward_data.annotation_data;
     m_edge_based_node_container.nodes[nbe_to_ebn_mapping[edge_id_1]].segregated =
-        segregated_edges.count(edge_id_1) > 0;
+        segregated_edges.contains(edge_id_1);
 
     if (nbe_to_ebn_mapping[edge_id_2] != SPECIAL_EDGEID)
     {
@@ -176,7 +176,7 @@ NBGToEBG EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const N
         m_edge_based_node_container.nodes[nbe_to_ebn_mapping[edge_id_2]].annotation_id =
             reverse_data.annotation_data;
         m_edge_based_node_container.nodes[nbe_to_ebn_mapping[edge_id_2]].segregated =
-            segregated_edges.count(edge_id_2) > 0;
+            segregated_edges.contains(edge_id_2);
     }
 
     // Add segments of edge-based nodes
@@ -382,7 +382,7 @@ EdgeBasedGraphFactory::GenerateEdgeExpandedNodes(const WayRestrictionMap &way_re
             m_edge_based_node_container.nodes[edge_based_node_id].annotation_id =
                 edge_data.annotation_data;
             m_edge_based_node_container.nodes[edge_based_node_id].segregated =
-                segregated_edges.count(eid) > 0;
+                segregated_edges.contains(eid);
 
             const auto ebn_weight = m_edge_based_node_weights[nbe_to_ebn_mapping[eid]];
             BOOST_ASSERT((ebn_weight & EdgeWeight{0x7fffffff}) == edge_data.weight);
@@ -942,7 +942,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
 
                             const auto turn_nodes = NodeBasedTurn{
                                 incoming_edge.node, intersection_node, outgoing_edge_target};
-                            const auto is_maneuver_turn = unresolved_turns.count(turn_nodes) > 0;
+                            const auto is_maneuver_turn = unresolved_turns.contains(turn_nodes);
 
                             if (is_maneuver_turn)
                             {
diff --git a/src/extractor/graph_compressor.cpp b/src/extractor/graph_compressor.cpp
@@ -83,7 +83,7 @@ void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
             }
 
             // check if v is an entry/exit via node for a turn restriction
-            if (incompressible_via_nodes.count(node_v) > 0)
+            if (incompressible_via_nodes.contains(node_v))
             {
                 continue;
             }
diff --git a/src/extractor/intersection/intersection_analysis.cpp b/src/extractor/intersection/intersection_analysis.cpp
@@ -622,7 +622,7 @@ IntersectionView convertToIntersectionView(const util::NodeBasedDynamicGraph &gr
     for (const auto &outgoing_edge : outgoing_edges)
     {
         const auto edge_it = findEdge(edge_geometries, outgoing_edge.edge);
-        const auto is_merged = merged_edges.count(outgoing_edge.edge) != 0;
+        const auto is_merged = merged_edges.contains(outgoing_edge.edge);
         const auto is_turn_allowed = intersection::isTurnAllowed(graph,
                                                                  node_data_container,
                                                                  restriction_map,
diff --git a/src/extractor/suffix_table.cpp b/src/extractor/suffix_table.cpp
@@ -28,7 +28,7 @@ bool SuffixTable::isSuffix(const std::string &possible_suffix) const
 
 bool SuffixTable::isSuffix(std::string_view possible_suffix) const
 {
-    return suffix_set.count(possible_suffix) > 0;
+    return suffix_set.contains(possible_suffix);
 }
 
 } // namespace osrm::extractor
diff --git a/src/extractor/way_restriction_map.cpp b/src/extractor/way_restriction_map.cpp
@@ -18,7 +18,7 @@ std::size_t WayRestrictionMap::NumberOfDuplicatedNodes() const
 
 bool WayRestrictionMap::IsViaWayEdge(const NodeID from, const NodeID to) const
 {
-    return restriction_graph.via_edge_to_node.count({from, to}) > 0;
+    return restriction_graph.via_edge_to_node.contains({from, to});
 }
 
 std::vector<DuplicatedNodeID> WayRestrictionMap::DuplicatedNodeIDs(const NodeID from,
diff --git a/src/guidance/roundabout_handler.cpp b/src/guidance/roundabout_handler.cpp
@@ -302,7 +302,7 @@ RoundaboutType RoundaboutHandler::getRoundaboutType(const NodeID nid) const
     if (roundabout == circular)
         return RoundaboutType::None;
 
-    while (0 == roundabout_nodes.count(last_node))
+    while (!roundabout_nodes.contains(last_node))
     {
         // only count exits/entry locations
         if (node_based_graph.GetOutDegree(last_node) > 2)
@@ -345,8 +345,8 @@ RoundaboutType RoundaboutHandler::getRoundaboutType(const NodeID nid) const
     // used with a reference and without. This will be fixed automatically
     // when we handle references separately or if the useage is more consistent
     const auto is_rotary = (1 == roundabout_name_ids.size()) &&
-                           (circular ||                                                    //
-                            ((0 == connected_names.count(*roundabout_name_ids.begin())) && //
+                           (circular ||                                                   //
+                            ((!connected_names.contains(*roundabout_name_ids.begin())) && //
                              (radius > MAX_ROUNDABOUT_RADIUS)));
 
     if (is_rotary)
diff --git a/src/guidance/turn_lane_handler.cpp b/src/guidance/turn_lane_handler.cpp
@@ -508,7 +508,7 @@ bool TurnLaneHandler::isSimpleIntersection(const LaneDataVector &lane_data,
         }();
         BOOST_ASSERT(best_match != intersection.end());
         std::size_t match_index = std::distance(intersection.begin(), best_match);
-        all_simple &= (matched_indices.count(match_index) == 0);
+        all_simple &= (!matched_indices.contains(match_index));
         matched_indices.insert(match_index);
         // in case of u-turns, we might need to activate them first
         all_simple &= (best_match->entry_allowed ||
diff --git a/src/partitioner/dinic_max_flow.cpp b/src/partitioner/dinic_max_flow.cpp
@@ -22,7 +22,7 @@ auto makeHasNeighborNotInCheck(const DinicMaxFlow::SourceSinkNodes &set,
     return [&](const NodeID nid)
     {
         const auto is_not_contained = [&set](const BisectionEdge &edge)
-        { return set.count(edge.target) == 0; };
+        { return !set.contains(edge.target); };
         return view.EndEdges(nid) !=
                std::find_if(view.BeginEdges(nid), view.EndEdges(nid), is_not_contained);
     };
@@ -128,7 +128,7 @@ DinicMaxFlow::ComputeLevelGraph(const BisectionGraphView &view,
         levels[node_id] = 0;
         level_queue.push(node_id);
         for (const auto &edge : view.Edges(node_id))
-            if (source_nodes.count(edge.target))
+            if (source_nodes.contains(edge.target))
                 levels[edge.target] = 0;
     }
     // check if there is flow present on an edge
@@ -139,7 +139,7 @@ DinicMaxFlow::ComputeLevelGraph(const BisectionGraphView &view,
     const auto relax_node = [&](const NodeID node_id)
     {
         // don't relax sink nodes
-        if (sink_nodes.count(node_id))
+        if (sink_nodes.contains(node_id))
             return;
 
         const auto level = levels[node_id] + 1;
@@ -264,7 +264,7 @@ std::vector<NodeID> DinicMaxFlow::GetAugmentingPath(LevelGraph &levels,
             dfs_stack.top().edge_iterator++;
 
             // check if the edge is valid
-            const auto has_capacity = flow[target].count(path.back()) == 0;
+            const auto has_capacity = !flow[target].contains(path.back());
             const auto descends_level_graph = levels[target] + 1 == levels[path.back()];
 
             if (has_capacity && descends_level_graph)
@@ -300,8 +300,9 @@ bool DinicMaxFlow::Validate(const BisectionGraphView &view,
     // sink and source cannot share a common node
     const auto separated = std::find_if(source_nodes.begin(),
                                         source_nodes.end(),
-                                        [&sink_nodes](const auto node)
-                                        { return sink_nodes.count(node); }) == source_nodes.end();
+                                        [&sink_nodes](const auto node) {
+                                            return sink_nodes.contains(node);
+                                        }) == source_nodes.end();
 
     const auto invalid_id = [&view](const NodeID nid) { return nid >= view.NumberOfNodes(); };
     const auto in_range_source =

Original file line number	Diff line number	Diff line change
`@@ -17,18 +17,18 @@ struct TrafficSignals`
`17`	`17`
`18`	`18`	`inline bool HasSignal(NodeID from, NodeID to) const`
`19`	`19`	`{`
`20`		`- return bidirectional_nodes.count(to) > 0 \|\| unidirectional_segments.count({from, to}) > 0;`
	`20`	`+ return bidirectional_nodes.contains(to) \|\| unidirectional_segments.contains({from, to});`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`void Compress(NodeID from, NodeID via, NodeID to)`
`24`	`24`	`{`
`25`	`25`	`bidirectional_nodes.erase(via);`
`26`		`- if (unidirectional_segments.count({via, to}))`
	`26`	`+ if (unidirectional_segments.contains({via, to}))`
`27`	`27`	`{`
`28`	`28`	`unidirectional_segments.erase({via, to});`
`29`	`29`	`unidirectional_segments.insert({from, to});`
`30`	`30`	`}`
`31`		`- if (unidirectional_segments.count({via, from}))`
	`31`	`+ if (unidirectional_segments.contains({via, from}))`
`32`	`32`	`{`
`33`	`33`	`unidirectional_segments.erase({via, from});`
`34`	`34`	`unidirectional_segments.insert({to, from});`
Original file line number	Diff line number	Diff line change
`@@ -248,7 +248,7 @@ filterViaCandidatesByViaNotOnPath(const WeightedViaNodePackedPath &path, RandIt`
`248`	`248`	`for (const auto &edge : path.path)`
`249`	`249`	`nodes.insert(std::get<1>(edge));`
`250`	`250`
`251`		`- const auto via_on_path = [&](const auto via) { return nodes.count(via.node) > 0; };`
	`251`	`+ const auto via_on_path = [&](const auto via) { return nodes.contains(via.node); };`
`252`	`252`
`253`	`253`	`return std::remove_if(first, last, via_on_path);`
`254`	`254`	`}`
`@@ -308,7 +308,7 @@ RandIt filterPackedPathsByCellSharing(RandIt first,`
`308`	`308`	`{`
`309`	`309`	`const auto source_cell = get_cell(std::get<0>(edge));`
`310`	`310`	`const auto target_cell = get_cell(std::get<1>(edge));`
`311`		`- return cells.count(source_cell) < 1 && cells.count(target_cell) < 1;`
	`311`	`+ return !cells.contains(source_cell) && !cells.contains(target_cell);`
`312`	`312`	`};`
`313`	`313`
`314`	`314`	`const auto different = std::count_if(begin(packed.path), end(packed.path), not_seen);`
`@@ -491,7 +491,7 @@ RandIt filterUnpackedPathsBySharing(RandIt first,`
`491`	`491`	`{`
`492`	`492`	`auto node_duration = facade.GetNodeDuration(node);`
`493`	`493`	`total_duration += node_duration;`
`494`		`- if (nodes.count(node) > 0)`
	`494`	`+ if (nodes.contains(node))`
`495`	`495`	`{`
`496`	`496`	`return duration + node_duration;`
`497`	`497`	`}`
Original file line number	Diff line number	Diff line change
`@@ -325,7 +325,7 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,`
`325`	`325`	`EdgeDuration initial_duration,`
`326`	`326`	`EdgeDistance initial_distance)`
`327`	`327`	`{`
`328`		`- if (target_nodes_index.count(node))`
	`328`	`+ if (target_nodes_index.contains(node))`
`329`	`329`	`{`
`330`	`330`	`// Source and target on the same edge node. If target is not reachable directly via`
`331`	`331`	`// the node (e.g destination is before source on oneway segment) we want to allow`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ std::vector<TurnData> generateTurns(const datafacade &facade,`
`49`	`49`	`{`
`50`	`50`	`// operator[] will construct an empty vector at [edge.u] if there is no value.`
`51`	`51`	`directed_graph[edge.u].push_back({edge.v, edge.forward_segment_id.id});`
`52`		`- if (edge_based_node_info.count(edge.forward_segment_id.id) == 0)`
	`52`	`+ if (!edge_based_node_info.contains(edge.forward_segment_id.id))`
`53`	`53`	`{`
`54`	`54`	`edge_based_node_info[edge.forward_segment_id.id] = {true, get_geometry_id(edge)};`
`55`	`55`	`}`
`@@ -64,7 +64,7 @@ std::vector<TurnData> generateTurns(const datafacade &facade,`
`64`	`64`	`if (edge.reverse_segment_id.enabled)`
`65`	`65`	`{`
`66`	`66`	`directed_graph[edge.v].push_back({edge.u, edge.reverse_segment_id.id});`
`67`		`- if (edge_based_node_info.count(edge.reverse_segment_id.id) == 0)`
	`67`	`+ if (!edge_based_node_info.contains(edge.reverse_segment_id.id))`
`68`	`68`	`{`
`69`	`69`	`edge_based_node_info[edge.reverse_segment_id.id] = {false, get_geometry_id(edge)};`
`70`	`70`	`}`
`@@ -106,7 +106,7 @@ std::vector<TurnData> generateTurns(const datafacade &facade,`
`106`	`106`	`{`
`107`	`107`	`// If the target of this edge doesn't exist in our directed`
`108`	`108`	`// graph, it's probably outside the tile, so we can skip it`
`109`		`- if (directed_graph.count(approachedge.target_node) == 0)`
	`109`	`+ if (!directed_graph.contains(approachedge.target_node))`
`110`	`110`	`continue;`
`111`	`111`
`112`	`112`	`// For each of the outgoing edges from our target coordinate`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`// check if v is an entry/exit via node for a turn restriction`
`86`		`- if (incompressible_via_nodes.count(node_v) > 0)`
	`86`	`+ if (incompressible_via_nodes.contains(node_v))`
`87`	`87`	`{`
`88`	`88`	`continue;`
`89`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -622,7 +622,7 @@ IntersectionView convertToIntersectionView(const util::NodeBasedDynamicGraph &gr`
`622`	`622`	`for (const auto &outgoing_edge : outgoing_edges)`
`623`	`623`	`{`
`624`	`624`	`const auto edge_it = findEdge(edge_geometries, outgoing_edge.edge);`
`625`		`- const auto is_merged = merged_edges.count(outgoing_edge.edge) != 0;`
	`625`	`+ const auto is_merged = merged_edges.contains(outgoing_edge.edge);`
`626`	`626`	`const auto is_turn_allowed = intersection::isTurnAllowed(graph,`
`627`	`627`	`node_data_container,`
`628`	`628`	`restriction_map,`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ bool SuffixTable::isSuffix(const std::string &possible_suffix) const`
`28`	`28`
`29`	`29`	`bool SuffixTable::isSuffix(std::string_view possible_suffix) const`
`30`	`30`	`{`
`31`		`- return suffix_set.count(possible_suffix) > 0;`
	`31`	`+ return suffix_set.contains(possible_suffix);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`} // namespace osrm::extractor`