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

further renaming of variable names, reduces legacy lint

Browse Source
This commit is contained in:
Dennis Luxen 2014-05-29 19:25:17 +02:00
parent 0766c3c62d
commit c21b40bebc
5 changed files with 91 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Algorithms/StronglyConnectedComponents.h
View File

@ -176,7 +176,7 @@ class TarjanSCC
edge.data.distance = (std::max)((int)input_edge.weight, 1); edge.data.distance = (std::max)((int)input_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.name_id = input_edge.name; edge.data.name_id = input_edge.name_id;
edge.data.type = input_edge.type; edge.data.type = input_edge.type;
edge.data.reversedEdge = false; edge.data.reversedEdge = false;
edge_list.push_back(edge); edge_list.push_back(edge);

17
Contractor/Contractor.h
View File

@ -164,14 +164,15 @@ class Contractor
ContractorEdge new_edge; ContractorEdge new_edge;
while (diter != dend) while (diter != dend)
{ {
new_edge.source = diter->source(); new_edge.source = diter->source;
new_edge.target = diter->target(); new_edge.target = diter->target;
new_edge.data = ContractorEdgeData((std::max)((int)diter->weight(), 1), new_edge.data = { static_cast<unsigned int>(std::max(diter->weight, 1)),
1, 1,
diter->id(), diter->edge_id,
false, false,
diter->isForward(), diter->forward,
diter->isBackward()); diter->backward};
BOOST_ASSERT_MSG(new_edge.data.distance > 0, "edge distance < 1"); BOOST_ASSERT_MSG(new_edge.data.distance > 0, "edge distance < 1");
#ifndef NDEBUG #ifndef NDEBUG
if (new_edge.data.distance > 24 * 60 * 60 * 10) if (new_edge.data.distance > 24 * 60 * 60 * 10)
@ -182,8 +183,8 @@ class Contractor
#endif #endif
edges.push_back(new_edge); edges.push_back(new_edge);
std::swap(new_edge.source, new_edge.target); std::swap(new_edge.source, new_edge.target);
new_edge.data.forward = diter->isBackward(); new_edge.data.forward = diter->backward;
new_edge.data.backward = diter->isForward(); new_edge.data.backward = diter->forward;
edges.push_back(new_edge); edges.push_back(new_edge);
++diter; ++diter;
} }

102
DataStructures/ImportEdge.cpp
View File

@ -44,72 +44,58 @@ bool NodeBasedEdge::operator<(const NodeBasedEdge &e) const
return (source < e.source); return (source < e.source);
} }
NodeBasedEdge::NodeBasedEdge(NodeID s, NodeBasedEdge::NodeBasedEdge(NodeID source,
NodeID t, NodeID target,
NodeID n, NodeID name_id,
EdgeWeight w, EdgeWeight weight,
bool f, bool forward,
bool b, bool backward,
short ty, short type,
bool ra, bool roundabout,
bool ig, bool in_tiny_cc,
bool ar, bool access_restricted,
bool cf, bool contra_flow,
bool is_split) bool is_split)
: source(s), target(t), name(n), weight(w), type(ty), forward(f), backward(b), : source(source), target(target), name_id(name_id), weight(weight), type(type),
roundabout(ra), ignoreInGrid(ig), accessRestricted(ar), contraFlow(cf), forward(forward), backward(backward), roundabout(roundabout), in_tiny_cc(in_tiny_cc),
is_split(is_split) access_restricted(access_restricted), contra_flow(contra_flow), is_split(is_split)
{ {
if (ty < 0) BOOST_ASSERT_MSG(type > 0, "negative edge type");
{ }
throw OSRMException("negative edge type");
}
}
bool EdgeBasedEdge::operator<(const EdgeBasedEdge &e) const bool EdgeBasedEdge::operator<(const EdgeBasedEdge &e) const
{
if (source == e.source)
{ {
if (source() == e.source()) if (target == e.target)
{ {
if (target() == e.target()) if (weight == e.weight)
{ {
if (weight() == e.weight()) return (forward && backward && ((!e.forward) || (!e.backward)));
{
return (isForward() && isBackward() && ((!e.isForward()) || (!e.isBackward())));
} }
return (weight() < e.weight()); return (weight < e.weight);
} }
return (target() < e.target()); return (target < e.target);
}
return (source() < e.source());
} }
return (source < e.source);
}
template <class EdgeT> template <class EdgeT>
EdgeBasedEdge::EdgeBasedEdge(const EdgeT &myEdge) EdgeBasedEdge::EdgeBasedEdge(const EdgeT &myEdge)
: m_source(myEdge.source), m_target(myEdge.target), m_edgeID(myEdge.data.via), : source(myEdge.source), target(myEdge.target), edge_id(myEdge.data.via),
m_weight(myEdge.data.distance), m_forward(myEdge.data.forward), weight(myEdge.data.distance), forward(myEdge.data.forward),
m_backward(myEdge.data.backward) backward(myEdge.data.backward)
{ {
} }
/** Default constructor. target and weight are set to 0.*/ /** Default constructor. target and weight are set to 0.*/
EdgeBasedEdge::EdgeBasedEdge() EdgeBasedEdge::EdgeBasedEdge()
: m_source(0), m_target(0), m_edgeID(0), m_weight(0), m_forward(false), m_backward(false) : source(0), target(0), edge_id(0), weight(0), forward(false), backward(false)
{ {
} }
EdgeBasedEdge::EdgeBasedEdge(const NodeID s, EdgeBasedEdge::EdgeBasedEdge(
const NodeID t, const NodeID s, const NodeID t, const NodeID v, const EdgeWeight w, const bool f, const bool b)
const NodeID v, : source(s), target(t), edge_id(v), weight(w), forward(f), backward(b)
const EdgeWeight w, {
const bool f, }
const bool b)
: m_source(s), m_target(t), m_edgeID(v), m_weight(w), m_forward(f), m_backward(b)
{
}
NodeID EdgeBasedEdge::target() const { return m_target; }
NodeID EdgeBasedEdge::source() const { return m_source; }
EdgeWeight EdgeBasedEdge::weight() const { return m_weight; }
NodeID EdgeBasedEdge::id() const { return m_edgeID; }
bool EdgeBasedEdge::isBackward() const { return m_backward; }
bool EdgeBasedEdge::isForward() const { return m_forward; }

73
DataStructures/ImportEdge.h
View File

@ -33,74 +33,61 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <boost/assert.hpp> #include <boost/assert.hpp>
class NodeBasedEdge struct NodeBasedEdge
{ {
public:
bool operator<(const NodeBasedEdge &e) const; bool operator<(const NodeBasedEdge &e) const;
explicit NodeBasedEdge(NodeID s, explicit NodeBasedEdge(NodeID source,
NodeID t, NodeID target,
NodeID n, NodeID name_id,
EdgeWeight w, EdgeWeight weight,
bool f, bool forward,
bool b, bool backward,
short ty, short type,
bool ra, bool roundabout,
bool ig, bool in_tiny_cc,
bool ar, bool access_restricted,
bool cf, bool contra_flow,
bool is_split); bool is_split);
NodeID source; NodeID source;
NodeID target; NodeID target;
NodeID name; NodeID name_id;
EdgeWeight weight; EdgeWeight weight;
short type; short type;
bool forward : 1; bool forward : 1;
bool backward : 1; bool backward : 1;
bool roundabout : 1; bool roundabout : 1;
bool ignoreInGrid : 1; bool in_tiny_cc : 1;
bool accessRestricted : 1; bool access_restricted : 1;
bool contraFlow : 1; bool contra_flow : 1;
bool is_split : 1; bool is_split : 1;
NodeBasedEdge() = delete; NodeBasedEdge() = delete;
}; };
class EdgeBasedEdge struct EdgeBasedEdge
{ {
public: public:
bool operator<(const EdgeBasedEdge &e) const; bool operator<(const EdgeBasedEdge &e) const;
template <class EdgeT> template <class EdgeT> explicit EdgeBasedEdge(const EdgeT &myEdge);
explicit EdgeBasedEdge(const EdgeT &myEdge);
/** Default constructor. target and weight are set to 0.*/
EdgeBasedEdge(); EdgeBasedEdge();
explicit EdgeBasedEdge(const NodeID s, explicit EdgeBasedEdge(const NodeID source,
const NodeID t, const NodeID target,
const NodeID v, const NodeID edge_id,
const EdgeWeight w, const EdgeWeight weight,
const bool f, const bool forward,
const bool b); const bool backward);
NodeID source;
NodeID target() const; NodeID target;
NodeID source() const; NodeID edge_id;
EdgeWeight weight() const; EdgeWeight weight : 30;
NodeID id() const; bool forward : 1;
bool isBackward() const; bool backward : 1;
bool isForward() const;
private:
NodeID m_source;
NodeID m_target;
NodeID m_edgeID;
EdgeWeight m_weight : 30;
bool m_forward : 1;
bool m_backward : 1;
}; };
typedef NodeBasedEdge ImportEdge; typedef NodeBasedEdge ImportEdge;

8
DataStructures/NodeBasedGraph.h
View File

@ -84,11 +84,11 @@ NodeBasedDynamicGraphFromImportEdges(int number_of_nodes, std::vector<ImportEdge
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.roundabout; edge.data.roundabout = import_edge.roundabout;
edge.data.ignore_in_grid = import_edge.ignoreInGrid; edge.data.ignore_in_grid = import_edge.in_tiny_cc;
edge.data.nameID = import_edge.name; edge.data.nameID = import_edge.name_id;
edge.data.type = import_edge.type; edge.data.type = import_edge.type;
edge.data.isAccessRestricted = import_edge.accessRestricted; edge.data.isAccessRestricted = import_edge.access_restricted;
edge.data.contraFlow = import_edge.contraFlow; edge.data.contraFlow = import_edge.contra_flow;
edges_list.push_back(edge); edges_list.push_back(edge);
if (!import_edge.is_split) if (!import_edge.is_split)