From e00ef3830509deba1a4639cba23464a641c2d95a Mon Sep 17 00:00:00 2001 From: Patrick Niklaus Date: Thu, 8 May 2014 23:29:24 +0200 Subject: [PATCH] Apply clang-format on BFSComponentExplorer and RestrictionMap --- Contractor/BFSComponentExplorer.h | 120 +++++++++++------------ DataStructures/NodeBasedGraph.h | 92 +++++++++--------- DataStructures/RestrictionMap.cpp | 153 +++++++++++++++--------------- DataStructures/RestrictionMap.h | 22 ++--- 4 files changed, 194 insertions(+), 193 deletions(-) diff --git a/Contractor/BFSComponentExplorer.h b/Contractor/BFSComponentExplorer.h index 564318248..4e0788aad 100644 --- a/Contractor/BFSComponentExplorer.h +++ b/Contractor/BFSComponentExplorer.h @@ -12,19 +12,16 @@ * Explores the components of the given graph while respecting turn restrictions * and barriers. */ -template -class BFSComponentExplorer +template class BFSComponentExplorer { -public: + public: typedef typename GraphT::NodeIterator NodeIterator; typedef typename GraphT::EdgeIterator EdgeIterator; - BFSComponentExplorer(const GraphT& dynamicGraph, - const RestrictionMap& restrictions, - const boost::unordered_set& barrier_nodes) - : m_graph(dynamicGraph) - , m_restriction_map(restrictions) - , m_barrier_nodes(barrier_nodes) + BFSComponentExplorer(const GraphT &dynamicGraph, + const RestrictionMap &restrictions, + const boost::unordered_set &barrier_nodes) + : m_graph(dynamicGraph), m_restriction_map(restrictions), m_barrier_nodes(barrier_nodes) { BOOST_ASSERT(m_graph.GetNumberOfNodes() > 0); } @@ -39,97 +36,94 @@ public: return m_component_index_size[m_component_index_list[node]]; } - inline unsigned int getNumberOfComponents() - { - return m_component_index_size.size(); - } + inline unsigned int getNumberOfComponents() { return m_component_index_size.size(); } /*! * Computes the component sizes. */ void run() { - std::queue > bfs_queue; + std::queue> bfs_queue; unsigned current_component = 0; - BOOST_ASSERT( m_component_index_list.empty() ); - BOOST_ASSERT( m_component_index_size.empty() ); + BOOST_ASSERT(m_component_index_list.empty()); + BOOST_ASSERT(m_component_index_size.empty()); unsigned num_nodes = m_graph.GetNumberOfNodes(); - m_component_index_list.resize( - num_nodes, - std::numeric_limits::max() - ); + m_component_index_list.resize(num_nodes, std::numeric_limits::max()); - BOOST_ASSERT (num_nodes > 0); + BOOST_ASSERT(num_nodes > 0); - //put unexplorered node with parent pointer into queue - for( NodeID node = 0; node < num_nodes; ++node) { - if(std::numeric_limits::max() == m_component_index_list[node]) { + // put unexplorered node with parent pointer into queue + for (NodeID node = 0; node < num_nodes; ++node) + { + if (std::numeric_limits::max() == m_component_index_list[node]) + { unsigned size = exploreComponent(bfs_queue, node, current_component); - //push size into vector + // push size into vector m_component_index_size.push_back(size); ++current_component; } } } -private: + private: /*! * Explores the current component that starts at node using BFS. */ - inline unsigned exploreComponent( - std::queue > &bfs_queue, - NodeID node, - unsigned current_component - ) { + inline unsigned exploreComponent(std::queue> &bfs_queue, + NodeID node, + unsigned current_component) + { bfs_queue.push(std::make_pair(node, node)); - //mark node as read + // mark node as read m_component_index_list[node] = current_component; unsigned current_component_size = 1; - while(!bfs_queue.empty()) { - //fetch element from BFS queue + while (!bfs_queue.empty()) + { + // fetch element from BFS queue std::pair current_queue_item = bfs_queue.front(); bfs_queue.pop(); - const NodeID v = current_queue_item.first; //current node - const NodeID u = current_queue_item.second; //parent - //increment size counter of current component + const NodeID v = current_queue_item.first; // current node + const NodeID u = current_queue_item.second; // parent + // increment size counter of current component ++current_component_size; const bool is_barrier_node = (m_barrier_nodes.find(v) != m_barrier_nodes.end()); - if(!is_barrier_node) { - const NodeID to_node_of_only_restriction = m_restriction_map.CheckForEmanatingIsOnlyTurn(u, v); + if (!is_barrier_node) + { + const NodeID to_node_of_only_restriction = + m_restriction_map.CheckForEmanatingIsOnlyTurn(u, v); - for( - EdgeIterator e2 = m_graph.BeginEdges(v); - e2 < m_graph.EndEdges(v); - ++e2 - ) { + for (EdgeIterator e2 = m_graph.BeginEdges(v); e2 < m_graph.EndEdges(v); ++e2) + { NodeIterator w = m_graph.GetTarget(e2); - if( - to_node_of_only_restriction != std::numeric_limits::max() && - w != to_node_of_only_restriction - ) { + if (to_node_of_only_restriction != std::numeric_limits::max() && + w != to_node_of_only_restriction) + { // At an only_-restriction but not at the right turn continue; } - 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. - if (!m_restriction_map.CheckIfTurnIsRestricted(u, v, w)) { - //only add an edge if turn is not prohibited - if(std::numeric_limits::max() == m_component_index_list[w]) { - //insert next (node, parent) only if w has - //not yet been explored - //mark node as read + 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. + if (!m_restriction_map.CheckIfTurnIsRestricted(u, v, w)) + { + // only add an edge if turn is not prohibited + if (std::numeric_limits::max() == m_component_index_list[w]) + { + // insert next (node, parent) only if w has + // not yet been explored + // mark node as read 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; } - std::vector m_component_index_list; - std::vector m_component_index_size; + std::vector m_component_index_list; + std::vector m_component_index_size; - const GraphT& m_graph; - const RestrictionMap& m_restriction_map; - const boost::unordered_set& m_barrier_nodes; + const GraphT &m_graph; + const RestrictionMap &m_restriction_map; + const boost::unordered_set &m_barrier_nodes; }; #endif diff --git a/DataStructures/NodeBasedGraph.h b/DataStructures/NodeBasedGraph.h index fcb65bc68..393add55b 100644 --- a/DataStructures/NodeBasedGraph.h +++ b/DataStructures/NodeBasedGraph.h @@ -4,35 +4,39 @@ #include "DynamicGraph.h" #include "ImportEdge.h" -struct NodeBasedEdgeData { - NodeBasedEdgeData() : distance(INVALID_EDGE_WEIGHT), edgeBasedNodeID(SPECIAL_NODEID), nameID(std::numeric_limits::max()), - type(std::numeric_limits::max()), isAccessRestricted(false), shortcut(false), forward(false), backward(false), - roundabout(false), ignore_in_grid(false), contraFlow(false) - { } +struct NodeBasedEdgeData +{ + NodeBasedEdgeData() + : distance(INVALID_EDGE_WEIGHT), edgeBasedNodeID(SPECIAL_NODEID), + nameID(std::numeric_limits::max()), type(std::numeric_limits::max()), + isAccessRestricted(false), shortcut(false), forward(false), backward(false), + roundabout(false), ignore_in_grid(false), contraFlow(false) + { + } int distance; unsigned edgeBasedNodeID; unsigned nameID; short type; - bool isAccessRestricted:1; - bool shortcut:1; - bool forward:1; - bool backward:1; - bool roundabout:1; - bool ignore_in_grid:1; - bool contraFlow:1; + bool isAccessRestricted : 1; + bool shortcut : 1; + bool forward : 1; + bool backward : 1; + bool roundabout : 1; + bool ignore_in_grid : 1; + bool contraFlow : 1; - void SwapDirectionFlags() { + void SwapDirectionFlags() + { bool temp_flag = forward; forward = backward; backward = temp_flag; } - bool IsEqualTo( const NodeBasedEdgeData & other ) const { - return (forward == other.forward) && - (backward == other.backward) && - (nameID == other.nameID) && - (ignore_in_grid == other.ignore_in_grid) && + bool IsEqualTo(const NodeBasedEdgeData &other) const + { + return (forward == other.forward) && (backward == other.backward) && + (nameID == other.nameID) && (ignore_in_grid == other.ignore_in_grid) && (contraFlow == other.contraFlow); } }; @@ -40,37 +44,41 @@ struct NodeBasedEdgeData { typedef DynamicGraph NodeBasedDynamicGraph; // Factory method to create NodeBasedDynamicGraph from ImportEdges -inline std::shared_ptr NodeBasedDynamicGraphFromImportEdges( - int number_of_nodes, - std::vector& input_edge_list -) { +inline std::shared_ptr +NodeBasedDynamicGraphFromImportEdges(int number_of_nodes, std::vector &input_edge_list) +{ 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 edges_list; 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.target = import_edge.source(); edge.data.backward = import_edge.isForward(); edge.data.forward = import_edge.isBackward(); - } else { + } + else + { edge.source = import_edge.source(); edge.target = import_edge.target(); edge.data.forward = import_edge.isForward(); edge.data.backward = import_edge.isBackward(); } - if( edge.source == edge.target ) { + if (edge.source == edge.target) + { continue; } - edge.data.distance = (std::max)((int)import_edge.weight(), 1 ); - BOOST_ASSERT( edge.data.distance > 0 ); + edge.data.distance = (std::max)((int)import_edge.weight(), 1); + BOOST_ASSERT(edge.data.distance > 0); edge.data.shortcut = false; edge.data.roundabout = import_edge.isRoundabout(); edge.data.ignore_in_grid = import_edge.ignoreInGrid(); @@ -78,29 +86,25 @@ inline std::shared_ptr NodeBasedDynamicGraphFromImportEdg edge.data.type = import_edge.type(); edge.data.isAccessRestricted = import_edge.isAccessRestricted(); edge.data.contraFlow = import_edge.isContraFlow(); - edges_list.push_back( edge ); + edges_list.push_back(edge); - if( !import_edge.IsSplit() ) { - using std::swap; //enable ADL - swap( edge.source, edge.target ); + if (!import_edge.IsSplit()) + { + using std::swap; // enable ADL + swap(edge.source, edge.target); edge.data.SwapDirectionFlags(); - edges_list.push_back( edge ); + edges_list.push_back(edge); } } - std::sort( edges_list.begin(), edges_list.end() ); - auto graph = std::make_shared( - number_of_nodes, - edges_list - ); + std::sort(edges_list.begin(), edges_list.end()); + auto graph = std::make_shared(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().swap(edges_list); - BOOST_ASSERT(0 == edges_list.size() ); + BOOST_ASSERT(0 == edges_list.size()); return graph; } - #endif - diff --git a/DataStructures/RestrictionMap.cpp b/DataStructures/RestrictionMap.cpp index 90c578677..69641f122 100644 --- a/DataStructures/RestrictionMap.cpp +++ b/DataStructures/RestrictionMap.cpp @@ -1,36 +1,42 @@ #include "RestrictionMap.h" #include "NodeBasedGraph.h" -RestrictionMap::RestrictionMap(const std::shared_ptr& graph, const std::vector & input_restrictions_list) -: m_count(0) -, m_graph(graph) +RestrictionMap::RestrictionMap(const std::shared_ptr &graph, + const std::vector &input_restrictions_list) + : m_count(0), m_graph(graph) { // decompose restirction consisting of a start, via and end note into a start-edge // and all end-nodes - for (auto& restriction : input_restrictions_list) { + for (auto &restriction : input_restrictions_list) + { std::pair restriction_source = std::make_pair(restriction.fromNode, restriction.viaNode); unsigned index; 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(); - m_restriction_bucket_list.resize(index+1); + m_restriction_bucket_list.resize(index + 1); m_restriction_map.emplace(restriction_source, index); - } else { + } + else + { index = restriction_iter->second; - //Map already contains an is_only_*-restriction - if(m_restriction_bucket_list.at(index).begin()->second) { + // Map already contains an is_only_*-restriction + if (m_restriction_bucket_list.at(index).begin()->second) + { 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_restriction_bucket_list.at(index).clear(); } } ++m_count; - m_restriction_bucket_list.at(index).push_back( - std::make_pair( restriction.toNode, restriction.flags.isOnly) - ); + m_restriction_bucket_list.at(index) + .push_back(std::make_pair(restriction.toNode, restriction.flags.isOnly)); } } @@ -39,41 +45,40 @@ RestrictionMap::RestrictionMap(const std::shared_ptr& gra * * Note: We need access to node based graph. */ -void RestrictionMap::FixupArrivingTurnRestriction( - const NodeID u, - const NodeID v, - const NodeID w -) { - BOOST_ASSERT( u != std::numeric_limits::max() ); - BOOST_ASSERT( v != std::numeric_limits::max() ); - BOOST_ASSERT( w != std::numeric_limits::max() ); +void RestrictionMap::FixupArrivingTurnRestriction(const NodeID u, const NodeID v, const NodeID w) +{ + BOOST_ASSERT(u != std::numeric_limits::max()); + BOOST_ASSERT(v != std::numeric_limits::max()); + BOOST_ASSERT(w != std::numeric_limits::max()); // find all possible start edges // it is more efficent to get a (small) list of potential start edges // than iterating over all buckets std::vector predecessors; - for( - EdgeID current_edge_id = m_graph->BeginEdges(u); - current_edge_id < m_graph->EndEdges(u); - ++current_edge_id - ) { - const EdgeData & edge_data = m_graph->GetEdgeData(current_edge_id); + for (EdgeID current_edge_id = m_graph->BeginEdges(u); current_edge_id < m_graph->EndEdges(u); + ++current_edge_id) + { + const EdgeData &edge_data = m_graph->GetEdgeData(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); } } - for(const NodeID x : predecessors) { - const std::pair restr_start = std::make_pair(x,u); - auto restriction_iterator = m_restriction_map.find( restr_start ); - if( restriction_iterator == m_restriction_map.end() ) + for (const NodeID x : predecessors) + { + const std::pair restr_start = std::make_pair(x, u); + auto restriction_iterator = m_restriction_map.find(restr_start); + if (restriction_iterator == m_restriction_map.end()) continue; const unsigned index = restriction_iterator->second; - auto& bucket = m_restriction_bucket_list.at(index); - for(RestrictionTarget& restriction_target : bucket) { - if( v == restriction_target.first ) { + auto &bucket = m_restriction_bucket_list.at(index); + for (RestrictionTarget &restriction_target : bucket) + { + if (v == restriction_target.first) + { restriction_target.first = w; } } @@ -83,26 +88,24 @@ void RestrictionMap::FixupArrivingTurnRestriction( /** * Replaces the start edge (v, w) with (u, w), only start node changes. */ -void RestrictionMap::FixupStartingTurnRestriction( - const NodeID u, - const NodeID v, - const NodeID w -) { - BOOST_ASSERT( u != std::numeric_limits::max() ); - BOOST_ASSERT( v != std::numeric_limits::max() ); - BOOST_ASSERT( w != std::numeric_limits::max() ); +void RestrictionMap::FixupStartingTurnRestriction(const NodeID u, const NodeID v, const NodeID w) +{ + BOOST_ASSERT(u != std::numeric_limits::max()); + BOOST_ASSERT(v != std::numeric_limits::max()); + BOOST_ASSERT(w != std::numeric_limits::max()); - const std::pair old_start = std::make_pair(v,w); + const std::pair old_start = std::make_pair(v, w); - auto restriction_iterator = m_restriction_map.find( old_start ); - if( restriction_iterator != m_restriction_map.end() ) { + auto restriction_iterator = m_restriction_map.find(old_start); + if (restriction_iterator != m_restriction_map.end()) + { const unsigned index = restriction_iterator->second; // 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) - const std::pair new_start = std::make_pair(u,w); - m_restriction_map.insert( std::make_pair(new_start, index) ); + const std::pair new_start = std::make_pair(u, w); + 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. * If so returns id of first target node. */ -NodeID RestrictionMap::CheckForEmanatingIsOnlyTurn( - const NodeID u, - const NodeID v -) const { - BOOST_ASSERT( u != std::numeric_limits::max() ); - BOOST_ASSERT( v != std::numeric_limits::max() ); +NodeID RestrictionMap::CheckForEmanatingIsOnlyTurn(const NodeID u, const NodeID v) const +{ + BOOST_ASSERT(u != std::numeric_limits::max()); + BOOST_ASSERT(v != std::numeric_limits::max()); const std::pair restriction_source = std::make_pair(u, v); 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; - auto& bucket = m_restriction_bucket_list.at(index); - for(const RestrictionSource& restriction_target : bucket) { - if(restriction_target.second) { + auto &bucket = m_restriction_bucket_list.at(index); + for (const RestrictionSource &restriction_target : bucket) + { + if (restriction_target.second) + { 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. */ -bool RestrictionMap::CheckIfTurnIsRestricted( - const NodeID u, - const NodeID v, - const NodeID w -) const { - BOOST_ASSERT( u != std::numeric_limits::max() ); - BOOST_ASSERT( v != std::numeric_limits::max() ); - BOOST_ASSERT( w != std::numeric_limits::max() ); +bool RestrictionMap::CheckIfTurnIsRestricted(const NodeID u, const NodeID v, const NodeID w) const +{ + BOOST_ASSERT(u != std::numeric_limits::max()); + BOOST_ASSERT(v != std::numeric_limits::max()); + BOOST_ASSERT(w != std::numeric_limits::max()); const std::pair restriction_source = std::make_pair(u, v); 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; - auto& bucket = m_restriction_bucket_list.at(index); - for(const RestrictionTarget & restriction_target : bucket) { - if( - ( w == restriction_target.first ) && // target found - ( !restriction_target.second ) // and not an only_-restr. - ) { + auto &bucket = m_restriction_bucket_list.at(index); + for (const RestrictionTarget &restriction_target : bucket) + { + if ((w == restriction_target.first) && // target found + (!restriction_target.second) // and not an only_-restr. + ) + { return true; } } diff --git a/DataStructures/RestrictionMap.h b/DataStructures/RestrictionMap.h index 05a73ca70..099397037 100644 --- a/DataStructures/RestrictionMap.h +++ b/DataStructures/RestrictionMap.h @@ -43,9 +43,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ class RestrictionMap { -public: - RestrictionMap(const std::shared_ptr& graph, - const std::vector & input_restrictions_list); + public: + RestrictionMap(const std::shared_ptr &graph, + const std::vector &input_restrictions_list); void FixupArrivingTurnRestriction(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; } -private: - typedef std::pair RestrictionSource; - typedef std::pair RestrictionTarget; - typedef std::vector EmanatingRestrictionsVector; - typedef NodeBasedDynamicGraph::EdgeData EdgeData; + private: + typedef std::pair RestrictionSource; + typedef std::pair RestrictionTarget; + typedef std::vector EmanatingRestrictionsVector; + typedef NodeBasedDynamicGraph::EdgeData EdgeData; - unsigned m_count; - std::shared_ptr m_graph; + unsigned m_count; + std::shared_ptr m_graph; //! index -> list of (target, isOnly) - std::vector m_restriction_bucket_list; + std::vector m_restriction_bucket_list; //! maps (start, via) -> bucket index boost::unordered_map m_restriction_map; };