Changes and corrections before change request

xlaussel · xlaussel · commit 8697a6b14a5a · 2020-11-24T12:43:08.000+01:00
Cucumber successfull
diff --git a/include/engine/routing_algorithms/routing_base_mld.hpp b/include/engine/routing_algorithms/routing_base_mld.hpp
@@ -230,7 +230,6 @@ template <bool DIRECTION, typename Algorithm, typename... Args>
 void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                         typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                         const typename SearchEngineData<Algorithm>::QueryHeap::HeapNode& heapNode,
-                        const EdgeWeight weight,
                         Args... args)
 {
     const auto &partition = facade.GetMultiLevelPartition();
@@ -253,8 +252,8 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
 
                 if (shortcut_weight != INVALID_EDGE_WEIGHT && heapNode.node != to)
                 {
-                    const EdgeWeight to_weight = weight + shortcut_weight;
-                    BOOST_ASSERT(to_weight >= weight);
+                    const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
+                    BOOST_ASSERT(to_weight >= heapNode.weight);
                     auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
                     if (!toHeapNode)
                     {
@@ -282,8 +281,8 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
 
                 if (shortcut_weight != INVALID_EDGE_WEIGHT && heapNode.node != to)
                 {
-                    const EdgeWeight to_weight = weight + shortcut_weight;
-                    BOOST_ASSERT(to_weight >= weight);
+                    const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
+                    BOOST_ASSERT(to_weight >= heapNode.weight);
                     auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
                     if (!toHeapNode)
                     {
@@ -320,7 +319,7 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
 
                 // TODO: BOOST_ASSERT(edge_data.weight == node_weight + turn_penalty);
 
-                const EdgeWeight to_weight = weight + node_weight + turn_penalty;
+                const EdgeWeight to_weight = heapNode.weight + node_weight + turn_penalty;
 
                 auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
                 if (!toHeapNode)
@@ -376,7 +375,7 @@ void routingStep(const DataFacade<Algorithm> &facade,
     }
 
     // Relax outgoing edges from node
-    relaxOutgoingEdges<DIRECTION>(facade, forward_heap, heapNode, weight, args...);
+    relaxOutgoingEdges<DIRECTION>(facade, forward_heap, heapNode, args...);
 }
 
 // With (s, middle, t) we trace back the paths middle -> s and middle -> t.
diff --git a/include/util/query_heap.hpp b/include/util/query_heap.hpp
@@ -297,17 +297,17 @@ class QueryHeap
     boost::optional<HeapNode&> GetHeapNodeIfWasInserted(const NodeID node)
     {
         const auto index = node_index.peek_index(node);
-        if (index >= static_cast<decltype(index)>(inserted_nodes.size()))
+        if (index >= static_cast<decltype(index)>(inserted_nodes.size()) || inserted_nodes[index].node!=node)
         {
             return {};
         }
         return inserted_nodes[index];
     }
 
-    const boost::optional<const HeapNode&> GetHeapNodeIfWasInserted(const NodeID node) const
+    boost::optional<const HeapNode&> GetHeapNodeIfWasInserted(const NodeID node) const
     {
         const auto index = node_index.peek_index(node);
-        if (index >= static_cast<decltype(index)>(inserted_nodes.size()))
+        if (index >= static_cast<decltype(index)>(inserted_nodes.size()) || inserted_nodes[index].node!=node)
         {
             return {};
         }
diff --git a/src/engine/routing_algorithms/many_to_many_mld.cpp b/src/engine/routing_algorithms/many_to_many_mld.cpp
@@ -94,9 +94,6 @@ void relaxBorderEdges(const DataFacade<mld::Algorithm> &facade,
 template <bool DIRECTION, typename... Args>
 void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                         const SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap::HeapNode& heapNode,
-                        const EdgeWeight weight,
-                        const EdgeDuration duration,
-                        const EdgeDistance distance,
                         typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
                         Args... args)
 {
@@ -131,9 +128,9 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
 
                 if (shortcut_weight != INVALID_EDGE_WEIGHT && node != to)
                 {
-                    const auto to_weight = weight + shortcut_weight;
-                    const auto to_duration = duration + shortcut_durations.front();
-                    const auto to_distance = distance + shortcut_distances.front();
+                    const auto to_weight = heapNode.weight + shortcut_weight;
+                    const auto to_duration = heapNode.data.duration + shortcut_durations.front();
+                    const auto to_distance =  heapNode.data.distance + shortcut_distances.front();
                     const auto& toHeapNode= query_heap.GetHeapNodeIfWasInserted(to);
                     if (!toHeapNode)
                     {
@@ -171,9 +168,9 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
 
                 if (shortcut_weight != INVALID_EDGE_WEIGHT && node != to)
                 {
-                    const auto to_weight = weight + shortcut_weight;
-                    const auto to_duration = duration + shortcut_durations.front();
-                    const auto to_distance = distance + shortcut_distances.front();
+                    const auto to_weight = heapNode.weight + shortcut_weight;
+                    const auto to_duration =  heapNode.data.duration + shortcut_durations.front();
+                    const auto to_distance =  heapNode.data.distance + shortcut_distances.front();
                     const auto& toHeapNode= query_heap.GetHeapNodeIfWasInserted(to);
                     if (!toHeapNode)
                     {
@@ -199,7 +196,7 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
         }
     }
 
-    relaxBorderEdges<DIRECTION>(facade, node, weight, duration, distance, query_heap, level);
+    relaxBorderEdges<DIRECTION>(facade, node, heapNode.weight, heapNode.data.duration, heapNode.data.distance, query_heap, level);
 }
 
 //
@@ -386,9 +383,6 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
         // Relax outgoing edges
         relaxOutgoingEdges<DIRECTION>(facade,
                                       heapNode,
-                                      weight,
-                                      duration,
-                                      distance,
                                       query_heap,
                                       phantom_nodes,
                                       phantom_index,
@@ -461,7 +455,7 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
     }
 
     relaxOutgoingEdges<DIRECTION>(
-        facade, heapNode, source_weight, source_duration, source_distance, query_heap, phantom_node);
+        facade, heapNode, query_heap, phantom_node);
 }
 
 template <bool DIRECTION>
@@ -487,9 +481,6 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
 
     relaxOutgoingEdges<!DIRECTION>(facade,
                                    heapNode,
-                                   target_weight,
-                                   target_duration,
-                                   target_distance,
                                    query_heap,
                                    phantom_node,
                                    maximal_level);

Original file line number	Diff line number	Diff line change
`@@ -230,7 +230,6 @@ template <bool DIRECTION, typename Algorithm, typename... Args>`
`230`	`230`	`void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,`
`231`	`231`	`typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,`
`232`	`232`	`const typename SearchEngineData<Algorithm>::QueryHeap::HeapNode& heapNode,`
`233`		`- const EdgeWeight weight,`
`234`	`233`	`Args... args)`
`235`	`234`	`{`
`236`	`235`	`const auto &partition = facade.GetMultiLevelPartition();`
`@@ -253,8 +252,8 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,`
`253`	`252`
`254`	`253`	`if (shortcut_weight != INVALID_EDGE_WEIGHT && heapNode.node != to)`
`255`	`254`	`{`
`256`		`- const EdgeWeight to_weight = weight + shortcut_weight;`
`257`		`- BOOST_ASSERT(to_weight >= weight);`
	`255`	`+ const EdgeWeight to_weight = heapNode.weight + shortcut_weight;`
	`256`	`+ BOOST_ASSERT(to_weight >= heapNode.weight);`
`258`	`257`	`auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);`
`259`	`258`	`if (!toHeapNode)`
`260`	`259`	`{`
`@@ -282,8 +281,8 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,`
`282`	`281`
`283`	`282`	`if (shortcut_weight != INVALID_EDGE_WEIGHT && heapNode.node != to)`
`284`	`283`	`{`
`285`		`- const EdgeWeight to_weight = weight + shortcut_weight;`
`286`		`- BOOST_ASSERT(to_weight >= weight);`
	`284`	`+ const EdgeWeight to_weight = heapNode.weight + shortcut_weight;`
	`285`	`+ BOOST_ASSERT(to_weight >= heapNode.weight);`
`287`	`286`	`auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);`
`288`	`287`	`if (!toHeapNode)`
`289`	`288`	`{`
`@@ -320,7 +319,7 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,`
`320`	`319`
`321`	`320`	`// TODO: BOOST_ASSERT(edge_data.weight == node_weight + turn_penalty);`
`322`	`321`
`323`		`- const EdgeWeight to_weight = weight + node_weight + turn_penalty;`
	`322`	`+ const EdgeWeight to_weight = heapNode.weight + node_weight + turn_penalty;`
`324`	`323`
`325`	`324`	`auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);`
`326`	`325`	`if (!toHeapNode)`
`@@ -376,7 +375,7 @@ void routingStep(const DataFacade<Algorithm> &facade,`
`376`	`375`	`}`
`377`	`376`
`378`	`377`	`// Relax outgoing edges from node`
`379`		`- relaxOutgoingEdges<DIRECTION>(facade, forward_heap, heapNode, weight, args...);`
	`378`	`+ relaxOutgoingEdges<DIRECTION>(facade, forward_heap, heapNode, args...);`
`380`	`379`	`}`
`381`	`380`
`382`	`381`	`// With (s, middle, t) we trace back the paths middle -> s and middle -> t.`
Original file line number	Diff line number	Diff line change
`@@ -297,17 +297,17 @@ class QueryHeap`
`297`	`297`	`boost::optional<HeapNode&> GetHeapNodeIfWasInserted(const NodeID node)`
`298`	`298`	`{`
`299`	`299`	`const auto index = node_index.peek_index(node);`
`300`		`- if (index >= static_cast<decltype(index)>(inserted_nodes.size()))`
	`300`	`+ if (index >= static_cast<decltype(index)>(inserted_nodes.size()) \|\| inserted_nodes[index].node!=node)`
`301`	`301`	`{`
`302`	`302`	`return {};`
`303`	`303`	`}`
`304`	`304`	`return inserted_nodes[index];`
`305`	`305`	`}`
`306`	`306`
`307`		`- const boost::optional<const HeapNode&> GetHeapNodeIfWasInserted(const NodeID node) const`
	`307`	`+ boost::optional<const HeapNode&> GetHeapNodeIfWasInserted(const NodeID node) const`
`308`	`308`	`{`
`309`	`309`	`const auto index = node_index.peek_index(node);`
`310`		`- if (index >= static_cast<decltype(index)>(inserted_nodes.size()))`
	`310`	`+ if (index >= static_cast<decltype(index)>(inserted_nodes.size()) \|\| inserted_nodes[index].node!=node)`
`311`	`311`	`{`
`312`	`312`	`return {};`
`313`	`313`	`}`