PGROUTING  2.5
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Path Class Reference

#include "basePath_SSEC.hpp"

Collaboration diagram for Path:

Public Member Functions

 Path ()
 
 Path (int64_t s_id, int64_t e_id)
 
 Path (const Path &)=default
 
template<typename G , typename V >
 Path (G &graph, int64_t source, double distance, const std::vector< V > &predecessors, const std::vector< double > &distances)
 
template<typename G , typename V >
 Path (G &graph, V v_source, double distance, const std::vector< V > &predecessors, const std::vector< double > &distances)
 
template<typename G , typename V >
 Path (const G &graph, const V v_source, const V v_target, const std::vector< V > &predecessors, const std::vector< double > &distances, bool only_cost, bool normal=true)
 
void append (const Path &other)
 Path: 2 -> 9 seq node edge cost agg_cost 0 2 4 1 0 1 5 8 1 1 2 6 9 1 2 3 9 -1 0 3 Path: 9 -> 3 seq node edge cost agg_cost 0 9 16 1 0 1 4 3 1 1 2 3 -1 0 2 Path: 2 -> 3 seq node edge cost agg_cost 0 2 4 1 0 1 5 8 1 1 2 6 9 1 2 3 9 16 1 3 4 4 3 1 4 5 3 -1 0 5. More...
 
void appendPath (const Path &o_path)
 
const Path_tback () const
 
Path_tback ()
 
pthIt begin ()
 
ConstpthIt begin () const
 
void clear ()
 
template<typename G , typename V >
void complete_path (const G &graph, const V v_source, const V v_target, const std::vector< V > &predecessors, const std::vector< double > &distances, bool normal)
 constructs a path based on results More...
 
bool empty () const
 
void empty_path (unsigned int d_vertex)
 
pthIt end ()
 
ConstpthIt end () const
 
int64_t end_id () const
 
void end_id (int64_t value)
 
void erase (pthIt pos)
 
const Path_tfront () const
 
Path_tfront ()
 
void generate_postgres_data (General_path_element_t **postgres_data, size_t &sequence) const
 
void get_pg_dd_path (General_path_element_t **ret_path, size_t &sequence) const
 
void get_pg_ksp_path (General_path_element_t **ret_path, size_t &sequence, int routeId) const
 
Path getSubpath (unsigned int j) const
 
bool isEqual (const Path &subpath) const
 
const Path_toperator[] (size_t i) const
 
Path_toperator[] (size_t i)
 
void push_back (Path_t data)
 
void push_front (Path_t data)
 
void push_front (int64_t d_vertex, int64_t d_edge, double d_cost, double d_tot_cost)
 
void reverse ()
 
Path_t set_data (int64_t d_from, int64_t d_to, int64_t d_vertex, int64_t d_edge, double d_cost, double d_tot_cost)
 
size_t size () const
 
void sort_by_node_agg_cost ()
 Sorts a path by node, aggcost ascending. More...
 
int64_t start_id () const
 
void start_id (int64_t value)
 
double tot_cost () const
 

Private Types

typedef std::deque< Path_t >
::const_iterator 
ConstpthIt
 
typedef std::deque< Path_t >
::iterator 
pthIt
 

Private Attributes

int64_t m_end_id
 
int64_t m_start_id
 
double m_tot_cost
 
std::deque< Path_tpath
 

Friends

size_t collapse_paths (General_path_element_t **ret_path, const std::deque< Path > &paths)
 
size_t count_tuples (const std::deque< Path > &paths)
 counts the tuples to be returned More...
 
void equi_cost (std::deque< Path > &paths)
 discards common vertices with greater agg_cost More...
 
std::ostream & operator<< (std::ostream &log, const Path &p)
 

Detailed Description

Definition at line 47 of file basePath_SSEC.hpp.

Member Typedef Documentation

typedef std::deque< Path_t >::const_iterator Path::ConstpthIt
private

Definition at line 49 of file basePath_SSEC.hpp.

typedef std::deque< Path_t >::iterator Path::pthIt
private

Definition at line 48 of file basePath_SSEC.hpp.

Constructor & Destructor Documentation

Path::Path ( )
inline

Definition at line 58 of file basePath_SSEC.hpp.

58 : m_tot_cost(0) {}
double m_tot_cost
Path::Path ( int64_t  s_id,
int64_t  e_id 
)
inline

Definition at line 59 of file basePath_SSEC.hpp.

60  : m_start_id(s_id), m_end_id(e_id), m_tot_cost(0)
61  {}
int64_t m_end_id
int64_t m_start_id
double m_tot_cost
Path::Path ( const Path )
default
template<typename G , typename V >
Path::Path ( G &  graph,
int64_t  source,
double  distance,
const std::vector< V > &  predecessors,
const std::vector< double > &  distances 
)
inline

Definition at line 145 of file basePath_SSEC.hpp.

References push_back().

150  :
151  m_start_id(source),
152  m_end_id(source) {
153  for (V i = 0; i < distances.size(); ++i) {
154  if (distances[i] <= distance) {
155  auto cost = distances[i] - distances[predecessors[i]];
156  auto edge_id = graph.get_edge_id(predecessors[i], i, cost);
157  push_back(
158  {graph[i].id,
159  edge_id, cost,
160  distances[i]});
161  }
162  }
163  }
int64_t m_end_id
int64_t m_start_id
void push_back(Path_t data)

Here is the call graph for this function:

template<typename G , typename V >
Path::Path ( G &  graph,
v_source,
double  distance,
const std::vector< V > &  predecessors,
const std::vector< double > &  distances 
)
inline

Definition at line 166 of file basePath_SSEC.hpp.

References push_back().

171  :
172  m_start_id(graph.graph[v_source].id),
173  m_end_id(graph.graph[v_source].id) {
174  for (V i = 0; i < distances.size(); ++i) {
175  if (distances[i] <= distance) {
176  auto cost = distances[i] - distances[predecessors[i]];
177  auto edge_id = graph.get_edge_id(predecessors[i], i, cost);
178  push_back(
179  {graph[i].id,
180  edge_id, cost,
181  distances[i]});
182  }
183  }
184  }
int64_t m_end_id
int64_t m_start_id
void push_back(Path_t data)

Here is the call graph for this function:

template<typename G , typename V >
Path::Path ( const G &  graph,
const V  v_source,
const V  v_target,
const std::vector< V > &  predecessors,
const std::vector< double > &  distances,
bool  only_cost,
bool  normal = true 
)
inline

Definition at line 188 of file basePath_SSEC.hpp.

References complete_path(), and push_front().

195  :
196  m_start_id(graph.graph[v_source].id),
197  m_end_id(graph.graph[v_target].id) {
198  if (!only_cost) {
199  complete_path(graph,
200  v_source,
201  v_target,
202  predecessors,
203  distances,
204  normal);
205  return;
206  }
207  /*
208  * only_cost
209  */
210  if (v_target != predecessors[v_target]) {
211  push_front(
212  {graph.graph[v_target].id,
213  -1,
214  distances[v_target],
215  distances[v_target]});
216  }
217  return;
218  }
int64_t m_end_id
void push_front(Path_t data)
int64_t m_start_id
void complete_path(const G &graph, const V v_source, const V v_target, const std::vector< V > &predecessors, const std::vector< double > &distances, bool normal)
constructs a path based on results

Here is the call graph for this function:

Member Function Documentation

void Path::append ( const Path other)

Path: 2 -> 9 seq node edge cost agg_cost 0 2 4 1 0 1 5 8 1 1 2 6 9 1 2 3 9 -1 0 3 Path: 9 -> 3 seq node edge cost agg_cost 0 9 16 1 0 1 4 3 1 1 2 3 -1 0 2 Path: 2 -> 3 seq node edge cost agg_cost 0 2 4 1 0 1 5 8 1 1 2 6 9 1 2 3 9 16 1 3 4 4 3 1 4 5 3 -1 0 5.

Definition at line 141 of file basePath_SSEC.cpp.

References m_end_id, m_start_id, path, pgassert, and push_back().

Referenced by pgrouting::bidirectional::Pgr_bidirectional< G >::bidirectional().

141  {
142  pgassert(m_end_id == other.m_start_id);
143  if (other.m_start_id == other.m_end_id) {
144  pgassert(other.path.empty());
145  return;
146  }
147  if (m_start_id == m_end_id) {
148  pgassert(path.empty());
149  *this = other;
150  return;
151  }
152 #if 0
153  pgassert(path.back().cost == 0);
154 #endif
155  pgassert(path.back().edge == -1);
156  m_end_id = other.m_end_id;
157 
158  auto last = path.back();
159  auto agg_cost = last.agg_cost;
160 
161  path.pop_back();
162 
163  for (auto item : other.path) {
164  item.agg_cost += agg_cost;
165  push_back(item);
166  }
167 }
int64_t m_end_id
int64_t m_start_id
void push_back(Path_t data)
#define pgassert(expr)
Uses the standard assert syntax.
Definition: pgr_assert.h:81
std::deque< Path_t > path

Here is the call graph for this function:

Here is the caller graph for this function:

void Path::appendPath ( const Path o_path)

Definition at line 112 of file basePath_SSEC.cpp.

References m_tot_cost, and path.

Referenced by Pgr_ksp< G >::doNextCycle().

112  {
113  path.insert(path.end(), o_path.path.begin(), o_path.path.end());
114  m_tot_cost += o_path.m_tot_cost;
115 }
std::deque< Path_t > path
double m_tot_cost

Here is the caller graph for this function:

const Path_t& Path::back ( ) const
inline

Definition at line 85 of file basePath_SSEC.hpp.

References path.

85 {return path.back();}
std::deque< Path_t > path
Path_t& Path::back ( )
inline

Definition at line 86 of file basePath_SSEC.hpp.

References path.

86 {return path.back();}
std::deque< Path_t > path
pthIt Path::begin ( )
inline

Definition at line 78 of file basePath_SSEC.hpp.

References path.

Referenced by isEqual().

78 {return path.begin();}
std::deque< Path_t > path

Here is the caller graph for this function:

ConstpthIt Path::begin ( ) const
inline

Definition at line 80 of file basePath_SSEC.hpp.

References path.

80 {return path.begin();}
std::deque< Path_t > path
void Path::clear ( )

Definition at line 65 of file basePath_SSEC.cpp.

References m_end_id, m_start_id, m_tot_cost, and path.

Referenced by process_dijkstra().

65  {
66  path.clear();
67  m_tot_cost = 0;
68  m_start_id = 0;
69  m_end_id = 0;
70 }
int64_t m_end_id
int64_t m_start_id
std::deque< Path_t > path
double m_tot_cost

Here is the caller graph for this function:

template<typename G , typename V >
void Path::complete_path ( const G &  graph,
const V  v_source,
const V  v_target,
const std::vector< V > &  predecessors,
const std::vector< double > &  distances,
bool  normal 
)
inline

constructs a path based on results

Normal = false for reversed search path like in pgr_bdDijkstra

Definition at line 224 of file basePath_SSEC.hpp.

References push_front().

Referenced by Path().

230  {
231  // no path was found
232  if (v_target == predecessors[v_target]) {
233  return;
234  }
235 
236  /*
237  * set the target
238  */
239  auto target = v_target;
240 
241  /*
242  * the last stop is the target
243  */
244  push_front(
245  {graph.graph[target].id, -1,
246  0, distances[target]});
247 
248  /*
249  * get the path
250  */
251  while (target != v_source) {
252  /*
253  * done when the predecesor of the target is the target
254  */
255  if (target == predecessors[target]) break;
256 
257  /*
258  * Inserting values in the path
259  */
260  auto cost = distances[target] - distances[predecessors[target]];
261  auto vertex_id = graph.graph[predecessors[target]].id;
262  auto edge_id = normal?
263  graph.get_edge_id(predecessors[target], target, cost)
264  : graph.get_edge_id(target, predecessors[target], cost);
265 
266  push_front({
267  vertex_id,
268  edge_id,
269  cost,
270  distances[target] - cost});
271  target = predecessors[target];
272  }
273 
274  return;
275  }
void push_front(Path_t data)

Here is the call graph for this function:

Here is the caller graph for this function:

bool Path::empty ( ) const
inline

Definition at line 71 of file basePath_SSEC.hpp.

References path.

Referenced by adjust_pids(), eliminate_details(), eliminate_details_dd(), Pgr_dijkstraTRSP< G >::getDijkstraSolution(), Pgr_ksp< G >::getFirstSolution(), isEqual(), and pgr_dijkstraViaVertex().

71 {return path.empty();}
std::deque< Path_t > path

Here is the caller graph for this function:

void Path::empty_path ( unsigned int  d_vertex)
pthIt Path::end ( )
inline

Definition at line 79 of file basePath_SSEC.hpp.

References path.

Referenced by isEqual().

79 {return path.end();}
std::deque< Path_t > path

Here is the caller graph for this function:

ConstpthIt Path::end ( ) const
inline

Definition at line 81 of file basePath_SSEC.hpp.

References path.

81 {return path.end();}
std::deque< Path_t > path
int64_t Path::end_id ( ) const
inline
void Path::end_id ( int64_t  value)
inline

Definition at line 67 of file basePath_SSEC.hpp.

References m_end_id.

67 {m_end_id = value;}
int64_t m_end_id
void Path::erase ( pthIt  pos)
inline

Definition at line 84 of file basePath_SSEC.hpp.

References path.

84 {path.erase(pos);}
std::deque< Path_t > path
const Path_t& Path::front ( ) const
inline

Definition at line 87 of file basePath_SSEC.hpp.

References path.

87 {return path.front();}
std::deque< Path_t > path
Path_t& Path::front ( )
inline

Definition at line 88 of file basePath_SSEC.hpp.

References path.

88 {return path.front();}
std::deque< Path_t > path
void Path::generate_postgres_data ( General_path_element_t **  postgres_data,
size_t &  sequence 
) const

Definition at line 170 of file basePath_SSEC.cpp.

References end_id(), path, and start_id().

Referenced by do_pgr_dijkstraTRSP().

172  {
173  int i = 1;
174  for (const auto e : path) {
175  (*postgres_data)[sequence] =
176  {i, start_id(), end_id(), e.node, e.edge, e.cost, e.agg_cost};
177  ++i;
178  ++sequence;
179  }
180 }
int64_t end_id() const
int64_t start_id() const
std::deque< Path_t > path

Here is the call graph for this function:

Here is the caller graph for this function:

void Path::get_pg_dd_path ( General_path_element_t **  ret_path,
size_t &  sequence 
) const

Definition at line 183 of file basePath_SSEC.cpp.

References path, and start_id().

185  {
186  for (unsigned int i = 0; i < path.size(); i++) {
187  (*ret_path)[sequence].seq = i;
188  (*ret_path)[sequence].start_id = start_id();
189  (*ret_path)[sequence].end_id = start_id();
190  (*ret_path)[sequence].node = path[i].node;
191  (*ret_path)[sequence].edge = path[i].edge;
192  (*ret_path)[sequence].cost = path[i].cost;
193  (*ret_path)[sequence].agg_cost = path[i].agg_cost;
194  sequence++;
195  }
196 }
int64_t start_id() const
std::deque< Path_t > path

Here is the call graph for this function:

void Path::get_pg_ksp_path ( General_path_element_t **  ret_path,
size_t &  sequence,
int  routeId 
) const

Definition at line 199 of file basePath_SSEC.cpp.

References end_id(), and path.

201  {
202  for (unsigned int i = 0; i < path.size(); i++) {
203  (*ret_path)[sequence].seq = i + 1;
204  (*ret_path)[sequence].start_id = routeId;
205  (*ret_path)[sequence].end_id = end_id();
206  (*ret_path)[sequence].node = path[i].node;
207  (*ret_path)[sequence].edge = path[i].edge;
208  (*ret_path)[sequence].cost = path[i].cost;
209  (*ret_path)[sequence].agg_cost = (i == 0)?
210  0 :
211  (*ret_path)[sequence-1].agg_cost + path[i-1].cost;
212  sequence++;
213  }
214 }
int64_t end_id() const
std::deque< Path_t > path

Here is the call graph for this function:

Path Path::getSubpath ( unsigned int  j) const

Definition at line 89 of file basePath_SSEC.cpp.

References end_id(), path, pgassert, push_back(), start_id(), and tot_cost().

89  {
90  Path result(start_id(), end_id());
91  if (j == 0) return result;
92  for (auto i = path.begin(); i != path.begin() + j; ++i) {
93  result.push_back((*i));
94  }
95  pgassert(result.tot_cost() != 0);
96  pgassert(this->tot_cost() != 0);
97  return result;
98 }
int64_t end_id() const
double tot_cost() const
#define pgassert(expr)
Uses the standard assert syntax.
Definition: pgr_assert.h:81
int64_t start_id() const
std::deque< Path_t > path

Here is the call graph for this function:

bool Path::isEqual ( const Path subpath) const

Definition at line 101 of file basePath_SSEC.cpp.

References begin(), empty(), end(), path, and size().

101  {
102  if (subpath.empty()) return true;
103  if (subpath.size() >= path.size()) return false;
104  std::deque< Path_t >::const_iterator i, j;
105  for (i = path.begin(), j = subpath.begin();
106  j != subpath.end();
107  ++i, ++j)
108  if ((*i).node != (*j).node) return false;
109  return true;
110 }
pthIt end()
pthIt begin()
bool empty() const
size_t size() const
std::deque< Path_t > path

Here is the call graph for this function:

const Path_t& Path::operator[] ( size_t  i) const
inline

Definition at line 75 of file basePath_SSEC.hpp.

References path.

75 {return path[i];}
std::deque< Path_t > path
Path_t& Path::operator[] ( size_t  i)
inline

Definition at line 76 of file basePath_SSEC.hpp.

References path.

76 {return path[i];}
std::deque< Path_t > path
void Path::push_back ( Path_t  data)

Definition at line 39 of file basePath_SSEC.cpp.

References Path_t::cost, m_tot_cost, and path.

Referenced by append(), Pgr_dijkstra< G >::drivingDistance_no_equicost(), eliminate_details(), eliminate_details_dd(), getSubpath(), and Path().

39  {
40  path.push_back(data);
41  m_tot_cost += data.cost;
42 }
double cost
Definition: path_t.h:39
std::deque< Path_t > path
double m_tot_cost

Here is the caller graph for this function:

void Path::push_front ( Path_t  data)

Definition at line 34 of file basePath_SSEC.cpp.

References Path_t::cost, m_tot_cost, and path.

Referenced by complete_path(), and Path().

34  {
35  path.push_front(data);
36  m_tot_cost += data.cost;
37 }
double cost
Definition: path_t.h:39
std::deque< Path_t > path
double m_tot_cost

Here is the caller graph for this function:

void Path::push_front ( int64_t  d_vertex,
int64_t  d_edge,
double  d_cost,
double  d_tot_cost 
)
void Path::reverse ( )

Definition at line 44 of file basePath_SSEC.cpp.

References m_end_id, m_start_id, and path.

Referenced by pgrouting::bidirectional::Pgr_bidirectional< G >::bidirectional(), pgr_astar(), and pgr_dijkstra().

44  {
45  std::swap(m_start_id, m_end_id);
46  if (path.size() <= 1) return;
47  std::deque< Path_t > newpath;
48  for (size_t i = 0; i < path.size(); ++i) {
49  newpath.push_front({
50  path[i].node,
51  (i == 0? -1 : path[i - 1].edge),
52  (i == 0? 0 : path[i - 1].cost),
53  0
54  });
55  }
56  for (size_t i = 0; i < newpath.size(); ++i) {
57  newpath[i].agg_cost = (i == 0)?
58  0 :
59  newpath[i - 1].agg_cost + newpath[i - 1].cost;
60  }
61  path = newpath;
62 }
int64_t m_end_id
int64_t m_start_id
std::deque< Path_t > path

Here is the caller graph for this function:

Path_t Path::set_data ( int64_t  d_from,
int64_t  d_to,
int64_t  d_vertex,
int64_t  d_edge,
double  d_cost,
double  d_tot_cost 
)
size_t Path::size ( ) const
inline

Definition at line 70 of file basePath_SSEC.hpp.

References path.

Referenced by do_pgr_dijkstraTRSP(), equi_cost(), isEqual(), Pgr_ksp< G >::compPaths::operator()(), pgr_dijkstraViaVertex(), and Pgr_ksp< G >::Yen().

70 {return path.size();}
std::deque< Path_t > path

Here is the caller graph for this function:

void Path::sort_by_node_agg_cost ( )

Sorts a path by node, aggcost ascending.

nodes ASC agg_cost ASC

Definition at line 223 of file basePath_SSEC.cpp.

References Path_t::agg_cost, Path_t::node, and path.

223  {
224  std::sort(path.begin(), path.end(),
225  [](const Path_t &l, const Path_t &r)
226  {return l.node < r.node;});
227  std::stable_sort(path.begin(), path.end(),
228  [](const Path_t &l, const Path_t &r)
229  {return l.agg_cost < r.agg_cost;});
230 }
int64_t node
Definition: path_t.h:37
Definition: path_t.h:36
std::deque< Path_t > path
double agg_cost
Definition: path_t.h:40
int64_t Path::start_id ( ) const
inline
void Path::start_id ( int64_t  value)
inline

Definition at line 65 of file basePath_SSEC.hpp.

References m_start_id.

65 {m_start_id = value;}
int64_t m_start_id
double Path::tot_cost ( ) const
inline

Definition at line 68 of file basePath_SSEC.hpp.

References m_tot_cost.

Referenced by getSubpath(), Pgr_ksp< G >::compPaths::operator()(), and process_dijkstra().

68 {return m_tot_cost;}
double m_tot_cost

Here is the caller graph for this function:

Friends And Related Function Documentation

size_t collapse_paths ( General_path_element_t **  ret_path,
const std::deque< Path > &  paths 
)
friend

Definition at line 238 of file basePath_SSEC.cpp.

240  {
241  size_t sequence = 0;
242  for (const Path &path : paths) {
243  if (path.path.size() > 0)
244  path.generate_postgres_data(ret_path, sequence);
245  }
246  return sequence;
247 }
std::deque< Path_t > path
size_t count_tuples ( const std::deque< Path > &  paths)
friend

counts the tuples to be returned

Definition at line 315 of file basePath_SSEC.cpp.

315  {
316  size_t count(0);
317  for (const Path &e : paths) {
318  count += e.path.size();
319  }
320  return count;
321 }
void equi_cost ( std::deque< Path > &  paths)
friend

discards common vertices with greater agg_cost

Definition at line 264 of file basePath_SSEC.cpp.

264  {
265  /* sort paths by size: largest first */
266  std::sort(paths.begin(), paths.end(),
267  [](const Path &e1, const Path &e2)->bool {
268  return e2.size() < e1.size();
269  });
270 
271  /* sort each path by node: smaller id first */
272  for (auto &p : paths) {
273  if (p.size() < 2) continue;
274  std::sort(p.begin(), p.end(),
275  [](const Path_t &e1, const Path_t &e2)->bool {
276  return e1.node < e2.node;
277  });
278  }
279 
280  for (auto &p1 : paths) {
281  for (const auto &p2 : paths) {
282  if (p1.start_id() == p2.start_id()) continue;
283  for (const auto &stop : p2.path) {
284  /* find the node of p2 in p1 */
285  auto pos = lower_bound(p1.begin(), p1.end(), stop,
286  [](const Path_t &l, const Path_t &r)->bool {
287  return l.node < r.node;
288  });
289 
290  if (pos != p1.end()
291  && (stop.node == pos->node)
292  && (stop.agg_cost < pos->agg_cost)) {
293  /* both share the same node &
294  * the second path has the smallest
295  * So erasing from the first path */
296  p1.erase(pos);
297  }
298  }
299  }
300  }
301  /* sort paths by start_id */
302  std::sort(paths.begin(), paths.end(),
303  [](const Path &e1, const Path &e2)->bool {
304  return e1.start_id() < e2.start_id();
305  });
306 
307  /* sort each path by agg_cost, node */
308  for (auto &path : paths) {
309  path.sort_by_node_agg_cost();
310  }
311 }
int64_t node
Definition: path_t.h:37
Definition: path_t.h:36
int64_t start_id() const
size_t size() const
std::deque< Path_t > path
std::ostream& operator<< ( std::ostream &  log,
const Path p 
)
friend

Definition at line 72 of file basePath_SSEC.cpp.

72  {
73  log << "Path: " << path.start_id() << " -> " << path.end_id() << "\n"
74  << "seq\tnode\tedge\tcost\tagg_cost\n";
75  int64_t i = 0;
76  for (const auto &e : path) {
77  log << i << "\t"
78  << e.node << "\t"
79  << e.edge << "\t"
80  << e.cost << "\t"
81  << e.agg_cost << "\n";
82  ++i;
83  }
84  return log;
85 }
std::deque< Path_t > path

Member Data Documentation

int64_t Path::m_end_id
private

Definition at line 54 of file basePath_SSEC.hpp.

Referenced by append(), clear(), end_id(), and reverse().

int64_t Path::m_start_id
private

Definition at line 53 of file basePath_SSEC.hpp.

Referenced by append(), clear(), reverse(), and start_id().

double Path::m_tot_cost
private

Definition at line 55 of file basePath_SSEC.hpp.

Referenced by appendPath(), clear(), push_back(), push_front(), and tot_cost().


The documentation for this class was generated from the following files: