allow handling of multiple restrictions sharing the same from/via

features/car/restrictions.feature

@@ -620,6 +620,22 @@ Feature: Car - Turn restrictions
                 |   |
                 |   |
                 |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
             a - b - c - - - - - - - - - - - - - - - - - - - f
                 |   | \                                     /
                 i - d - e - - - - - - - - - - - - - - - - -

include/extractor/edge_based_graph_factory.hpp

@@ -173,9 +173,6 @@ class EdgeBasedGraphFactory
     util::ConcurrentIDMap<util::guidance::BearingClass, BearingClassID> bearing_class_hash;
     std::vector<BearingClassID> bearing_class_by_node_based_node;
     util::ConcurrentIDMap<util::guidance::EntryClass, EntryClassID> entry_class_hash;
-
-    // a mapping from a restriction way to the duplicate node
-    std::vector<NodeID> edge_based_node_by_via_way;
 };
 } // namespace extractor
 } // namespace osrm

include/extractor/restriction.hpp

@@ -63,6 +63,8 @@ struct Bits
     bool is_only;
     // when adding more bits, consider using bitfields just as in
     // bool unused : 7;
+
+    bool operator==(const Bits &other) const { return is_only == other.is_only; }
 };
 
 } // namespace restriction
@@ -141,6 +143,11 @@ struct NodeRestriction
         return "From " + std::to_string(from) + " via " + std::to_string(via) + " to " +
                std::to_string(to);
     }
+
+    bool operator==(const NodeRestriction &other) const
+    {
+        return std::tie(from, via, to) == std::tie(other.from, other.via, other.to);
+    }
 };
 
 // A way restriction in the context of OSRM requires translation into NodeIDs. This is due to the
@@ -165,6 +172,12 @@ struct WayRestriction
     // case a way restrction is not fully collapsed
     NodeRestriction in_restriction;
     NodeRestriction out_restriction;
+
+    bool operator==(const WayRestriction &other) const
+    {
+        return std::tie(in_restriction, out_restriction) ==
+               std::tie(other.in_restriction, other.out_restriction);
+    }
 };
 
 // Wrapper for turn restrictions that gives more information on its type / handles the switch
@@ -239,6 +252,24 @@ struct TurnRestriction
         }
     }
 
+    bool operator==(const TurnRestriction &other) const
+    {
+        if (!(flags == other.flags))
+            return false;
+
+        if (Type() != other.Type())
+            return false;
+
+        if (Type() == RestrictionType::WAY_RESTRICTION)
+        {
+            return AsWayRestriction() == other.AsWayRestriction();
+        }
+        else
+        {
+            return AsNodeRestriction() == other.AsNodeRestriction();
+        }
+    }
+
     std::string ToString() const
     {
         std::string representation;

include/extractor/way_restriction_map.hpp

@@ -34,18 +34,32 @@ class WayRestrictionMap
     bool IsStart(const NodeID from, const NodeID to) const;
     bool IsEnd(const NodeID from, const NodeID to) const;
 
-    std::vector<ViaWay> ViaWays() const;
-
     std::size_t Size() const;
+
+    // number of duplicated nodes
+    std::size_t NumberOfDuplicatedNodes() const;
+
+    // find the ID of the duplicated node (zero based) for a given restriction id
+    std::size_t DuplicatedNodeID(const std::size_t restriction_id) const;
+
+    // returns a representative for the duplicated way, consisting of the representative ID (first
+    // ID of the nodes restrictions) and the from/to vertices of the via-way
+    std::vector<ViaWay> DuplicatedNodeRepresentatives() const;
+
     std::vector<std::size_t> GetIDs(const NodeID from, const NodeID to) const;
 
     TurnRestriction const &GetRestriction(std::size_t) const;
 
   private:
-    // acces to the turn restrictions based on the via way they use
+    // access all restrictions that have the same starting way and via way. Any duplicated node
+    // represents the same in-way + via-way combination. This vector contains data about all
+    // restrictions and their assigned duplicated nodes. It indicates the minimum restriciton ID
+    // that is represented by the next node. The ID of a node is defined as the position of the
+    // lower bound of the restrictions ID within this array
+    std::vector<std::size_t> duplicated_node_groups;
+
     boost::unordered_multimap<std::pair<NodeID, NodeID>, std::size_t> restriction_starts;
     boost::unordered_multimap<std::pair<NodeID, NodeID>, std::size_t> restriction_ends;
-
     boost::unordered_multimap<std::pair<NodeID, NodeID>, std::size_t> via_ways;
 
     std::vector<TurnRestriction> restriction_data;