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

Apply clang-format on BFSComponentExplorer and RestrictionMap

Browse Source
This commit is contained in:
Patrick Niklaus 2014-05-08 23:29:24 +02:00
parent 22d0861f6d
commit e00ef38305
4 changed files with 194 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
Contractor/BFSComponentExplorer.h
View File

@ -12,19 +12,16 @@
* Explores the components of the given graph while respecting turn restrictions * Explores the components of the given graph while respecting turn restrictions
* and barriers. * and barriers.
*/ */
template<typename GraphT> template <typename GraphT> class BFSComponentExplorer
class BFSComponentExplorer
{ {
public: public:
typedef typename GraphT::NodeIterator NodeIterator; typedef typename GraphT::NodeIterator NodeIterator;
typedef typename GraphT::EdgeIterator EdgeIterator; typedef typename GraphT::EdgeIterator EdgeIterator;
BFSComponentExplorer(const GraphT& dynamicGraph, BFSComponentExplorer(const GraphT &dynamicGraph,
const RestrictionMap& restrictions, const RestrictionMap &restrictions,
const boost::unordered_set<NodeID>& barrier_nodes) const boost::unordered_set<NodeID> &barrier_nodes)
: m_graph(dynamicGraph) : m_graph(dynamicGraph), m_restriction_map(restrictions), m_barrier_nodes(barrier_nodes)
, m_restriction_map(restrictions)
, m_barrier_nodes(barrier_nodes)
{ {
BOOST_ASSERT(m_graph.GetNumberOfNodes() > 0); BOOST_ASSERT(m_graph.GetNumberOfNodes() > 0);
} }
@ -39,97 +36,94 @@ public:
return m_component_index_size[m_component_index_list[node]]; return m_component_index_size[m_component_index_list[node]];
} }
inline unsigned int getNumberOfComponents() inline unsigned int getNumberOfComponents() { return m_component_index_size.size(); }
{
return m_component_index_size.size();
}
/*! /*!
* Computes the component sizes. * Computes the component sizes.
*/ */
void run() void run()
{ {
std::queue<std::pair<NodeID, NodeID> > bfs_queue; std::queue<std::pair<NodeID, NodeID>> bfs_queue;
unsigned current_component = 0; unsigned current_component = 0;
BOOST_ASSERT( m_component_index_list.empty() ); BOOST_ASSERT(m_component_index_list.empty());
BOOST_ASSERT( m_component_index_size.empty() ); BOOST_ASSERT(m_component_index_size.empty());
unsigned num_nodes = m_graph.GetNumberOfNodes(); unsigned num_nodes = m_graph.GetNumberOfNodes();
m_component_index_list.resize( m_component_index_list.resize(num_nodes, std::numeric_limits<unsigned>::max());
num_nodes,
std::numeric_limits<unsigned>::max()
);
BOOST_ASSERT (num_nodes > 0); BOOST_ASSERT(num_nodes > 0);
//put unexplorered node with parent pointer into queue // put unexplorered node with parent pointer into queue
for( NodeID node = 0; node < num_nodes; ++node) { for (NodeID node = 0; node < num_nodes; ++node)
if(std::numeric_limits<unsigned>::max() == m_component_index_list[node]) { {
if (std::numeric_limits<unsigned>::max() == m_component_index_list[node])
{
unsigned size = exploreComponent(bfs_queue, node, current_component); unsigned size = exploreComponent(bfs_queue, node, current_component);
//push size into vector // push size into vector
m_component_index_size.push_back(size); m_component_index_size.push_back(size);
++current_component; ++current_component;
} }
} }
} }
private: private:
/*! /*!
* Explores the current component that starts at node using BFS. * Explores the current component that starts at node using BFS.
*/ */
inline unsigned exploreComponent( inline unsigned exploreComponent(std::queue<std::pair<NodeID, NodeID>> &bfs_queue,
std::queue<std::pair<NodeID, NodeID> > &bfs_queue, NodeID node,
NodeID node, unsigned current_component)
unsigned current_component {
) {
bfs_queue.push(std::make_pair(node, node)); bfs_queue.push(std::make_pair(node, node));
//mark node as read // mark node as read
m_component_index_list[node] = current_component; m_component_index_list[node] = current_component;
unsigned current_component_size = 1; unsigned current_component_size = 1;
while(!bfs_queue.empty()) { while (!bfs_queue.empty())
//fetch element from BFS queue {
// fetch element from BFS queue
std::pair<NodeID, NodeID> current_queue_item = bfs_queue.front(); std::pair<NodeID, NodeID> current_queue_item = bfs_queue.front();
bfs_queue.pop(); bfs_queue.pop();
const NodeID v = current_queue_item.first; //current node const NodeID v = current_queue_item.first; // current node
const NodeID u = current_queue_item.second; //parent const NodeID u = current_queue_item.second; // parent
//increment size counter of current component // increment size counter of current component
++current_component_size; ++current_component_size;
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());
if(!is_barrier_node) { if (!is_barrier_node)
const NodeID to_node_of_only_restriction = m_restriction_map.CheckForEmanatingIsOnlyTurn(u, v); {
const NodeID to_node_of_only_restriction =
m_restriction_map.CheckForEmanatingIsOnlyTurn(u, v);
for( for (EdgeIterator e2 = m_graph.BeginEdges(v); e2 < m_graph.EndEdges(v); ++e2)
EdgeIterator e2 = m_graph.BeginEdges(v); {
e2 < m_graph.EndEdges(v);
++e2
) {
NodeIterator w = m_graph.GetTarget(e2); NodeIterator w = m_graph.GetTarget(e2);
if( if (to_node_of_only_restriction != std::numeric_limits<unsigned>::max() &&
to_node_of_only_restriction != std::numeric_limits<unsigned>::max() && w != to_node_of_only_restriction)
w != to_node_of_only_restriction {
) {
// At an only_-restriction but not at the right turn // At an only_-restriction but not at the right turn
continue; continue;
} }
if( u != w ) { if (u != w)
//only add an edge if turn is not a U-turn except {
//when it is at the end of a dead-end street. // only add an edge if turn is not a U-turn except
if (!m_restriction_map.CheckIfTurnIsRestricted(u, v, w)) { // when it is at the end of a dead-end street.
//only add an edge if turn is not prohibited if (!m_restriction_map.CheckIfTurnIsRestricted(u, v, w))
if(std::numeric_limits<unsigned>::max() == m_component_index_list[w]) { {
//insert next (node, parent) only if w has // only add an edge if turn is not prohibited
//not yet been explored if (std::numeric_limits<unsigned>::max() == m_component_index_list[w])
//mark node as read {
// insert next (node, parent) only if w has
// not yet been explored
// mark node as read
m_component_index_list[w] = current_component; m_component_index_list[w] = current_component;
bfs_queue.push(std::make_pair(w,v)); bfs_queue.push(std::make_pair(w, v));
} }
} }
} }
@ -140,12 +134,12 @@ private:
return current_component_size; return current_component_size;
} }
std::vector<unsigned> m_component_index_list; std::vector<unsigned> m_component_index_list;
std::vector<NodeID> m_component_index_size; std::vector<NodeID> m_component_index_size;
const GraphT& m_graph; const GraphT &m_graph;
const RestrictionMap& m_restriction_map; const RestrictionMap &m_restriction_map;
const boost::unordered_set<NodeID>& m_barrier_nodes; const boost::unordered_set<NodeID> &m_barrier_nodes;
}; };
#endif #endif

92
DataStructures/NodeBasedGraph.h
View File

@ -4,35 +4,39 @@
#include "DynamicGraph.h" #include "DynamicGraph.h"
#include "ImportEdge.h" #include "ImportEdge.h"
struct NodeBasedEdgeData { struct NodeBasedEdgeData
NodeBasedEdgeData() : distance(INVALID_EDGE_WEIGHT), edgeBasedNodeID(SPECIAL_NODEID), nameID(std::numeric_limits<unsigned>::max()), {
type(std::numeric_limits<short>::max()), isAccessRestricted(false), shortcut(false), forward(false), backward(false), NodeBasedEdgeData()
roundabout(false), ignore_in_grid(false), contraFlow(false) : distance(INVALID_EDGE_WEIGHT), edgeBasedNodeID(SPECIAL_NODEID),
{ } nameID(std::numeric_limits<unsigned>::max()), type(std::numeric_limits<short>::max()),
isAccessRestricted(false), shortcut(false), forward(false), backward(false),
roundabout(false), ignore_in_grid(false), contraFlow(false)
{
}
int distance; int distance;
unsigned edgeBasedNodeID; unsigned edgeBasedNodeID;
unsigned nameID; unsigned nameID;
short type; short type;
bool isAccessRestricted:1; bool isAccessRestricted : 1;
bool shortcut:1; bool shortcut : 1;
bool forward:1; bool forward : 1;
bool backward:1; bool backward : 1;
bool roundabout:1; bool roundabout : 1;
bool ignore_in_grid:1; bool ignore_in_grid : 1;
bool contraFlow:1; bool contraFlow : 1;
void SwapDirectionFlags() { void SwapDirectionFlags()
{
bool temp_flag = forward; bool temp_flag = forward;
forward = backward; forward = backward;
backward = temp_flag; backward = temp_flag;
} }
bool IsEqualTo( const NodeBasedEdgeData & other ) const { bool IsEqualTo(const NodeBasedEdgeData &other) const
return (forward == other.forward) && {
(backward == other.backward) && return (forward == other.forward) && (backward == other.backward) &&
(nameID == other.nameID) && (nameID == other.nameID) && (ignore_in_grid == other.ignore_in_grid) &&
(ignore_in_grid == other.ignore_in_grid) &&
(contraFlow == other.contraFlow); (contraFlow == other.contraFlow);
} }
}; };
@ -40,37 +44,41 @@ struct NodeBasedEdgeData {
typedef DynamicGraph<NodeBasedEdgeData> NodeBasedDynamicGraph; typedef DynamicGraph<NodeBasedEdgeData> NodeBasedDynamicGraph;
// Factory method to create NodeBasedDynamicGraph from ImportEdges // Factory method to create NodeBasedDynamicGraph from ImportEdges
inline std::shared_ptr<NodeBasedDynamicGraph> NodeBasedDynamicGraphFromImportEdges( inline std::shared_ptr<NodeBasedDynamicGraph>
int number_of_nodes, NodeBasedDynamicGraphFromImportEdges(int number_of_nodes, std::vector<ImportEdge> &input_edge_list)
std::vector<ImportEdge>& input_edge_list {
) {
typedef NodeBasedDynamicGraph::InputEdge DynInputEdge; typedef NodeBasedDynamicGraph::InputEdge DynInputEdge;
std::sort( input_edge_list.begin(), input_edge_list.end() ); std::sort(input_edge_list.begin(), input_edge_list.end());
//TODO: remove duplicate edges // TODO: remove duplicate edges
DeallocatingVector<DynInputEdge> edges_list; DeallocatingVector<DynInputEdge> edges_list;
DynInputEdge edge; DynInputEdge edge;
for(const ImportEdge& import_edge : input_edge_list) { for (const ImportEdge &import_edge : input_edge_list)
{
if( !import_edge.isForward() ) { if (!import_edge.isForward())
{
edge.source = import_edge.target(); edge.source = import_edge.target();
edge.target = import_edge.source(); edge.target = import_edge.source();
edge.data.backward = import_edge.isForward(); edge.data.backward = import_edge.isForward();
edge.data.forward = import_edge.isBackward(); edge.data.forward = import_edge.isBackward();
} else { }
else
{
edge.source = import_edge.source(); edge.source = import_edge.source();
edge.target = import_edge.target(); edge.target = import_edge.target();
edge.data.forward = import_edge.isForward(); edge.data.forward = import_edge.isForward();
edge.data.backward = import_edge.isBackward(); edge.data.backward = import_edge.isBackward();
} }
if( edge.source == edge.target ) { if (edge.source == edge.target)
{
continue; continue;
} }
edge.data.distance = (std::max)((int)import_edge.weight(), 1 ); edge.data.distance = (std::max)((int)import_edge.weight(), 1);
BOOST_ASSERT( edge.data.distance > 0 ); BOOST_ASSERT(edge.data.distance > 0);
edge.data.shortcut = false; edge.data.shortcut = false;
edge.data.roundabout = import_edge.isRoundabout(); edge.data.roundabout = import_edge.isRoundabout();
edge.data.ignore_in_grid = import_edge.ignoreInGrid(); edge.data.ignore_in_grid = import_edge.ignoreInGrid();
@ -78,29 +86,25 @@ inline std::shared_ptr<NodeBasedDynamicGraph> NodeBasedDynamicGraphFromImportEdg
edge.data.type = import_edge.type(); edge.data.type = import_edge.type();
edge.data.isAccessRestricted = import_edge.isAccessRestricted(); edge.data.isAccessRestricted = import_edge.isAccessRestricted();
edge.data.contraFlow = import_edge.isContraFlow(); edge.data.contraFlow = import_edge.isContraFlow();
edges_list.push_back( edge ); edges_list.push_back(edge);
if( !import_edge.IsSplit() ) { if (!import_edge.IsSplit())
using std::swap; //enable ADL {
swap( edge.source, edge.target ); using std::swap; // enable ADL
swap(edge.source, edge.target);
edge.data.SwapDirectionFlags(); edge.data.SwapDirectionFlags();
edges_list.push_back( edge ); edges_list.push_back(edge);
} }
} }
std::sort( edges_list.begin(), edges_list.end() ); std::sort(edges_list.begin(), edges_list.end());
auto graph = std::make_shared<NodeBasedDynamicGraph>( auto graph = std::make_shared<NodeBasedDynamicGraph>(number_of_nodes, edges_list);
number_of_nodes,
edges_list
);
//FIXME probably unneeded since this is the end of scope // FIXME probably unneeded since this is the end of scope
DeallocatingVector<DynInputEdge>().swap(edges_list); DeallocatingVector<DynInputEdge>().swap(edges_list);
BOOST_ASSERT(0 == edges_list.size() ); BOOST_ASSERT(0 == edges_list.size());
return graph; return graph;
} }
#endif #endif

153
DataStructures/RestrictionMap.cpp
View File

@ -1,36 +1,42 @@
#include "RestrictionMap.h" #include "RestrictionMap.h"
#include "NodeBasedGraph.h" #include "NodeBasedGraph.h"
RestrictionMap::RestrictionMap(const std::shared_ptr<NodeBasedDynamicGraph>& graph, const std::vector<TurnRestriction> & input_restrictions_list) RestrictionMap::RestrictionMap(const std::shared_ptr<NodeBasedDynamicGraph> &graph,
: m_count(0) const std::vector<TurnRestriction> &input_restrictions_list)
, m_graph(graph) : m_count(0), m_graph(graph)
{ {
// decompose restirction consisting of a start, via and end note into a start-edge // decompose restirction consisting of a start, via and end note into a start-edge
// and all end-nodes // and all end-nodes
for (auto& restriction : input_restrictions_list) { for (auto &restriction : input_restrictions_list)
{
std::pair<NodeID, NodeID> restriction_source = std::pair<NodeID, NodeID> restriction_source =
std::make_pair(restriction.fromNode, restriction.viaNode); std::make_pair(restriction.fromNode, restriction.viaNode);
unsigned index; unsigned index;
auto restriction_iter = m_restriction_map.find(restriction_source); auto restriction_iter = m_restriction_map.find(restriction_source);
if(restriction_iter == m_restriction_map.end()) { if (restriction_iter == m_restriction_map.end())
{
index = m_restriction_bucket_list.size(); index = m_restriction_bucket_list.size();
m_restriction_bucket_list.resize(index+1); m_restriction_bucket_list.resize(index + 1);
m_restriction_map.emplace(restriction_source, index); m_restriction_map.emplace(restriction_source, index);
} else { }
else
{
index = restriction_iter->second; index = restriction_iter->second;
//Map already contains an is_only_*-restriction // Map already contains an is_only_*-restriction
if(m_restriction_bucket_list.at(index).begin()->second) { if (m_restriction_bucket_list.at(index).begin()->second)
{
continue; continue;
} else if(restriction.flags.isOnly) { }
//We are going to insert an is_only_*-restriction. There can be only one. else if (restriction.flags.isOnly)
{
// We are going to insert an is_only_*-restriction. There can be only one.
m_count -= m_restriction_bucket_list.at(index).size(); m_count -= m_restriction_bucket_list.at(index).size();
m_restriction_bucket_list.at(index).clear(); m_restriction_bucket_list.at(index).clear();
} }
} }
++m_count; ++m_count;
m_restriction_bucket_list.at(index).push_back( m_restriction_bucket_list.at(index)
std::make_pair( restriction.toNode, restriction.flags.isOnly) .push_back(std::make_pair(restriction.toNode, restriction.flags.isOnly));
);
} }
} }
@ -39,41 +45,40 @@ RestrictionMap::RestrictionMap(const std::shared_ptr<NodeBasedDynamicGraph>& gra
* *
* Note: We need access to node based graph. * Note: We need access to node based graph.
*/ */
void RestrictionMap::FixupArrivingTurnRestriction( void RestrictionMap::FixupArrivingTurnRestriction(const NodeID u, const NodeID v, const NodeID w)
const NodeID u, {
const NodeID v, BOOST_ASSERT(u != std::numeric_limits<unsigned>::max());
const NodeID w BOOST_ASSERT(v != std::numeric_limits<unsigned>::max());
) { BOOST_ASSERT(w != std::numeric_limits<unsigned>::max());
BOOST_ASSERT( u != std::numeric_limits<unsigned>::max() );
BOOST_ASSERT( v != std::numeric_limits<unsigned>::max() );
BOOST_ASSERT( w != std::numeric_limits<unsigned>::max() );
// find all possible start edges // find all possible start edges
// 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( for (EdgeID current_edge_id = m_graph->BeginEdges(u); current_edge_id < m_graph->EndEdges(u);
EdgeID current_edge_id = m_graph->BeginEdges(u); ++current_edge_id)
current_edge_id < m_graph->EndEdges(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);
if( edge_data.backward && ( v != target) ) { if (edge_data.backward && (v != target))
{
predecessors.push_back(target); predecessors.push_back(target);
} }
} }
for(const NodeID x : predecessors) { for (const NodeID x : predecessors)
const std::pair<NodeID, NodeID> restr_start = std::make_pair(x,u); {
auto restriction_iterator = m_restriction_map.find( restr_start ); const std::pair<NodeID, NodeID> restr_start = std::make_pair(x, u);
if( restriction_iterator == m_restriction_map.end() ) auto restriction_iterator = m_restriction_map.find(restr_start);
if (restriction_iterator == m_restriction_map.end())
continue; continue;
const unsigned index = restriction_iterator->second; const unsigned index = restriction_iterator->second;
auto& bucket = m_restriction_bucket_list.at(index); auto &bucket = m_restriction_bucket_list.at(index);
for(RestrictionTarget& restriction_target : bucket) { for (RestrictionTarget &restriction_target : bucket)
if( v == restriction_target.first ) { {
if (v == restriction_target.first)
{
restriction_target.first = w; restriction_target.first = w;
} }
} }
@ -83,26 +88,24 @@ void RestrictionMap::FixupArrivingTurnRestriction(
/** /**
* Replaces the start edge (v, w) with (u, w), only start node changes. * Replaces the start edge (v, w) with (u, w), only start node changes.
*/ */
void RestrictionMap::FixupStartingTurnRestriction( void RestrictionMap::FixupStartingTurnRestriction(const NodeID u, const NodeID v, const NodeID w)
const NodeID u, {
const NodeID v, BOOST_ASSERT(u != std::numeric_limits<unsigned>::max());
const NodeID w BOOST_ASSERT(v != std::numeric_limits<unsigned>::max());
) { BOOST_ASSERT(w != std::numeric_limits<unsigned>::max());
BOOST_ASSERT( u != std::numeric_limits<unsigned>::max() );
BOOST_ASSERT( v != std::numeric_limits<unsigned>::max() );
BOOST_ASSERT( w != std::numeric_limits<unsigned>::max() );
const std::pair<NodeID, NodeID> old_start = std::make_pair(v,w); const std::pair<NodeID, NodeID> old_start = std::make_pair(v, w);
auto restriction_iterator = m_restriction_map.find( old_start ); auto restriction_iterator = m_restriction_map.find(old_start);
if( restriction_iterator != m_restriction_map.end() ) { if (restriction_iterator != m_restriction_map.end())
{
const unsigned index = restriction_iterator->second; const unsigned index = restriction_iterator->second;
// remove old restriction start (v,w) // remove old restriction start (v,w)
m_restriction_map.erase( restriction_iterator ); m_restriction_map.erase(restriction_iterator);
// insert new restriction start (u,w) (point to index) // insert new restriction start (u,w) (point to index)
const std::pair<NodeID, NodeID> new_start = std::make_pair(u,w); const std::pair<NodeID, NodeID> new_start = std::make_pair(u, w);
m_restriction_map.insert( std::make_pair(new_start, index) ); m_restriction_map.insert(std::make_pair(new_start, index));
} }
} }
@ -110,21 +113,22 @@ void RestrictionMap::FixupStartingTurnRestriction(
* Check if the edge (u, v) is contained in any turn restriction. * Check if the edge (u, v) is contained in any turn restriction.
* If so returns id of first target node. * If so returns id of first target node.
*/ */
NodeID RestrictionMap::CheckForEmanatingIsOnlyTurn( NodeID RestrictionMap::CheckForEmanatingIsOnlyTurn(const NodeID u, const NodeID v) const
const NodeID u, {
const NodeID v BOOST_ASSERT(u != std::numeric_limits<unsigned>::max());
) const { BOOST_ASSERT(v != std::numeric_limits<unsigned>::max());
BOOST_ASSERT( u != std::numeric_limits<unsigned>::max() );
BOOST_ASSERT( v != std::numeric_limits<unsigned>::max() );
const std::pair<NodeID, NodeID> restriction_source = std::make_pair(u, v); const std::pair<NodeID, NodeID> restriction_source = std::make_pair(u, v);
auto restriction_iter = m_restriction_map.find(restriction_source); auto restriction_iter = m_restriction_map.find(restriction_source);
if (restriction_iter != m_restriction_map.end()) { if (restriction_iter != m_restriction_map.end())
{
const unsigned index = restriction_iter->second; const unsigned index = restriction_iter->second;
auto& bucket = m_restriction_bucket_list.at(index); auto &bucket = m_restriction_bucket_list.at(index);
for(const RestrictionSource& restriction_target : bucket) { for (const RestrictionSource &restriction_target : bucket)
if(restriction_target.second) { {
if (restriction_target.second)
{
return restriction_target.first; return restriction_target.first;
} }
} }
@ -136,26 +140,25 @@ NodeID RestrictionMap::CheckForEmanatingIsOnlyTurn(
/** /**
* Checks if the turn described by start u, via v and targed w is covert by any turn restriction. * Checks if the turn described by start u, via v and targed w is covert by any turn restriction.
*/ */
bool RestrictionMap::CheckIfTurnIsRestricted( bool RestrictionMap::CheckIfTurnIsRestricted(const NodeID u, const NodeID v, const NodeID w) const
const NodeID u, {
const NodeID v, BOOST_ASSERT(u != std::numeric_limits<unsigned>::max());
const NodeID w BOOST_ASSERT(v != std::numeric_limits<unsigned>::max());
) const { BOOST_ASSERT(w != std::numeric_limits<unsigned>::max());
BOOST_ASSERT( u != std::numeric_limits<unsigned>::max() );
BOOST_ASSERT( v != std::numeric_limits<unsigned>::max() );
BOOST_ASSERT( w != std::numeric_limits<unsigned>::max() );
const std::pair<NodeID, NodeID> restriction_source = std::make_pair(u, v); const std::pair<NodeID, NodeID> restriction_source = std::make_pair(u, v);
auto restriction_iter = m_restriction_map.find(restriction_source); auto restriction_iter = m_restriction_map.find(restriction_source);
if (restriction_iter != m_restriction_map.end()) { if (restriction_iter != m_restriction_map.end())
{
const unsigned index = restriction_iter->second; const unsigned index = restriction_iter->second;
auto& bucket = m_restriction_bucket_list.at(index); auto &bucket = m_restriction_bucket_list.at(index);
for(const RestrictionTarget & restriction_target : bucket) { for (const RestrictionTarget &restriction_target : bucket)
if( {
( w == restriction_target.first ) && // target found if ((w == restriction_target.first) && // target found
( !restriction_target.second ) // and not an only_-restr. (!restriction_target.second) // and not an only_-restr.
) { )
{
return true; return true;
} }
} }

22
DataStructures/RestrictionMap.h
View File

@ -43,9 +43,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
class RestrictionMap class RestrictionMap
{ {
public: public:
RestrictionMap(const std::shared_ptr<NodeBasedDynamicGraph>& graph, RestrictionMap(const std::shared_ptr<NodeBasedDynamicGraph> &graph,
const std::vector<TurnRestriction> & input_restrictions_list); const std::vector<TurnRestriction> &input_restrictions_list);
void FixupArrivingTurnRestriction(const NodeID u, const NodeID v, const NodeID w); void FixupArrivingTurnRestriction(const NodeID u, const NodeID v, const NodeID w);
void FixupStartingTurnRestriction(const NodeID u, const NodeID v, const NodeID w); void FixupStartingTurnRestriction(const NodeID u, const NodeID v, const NodeID w);
@ -54,16 +54,16 @@ public:
unsigned size() { return m_count; } unsigned size() { return m_count; }
private: private:
typedef std::pair<NodeID, NodeID> RestrictionSource; typedef std::pair<NodeID, NodeID> RestrictionSource;
typedef std::pair<NodeID, bool> RestrictionTarget; typedef std::pair<NodeID, bool> RestrictionTarget;
typedef std::vector<RestrictionTarget> EmanatingRestrictionsVector; typedef std::vector<RestrictionTarget> EmanatingRestrictionsVector;
typedef NodeBasedDynamicGraph::EdgeData EdgeData; typedef NodeBasedDynamicGraph::EdgeData EdgeData;
unsigned m_count; unsigned m_count;
std::shared_ptr<NodeBasedDynamicGraph> m_graph; std::shared_ptr<NodeBasedDynamicGraph> m_graph;
//! index -> list of (target, isOnly) //! index -> list of (target, isOnly)
std::vector<EmanatingRestrictionsVector> m_restriction_bucket_list; std::vector<EmanatingRestrictionsVector> m_restriction_bucket_list;
//! maps (start, via) -> bucket index //! maps (start, via) -> bucket index
boost::unordered_map<RestrictionSource, unsigned> m_restriction_map; boost::unordered_map<RestrictionSource, unsigned> m_restriction_map;
}; };