PGROUTING  3.0
pgrouting::graph::Pgr_base_graph< G, T_V, T_E > Class Template Reference

#include "pgr_base_graph.hpp"

Inheritance diagram for pgrouting::graph::Pgr_base_graph< G, T_V, T_E >:
Collaboration diagram for pgrouting::graph::Pgr_base_graph< G, T_V, T_E >:

Public Types

Graph related types
Type boost meaning pgRouting meaning
G boost::adjacency_list Graph
V vertex_descriptor Think of it as local ID of a vertex
E edge_descriptor Think of it as local ID of an edge
V_i vertex_iterator To cycle the vertices of the Graph
E_i edge_iterator To cycle the edges of the Graph
EO_i out_edge_iterator To cycle the out going edges of a vertex
EI_i in_edge_iterator To cycle the in coming edges of a vertex (only in bidirectional graphs)
typedef G B_G
 
typedef T_E G_T_E
 
typedef T_V G_T_V
 
typedef boost::graph_traits< G >::vertex_descriptor V
 
typedef boost::graph_traits< G >::edge_descriptor E
 
typedef boost::graph_traits< G >::vertex_iterator V_i
 
typedef boost::graph_traits< G >::edge_iterator E_i
 
typedef boost::graph_traits< G >::out_edge_iterator EO_i
 
typedef boost::graph_traits< G >::in_edge_iterator EI_i
 
typedef boost::graph_traits< G >::vertices_size_type vertices_size_type
 
typedef boost::graph_traits< G >::edges_size_type edges_size_type
 
typedef boost::graph_traits< G >::degree_size_type degree_size_type
 
Id handling related types
Type Meaning pgRouting Meaning
id_to_V maps id -> V given an id store the V
LI Left Iterator iterates over id_to_V
typedef std::map< int64_t, Vid_to_V
 
typedef id_to_V::const_iterator LI
 

Public Member Functions

E get_edge (V from, V to, double &distance) const
 
int64_t get_edge_id (V from, V to, double &distance) const
 
void graph_add_edge (const T_E &edge)
 
template<typename T >
void graph_add_edge (const T &edge, bool normal=true)
 
template<typename T >
void graph_add_edge_no_create_vertex (const T &edge)
 Use this function when the vertices are already inserted in the graph. More...
 
template<typename T >
void graph_add_min_edge_no_parallel (const T &edge)
 
template<typename T >
void graph_add_neg_edge (const T &edge, bool normal=true)
 
size_t num_edges () const
 
size_t num_vertices () const
 
Insert edges
template<typename T >
void insert_edges (const T *edges, int64_t count)
 Inserts count edges of type T into the graph. More...
 
template<typename T >
void insert_edges_neg (const T *edges, int64_t count)
 
template<typename T >
void insert_edges (T *edges, int64_t count, bool)
 
template<typename T >
void insert_negative_edges (const T *edges, int64_t count)
 
template<typename T >
void insert_edges (const std::vector< T > &edges, bool normal=true)
 Inserts count edges of type pgr_edge_t into the graph The set of edges should not have an illegal vertex defined When the graph is empty calls: More...
 
template<typename T >
void insert_min_edges_no_parallel (const T *edges, int64_t count)
 
template<typename T >
void insert_min_edges_no_parallel (const std::vector< T > &edges)
 
template<typename T >
void insert_negative_edges (const std::vector< T > &edges, bool normal=true)
 
boost wrappers with original id
degree_size_type out_degree (int64_t vertex_id) const
 get the out-degree of a vertex More...
 
degree_size_type in_degree (int64_t vertex_id) const
 
V get_V (const T_V &vertex)
 get the vertex descriptor of the vertex When the vertex does not exist More...
 
V get_V (int64_t vid) const
 get the vertex descriptor of the vid Call has_vertex(vid) before calling this function More...
 
bool has_vertex (int64_t vid) const
 True when vid is in the graph. More...
 
to be or not to be
bool is_directed () const
 
bool is_undirected () const
 
bool is_source (V v_idx, E e_idx) const
 
bool is_target (V v_idx, E e_idx) const
 
boost wrappers with V
T_E & operator[] (E e_idx)
 
const T_E & operator[] (E e_idx) const
 
T_V & operator[] (V v_idx)
 
const T_V & operator[] (V v_idx) const
 
V source (E e_idx) const
 
V target (E e_idx) const
 
V adjacent (V v_idx, E e_idx) const
 
degree_size_type in_degree (V &v) const
 in degree of a vertex More...
 
degree_size_type out_degree (V &v) const
 out degree of a vertex More...
 
edge disconection/reconnection
void disconnect_edge (int64_t p_from, int64_t p_to)
 Disconnects all edges from p_from to p_to. More...
 
void disconnect_out_going_edge (int64_t vertex_id, int64_t edge_id)
 Disconnects the outgoing edges of a vertex. More...
 
void disconnect_vertex (int64_t p_vertex)
 Disconnects all incoming and outgoing edges from the vertex. More...
 
void disconnect_vertex (V vertex)
 
void restore_graph ()
 Reconnects all edges that were removed. More...
 

Public Attributes

Graph Modification
std::deque< T_E > removed_edges
 Used for storing the removed_edges. More...
 

Private Member Functions

void add_vertices (std::vector< T_V > vertices)
 adds the vertices into the graph More...
 

Friends

only for stand by program
std::ostream & operator<< (std::ostream &log, const Pgr_base_graph< G, T_V, T_E > &g)
 

The Graph

graph
 The graph. More...
 
graphType m_gType
 type (DIRECTED or UNDIRECTED) More...
 
 Pgr_base_graph (const std::vector< T_V > &vertices, graphType gtype)
 Constructor. More...
 
 Pgr_base_graph (graphType gtype)
 Prepares the graph to be of type gtype with 0 vertices. More...
 

Id mapping handling

typedef std::map< V, size_t > IndexMap
 
id_to_V vertices_map
 id -> graph id More...
 
boost::property_map< G, boost::vertex_index_t >::type vertIndex
 
IndexMap mapIndex
 
boost::associative_property_map< IndexMappropmapIndex
 

Detailed Description

template<typename G, typename T_V, typename T_E>
class pgrouting::graph::Pgr_base_graph< G, T_V, T_E >

Definition at line 168 of file pgr_base_graph.hpp.

Member Typedef Documentation

◆ B_G

template<typename G, typename T_V, typename T_E>
typedef G pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::B_G

Definition at line 226 of file pgr_base_graph.hpp.

◆ degree_size_type

template<typename G, typename T_V, typename T_E>
typedef boost::graph_traits< G >::degree_size_type pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::degree_size_type

Definition at line 241 of file pgr_base_graph.hpp.

◆ E

template<typename G, typename T_V, typename T_E>
typedef boost::graph_traits< G >::edge_descriptor pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::E

Definition at line 230 of file pgr_base_graph.hpp.

◆ E_i

template<typename G, typename T_V, typename T_E>
typedef boost::graph_traits< G >::edge_iterator pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::E_i

Definition at line 232 of file pgr_base_graph.hpp.

◆ edges_size_type

template<typename G, typename T_V, typename T_E>
typedef boost::graph_traits< G >::edges_size_type pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::edges_size_type

Definition at line 239 of file pgr_base_graph.hpp.

◆ EI_i

template<typename G, typename T_V, typename T_E>
typedef boost::graph_traits< G >::in_edge_iterator pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::EI_i

Definition at line 234 of file pgr_base_graph.hpp.

◆ EO_i

template<typename G, typename T_V, typename T_E>
typedef boost::graph_traits< G >::out_edge_iterator pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::EO_i

Definition at line 233 of file pgr_base_graph.hpp.

◆ G_T_E

template<typename G, typename T_V, typename T_E>
typedef T_E pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::G_T_E

Definition at line 227 of file pgr_base_graph.hpp.

◆ G_T_V

template<typename G, typename T_V, typename T_E>
typedef T_V pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::G_T_V

Definition at line 228 of file pgr_base_graph.hpp.

◆ id_to_V

template<typename G, typename T_V, typename T_E>
typedef std::map< int64_t, V > pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::id_to_V

Definition at line 253 of file pgr_base_graph.hpp.

◆ IndexMap

template<typename G, typename T_V, typename T_E>
typedef std::map<V, size_t> pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::IndexMap

Definition at line 271 of file pgr_base_graph.hpp.

◆ LI

template<typename G, typename T_V, typename T_E>
typedef id_to_V::const_iterator pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::LI

Definition at line 254 of file pgr_base_graph.hpp.

◆ V

template<typename G, typename T_V, typename T_E>
typedef boost::graph_traits< G >::vertex_descriptor pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::V

Definition at line 229 of file pgr_base_graph.hpp.

◆ V_i

template<typename G, typename T_V, typename T_E>
typedef boost::graph_traits< G >::vertex_iterator pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::V_i

Definition at line 231 of file pgr_base_graph.hpp.

◆ vertices_size_type

template<typename G, typename T_V, typename T_E>
typedef boost::graph_traits< G >::vertices_size_type pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::vertices_size_type

Definition at line 237 of file pgr_base_graph.hpp.

Constructor & Destructor Documentation

◆ Pgr_base_graph() [1/2]

template<typename G, typename T_V, typename T_E>
pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::Pgr_base_graph ( const std::vector< T_V > &  vertices,
graphType  gtype 
)
inline

Constructor.

  • Prepares the graph to be of type gtype
  • inserts the vertices
  • The vertices must be checked (if necessary) before calling the constructor

Definition at line 295 of file pgr_base_graph.hpp.

297  : graph(vertices.size()),
298 #if 0
299  m_num_vertices(vertices.size()),
300 #endif
301  m_gType(gtype),
302  vertIndex(boost::get(boost::vertex_index, graph)),
304  // add_vertices(vertices);
305  // This code does not work with contraction
306 #if 0
307  pgassert(pgrouting::check_vertices(vertices) == 0);
308 #endif
309  size_t i = 0;
310  for (auto vi = boost::vertices(graph).first;
311  vi != boost::vertices(graph).second; ++vi) {
312  vertices_map[vertices[i].id] = (*vi);
313  graph[(*vi)].cp_members(vertices[i]);
314  // put(propmapIndex, *vi, num_vertices());
315  pgassert(vertIndex[*vi] == i);
316  ++i;
317  }
318 
319  std::ostringstream log;
320  for (auto iter = vertices_map.begin();
321  iter != vertices_map.end();
322  iter++) {
323  log << "Key: "
324  << iter->first <<"\tValue:" << iter->second << "\n";
325  }
326  for (const auto vertex : vertices) {
327  pgassert(has_vertex(vertex.id));
328  }
329  // pgassert(mapIndex.size() == vertices.size());
330  }
boost::associative_property_map< IndexMap > propmapIndex
boost::property_map< G, boost::vertex_index_t >::type vertIndex
graphType m_gType
type (DIRECTED or UNDIRECTED)
bool has_vertex(int64_t vid) const
True when vid is in the graph.
#define pgassert(expr)
Uses the standard assert syntax.
Definition: pgr_assert.h:94
id_to_V vertices_map
id -> graph id
size_t check_vertices(std::vector< Basic_vertex > vertices)

◆ Pgr_base_graph() [2/2]

template<typename G, typename T_V, typename T_E>
pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::Pgr_base_graph ( graphType  gtype)
inlineexplicit

Prepares the graph to be of type gtype with 0 vertices.

Definition at line 335 of file pgr_base_graph.hpp.

336  : graph(0),
337 #if 0
338  m_num_vertices(0),
339 #endif
340  m_gType(gtype),
341  vertIndex(boost::get(boost::vertex_index, graph)),
343  }
boost::associative_property_map< IndexMap > propmapIndex
boost::property_map< G, boost::vertex_index_t >::type vertIndex
graphType m_gType
type (DIRECTED or UNDIRECTED)

Member Function Documentation

◆ add_vertices()

template<typename G, typename T_V, typename T_E>
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::add_vertices ( std::vector< T_V >  vertices)
inlineprivate

adds the vertices into the graph

PRECONDITIONS:

  • The graph has not being initialized before
  • There are no dupicated vertices
precondition(boost::num_vertices(graph) == 0);
for (vertex : vertices)
precondition(!has_vertex(vertex.id));

POSTCONDITIONS:

postcondition(boost::num_vertices(graph) == vertices.size());
for (vertex : vertices)
postcondition(has_vertex(vertex.id));

Example use:

pgrouting::DirectedGraph digraph(gType);
auto vertices(pgrouting::extract_vertices(data_edges, total_edges));
digraph.add_vertices(vertices);

Definition at line 462 of file pgr_base_graph.hpp.

463  {
464  pgassert(num_vertices() == 0);
465  for (const auto vertex : vertices) {
466  pgassert(!has_vertex(vertex.id));
467 
468  auto v = add_vertex(graph);
469  vertices_map[vertex.id] = v;
470  graph[v].cp_members(vertex);
471  // put(propmapIndex, v, num_vertices());
472 
473  pgassert(has_vertex(vertex.id));
474  }
475  // pgassert(mapIndex.size() == vertices.size());
476  pgassert(num_vertices() == vertices.size());
477  }
bool has_vertex(int64_t vid) const
True when vid is in the graph.
#define pgassert(expr)
Uses the standard assert syntax.
Definition: pgr_assert.h:94
id_to_V vertices_map
id -> graph id

◆ adjacent()

template<typename G, typename T_V, typename T_E>
V pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::adjacent ( V  v_idx,
E  e_idx 
) const
inline

Definition at line 560 of file pgr_base_graph.hpp.

Referenced by pgrouting::alphashape::Pgr_alphaShape::make_triangles().

560  {
561  pgassert(is_source(v_idx, e_idx) || is_target(v_idx, e_idx));
562  return is_source(v_idx, e_idx)?
563  target(e_idx) :
564  source(e_idx);
565  }
bool is_source(V v_idx, E e_idx) const
bool is_target(V v_idx, E e_idx) const
#define pgassert(expr)
Uses the standard assert syntax.
Definition: pgr_assert.h:94

◆ disconnect_edge()

template<class G , typename T_V , typename T_E >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::disconnect_edge ( int64_t  p_from,
int64_t  p_to 
)

Disconnects all edges from p_from to p_to.

  • No edge is disconnected if the vertices id's do not exist in the graph
  • All removed edges are stored for future reinsertion
  • All parallel edges are disconnected (automatically by boost)
    disconnectEdgeUndirected.png
    disconnect_edge(2,3) on an UNDIRECTED graph
    disconnectEdgeDirected.png
    disconnect_edge(2,3) on a DIRECTED graph
    Parameters
    [in]p_fromoriginal vertex id of the starting point of the edge
    [in]p_tooriginal vertex id of the ending point of the edge

Definition at line 763 of file pgr_base_graph.hpp.

763  {
764  T_E d_edge;
765 
766  // nothing to do, the vertex doesn't exist
767  if (!has_vertex(p_from) || !has_vertex(p_to)) return;
768 
769  EO_i out, out_end;
770  V g_from(get_V(p_from));
771  V g_to(get_V(p_to));
772 
773  // store the edges that are going to be removed
774  for (boost::tie(out, out_end) = out_edges(g_from, graph);
775  out != out_end; ++out) {
776  if (target(*out) == g_to) {
777  d_edge.id = graph[*out].id;
778  d_edge.source = graph[source(*out)].id;
779  d_edge.target = graph[target(*out)].id;
780  d_edge.cost = graph[*out].cost;
781  removed_edges.push_back(d_edge);
782  }
783  }
784  // the actual removal
785  boost::remove_edge(g_from, g_to, graph);
786 }
boost::graph_traits< G >::out_edge_iterator EO_i
std::deque< T_E > removed_edges
Used for storing the removed_edges.
V get_V(const T_V &vertex)
get the vertex descriptor of the vertex When the vertex does not exist
bool has_vertex(int64_t vid) const
True when vid is in the graph.
boost::graph_traits< G >::vertex_descriptor V

◆ disconnect_out_going_edge()

template<class G , typename T_V , typename T_E >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::disconnect_out_going_edge ( int64_t  vertex_id,
int64_t  edge_id 
)

Disconnects the outgoing edges of a vertex.

  • No edge is disconnected if it doesn't exist in the graph
  • Removed edges are stored for future reinsertion
  • all outgoing edges with the edge_id are removed if they exist
    Parameters
    [in]vertex_idoriginal vertex
    [in]edge_idoriginal edge_id

Definition at line 792 of file pgr_base_graph.hpp.

793  {
794  T_E d_edge;
795 
796  // nothing to do, the vertex doesn't exist
797  if (!has_vertex(vertex_id)) return;
798  auto v_from(get_V(vertex_id));
799 
800  EO_i out, out_end;
801  bool change = true;
802  // store the edge that are going to be removed
803  while (change) {
804  change = false;
805  for (boost::tie(out, out_end) = out_edges(v_from, graph);
806  out != out_end; ++out) {
807  if (graph[*out].id == edge_id) {
808  d_edge.id = graph[*out].id;
809  d_edge.source = graph[source(*out)].id;
810  d_edge.target = graph[target(*out)].id;
811  d_edge.cost = graph[*out].cost;
812  removed_edges.push_back(d_edge);
813  boost::remove_edge((*out), graph);
814  change = true;
815  break;
816  }
817  }
818  }
819 }
boost::graph_traits< G >::out_edge_iterator EO_i
std::deque< T_E > removed_edges
Used for storing the removed_edges.
V get_V(const T_V &vertex)
get the vertex descriptor of the vertex When the vertex does not exist
bool has_vertex(int64_t vid) const
True when vid is in the graph.

◆ disconnect_vertex() [1/2]

template<class G , typename T_V , typename T_E >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::disconnect_vertex ( int64_t  p_vertex)

Disconnects all incoming and outgoing edges from the vertex.

boost::graph doesn't recommend th to insert/remove vertices, so a vertex removal is simulated by disconnecting the vertex from the graph

  • No edge is disconnected if the vertices id's do not exist in the graph
  • All removed edges are stored for future reinsertion
  • All parallel edges are disconnected (automatically by boost)
    disconnectVertexUndirected.png
    disconnect_vertex(2) on an UNDIRECTED graph
    disconnectVertexDirected.png
    disconnect_vertex(2) on a DIRECTED graph
    Parameters
    [in]p_vertexoriginal vertex id of the starting point of the edge

Definition at line 824 of file pgr_base_graph.hpp.

824  {
825  if (!has_vertex(vertex)) return;
826  disconnect_vertex(get_V(vertex));
827 }
void disconnect_vertex(int64_t p_vertex)
Disconnects all incoming and outgoing edges from the vertex.
V get_V(const T_V &vertex)
get the vertex descriptor of the vertex When the vertex does not exist
bool has_vertex(int64_t vid) const
True when vid is in the graph.

◆ disconnect_vertex() [2/2]

template<class G , typename T_V , typename T_E >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::disconnect_vertex ( V  vertex)

Definition at line 831 of file pgr_base_graph.hpp.

831  {
832  T_E d_edge;
833 
834  EO_i out, out_end;
835  // store the edges that are going to be removed
836  for (boost::tie(out, out_end) = out_edges(vertex, graph);
837  out != out_end; ++out) {
838  d_edge.id = graph[*out].id;
839  d_edge.source = graph[source(*out)].id;
840  d_edge.target = graph[target(*out)].id;
841  d_edge.cost = graph[*out].cost;
842  removed_edges.push_back(d_edge);
843  }
844 
845  // special case
846  if (m_gType == DIRECTED) {
847  EI_i in, in_end;
848  for (boost::tie(in, in_end) = in_edges(vertex, graph);
849  in != in_end; ++in) {
850  d_edge.id = graph[*in].id;
851  d_edge.source = graph[source(*in)].id;
852  d_edge.target = graph[target(*in)].id;
853  d_edge.cost = graph[*in].cost;
854  removed_edges.push_back(d_edge);
855  }
856  }
857 
858  // delete incoming and outgoing edges from the vertex
859  boost::clear_vertex(vertex, graph);
860 }
boost::graph_traits< G >::out_edge_iterator EO_i
std::deque< T_E > removed_edges
Used for storing the removed_edges.
graphType m_gType
type (DIRECTED or UNDIRECTED)
boost::graph_traits< G >::in_edge_iterator EI_i

◆ get_edge()

template<typename G, typename T_V, typename T_E>
E pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::get_edge ( V  from,
V  to,
double &  distance 
) const
inline

Definition at line 669 of file pgr_base_graph.hpp.

672  {
673  E e;
674  EO_i out_i, out_end;
675  V v_source, v_target;
676  double minCost = (std::numeric_limits<double>::max)();
677  E minEdge;
678  bool valid = false;
679  for (boost::tie(out_i, out_end) = boost::out_edges(from, graph);
680  out_i != out_end; ++out_i) {
681  e = *out_i;
682  if (!valid) {
683  minEdge = e;
684  valid = true;
685  }
686  v_target = target(e);
687  v_source = source(e);
688  if ((from == v_source) && (to == v_target)
689  && (distance == graph[e].cost)) {
690  return e;
691  }
692  if ((from == v_source) && (to == v_target)
693  && (minCost > graph[e].cost)) {
694  minCost = graph[e].cost;
695  minEdge = e;
696  }
697  }
698  return minEdge;
699  }
boost::graph_traits< G >::out_edge_iterator EO_i
boost::graph_traits< G >::vertex_descriptor V
boost::graph_traits< G >::edge_descriptor E

◆ get_edge_id()

template<class G , typename T_V , typename T_E >
int64_t pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::get_edge_id ( V  from,
V  to,
double &  distance 
) const

Definition at line 876 of file pgr_base_graph.hpp.

879  {
880  E e;
881  EO_i out_i, out_end;
882  V v_source, v_target;
883  double minCost = (std::numeric_limits<double>::max)();
884  int64_t minEdge = -1;
885  for (boost::tie(out_i, out_end) = boost::out_edges(from, graph);
886  out_i != out_end; ++out_i) {
887  e = *out_i;
888  v_target = target(e);
889  v_source = source(e);
890  if ((from == v_source) && (to == v_target)
891  && (distance == graph[e].cost))
892  return graph[e].id;
893  if ((from == v_source) && (to == v_target)
894  && (minCost > graph[e].cost)) {
895  minCost = graph[e].cost;
896  minEdge = graph[e].id;
897  }
898  }
899  distance = minEdge == -1? 0: minCost;
900  return minEdge;
901 }
boost::graph_traits< G >::out_edge_iterator EO_i
boost::graph_traits< G >::vertex_descriptor V
boost::graph_traits< G >::edge_descriptor E

◆ get_V() [1/2]

template<typename G, typename T_V, typename T_E>
V pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::get_V ( const T_V &  vertex)
inline

get the vertex descriptor of the vertex When the vertex does not exist

  • creates a new vetex
    Returns
    V: The vertex descriptor of the vertex

Definition at line 510 of file pgr_base_graph.hpp.

Referenced by pgrouting::graph::Pgr_lineGraph< G, T_V, T_E >::graph_add_edge(), and pgrouting::graph::Pgr_lineGraphFull< G, T_V, T_E >::graph_add_edge().

510  {
511  auto vm_s(vertices_map.find(vertex.id));
512  if (vm_s == vertices_map.end()) {
513  auto v = add_vertex(graph);
514  graph[v].cp_members(vertex);
515  vertices_map[vertex.id] = v;
516  put(propmapIndex, v, num_vertices());
517  return v;
518  }
519  return vm_s->second;
520  }
boost::associative_property_map< IndexMap > propmapIndex
id_to_V vertices_map
id -> graph id

◆ get_V() [2/2]

template<typename G, typename T_V, typename T_E>
V pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::get_V ( int64_t  vid) const
inline

get the vertex descriptor of the vid Call has_vertex(vid) before calling this function

Returns
V: The vertex descriptor of the vertex

Definition at line 526 of file pgr_base_graph.hpp.

526  {
527  pgassert(has_vertex(vid));
528  return vertices_map.find(vid)->second;
529  }
bool has_vertex(int64_t vid) const
True when vid is in the graph.
#define pgassert(expr)
Uses the standard assert syntax.
Definition: pgr_assert.h:94
id_to_V vertices_map
id -> graph id

◆ graph_add_edge() [1/2]

template<class G , typename T_V , typename T_E>
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::graph_add_edge ( const T_E &  edge)

Definition at line 906 of file pgr_base_graph.hpp.

906  {
907  typename Pgr_base_graph< G, T_V, T_E >::LI vm_s, vm_t;
909 
910  vm_s = vertices_map.find(edge.source);
911  if (vm_s == vertices_map.end()) {
913  vm_s = vertices_map.find(edge.source);
914  }
915 
916  vm_t = vertices_map.find(edge.target);
917  if (vm_t == vertices_map.end()) {
919  vm_t = vertices_map.find(edge.target);
920  }
921 
922  if (edge.cost >= 0) {
923  bool inserted;
924  boost::tie(e, inserted) =
925  boost::add_edge(vm_s->second, vm_t->second, graph);
926  graph[e].cp_members(edge);
927  }
928 }
float8 cost
Definition: trsp.h:45
int64 target
Definition: trsp.h:44
Definition: trsp.h:41
int64 source
Definition: trsp.h:43
id_to_V vertices_map
id -> graph id
boost::graph_traits< G >::edge_descriptor E

◆ graph_add_edge() [2/2]

template<class G , typename T_V , typename T_E >
template<typename T >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::graph_add_edge ( const T &  edge,
bool  normal = true 
)

Definition at line 934 of file pgr_base_graph.hpp.

934  {
935  bool inserted;
937  if ((edge.cost < 0) && (edge.reverse_cost < 0))
938  return;
939 
940  /*
941  * true: for source
942  * false: for target
943  */
944  auto vm_s = get_V(T_V(edge, true));
945  auto vm_t = get_V(T_V(edge, false));
946 
947  pgassert(vertices_map.find(edge.source) != vertices_map.end());
948  pgassert(vertices_map.find(edge.target) != vertices_map.end());
949  if (edge.cost >= 0) {
950  boost::tie(e, inserted) =
951  boost::add_edge(vm_s, vm_t, graph);
952  graph[e].cost = edge.cost;
953  graph[e].id = edge.id;
954  }
955 
956  if (edge.reverse_cost >= 0
957  && (m_gType == DIRECTED
958  || (m_gType == UNDIRECTED && edge.cost != edge.reverse_cost))) {
959  boost::tie(e, inserted) =
960  boost::add_edge(vm_t, vm_s, graph);
961 
962  graph[e].cost = edge.reverse_cost;
963  graph[e].id = normal? edge.id : -edge.id;
964  }
965 }
float8 cost
Definition: trsp.h:45
int64 target
Definition: trsp.h:44
Definition: trsp.h:41
V get_V(const T_V &vertex)
get the vertex descriptor of the vertex When the vertex does not exist
graphType m_gType
type (DIRECTED or UNDIRECTED)
int64 source
Definition: trsp.h:43
#define pgassert(expr)
Uses the standard assert syntax.
Definition: pgr_assert.h:94
id_to_V vertices_map
id -> graph id
int64 id
Definition: trsp.h:42
float8 reverse_cost
Definition: trsp.h:46
boost::graph_traits< G >::edge_descriptor E

◆ graph_add_edge_no_create_vertex()

template<typename G, typename T_V, typename T_E>
template<typename T >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::graph_add_edge_no_create_vertex ( const T &  edge)
inline

Use this function when the vertices are already inserted in the graph.

Definition at line 719 of file pgr_base_graph.hpp.

719  {
720  bool inserted;
721  E e;
722  if ((edge.cost < 0) && (edge.reverse_cost < 0))
723  return;
724 
725 #if 0
726  std::ostringstream log;
727  for (auto iter = vertices_map.begin();
728  iter != vertices_map.end();
729  iter++) {
730  log << "Key: " << iter->first <<"\tValue:" << iter->second << "\n";
731  }
732  pgassertwm(has_vertex(edge.source), log.str().c_str());
734 #endif
735 
736  auto vm_s = get_V(edge.source);
737  auto vm_t = get_V(edge.target);
738 
739 
740  if (edge.cost >= 0) {
741  boost::tie(e, inserted) =
742  boost::add_edge(vm_s, vm_t, graph);
743  graph[e].cost = edge.cost;
744  graph[e].id = edge.id;
745  }
746 
747 
748  if (edge.reverse_cost >= 0 && (is_directed()
749  || (is_undirected() && edge.cost != edge.reverse_cost))) {
750  boost::tie(e, inserted) =
751  boost::add_edge(vm_t, vm_s, graph);
752  graph[e].cost = edge.reverse_cost;
753  graph[e].id = edge.id;
754  }
755  }
float8 cost
Definition: trsp.h:45
int64 target
Definition: trsp.h:44
Definition: trsp.h:41
#define pgassertwm(expr, msg)
Adds a message to the assertion.
Definition: pgr_assert.h:117
V get_V(const T_V &vertex)
get the vertex descriptor of the vertex When the vertex does not exist
bool has_vertex(int64_t vid) const
True when vid is in the graph.
int64 source
Definition: trsp.h:43
#define pgassert(expr)
Uses the standard assert syntax.
Definition: pgr_assert.h:94
id_to_V vertices_map
id -> graph id
int64 id
Definition: trsp.h:42
float8 reverse_cost
Definition: trsp.h:46
boost::graph_traits< G >::edge_descriptor E

◆ graph_add_min_edge_no_parallel()

template<class G , typename T_V , typename T_E >
template<typename T >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::graph_add_min_edge_no_parallel ( const T &  edge)

Definition at line 970 of file pgr_base_graph.hpp.

970  {
971  bool inserted;
973  if ((edge.cost < 0) && (edge.reverse_cost < 0))
974  return;
975 
976  /*
977  * true: for source
978  * false: for target
979  */
980  auto vm_s = get_V(T_V(edge, true));
981  auto vm_t = get_V(T_V(edge, false));
982 
983  pgassert(vertices_map.find(edge.source) != vertices_map.end());
984  pgassert(vertices_map.find(edge.target) != vertices_map.end());
985  if (edge.cost >= 0) {
986  E e1;
987  bool found;
988  boost::tie(e1, found) = edge(vm_s, vm_t, graph);
989  if (found) {
990  if (edge.cost < graph[e1].cost) {
991  graph[e1].cost = edge.cost;
992  graph[e1].id = edge.id;
993  }
994  } else {
995  boost::tie(e, inserted) =
996  boost::add_edge(vm_s, vm_t, graph);
997  graph[e].cost = edge.cost;
998  graph[e].id = edge.id;
999  }
1000  }
1001 
1002  if (edge.reverse_cost >= 0
1003  && (m_gType == DIRECTED
1004  || (m_gType == UNDIRECTED && edge.cost != edge.reverse_cost))) {
1005  E e1;
1006  bool found;
1007  boost::tie(e1, found) = edge(vm_t, vm_s, graph);
1008  if (found) {
1009  if (edge.reverse_cost < graph[e1].cost) {
1010  graph[e1].cost = edge.reverse_cost;
1011  graph[e1].id = edge.id;
1012  }
1013  } else {
1014  boost::tie(e, inserted) =
1015  boost::add_edge(vm_t, vm_s, graph);
1016 
1017  graph[e].cost = edge.reverse_cost;
1018  graph[e].id = edge.id;
1019  }
1020  }
1021 }
float8 cost
Definition: trsp.h:45
int64 target
Definition: trsp.h:44
Definition: trsp.h:41
V get_V(const T_V &vertex)
get the vertex descriptor of the vertex When the vertex does not exist
graphType m_gType
type (DIRECTED or UNDIRECTED)
int64 source
Definition: trsp.h:43
#define pgassert(expr)
Uses the standard assert syntax.
Definition: pgr_assert.h:94
id_to_V vertices_map
id -> graph id
int64 id
Definition: trsp.h:42
float8 reverse_cost
Definition: trsp.h:46
boost::graph_traits< G >::edge_descriptor E

◆ graph_add_neg_edge()

template<class G , typename T_V , typename T_E >
template<typename T >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::graph_add_neg_edge ( const T &  edge,
bool  normal = true 
)

Definition at line 1033 of file pgr_base_graph.hpp.

1033  {
1034  bool inserted;
1036 
1037  auto vm_s = get_V(T_V(edge, true));
1038  auto vm_t = get_V(T_V(edge, false));
1039 
1040  pgassert(vertices_map.find(edge.source) != vertices_map.end());
1041  pgassert(vertices_map.find(edge.target) != vertices_map.end());
1042 
1043  boost::tie(e, inserted) =
1044  boost::add_edge(vm_s, vm_t, graph);
1045  if (edge.cost < 0) {
1046  // reading negative edges as positive
1047  graph[e].cost = (-0.5)*edge.cost;
1048  } else {
1049  graph[e].cost = edge.cost;
1050  }
1051  graph[e].id = edge.id;
1052 
1053  if (m_gType == DIRECTED
1054  || (m_gType == UNDIRECTED && edge.cost > edge.reverse_cost)) {
1055  boost::tie(e, inserted) =
1056  boost::add_edge(vm_t, vm_s, graph);
1057  if (edge.reverse_cost < 0) {
1058  // reading negative edges as positive
1059  graph[e].cost = (-0.5)*edge.reverse_cost;
1060  } else {
1061  graph[e].cost = edge.reverse_cost;
1062  }
1063 
1064  graph[e].id = normal? edge.id : -edge.id;
1065  }
1066 }
float8 cost
Definition: trsp.h:45
int64 target
Definition: trsp.h:44
Definition: trsp.h:41
V get_V(const T_V &vertex)
get the vertex descriptor of the vertex When the vertex does not exist
graphType m_gType
type (DIRECTED or UNDIRECTED)
int64 source
Definition: trsp.h:43
#define pgassert(expr)
Uses the standard assert syntax.
Definition: pgr_assert.h:94
id_to_V vertices_map
id -> graph id
int64 id
Definition: trsp.h:42
float8 reverse_cost
Definition: trsp.h:46
boost::graph_traits< G >::edge_descriptor E

◆ has_vertex()

template<typename G, typename T_V, typename T_E>
bool pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::has_vertex ( int64_t  vid) const
inline

True when vid is in the graph.

Definition at line 532 of file pgr_base_graph.hpp.

532  {
533  return vertices_map.find(vid) != vertices_map.end();
534  }
id_to_V vertices_map
id -> graph id

◆ in_degree() [1/2]

template<typename G, typename T_V, typename T_E>
degree_size_type pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::in_degree ( int64_t  vertex_id) const
inline

Definition at line 495 of file pgr_base_graph.hpp.

495  {
496  if (!has_vertex(vertex_id)) {
497  return 0;
498  }
499  return is_directed()?
500  in_degree(get_V(vertex_id))
501  : out_degree(get_V(vertex_id));
502  }
V get_V(const T_V &vertex)
get the vertex descriptor of the vertex When the vertex does not exist
bool has_vertex(int64_t vid) const
True when vid is in the graph.
degree_size_type out_degree(int64_t vertex_id) const
get the out-degree of a vertex
degree_size_type in_degree(int64_t vertex_id) const

◆ in_degree() [2/2]

template<typename G, typename T_V, typename T_E>
degree_size_type pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::in_degree ( V v) const
inline

in degree of a vertex

  • when its undirected there is no "concept" of in degree
    • out degree is returned
  • on directed in degree of vertex is returned

Definition at line 574 of file pgr_base_graph.hpp.

574  {
575  return is_directed()?
576  boost::in_degree(v, graph) :
577  boost::out_degree(v, graph);
578  }
degree_size_type out_degree(int64_t vertex_id) const
get the out-degree of a vertex

◆ insert_edges() [1/3]

template<typename G, typename T_V, typename T_E>
template<typename T >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::insert_edges ( const T *  edges,
int64_t  count 
)
inline

◆ insert_edges() [2/3]

template<typename G, typename T_V, typename T_E>
template<typename T >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::insert_edges ( T *  edges,
int64_t  count,
bool   
)
inline

Definition at line 367 of file pgr_base_graph.hpp.

367  {
368  for (int64_t i = 0; i < count; ++i) {
369  pgassert(has_vertex(edges[i].source));
370  pgassert(has_vertex(edges[i].target));
372  }
373  }
void graph_add_edge_no_create_vertex(const T &edge)
Use this function when the vertices are already inserted in the graph.
bool has_vertex(int64_t vid) const
True when vid is in the graph.
#define pgassert(expr)
Uses the standard assert syntax.
Definition: pgr_assert.h:94

◆ insert_edges() [3/3]

template<typename G, typename T_V, typename T_E>
template<typename T >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::insert_edges ( const std::vector< T > &  edges,
bool  normal = true 
)
inline

Inserts count edges of type pgr_edge_t into the graph The set of edges should not have an illegal vertex defined When the graph is empty calls:

  • extract_vertices and throws an exception if there are illegal vertices. When developing:
    • if an illegal vertex is found an exception is thrown
    • That means that the set of vertices should be checked in the code that is being developed No edge is inserted when there is an error on the vertices
      Parameters
      edges
      normal

Definition at line 395 of file pgr_base_graph.hpp.

395  {
396 #if 0
397  // This code does not work with contraction
398  if (num_vertices() == 0) {
399  auto vertices = pgrouting::extract_vertices(edges);
400  pgassert(pgrouting::check_vertices(vertices) == 0);
401  add_vertices(vertices);
402  }
403 #endif
404  for (const auto edge : edges) {
405  graph_add_edge(edge, normal);
406  }
407  }
Definition: trsp.h:41
void graph_add_edge(const T_E &edge)
#define pgassert(expr)
Uses the standard assert syntax.
Definition: pgr_assert.h:94
std::vector< Basic_vertex > extract_vertices(std::vector< Basic_vertex > vertices, const std::vector< pgr_edge_t > data_edges)
void add_vertices(std::vector< T_V > vertices)
adds the vertices into the graph
size_t check_vertices(std::vector< Basic_vertex > vertices)

◆ insert_edges_neg()

template<typename G, typename T_V, typename T_E>
template<typename T >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::insert_edges_neg ( const T *  edges,
int64_t  count 
)
inline

Definition at line 362 of file pgr_base_graph.hpp.

Referenced by do_pgr_lineGraph(), and do_pgr_lineGraphFull().

362  {
363  insert_edges(std::vector < T >(edges, edges + count), false);
364  }
void insert_edges(const T *edges, int64_t count)
Inserts count edges of type T into the graph.

◆ insert_min_edges_no_parallel() [1/2]

template<typename G, typename T_V, typename T_E>
template<typename T >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::insert_min_edges_no_parallel ( const T *  edges,
int64_t  count 
)
inline

Definition at line 410 of file pgr_base_graph.hpp.

Referenced by do_pgr_prim().

410  {
411  insert_edges(std::vector<T>(edges, edges + count));
412  }
void insert_edges(const T *edges, int64_t count)
Inserts count edges of type T into the graph.

◆ insert_min_edges_no_parallel() [2/2]

template<typename G, typename T_V, typename T_E>
template<typename T >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::insert_min_edges_no_parallel ( const std::vector< T > &  edges)
inline

Definition at line 416 of file pgr_base_graph.hpp.

416  {
417  for (const auto edge : edges) {
419  }
420  }
void graph_add_min_edge_no_parallel(const T &edge)
Definition: trsp.h:41

◆ insert_negative_edges() [1/2]

template<typename G, typename T_V, typename T_E>
template<typename T >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::insert_negative_edges ( const T *  edges,
int64_t  count 
)
inline

Definition at line 376 of file pgr_base_graph.hpp.

Referenced by do_pgr_bellman_ford_neg().

376  {
377  insert_negative_edges(std::vector < T >(edges, edges + count));
378  }
void insert_negative_edges(const T *edges, int64_t count)

◆ insert_negative_edges() [2/2]

template<typename G, typename T_V, typename T_E>
template<typename T >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::insert_negative_edges ( const std::vector< T > &  edges,
bool  normal = true 
)
inline

Definition at line 423 of file pgr_base_graph.hpp.

425  {
426  for (const auto edge : edges) {
427  graph_add_neg_edge(edge, normal);
428  }
429  }
Definition: trsp.h:41
void graph_add_neg_edge(const T &edge, bool normal=true)

◆ is_directed()

template<typename G, typename T_V, typename T_E>
bool pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::is_directed ( ) const
inline

Definition at line 541 of file pgr_base_graph.hpp.

541 {return m_gType == DIRECTED;}
graphType m_gType
type (DIRECTED or UNDIRECTED)

◆ is_source()

template<typename G, typename T_V, typename T_E>
bool pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::is_source ( V  v_idx,
E  e_idx 
) const
inline

Definition at line 543 of file pgr_base_graph.hpp.

543 {return v_idx == source(e_idx);}

◆ is_target()

template<typename G, typename T_V, typename T_E>
bool pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::is_target ( V  v_idx,
E  e_idx 
) const
inline

Definition at line 544 of file pgr_base_graph.hpp.

544 {return v_idx == target(e_idx);}

◆ is_undirected()

template<typename G, typename T_V, typename T_E>
bool pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::is_undirected ( ) const
inline

Definition at line 542 of file pgr_base_graph.hpp.

542 {return m_gType == UNDIRECTED;}
graphType m_gType
type (DIRECTED or UNDIRECTED)

◆ num_edges()

template<typename G, typename T_V, typename T_E>
size_t pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::num_edges ( ) const
inline

Definition at line 702 of file pgr_base_graph.hpp.

Referenced by pgrouting::graph::Pgr_lineGraph< G, T_V, T_E >::graph_add_edge().

702 { return boost::num_edges(graph);}

◆ num_vertices()

template<typename G, typename T_V, typename T_E>
size_t pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::num_vertices ( ) const
inline

◆ operator[]() [1/4]

template<typename G, typename T_V, typename T_E>
T_E& pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::operator[] ( E  e_idx)
inline

Definition at line 552 of file pgr_base_graph.hpp.

552 {return graph[e_idx];}

◆ operator[]() [2/4]

template<typename G, typename T_V, typename T_E>
const T_E& pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::operator[] ( E  e_idx) const
inline

Definition at line 553 of file pgr_base_graph.hpp.

553 {return graph[e_idx];}

◆ operator[]() [3/4]

template<typename G, typename T_V, typename T_E>
T_V& pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::operator[] ( V  v_idx)
inline

Definition at line 555 of file pgr_base_graph.hpp.

555 {return graph[v_idx];}

◆ operator[]() [4/4]

template<typename G, typename T_V, typename T_E>
const T_V& pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::operator[] ( V  v_idx) const
inline

Definition at line 556 of file pgr_base_graph.hpp.

556 {return graph[v_idx];}

◆ out_degree() [1/2]

template<typename G, typename T_V, typename T_E>
degree_size_type pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::out_degree ( int64_t  vertex_id) const
inline

get the out-degree of a vertex

Returns
0: The out degree of a vertex that its not in the graph
Parameters
[in]vertex_idoriginal vertex id

Definition at line 489 of file pgr_base_graph.hpp.

Referenced by pgrouting::algorithms::bridges().

489  {
490  if (!has_vertex(vertex_id)) {
491  return 0;
492  }
493  return out_degree(get_V(vertex_id));
494  }
V get_V(const T_V &vertex)
get the vertex descriptor of the vertex When the vertex does not exist
bool has_vertex(int64_t vid) const
True when vid is in the graph.
degree_size_type out_degree(int64_t vertex_id) const
get the out-degree of a vertex

◆ out_degree() [2/2]

template<typename G, typename T_V, typename T_E>
degree_size_type pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::out_degree ( V v) const
inline

out degree of a vertex

regardles of undirected or directed graph

  • out degree is returned

Definition at line 585 of file pgr_base_graph.hpp.

585  {
586  return boost::out_degree(v, graph);
587  }

◆ restore_graph()

template<class G , typename T_V , typename T_E >
void pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::restore_graph ( )

Reconnects all edges that were removed.

Definition at line 864 of file pgr_base_graph.hpp.

864  {
865  while (removed_edges.size() != 0) {
867  removed_edges.pop_front();
868  }
869 }
std::deque< T_E > removed_edges
Used for storing the removed_edges.
void graph_add_edge(const T_E &edge)

◆ source()

◆ target()

Friends And Related Function Documentation

◆ operator<<

template<typename G, typename T_V, typename T_E>
std::ostream& operator<< ( std::ostream &  log,
const Pgr_base_graph< G, T_V, T_E > &  g 
)
friend

Definition at line 643 of file pgr_base_graph.hpp.

644  {
645  typename Pgr_base_graph< G, T_V, T_E >::EO_i out, out_end;
646 
647  for (auto vi = vertices(g.graph).first;
648  vi != vertices(g.graph).second; ++vi) {
649  if ((*vi) >= g.num_vertices()) break;
650  log << (*vi) << ": " << " out_edges_of(" << g.graph[(*vi)] << "):";
651  for (boost::tie(out, out_end) = out_edges(*vi, g.graph);
652  out != out_end; ++out) {
653  log << ' '
654  << g.graph[*out].id << "=("
655  << g[g.source(*out)].id << ", "
656  << g[g.target(*out)].id << ") = "
657  << g.graph[*out].cost <<"\t";
658  }
659  log << std::endl;
660  }
661  return log;
662  }
boost::graph_traits< G >::out_edge_iterator EO_i

Member Data Documentation

◆ graph

◆ m_gType

template<typename G, typename T_V, typename T_E>
graphType pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::m_gType

type (DIRECTED or UNDIRECTED)

Definition at line 261 of file pgr_base_graph.hpp.

◆ mapIndex

template<typename G, typename T_V, typename T_E>
IndexMap pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::mapIndex

Definition at line 272 of file pgr_base_graph.hpp.

◆ propmapIndex

template<typename G, typename T_V, typename T_E>
boost::associative_property_map<IndexMap> pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::propmapIndex

Definition at line 273 of file pgr_base_graph.hpp.

◆ removed_edges

template<typename G, typename T_V, typename T_E>
std::deque< T_E > pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::removed_edges

Used for storing the removed_edges.

Definition at line 281 of file pgr_base_graph.hpp.

◆ vertices_map

◆ vertIndex

template<typename G, typename T_V, typename T_E>
boost::property_map<G, boost::vertex_index_t>::type pgrouting::graph::Pgr_base_graph< G, T_V, T_E >::vertIndex

Definition at line 269 of file pgr_base_graph.hpp.


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