Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

use range based for loops to traverse graphs

Browse Source
This commit is contained in:
Dennis Luxen 2014-05-13 16:56:30 +02:00
parent 9b68821f05
commit e769821e0f
13 changed files with 70 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Algorithms/BFSComponentExplorer.h
View File

@ -94,7 +94,7 @@ template <typename GraphT> class BFSComponentExplorer
const NodeID to_node_of_only_restriction = const NodeID to_node_of_only_restriction =
m_restriction_map.CheckForEmanatingIsOnlyTurn(u, v); m_restriction_map.CheckForEmanatingIsOnlyTurn(u, v);
for (auto e2 = m_graph.BeginEdges(v); e2 < m_graph.EndEdges(v); ++e2) for (auto e2 : m_graph.GetAdjacentEdgeRange(v))
{ {
const NodeID w = m_graph.GetTarget(e2); const NodeID w = m_graph.GetTarget(e2);

6
Algorithms/StronglyConnectedComponents.h
View File

@ -283,8 +283,7 @@ class TarjanSCC
++index; ++index;
// Traverse outgoing edges // Traverse outgoing edges
EdgeID end_edge = m_node_based_graph->EndEdges(v); for (auto e2 : m_node_based_graph->GetAdjacentEdgeRange(v))
for (auto e2 = m_node_based_graph->BeginEdges(v); e2 < end_edge; ++e2)
{ {
const TarjanDynamicGraph::NodeIterator vprime = const TarjanDynamicGraph::NodeIterator vprime =
m_node_based_graph->GetTarget(e2); m_node_based_graph->GetTarget(e2);
@ -357,8 +356,7 @@ class TarjanSCC
for (NodeID u = 0; u < last_u_node; ++u) for (NodeID u = 0; u < last_u_node; ++u)
{ {
p.printIncrement(); p.printIncrement();
EdgeID last_edge = m_node_based_graph->EndEdges(u); for (auto e1 : m_node_based_graph->GetAdjacentEdgeRange(u))
for (auto e1 = m_node_based_graph->BeginEdges(u); e1 < last_edge; ++e1)
{ {
if (!m_node_based_graph->GetEdgeData(e1).reversedEdge) if (!m_node_based_graph->GetEdgeData(e1).reversedEdge)
{ {

33
Contractor/Contractor.h
View File

@ -340,10 +340,7 @@ class Contractor
for (unsigned i = 0; i < contractor_graph->GetNumberOfNodes(); ++i) for (unsigned i = 0; i < contractor_graph->GetNumberOfNodes(); ++i)
{ {
const NodeID start = i; const NodeID start = i;
auto last_edge = contractor_graph->EndEdges(start); for (auto current_edge : contractor_graph->GetAdjacentEdgeRange(start))
for (auto current_edge = contractor_graph->BeginEdges(start);
current_edge < last_edge;
++current_edge)
{ {
ContractorGraph::EdgeData &data = ContractorGraph::EdgeData &data =
contractor_graph->GetEdgeData(current_edge); contractor_graph->GetEdgeData(current_edge);
@ -531,8 +528,7 @@ class Contractor
for (NodeID node = 0; node < number_of_nodes; ++node) for (NodeID node = 0; node < number_of_nodes; ++node)
{ {
p.printStatus(node); p.printStatus(node);
auto endEdges = contractor_graph->EndEdges(node); for (auto edge : contractor_graph->GetAdjacentEdgeRange(node))
for (auto edge = contractor_graph->BeginEdges(node); edge < endEdges; ++edge)
{ {
const NodeID target = contractor_graph->GetTarget(edge); const NodeID target = contractor_graph->GetTarget(edge);
const ContractorGraph::EdgeData &data = contractor_graph->GetEdgeData(edge); const ContractorGraph::EdgeData &data = contractor_graph->GetEdgeData(edge);
@ -634,8 +630,7 @@ class Contractor
} }
// iterate over all edges of node // iterate over all edges of node
auto end_edges = contractor_graph->EndEdges(node); for (auto edge : contractor_graph->GetAdjacentEdgeRange(node))
for (auto edge = contractor_graph->BeginEdges(node); edge != end_edges; ++edge)
{ {
const ContractorEdgeData &data = contractor_graph->GetEdgeData(edge); const ContractorEdgeData &data = contractor_graph->GetEdgeData(edge);
if (!data.forward) if (!data.forward)
@ -698,8 +693,7 @@ class Contractor
int inserted_edges_size = data->inserted_edges.size(); int inserted_edges_size = data->inserted_edges.size();
std::vector<ContractorEdge> &inserted_edges = data->inserted_edges; std::vector<ContractorEdge> &inserted_edges = data->inserted_edges;
auto end_in_edges = contractor_graph->EndEdges(node); for (auto in_edge : contractor_graph->GetAdjacentEdgeRange(node))
for (auto in_edge = contractor_graph->BeginEdges(node); in_edge != end_in_edges; ++in_edge)
{ {
const ContractorEdgeData &in_data = contractor_graph->GetEdgeData(in_edge); const ContractorEdgeData &in_data = contractor_graph->GetEdgeData(in_edge);
const NodeID source = contractor_graph->GetTarget(in_edge); const NodeID source = contractor_graph->GetTarget(in_edge);
@ -719,9 +713,7 @@ class Contractor
int max_distance = 0; int max_distance = 0;
unsigned number_of_targets = 0; unsigned number_of_targets = 0;
auto end_out_edges = contractor_graph->EndEdges(node); for (auto out_edge : contractor_graph->GetAdjacentEdgeRange(node))
for (auto out_edge = contractor_graph->BeginEdges(node); out_edge != end_out_edges;
++out_edge)
{ {
const ContractorEdgeData &out_data = contractor_graph->GetEdgeData(out_edge); const ContractorEdgeData &out_data = contractor_graph->GetEdgeData(out_edge);
if (!out_data.forward) if (!out_data.forward)
@ -746,10 +738,7 @@ class Contractor
{ {
Dijkstra(max_distance, number_of_targets, 2000, data, node); Dijkstra(max_distance, number_of_targets, 2000, data, node);
} }
for (auto out_edge = contractor_graph->BeginEdges(node), for (auto out_edge : contractor_graph->GetAdjacentEdgeRange(node))
endOutEdges = contractor_graph->EndEdges(node);
out_edge != endOutEdges;
++out_edge)
{ {
const ContractorEdgeData &out_data = contractor_graph->GetEdgeData(out_edge); const ContractorEdgeData &out_data = contractor_graph->GetEdgeData(out_edge);
if (!out_data.forward) if (!out_data.forward)
@ -835,7 +824,7 @@ class Contractor
neighbours.clear(); neighbours.clear();
// find all neighbours // find all neighbours
for (auto e = contractor_graph->BeginEdges(node); e < contractor_graph->EndEdges(node); ++e) for (auto e : contractor_graph->GetAdjacentEdgeRange(node))
{ {
const NodeID u = contractor_graph->GetTarget(e); const NodeID u = contractor_graph->GetTarget(e);
if (u != node) if (u != node)
@ -862,8 +851,7 @@ class Contractor
neighbours.clear(); neighbours.clear();
// find all neighbours // find all neighbours
auto end_edges = contractor_graph->EndEdges(node); for (auto e : contractor_graph->GetAdjacentEdgeRange(node))
for (auto e = contractor_graph->BeginEdges(node); e < end_edges; ++e)
{ {
const NodeID u = contractor_graph->GetTarget(e); const NodeID u = contractor_graph->GetTarget(e);
if (u == node) if (u == node)
@ -895,7 +883,7 @@ class Contractor
std::vector<NodeID> &neighbours = data->neighbours; std::vector<NodeID> &neighbours = data->neighbours;
neighbours.clear(); neighbours.clear();
for (auto e = contractor_graph->BeginEdges(node); e < contractor_graph->EndEdges(node); ++e) for (auto e : contractor_graph->GetAdjacentEdgeRange(node))
{ {
const NodeID target = contractor_graph->GetTarget(e); const NodeID target = contractor_graph->GetTarget(e);
if (node == target) if (node == target)
@ -924,8 +912,7 @@ class Contractor
// examine all neighbours that are at most 2 hops away // examine all neighbours that are at most 2 hops away
for (const NodeID u : neighbours) for (const NodeID u : neighbours)
{ {
auto end_edges = contractor_graph->EndEdges(u); for (auto e : contractor_graph->GetAdjacentEdgeRange(u))
for (auto e = contractor_graph->BeginEdges(u); e < end_edges; ++e)
{ {
const NodeID target = contractor_graph->GetTarget(e); const NodeID target = contractor_graph->GetTarget(e);
if (node == target) if (node == target)

19
Contractor/EdgeBasedGraphFactory.cpp
View File

@ -438,9 +438,7 @@ void EdgeBasedGraphFactory::RenumberEdges()
for (NodeID current_node = 0; current_node < m_node_based_graph->GetNumberOfNodes(); for (NodeID current_node = 0; current_node < m_node_based_graph->GetNumberOfNodes();
++current_node) ++current_node)
{ {
for (EdgeID current_edge = m_node_based_graph->BeginEdges(current_node); for (EdgeID current_edge : m_node_based_graph->GetAdjacentEdgeRange(current_node))
current_edge < m_node_based_graph->EndEdges(current_node);
++current_edge)
{ {
EdgeData &edge_data = m_node_based_graph->GetEdgeData(current_edge); EdgeData &edge_data = m_node_based_graph->GetEdgeData(current_edge);
if (!edge_data.forward) if (!edge_data.forward)
@ -483,10 +481,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
BOOST_ASSERT(u != SPECIAL_NODEID); BOOST_ASSERT(u != SPECIAL_NODEID);
BOOST_ASSERT(u < m_node_based_graph->GetNumberOfNodes()); BOOST_ASSERT(u < m_node_based_graph->GetNumberOfNodes());
p.printIncrement(); p.printIncrement();
for (EdgeID e1 = m_node_based_graph->BeginEdges(u), for (EdgeID e1 : m_node_based_graph->GetAdjacentEdgeRange(u))
last_edge = m_node_based_graph->EndEdges(u);
e1 < last_edge;
++e1)
{ {
const EdgeData &edge_data = m_node_based_graph->GetEdgeData(e1); const EdgeData &edge_data = m_node_based_graph->GetEdgeData(e1);
if (edge_data.edgeBasedNodeID == SPECIAL_NODEID) if (edge_data.edgeBasedNodeID == SPECIAL_NODEID)
@ -552,10 +547,7 @@ EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(const std::string &original_edg
for (NodeID u = 0, end = m_node_based_graph->GetNumberOfNodes(); u < end; ++u) for (NodeID u = 0, end = m_node_based_graph->GetNumberOfNodes(); u < end; ++u)
{ {
for (EdgeID e1 = m_node_based_graph->BeginEdges(u), for (EdgeID e1 : m_node_based_graph->GetAdjacentEdgeRange(u))
last_edge_u = m_node_based_graph->EndEdges(u);
e1 < last_edge_u;
++e1)
{ {
if (!m_node_based_graph->GetEdgeData(e1).forward) if (!m_node_based_graph->GetEdgeData(e1).forward)
{ {
@ -568,10 +560,7 @@ EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(const std::string &original_edg
m_restriction_map->CheckForEmanatingIsOnlyTurn(u, v); m_restriction_map->CheckForEmanatingIsOnlyTurn(u, v);
const bool is_barrier_node = (m_barrier_nodes.find(v) != m_barrier_nodes.end()); const bool is_barrier_node = (m_barrier_nodes.find(v) != m_barrier_nodes.end());
for (EdgeID e2 = m_node_based_graph->BeginEdges(v), for (EdgeID e2 : m_node_based_graph->GetAdjacentEdgeRange(v))
last_edge_v = m_node_based_graph->EndEdges(v);
e2 < last_edge_v;
++e2)
{ {
if (!m_node_based_graph->GetEdgeData(e2).forward) if (!m_node_based_graph->GetEdgeData(e2).forward)
{ {

7
DataStructures/DynamicGraph.h
View File

@ -31,6 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "../DataStructures/DeallocatingVector.h" #include "../DataStructures/DeallocatingVector.h"
#include <boost/assert.hpp> #include <boost/assert.hpp>
#include <boost/range/irange.hpp>
#include <cstdint> #include <cstdint>
@ -41,6 +42,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
template <typename EdgeDataT> class DynamicGraph template <typename EdgeDataT> class DynamicGraph
{ {
public: public:
typedef decltype(boost::irange(0u,0u)) EdgeRange;
typedef EdgeDataT EdgeData; typedef EdgeDataT EdgeData;
typedef unsigned NodeIterator; typedef unsigned NodeIterator;
typedef unsigned EdgeIterator; typedef unsigned EdgeIterator;
@ -133,6 +135,11 @@ template <typename EdgeDataT> class DynamicGraph
return EdgeIterator(m_nodes[n].firstEdge + m_nodes[n].edges); return EdgeIterator(m_nodes[n].firstEdge + m_nodes[n].edges);
} }
EdgeRange GetAdjacentEdgeRange(const NodeID node) const
{
return boost::irange(BeginEdges(node), EndEdges(node));
}
// adds an edge. Invalidates edge iterators for the source node // adds an edge. Invalidates edge iterators for the source node
EdgeIterator InsertEdge(const NodeIterator from, const NodeIterator to, const EdgeDataT &data) EdgeIterator InsertEdge(const NodeIterator from, const NodeIterator to, const EdgeDataT &data)
{ {

3
DataStructures/RestrictionMap.cpp
View File

@ -55,8 +55,7 @@ void RestrictionMap::FixupArrivingTurnRestriction(const NodeID u, const NodeID v
// it is more efficent to get a (small) list of potential start edges // it is more efficent to get a (small) list of potential start edges
// than iterating over all buckets // than iterating over all buckets
std::vector<NodeID> predecessors; std::vector<NodeID> predecessors;
for (EdgeID current_edge_id = m_graph->BeginEdges(u); current_edge_id < m_graph->EndEdges(u); for (EdgeID current_edge_id : m_graph->GetAdjacentEdgeRange(u))
++current_edge_id)
{ {
const EdgeData &edge_data = m_graph->GetEdgeData(current_edge_id); const EdgeData &edge_data = m_graph->GetEdgeData(current_edge_id);
const NodeID target = m_graph->GetTarget(current_edge_id); const NodeID target = m_graph->GetTarget(current_edge_id);

36
DataStructures/StaticGraph.h
View File

@ -33,6 +33,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "../Util/SimpleLogger.h" #include "../Util/SimpleLogger.h"
#include "../typedefs.h" #include "../typedefs.h"
#include <boost/range/irange.hpp>
#include <algorithm> #include <algorithm>
#include <limits> #include <limits>
#include <vector> #include <vector>
@ -40,6 +42,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
{ {
public: public:
typedef decltype(boost::irange(0u,0u)) EdgeRange;
typedef NodeID NodeIterator; typedef NodeID NodeIterator;
typedef NodeID EdgeIterator; typedef NodeID EdgeIterator;
typedef EdgeDataT EdgeData; typedef EdgeDataT EdgeData;
@ -62,7 +65,7 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
struct NodeArrayEntry struct NodeArrayEntry
{ {
// index of the first edge // index of the first edge
EdgeIterator firstEdge; EdgeIterator first_edge;
}; };
struct EdgeArrayEntry struct EdgeArrayEntry
@ -71,6 +74,11 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
EdgeDataT data; EdgeDataT data;
}; };
EdgeRange GetAdjacentEdgeRange(const NodeID node) const
{
return boost::irange(BeginEdges(node), EndEdges(node));
}
StaticGraph(const int nodes, std::vector<InputEdge> &graph) StaticGraph(const int nodes, std::vector<InputEdge> &graph)
{ {
std::sort(graph.begin(), graph.end()); std::sort(graph.begin(), graph.end());
@ -81,18 +89,20 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
EdgeIterator position = 0; EdgeIterator position = 0;
for (NodeIterator node = 0; node <= number_of_nodes; ++node) for (NodeIterator node = 0; node <= number_of_nodes; ++node)
{ {
EdgeIterator lastEdge = edge; EdgeIterator last_edge = edge;
while (edge < number_of_edges && graph[edge].source == node) while (edge < number_of_edges && graph[edge].source == node)
{
++edge; ++edge;
node_array[node].firstEdge = position; //=edge }
position += edge - lastEdge; // remove node_array[node].first_edge = position; //=edge
position += edge - last_edge; // remove
} }
edge_array.resize(position); //(edge) edge_array.resize(position); //(edge)
edge = 0; edge = 0;
for (NodeIterator node = 0; node < number_of_nodes; ++node) for (NodeIterator node = 0; node < number_of_nodes; ++node)
{ {
EdgeIterator e = node_array[node + 1].firstEdge; EdgeIterator e = node_array[node + 1].first_edge;
for (EdgeIterator i = node_array[node].firstEdge; i != e; ++i) for (EdgeIterator i = node_array[node].first_edge; i != e; ++i)
{ {
edge_array[i].target = graph[edge].target; edge_array[i].target = graph[edge].target;
edge_array[i].data = graph[edge].data; edge_array[i].data = graph[edge].data;
@ -115,10 +125,10 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
Percent p(GetNumberOfNodes()); Percent p(GetNumberOfNodes());
for (unsigned u = 0; u < GetNumberOfNodes(); ++u) for (unsigned u = 0; u < GetNumberOfNodes(); ++u)
{ {
for (unsigned eid = BeginEdges(u); eid < EndEdges(u); ++eid) for (auto eid : GetAdjacentEdgeRange(u))
{ {
unsigned v = GetTarget(eid); const unsigned v = GetTarget(eid);
EdgeData &data = GetEdgeData(eid); const EdgeData &data = GetEdgeData(eid);
if (data.shortcut) if (data.shortcut)
{ {
const EdgeID first_edge_id = FindEdgeInEitherDirection(u, data.id); const EdgeID first_edge_id = FindEdgeInEitherDirection(u, data.id);
@ -144,7 +154,7 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
#endif #endif
} }
unsigned GetNumberOfNodes() const { return number_of_nodes; } unsigned GetNumberOfNodes() const { return number_of_nodes -1; }
unsigned GetNumberOfEdges() const { return number_of_edges; } unsigned GetNumberOfEdges() const { return number_of_edges; }
@ -161,12 +171,12 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
EdgeIterator BeginEdges(const NodeIterator n) const EdgeIterator BeginEdges(const NodeIterator n) const
{ {
return EdgeIterator(node_array.at(n).firstEdge); return EdgeIterator(node_array.at(n).first_edge);
} }
EdgeIterator EndEdges(const NodeIterator n) const EdgeIterator EndEdges(const NodeIterator n) const
{ {
return EdgeIterator(node_array.at(n + 1).firstEdge); return EdgeIterator(node_array.at(n + 1).first_edge);
} }
// searches for a specific edge // searches for a specific edge
@ -174,7 +184,7 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
{ {
EdgeIterator smallest_edge = SPECIAL_EDGEID; EdgeIterator smallest_edge = SPECIAL_EDGEID;
EdgeWeight smallest_weight = INVALID_EDGE_WEIGHT; EdgeWeight smallest_weight = INVALID_EDGE_WEIGHT;
for (EdgeIterator edge = BeginEdges(from); edge < EndEdges(from); edge++) for (auto edge : GetAdjacentEdgeRange(from))
{ {
const NodeID target = GetTarget(edge); const NodeID target = GetTarget(edge);
const EdgeWeight weight = GetEdgeData(edge).distance; const EdgeWeight weight = GetEdgeData(edge).distance;

2
RoutingAlgorithms/AlternativePathRouting.h
View File

@ -604,7 +604,7 @@ template <class DataFacadeT> class AlternativeRouting : private BasicRoutingInte
} }
} }
for (EdgeID edge = facade->BeginEdges(node); edge < facade->EndEdges(node); ++edge) for (auto edge : facade->GetAdjacentEdgeRange(node))
{ {
const EdgeData &data = facade->GetEdgeData(edge); const EdgeData &data = facade->GetEdgeData(edge);
const bool edge_is_forward_directed = const bool edge_is_forward_directed =

22
RoutingAlgorithms/BasicRoutingInterface.h
View File

@ -87,7 +87,7 @@ template <class DataFacadeT> class BasicRoutingInterface
} }
// Stalling // Stalling
for (EdgeID edge = facade->BeginEdges(node); edge < facade->EndEdges(node); ++edge) for (auto edge : facade->GetAdjacentEdgeRange(node))
{ {
const EdgeData &data = facade->GetEdgeData(edge); const EdgeData &data = facade->GetEdgeData(edge);
const bool reverse_flag = ((!forward_direction) ? data.forward : data.backward); const bool reverse_flag = ((!forward_direction) ? data.forward : data.backward);
@ -108,9 +108,7 @@ template <class DataFacadeT> class BasicRoutingInterface
} }
} }
for (EdgeID edge = facade->BeginEdges(node), end_edge = facade->EndEdges(node); for (auto edge : facade->GetAdjacentEdgeRange(node))
edge < end_edge;
++edge)
{ {
const EdgeData &data = facade->GetEdgeData(edge); const EdgeData &data = facade->GetEdgeData(edge);
bool forward_directionFlag = (forward_direction ? data.forward : data.backward); bool forward_directionFlag = (forward_direction ? data.forward : data.backward);
@ -167,9 +165,7 @@ template <class DataFacadeT> class BasicRoutingInterface
// The above explanation unclear? Think! // The above explanation unclear? Think!
EdgeID smaller_edge_id = SPECIAL_EDGEID; EdgeID smaller_edge_id = SPECIAL_EDGEID;
int edge_weight = INT_MAX; int edge_weight = INT_MAX;
for (EdgeID edge_id = facade->BeginEdges(edge.first); for (auto edge_id : facade->GetAdjacentEdgeRange(edge.first))
edge_id < facade->EndEdges(edge.first);
++edge_id)
{ {
const int weight = facade->GetEdgeData(edge_id).distance; const int weight = facade->GetEdgeData(edge_id).distance;
if ((facade->GetTarget(edge_id) == edge.second) && (weight < edge_weight) && if ((facade->GetTarget(edge_id) == edge.second) && (weight < edge_weight) &&
@ -181,9 +177,7 @@ template <class DataFacadeT> class BasicRoutingInterface
} }
if (SPECIAL_EDGEID == smaller_edge_id) if (SPECIAL_EDGEID == smaller_edge_id)
{ {
for (EdgeID edge_id = facade->BeginEdges(edge.second); for (auto edge_id : facade->GetAdjacentEdgeRange(edge.second))
edge_id < facade->EndEdges(edge.second);
++edge_id)
{ {
const int weight = facade->GetEdgeData(edge_id).distance; const int weight = facade->GetEdgeData(edge_id).distance;
if ((facade->GetTarget(edge_id) == edge.first) && (weight < edge_weight) && if ((facade->GetTarget(edge_id) == edge.first) && (weight < edge_weight) &&
@ -323,9 +317,7 @@ template <class DataFacadeT> class BasicRoutingInterface
EdgeID smaller_edge_id = SPECIAL_EDGEID; EdgeID smaller_edge_id = SPECIAL_EDGEID;
int edge_weight = INT_MAX; int edge_weight = INT_MAX;
for (EdgeID edge_id = facade->BeginEdges(edge.first); for (auto edge_id : facade->GetAdjacentEdgeRange(edge.first))
edge_id < facade->EndEdges(edge.first);
++edge_id)
{ {
const int weight = facade->GetEdgeData(edge_id).distance; const int weight = facade->GetEdgeData(edge_id).distance;
if ((facade->GetTarget(edge_id) == edge.second) && (weight < edge_weight) && if ((facade->GetTarget(edge_id) == edge.second) && (weight < edge_weight) &&
@ -338,9 +330,7 @@ template <class DataFacadeT> class BasicRoutingInterface
if (SPECIAL_EDGEID == smaller_edge_id) if (SPECIAL_EDGEID == smaller_edge_id)
{ {
for (EdgeID edge_id = facade->BeginEdges(edge.second); for (auto edge_id : facade->GetAdjacentEdgeRange(edge.second))
edge_id < facade->EndEdges(edge.second);
++edge_id)
{ {
const int weight = facade->GetEdgeData(edge_id).distance; const int weight = facade->GetEdgeData(edge_id).distance;
if ((facade->GetTarget(edge_id) == edge.first) && (weight < edge_weight) && if ((facade->GetTarget(edge_id) == edge.first) && (weight < edge_weight) &&

6
Server/DataStructures/BaseDataFacade.h
View File

@ -38,10 +38,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "../../Util/StringUtil.h" #include "../../Util/StringUtil.h"
#include "../../typedefs.h" #include "../../typedefs.h"
#include <boost/range/irange.hpp>
#include <osrm/Coordinate.h> #include <osrm/Coordinate.h>
#include <string> #include <string>
typedef decltype(boost::irange(0u,0u)) EdgeRange;
template <class EdgeDataT> class BaseDataFacade template <class EdgeDataT> class BaseDataFacade
{ {
public: public:
@ -67,6 +71,8 @@ template <class EdgeDataT> class BaseDataFacade
virtual EdgeID EndEdges(const NodeID n) const = 0; virtual EdgeID EndEdges(const NodeID n) const = 0;
virtual EdgeRange GetAdjacentEdgeRange(const NodeID node) const = 0;
// searches for a specific edge // searches for a specific edge
virtual EdgeID FindEdge(const NodeID from, const NodeID to) const = 0; virtual EdgeID FindEdge(const NodeID from, const NodeID to) const = 0;

2
Server/DataStructures/InternalDataFacade.h
View File

@ -309,6 +309,8 @@ template <class EdgeDataT> class InternalDataFacade : public BaseDataFacade<Edge
EdgeID EndEdges(const NodeID n) const { return m_query_graph->EndEdges(n); } EdgeID EndEdges(const NodeID n) const { return m_query_graph->EndEdges(n); }
EdgeRange GetAdjacentEdgeRange(const NodeID node) const { return m_query_graph->GetAdjacentEdgeRange(node); };
// searches for a specific edge // searches for a specific edge
EdgeID FindEdge(const NodeID from, const NodeID to) const EdgeID FindEdge(const NodeID from, const NodeID to) const
{ {

2
Server/DataStructures/SharedDataFacade.h
View File

@ -254,6 +254,8 @@ template <class EdgeDataT> class SharedDataFacade : public BaseDataFacade<EdgeDa
EdgeID EndEdges(const NodeID n) const { return m_query_graph->EndEdges(n); } EdgeID EndEdges(const NodeID n) const { return m_query_graph->EndEdges(n); }
EdgeRange GetAdjacentEdgeRange(const NodeID node) const { return m_query_graph->GetAdjacentEdgeRange(node); };
// searches for a specific edge // searches for a specific edge
EdgeID FindEdge(const NodeID from, const NodeID to) const EdgeID FindEdge(const NodeID from, const NodeID to) const
{ {

10
prepare.cpp
View File

@ -392,24 +392,24 @@ int main(int argc, char *argv[])
SimpleLogger().Write() << "Building node array"; SimpleLogger().Write() << "Building node array";
StaticGraph<EdgeData>::EdgeIterator edge = 0; StaticGraph<EdgeData>::EdgeIterator edge = 0;
StaticGraph<EdgeData>::EdgeIterator position = 0; StaticGraph<EdgeData>::EdgeIterator position = 0;
StaticGraph<EdgeData>::EdgeIterator lastEdge = edge; StaticGraph<EdgeData>::EdgeIterator last_edge = edge;
for (StaticGraph<EdgeData>::NodeIterator node = 0; node < max_used_node_id; ++node) for (StaticGraph<EdgeData>::NodeIterator node = 0; node < max_used_node_id; ++node)
{ {
lastEdge = edge; last_edge = edge;
while ((edge < contracted_edge_count) && (contracted_edge_list[edge].source == node)) while ((edge < contracted_edge_count) && (contracted_edge_list[edge].source == node))
{ {
++edge; ++edge;
} }
node_array[node].firstEdge = position; //=edge node_array[node].first_edge = position; //=edge
position += edge - lastEdge; // remove position += edge - last_edge; // remove
} }
for (unsigned sentinel_counter = max_used_node_id; sentinel_counter != node_array.size(); for (unsigned sentinel_counter = max_used_node_id; sentinel_counter != node_array.size();
++sentinel_counter) ++sentinel_counter)
{ {
// sentinel element, guarded against underflow // sentinel element, guarded against underflow
node_array[sentinel_counter].firstEdge = contracted_edge_count; node_array[sentinel_counter].first_edge = contracted_edge_count;
} }
unsigned node_array_size = node_array.size(); unsigned node_array_size = node_array.size();