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

Replaced std::pair with classes.

Browse Source 
Looks like fixed wrong restriction type in CheckForEmanatingIsOnlyTurn (now RestrictionTarget instead if RestrictionSource).
This commit is contained in:
dmbreaker 2014-06-25 18:03:11 +04:00 committed by Dennis Luxen
parent 2d9645b9b0
commit 07e13e2499
2 changed files with 25 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
DataStructures/RestrictionMap.cpp
View File

@ -46,7 +46,7 @@ RestrictionMap::RestrictionMap(const std::shared_ptr<NodeBasedDynamicGraph> &gra
m_restriction_start_nodes.insert(restriction.fromNode); m_restriction_start_nodes.insert(restriction.fromNode);
m_no_turn_via_node_set.insert(restriction.viaNode); m_no_turn_via_node_set.insert(restriction.viaNode);
std::pair<NodeID, NodeID> restriction_source = {restriction.fromNode, restriction.viaNode}; RestrictionSource restriction_source(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);
@ -60,7 +60,7 @@ RestrictionMap::RestrictionMap(const std::shared_ptr<NodeBasedDynamicGraph> &gra
{ {
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()->IsOnly())
{ {
continue; continue;
} }
@ -116,9 +116,9 @@ void RestrictionMap::FixupArrivingTurnRestriction(const NodeID node_u,
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 (node_v == restriction_target.first) if (node_v == restriction_target.TargetNode())
{ {
restriction_target.first = node_w; restriction_target.SetTarget(node_w);
} }
} }
} }
@ -169,11 +169,11 @@ NodeID RestrictionMap::CheckForEmanatingIsOnlyTurn(const NodeID node_u,
{ {
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 RestrictionTarget &restriction_target : bucket)
{ {
if (restriction_target.second) if (restriction_target.IsOnly())
{ {
return restriction_target.first; return restriction_target.TargetNode();
} }
} }
} }
@ -203,8 +203,9 @@ bool RestrictionMap::CheckIfTurnIsRestricted(const NodeID node_u,
const auto &bucket = m_restriction_bucket_list.at(index); const auto &bucket = m_restriction_bucket_list.at(index);
for (const RestrictionTarget &restriction_target : bucket) for (const RestrictionTarget &restriction_target : bucket)
{ {
if ((node_w == restriction_target.first) && // target found if ((node_w == restriction_target.TargetNode()) && // target found
(!restriction_target.second)) // and not an only_-restr. (!restriction_target.IsOnly()) // and not an only_-restr.
)
{ {
return true; return true;
} }

32
DataStructures/RestrictionMap.h
View File

@ -40,36 +40,36 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <unordered_set> #include <unordered_set>
struct RestrictionSource//: public std::pair<NodeID, NodeID> struct RestrictionSource
{ {
NodeID start; NodeID start_node;
NodeID via; NodeID via_node;
RestrictionSource(NodeID _start, NodeID _via)//:std::pair<NodeID, NodeID>(from, via) {} RestrictionSource(NodeID start, NodeID via)
: start(_start), via(_via) {} : start_node(start), via_node(via) {}
inline NodeID StartNode() const { return start; } inline NodeID StartNode() const { return start_node; }
inline NodeID ViaNode() const { return via; } inline NodeID ViaNode() const { return via_node; }
friend inline bool operator==(const RestrictionSource& lhs, const RestrictionSource& rhs) friend inline bool operator==(const RestrictionSource& lhs, const RestrictionSource& rhs)
{ {
return (lhs.start == rhs.start && lhs.via == rhs.via); return (lhs.start_node == rhs.start_node && lhs.via_node == rhs.via_node);
} }
}; };
struct RestrictionTarget//: public std::pair<NodeID, bool> struct RestrictionTarget
{ {
NodeID target; NodeID target_node;
bool is_only; bool is_only;
RestrictionTarget(NodeID _target, bool _only)//:std::pair<NodeID, bool>(to, _only) {} RestrictionTarget(NodeID target, bool only)
: target(_target), is_only(_only) {} : target_node(target), is_only(only) {}
inline NodeID TargetNode() const { return target; } inline NodeID TargetNode() const { return target_node; }
inline NodeID IsOnly() const { return is_only; } //!< an only_-restriction inline NodeID IsOnly() const { return is_only; } //!< an only_-restriction
inline void SetTarget(NodeID _target) { target = _target; } //!< an only_-restriction inline void SetTarget(NodeID target) { target_node = target; } //!< an only_-restriction
friend inline bool operator==(const RestrictionTarget& lhs, const RestrictionTarget& rhs) friend inline bool operator==(const RestrictionTarget& lhs, const RestrictionTarget& rhs)
{ {
return (lhs.target == rhs.target && lhs.is_only == rhs.is_only); return (lhs.target_node == rhs.target_node && lhs.is_only == rhs.is_only);
} }
}; };
@ -111,8 +111,6 @@ class RestrictionMap
private: private:
bool IsSourceNode(const NodeID node) const; bool IsSourceNode(const NodeID node) const;
typedef std::pair<NodeID, NodeID> RestrictionSource;
typedef std::pair<NodeID, bool> RestrictionTarget;
typedef std::vector<RestrictionTarget> EmanatingRestrictionsVector; typedef std::vector<RestrictionTarget> EmanatingRestrictionsVector;
typedef NodeBasedDynamicGraph::EdgeData EdgeData; typedef NodeBasedDynamicGraph::EdgeData EdgeData;