#include "pgr_trspHandler.h"

Collaboration diagram for pgrouting::trsp::Pgr_trspHandler:

[legend]

Classes
class	CostHolder

class	Predecessor

Public Member Functions
	Pgr_trspHandler (pgr_edge_t *edges, const size_t edge_count, const bool directed, const std::vector< Rule > &ruleList)

	Pgr_trspHandler (void)=delete

	~Pgr_trspHandler (void)=default

void	clear ()

Path	process (const int64_t start_vertex, const int64_t end_vertex)
	process More...

std::deque< Path >	process (const std::vector< int64_t > sources, const std::vector< int64_t > targets)
	process More...

Private Types
typedef std::pair< double, std::pair< int64_t, bool > >	PDP
	Used in the priority queue. More...

enum	Position { ILLEGAL = -1, RC_EDGE = 0, C_EDGE = 1 }
	predecesor edge More...

Private Member Functions
void	add_to_que (double cost, size_t e_idx, bool isStart)

bool	addEdge (const pgr_edge_t edgeIn)

void	connectEndEdge (size_t firstEdge_idx, size_t secondEdge_idx)

void	connectStartEdge (size_t firstEdge_idx, size_t secondEdge_idx)

void	construct_graph (pgr_edge_t *edges, const size_t edge_count, const bool directed)

double	construct_path (int64_t ed_id, Position pos)

EdgeInfo	dijkstra_exploration ()

void	explore (int64_t cur_node, const EdgeInfo cur_edge, bool isStart)

double	get_tot_cost (double cost, size_t edge_idx, bool isStart)

double	getRestrictionCost (int64_t cur_node, const EdgeInfo &new_edge, bool isStart)

void	initialize_que ()

int	initialize_restrictions (const std::vector< Rule > &ruleList)

Path	process_trsp (size_t edge_count)

int64_t	renumber_edges (pgr_edge_t *edges, const size_t edge_count) const

Private Attributes
int64_t	current_node

std::map< int64_t, std::vector< size_t > >	m_adjacency
	m_adjacency[vertex] = {edges} More...

std::vector< CostHolder >	m_dCost

std::vector< EdgeInfo >	m_edges

int64_t	m_end_vertex

std::map< int64_t, int64_t >	m_mapEdgeId2Index
	Used only to veryfy that there are no reppetitions inserted the way it orks, repeating edges id is not allowed. More...

int64_t	m_min_id

std::vector< Predecessor >	m_parent

Path	m_path

std::map< int64_t, std::vector< Rule > >	m_ruleTable

int64_t	m_start_vertex

std::priority_queue< PDP, std::vector< PDP >, std::greater< PDP > >	que

Detailed Description

Definition at line 52 of file pgr_trspHandler.h.

Member Typedef Documentation

◆ PDP

typedef std::pair<double, std::pair<int64_t, bool> > pgrouting::trsp::Pgr_trspHandler::PDP

private

Used in the priority queue.

Definition at line 56 of file pgr_trspHandler.h.

Member Enumeration Documentation

◆ Position

enum pgrouting::trsp::Pgr_trspHandler::Position

private

predecesor edge

because each row represents 2 edges, this enumeration is needed for the predecessors

C_EDGE: If the predecessor comes from the "cost" edge
RC_EDGE: If the predecessor comes from the "reverse_cost" edge
ILLEGAL: Its not a predecessor of anything

The "legal" values are indices to vectors

Enumerator
ILLEGAL
RC_EDGE
C_EDGE

Definition at line 68 of file pgr_trspHandler.h.

68 {ILLEGAL = -1, RC_EDGE = 0, C_EDGE = 1};

Constructor & Destructor Documentation

◆ Pgr_trspHandler() [1/2]

pgrouting::trsp::Pgr_trspHandler::Pgr_trspHandler	(	pgr_edge_t *	edges,
		const size_t	edge_count,
		const bool	directed,
		const std::vector< Rule > &	ruleList
	)

Definition at line 43 of file pgr_trspHandler.cpp.

                                          :
     m_ruleTable() {
     initialize_restrictions(ruleList);
  
     m_min_id = renumber_edges(edges, edge_count);
  
     construct_graph(
             edges,
             edge_count,
             directed);
 }

References construct_graph(), initialize_restrictions(), m_min_id, and renumber_edges().

◆ Pgr_trspHandler() [2/2]

pgrouting::trsp::Pgr_trspHandler::Pgr_trspHandler ( void )

delete

◆ ~Pgr_trspHandler()

pgrouting::trsp::Pgr_trspHandler::~Pgr_trspHandler ( void )

default

Member Function Documentation

◆ add_to_que()

void pgrouting::trsp::Pgr_trspHandler::add_to_que	(	double	cost,
		size_t	e_idx,
		bool	isStart
	)

private

Definition at line 317 of file pgr_trspHandler.cpp.

                       {
     que.push(std::make_pair(cost,
                 std::make_pair(e_idx, isStart)));
 }

References que.

Referenced by explore(), and initialize_que().

◆ addEdge()

bool pgrouting::trsp::Pgr_trspHandler::addEdge ( const pgr_edge_t edgeIn )

private

Definition at line 508 of file pgr_trspHandler.cpp.

                                                      {
     /*
      * The edge was already inserted
      *
      * If the user has rows with repeated edge id, the subsequent edges will be ignored
      *
      * When changing to boost graph, the additional edges are to be added
      */
     if (m_mapEdgeId2Index.find(edgeIn.id) != m_mapEdgeId2Index.end()) {
         return false;
     }
  
  
     /*
      * the index of this new edge in the edges container is
      *  m_edges.size()
      */
     EdgeInfo edge(edgeIn, m_edges.size());
  
     // Adding edge to the list
     m_mapEdgeId2Index.insert(
             std::make_pair(
                 edge.edgeID(),
                 m_edges.size()));
  
     m_edges.push_back(edge);
  
     EdgeInfo &newEdge = m_edges[m_edges.size()-1];
  
  
  
     /*
      *  Searching the start node for connectivity
      */
     auto itNodeMap = m_adjacency.find(edgeIn.source);
  
     if (itNodeMap != m_adjacency.end()) {
         for (const auto e_idx : itNodeMap->second) {
             connectStartEdge(edge.idx(), e_idx);
         }
     }
  
  
     /*
      *  Searching the end node for connectivity
      */
     itNodeMap = m_adjacency.find(edgeIn.target);
     if (itNodeMap != m_adjacency.end()) {
         for (const auto e_idx : itNodeMap->second) {
             connectEndEdge(edge.idx(), e_idx);
         }
     }
  
  
     /*
      * Add the edges to the adjacency list
      */
     m_adjacency[edgeIn.source].push_back(newEdge.idx());
     m_adjacency[edgeIn.target].push_back(newEdge.idx());
  
  
  
     return true;
 }

References connectEndEdge(), connectStartEdge(), pgr_edge_t::id, pgrouting::trsp::EdgeInfo::idx(), m_adjacency, m_edges, m_mapEdgeId2Index, pgr_edge_t::source, and pgr_edge_t::target.

Referenced by construct_graph().

◆ clear()

void pgrouting::trsp::Pgr_trspHandler::clear ( )

Definition at line 87 of file pgr_trspHandler.cpp.

                             {
     m_parent.clear();
     m_dCost.clear();
     m_path.clear();
 }

References Path::clear(), m_dCost, m_parent, and m_path.

Referenced by process().

◆ connectEndEdge()

void pgrouting::trsp::Pgr_trspHandler::connectEndEdge	(	size_t	firstEdge_idx,
		size_t	secondEdge_idx
	)

private

Definition at line 485 of file pgr_trspHandler.cpp.

                                {
     EdgeInfo &firstEdge = m_edges[firstEdge_idx];
     EdgeInfo &secondEdge = m_edges[secondEdge_idx];
  
     if (firstEdge.cost() >= 0.0) {
         firstEdge.connect_endEdge(secondEdge_idx);
     }
  
     if (firstEdge.endNode() == secondEdge.startNode()
             && secondEdge.r_cost() >= 0.0) {
         secondEdge.connect_startEdge(firstEdge_idx);
     }
  
     if (firstEdge.endNode() == secondEdge.endNode()
             && secondEdge.cost() >= 0.0) {
         secondEdge.connect_endEdge(firstEdge_idx);
     }
 }

References pgrouting::trsp::EdgeInfo::connect_endEdge(), pgrouting::trsp::EdgeInfo::connect_startEdge(), pgrouting::trsp::EdgeInfo::cost(), pgrouting::trsp::EdgeInfo::endNode(), m_edges, pgrouting::trsp::EdgeInfo::r_cost(), and pgrouting::trsp::EdgeInfo::startNode().

Referenced by addEdge().

◆ connectStartEdge()

void pgrouting::trsp::Pgr_trspHandler::connectStartEdge	(	size_t	firstEdge_idx,
		size_t	secondEdge_idx
	)

private

Definition at line 462 of file pgr_trspHandler.cpp.

                                {
     EdgeInfo &firstEdge = m_edges[firstEdge_idx];
     EdgeInfo &secondEdge = m_edges[secondEdge_idx];
  
     if (firstEdge.r_cost() >= 0.0) {
         firstEdge.connect_startEdge(secondEdge_idx);
     }
  
     if (firstEdge.startNode() == secondEdge.startNode()
             && secondEdge.r_cost() >= 0.0) {
             secondEdge.connect_startEdge(firstEdge_idx);
     }
  
     if (firstEdge.startNode() == secondEdge.endNode()
             &&secondEdge.cost() >= 0.0) {
         secondEdge.connect_endEdge(firstEdge_idx);
     }
 }

References pgrouting::trsp::EdgeInfo::connect_endEdge(), pgrouting::trsp::EdgeInfo::connect_startEdge(), pgrouting::trsp::EdgeInfo::cost(), pgrouting::trsp::EdgeInfo::endNode(), m_edges, pgrouting::trsp::EdgeInfo::r_cost(), and pgrouting::trsp::EdgeInfo::startNode().

Referenced by addEdge().

◆ construct_graph()

void pgrouting::trsp::Pgr_trspHandler::construct_graph	(	pgr_edge_t *	edges,
		const size_t	edge_count,
		const bool	directed
	)

private

Definition at line 435 of file pgr_trspHandler.cpp.

                              {
     for (size_t i = 0; i < edge_count; i++) {
         auto current_edge = &edges[i];
  
         /*
          * making all costs > 0
          */
         if (current_edge->cost < 0 && current_edge->reverse_cost > 0) {
             std::swap(current_edge->cost, current_edge->reverse_cost);
             std::swap(current_edge->source, current_edge->target);
         }
  
         if (!directed) {
             if (current_edge->reverse_cost < 0) {
                 current_edge->reverse_cost = current_edge->cost;
             }
         }
         addEdge(*current_edge);
     }
     m_mapEdgeId2Index.clear();
 }

References addEdge(), and m_mapEdgeId2Index.

Referenced by Pgr_trspHandler().

◆ construct_path()

double pgrouting::trsp::Pgr_trspHandler::construct_path	(	int64_t	ed_id,
		Position	pos
	)

private

Definition at line 95 of file pgr_trspHandler.cpp.

                                                                   {
     pgassert(pos != ILLEGAL);
     if (pos == ILLEGAL) return (std::numeric_limits<double>::max)();
  
     if (m_parent[static_cast<size_t>(ed_id)].isIllegal(pos)) {
         Path_t pelement;
         auto cur_edge = &m_edges[static_cast<size_t>(ed_id)];
         if (pos == RC_EDGE) {
             pelement.node = cur_edge->startNode();
             pelement.cost = cur_edge->cost();
         } else {
             pelement.node = cur_edge->endNode();
             pelement.cost = cur_edge->r_cost();
         }
         pelement.edge = cur_edge->edgeID();
  
         m_path.push_back(pelement);
         pgassert(m_path.start_id() == m_start_vertex);
         return pelement.cost;
     }
  
     double ret = construct_path(
         static_cast<int64_t>(m_parent[static_cast<size_t>(ed_id)].e_idx[static_cast<size_t>(pos)]),
         static_cast<Position>(m_parent[static_cast<size_t>(ed_id)].v_pos[static_cast<size_t>(pos)]));
     Path_t pelement;
     auto cur_edge = &m_edges[static_cast<size_t>(ed_id)];
     if (pos == RC_EDGE) {
         pelement.node = cur_edge->startNode();
         pelement.cost = m_dCost[static_cast<size_t>(ed_id)].endCost - ret;
         ret = m_dCost[static_cast<size_t>(ed_id)].endCost;
     } else {
         pelement.node = cur_edge->endNode();
         pelement.cost = m_dCost[static_cast<size_t>(ed_id)].startCost - ret;
         ret = m_dCost[static_cast<size_t>(ed_id)].startCost;
     }
     pelement.edge = cur_edge->edgeID();
  
     m_path.push_back(pelement);
  
     return ret;
 }

References Path_t::cost, Path_t::edge, ILLEGAL, m_dCost, m_edges, m_parent, m_path, m_start_vertex, Path_t::node, pgassert, Path::push_back(), RC_EDGE, and Path::start_id().

Referenced by process_trsp().

◆ dijkstra_exploration()

EdgeInfo pgrouting::trsp::Pgr_trspHandler::dijkstra_exploration ( )

private

Definition at line 353 of file pgr_trspHandler.cpp.

                                                {
     EdgeInfo cur_edge;
     pgassert(current_node == m_start_vertex);
  
     while (!que.empty()) {
         auto cur_pos = que.top();
         que.pop();
  
         auto cure_idxex = cur_pos.second.first;
         cur_edge = m_edges[static_cast<size_t>(cure_idxex)];
  
         if (cur_pos.second.second) {
             /*
              * explore edges connected to end node
              */
             current_node = cur_edge.endNode();
             if (cur_edge.cost() < 0.0) continue;
             if (current_node == m_end_vertex) break;
             explore(current_node, cur_edge, false);
         } else {
             /*
              *  explore edges connected to start node
              */
             current_node = cur_edge.startNode();
             if (cur_edge.r_cost() < 0.0) continue;
             if (current_node == m_end_vertex) break;
             explore(current_node, cur_edge, true);
         }
     }
     return cur_edge;
 }

References pgrouting::trsp::EdgeInfo::cost(), current_node, pgrouting::trsp::EdgeInfo::endNode(), explore(), m_edges, m_end_vertex, m_start_vertex, pgassert, que, pgrouting::trsp::EdgeInfo::r_cost(), and pgrouting::trsp::EdgeInfo::startNode().

Referenced by process_trsp().

◆ explore()

void pgrouting::trsp::Pgr_trspHandler::explore	(	int64_t	cur_node,
		const EdgeInfo	cur_edge,
		bool	isStart
	)

private

Definition at line 186 of file pgr_trspHandler.cpp.

                       {
     double totalCost;
  
     auto vecIndex = cur_edge.get_idx(isStart);
  
     for (const auto &index : vecIndex) {
         auto edge = m_edges[index];
  
         auto extra_cost = getRestrictionCost(
                 static_cast<int64_t>(cur_edge.idx()),
                 edge, isStart);
  
         if ((edge.startNode() == cur_node) && (edge.cost() >= 0.0)) {
             totalCost = get_tot_cost(
                     edge.cost() + extra_cost,
                     cur_edge.idx(),
                     isStart);
  
             if (totalCost < m_dCost[index].endCost) {
                 m_dCost[index].endCost = totalCost;
                 m_parent[edge.idx()].v_pos[RC_EDGE] = isStart? C_EDGE : RC_EDGE;
                 m_parent[edge.idx()].e_idx[RC_EDGE] =
                     cur_edge.idx();
  
                 add_to_que(totalCost, edge.idx(), true);
             }
         }
  
        if ((edge.endNode() == cur_node) && (edge.r_cost() >= 0.0)) {
             totalCost = get_tot_cost(
                     edge.r_cost() + extra_cost,
                     cur_edge.idx(),
                     isStart);
  
             if (totalCost < m_dCost[index].startCost) {
                 m_dCost[index].startCost = totalCost;
                 m_parent[edge.idx()].v_pos[C_EDGE] = isStart? C_EDGE : RC_EDGE;
                 m_parent[edge.idx()].e_idx[C_EDGE] = cur_edge.idx();
  
                 add_to_que(totalCost, edge.idx(), false);
             }
         }
     }  // for
 }

References add_to_que(), C_EDGE, edge::cost, pgrouting::trsp::EdgeInfo::get_idx(), get_tot_cost(), getRestrictionCost(), pgrouting::trsp::EdgeInfo::idx(), m_dCost, m_edges, m_parent, and RC_EDGE.

Referenced by dijkstra_exploration().

◆ get_tot_cost()

double pgrouting::trsp::Pgr_trspHandler::get_tot_cost	(	double	cost,
		size_t	edge_idx,
		bool	isStart
	)

private

Definition at line 172 of file pgr_trspHandler.cpp.

                       {
     if (isStart) {
         return m_dCost[edge_idx].startCost +
             cost;
     }
     return m_dCost[edge_idx].endCost +
         cost;
 }

References m_dCost.

Referenced by explore().

◆ getRestrictionCost()

double pgrouting::trsp::Pgr_trspHandler::getRestrictionCost	(	int64_t	cur_node,
		const EdgeInfo &	new_edge,
		bool	isStart
	)

private

Definition at line 139 of file pgr_trspHandler.cpp.

                       {
     double cost = 0.0;
     int64_t edge_id = edge.edgeID();
     if (m_ruleTable.find(edge_id) == m_ruleTable.end()) {
         return(0.0);
     }
     auto vecRules = m_ruleTable[edge_id];
     int64_t st_edge_ind = edge_ind;
     for (const auto &rule : vecRules) {
         bool flag = true;
         int64_t v_pos = (isStart? C_EDGE : RC_EDGE);
         edge_ind = st_edge_ind;
  
         pgassert(!(edge_ind == -1));
         for (auto const &precedence : rule.precedencelist()) {
             if (precedence != m_edges[static_cast<size_t>(edge_ind)].edgeID()) {
                 flag = false;
                 break;
             }
             auto m_parent_ind = m_parent[static_cast<size_t>(edge_ind)].e_idx[static_cast<size_t>(v_pos)];
             v_pos = m_parent[static_cast<size_t>(edge_ind)].v_pos[static_cast<size_t>(v_pos)];
             edge_ind = static_cast<int64_t>(m_parent_ind);
         }
         if (flag)
             cost += rule.cost();
     }
     return cost;
 }

References C_EDGE, m_edges, m_parent, m_ruleTable, pgassert, and RC_EDGE.

Referenced by explore().

◆ initialize_que()

void pgrouting::trsp::Pgr_trspHandler::initialize_que ( )

private

Definition at line 329 of file pgr_trspHandler.cpp.

                                       {
     /*
      * For each adjacent edge to the start_vertex
      */
     for (const auto source : m_adjacency[m_start_vertex]) {
         EdgeInfo &cur_edge = m_edges[source];
  
         if (cur_edge.startNode() == m_start_vertex
                 && cur_edge.cost() >= 0.0) {
             m_dCost[cur_edge.idx()].endCost = cur_edge.cost();
             m_parent[cur_edge.idx()].v_pos[0] = ILLEGAL;
             add_to_que(cur_edge.cost(), cur_edge.idx(), true);
         }
  
         if (cur_edge.endNode() == m_start_vertex
                 && cur_edge.r_cost() >= 0.0) {
             m_dCost[cur_edge.idx()].startCost =
                 cur_edge.r_cost();
             m_parent[cur_edge.idx()].v_pos[1] = ILLEGAL;
             add_to_que(cur_edge.r_cost(), cur_edge.idx(), false);
         }
     }
 }

References add_to_que(), pgrouting::trsp::EdgeInfo::cost(), pgrouting::trsp::EdgeInfo::endNode(), pgrouting::trsp::EdgeInfo::idx(), ILLEGAL, m_adjacency, m_dCost, m_edges, m_parent, m_start_vertex, pgrouting::trsp::EdgeInfo::r_cost(), and pgrouting::trsp::EdgeInfo::startNode().

Referenced by process_trsp().

◆ initialize_restrictions()

int pgrouting::trsp::Pgr_trspHandler::initialize_restrictions ( const std::vector< Rule > & ruleList )

private

Definition at line 237 of file pgr_trspHandler.cpp.

                                          {
     for (const auto &rule : ruleList) {
         auto dest_edge_id = rule.dest_id();
         if (m_ruleTable.find(dest_edge_id) != m_ruleTable.end()) {
             m_ruleTable[dest_edge_id].push_back(rule);
         } else {
             std::vector<Rule> r;
             r.push_back(rule);
             m_ruleTable.insert(std::make_pair(dest_edge_id, r));
         }
     }
  
     return true;
 }

References m_ruleTable.

Referenced by Pgr_trspHandler().

◆ process() [1/2]

Path pgrouting::trsp::Pgr_trspHandler::process	(	const int64_t	start_vertex,
		const int64_t	end_vertex
	)

process

does the processisng

Definition at line 259 of file pgr_trspHandler.cpp.

                                   {
     clear();
  
     m_start_vertex = start_vertex - m_min_id;
     m_end_vertex = end_vertex - m_min_id;
  
     Path tmp(m_start_vertex, m_end_vertex);
     m_path = tmp;
  
     if (m_adjacency.find(m_start_vertex) == m_adjacency.end()) {
         return Path();
     }
  
     if (m_adjacency.find(m_end_vertex) == m_adjacency.end()) {
         return Path();
     }
  
     return process_trsp(m_edges.size());
 }

References clear(), m_adjacency, m_edges, m_end_vertex, m_min_id, m_path, m_start_vertex, and process_trsp().

Referenced by do_trsp(), and process().

◆ process() [2/2]

std::deque< Path > pgrouting::trsp::Pgr_trspHandler::process	(	const std::vector< int64_t >	sources,
		const std::vector< int64_t >	targets
	)

process

does many to many processisng

Definition at line 292 of file pgr_trspHandler.cpp.

                                           {
     std::deque<Path> paths;
     for (const auto &s : sources) {
         for (const auto &t : targets) {
             paths.push_back(process(s, t));
         }
     }
  
     std::sort(paths.begin(), paths.end(),
             [](const Path &e1, const Path &e2)->bool {
             return e1.end_id() < e2.end_id();
             });
     std::stable_sort(paths.begin(), paths.end(),
             [](const Path &e1, const Path &e2)->bool {
             return e1.start_id() < e2.start_id();
             });
     return paths;
 }

References process().

◆ process_trsp()

Path pgrouting::trsp::Pgr_trspHandler::process_trsp ( size_t edge_count )

private

Definition at line 389 of file pgr_trspHandler.cpp.

                            {
     pgassert(m_path.start_id() == m_start_vertex);
     pgassert(m_path.end_id() == m_end_vertex);
     pgassert(m_parent.empty());
  
     m_parent.resize(edge_count + 1);
     m_dCost.resize(edge_count + 1);
  
     initialize_que();
  
     current_node = m_start_vertex;
  
     pgassert(m_path.start_id() == m_start_vertex);
  
     auto cur_edge = dijkstra_exploration();
  
     pgassert(m_path.start_id() == m_start_vertex);
     if (current_node != m_end_vertex) {
         Path result(m_start_vertex, m_end_vertex);
         return result.renumber_vertices(m_min_id);;
     }
  
     pgassert(m_path.start_id() == m_start_vertex);
  
     if (current_node == cur_edge.startNode()) {
         construct_path(static_cast<int64_t>(cur_edge.idx()), C_EDGE);
     } else {
         construct_path(static_cast<int64_t>(cur_edge.idx()), RC_EDGE);
     }
  
     Path_t pelement;
     pelement.node = m_end_vertex;
     pelement.edge = -1;
     pelement.cost = 0.0;
     m_path.push_back(pelement);
  
     m_path.Path::recalculate_agg_cost();
     return m_path.renumber_vertices(m_min_id);
 }

References C_EDGE, construct_path(), Path_t::cost, current_node, dijkstra_exploration(), Path_t::edge, Path::end_id(), initialize_que(), m_dCost, m_end_vertex, m_min_id, m_parent, m_path, m_start_vertex, Path_t::node, pgassert, Path::push_back(), RC_EDGE, Path::renumber_vertices(), and Path::start_id().

Referenced by process().

◆ renumber_edges()

int64_t pgrouting::trsp::Pgr_trspHandler::renumber_edges	(	pgr_edge_t *	edges,
		const size_t	edge_count
	)		const

private

Definition at line 62 of file pgr_trspHandler.cpp.

                                   {
         int64_t v_min_id = INT64_MAX;
         size_t z;
         for (z = 0; z < total_edges; z++) {
             if (edges[z].source < v_min_id)
                 v_min_id = edges[z].source;
  
             if (edges[z].target < v_min_id)
                 v_min_id = edges[z].target;
         }
  
         for (z = 0; z < total_edges; z++) {
             edges[z].source -= v_min_id;
             edges[z].target -= v_min_id;
         }
  
         return v_min_id;
 }

References pgr_edge_t::source, and pgr_edge_t::target.

Referenced by Pgr_trspHandler().

Member Data Documentation

◆ current_node

int64_t pgrouting::trsp::Pgr_trspHandler::current_node

private

Definition at line 199 of file pgr_trspHandler.h.

Referenced by dijkstra_exploration(), and process_trsp().

◆ m_adjacency

std::map<int64_t, std::vector<size_t> > pgrouting::trsp::Pgr_trspHandler::m_adjacency

private

m_adjacency[vertex] = {edges}

Definition at line 190 of file pgr_trspHandler.h.

Referenced by addEdge(), initialize_que(), and process().

◆ m_dCost

std::vector<CostHolder> pgrouting::trsp::Pgr_trspHandler::m_dCost

private

Definition at line 206 of file pgr_trspHandler.h.

Referenced by clear(), construct_path(), explore(), get_tot_cost(), initialize_que(), and process_trsp().

◆ m_edges

std::vector<EdgeInfo> pgrouting::trsp::Pgr_trspHandler::m_edges

private

Definition at line 179 of file pgr_trspHandler.h.

Referenced by addEdge(), connectEndEdge(), connectStartEdge(), construct_path(), dijkstra_exploration(), explore(), getRestrictionCost(), initialize_que(), and process().

◆ m_end_vertex

int64_t pgrouting::trsp::Pgr_trspHandler::m_end_vertex

private

Definition at line 194 of file pgr_trspHandler.h.

Referenced by dijkstra_exploration(), process(), and process_trsp().

◆ m_mapEdgeId2Index

std::map<int64_t, int64_t> pgrouting::trsp::Pgr_trspHandler::m_mapEdgeId2Index

private

Used only to veryfy that there are no reppetitions inserted the way it orks, repeating edges id is not allowed.

Definition at line 185 of file pgr_trspHandler.h.

Referenced by addEdge(), and construct_graph().

◆ m_min_id

int64_t pgrouting::trsp::Pgr_trspHandler::m_min_id

private

Definition at line 201 of file pgr_trspHandler.h.

Referenced by Pgr_trspHandler(), process(), and process_trsp().

◆ m_parent

std::vector<Predecessor> pgrouting::trsp::Pgr_trspHandler::m_parent

private

Definition at line 205 of file pgr_trspHandler.h.

Referenced by clear(), construct_path(), explore(), getRestrictionCost(), initialize_que(), and process_trsp().

◆ m_path

Path pgrouting::trsp::Pgr_trspHandler::m_path

private

Definition at line 203 of file pgr_trspHandler.h.

Referenced by clear(), construct_path(), process(), and process_trsp().

◆ m_ruleTable

std::map<int64_t, std::vector<Rule> > pgrouting::trsp::Pgr_trspHandler::m_ruleTable

private

Definition at line 208 of file pgr_trspHandler.h.

Referenced by getRestrictionCost(), and initialize_restrictions().

◆ m_start_vertex

int64_t pgrouting::trsp::Pgr_trspHandler::m_start_vertex

private

Definition at line 193 of file pgr_trspHandler.h.

Referenced by construct_path(), dijkstra_exploration(), initialize_que(), process(), and process_trsp().

◆ que

std::priority_queue<PDP, std::vector<PDP>, std::greater<PDP> > pgrouting::trsp::Pgr_trspHandler::que

private

Definition at line 213 of file pgr_trspHandler.h.

Referenced by add_to_que(), and dijkstra_exploration().

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

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ PDP

Member Enumeration Documentation

◆ Position

Constructor & Destructor Documentation

◆ Pgr_trspHandler() [1/2]

◆ Pgr_trspHandler() [2/2]

◆ ~Pgr_trspHandler()

Member Function Documentation

◆ add_to_que()

◆ addEdge()

◆ clear()

◆ connectEndEdge()

◆ connectStartEdge()

◆ construct_graph()

◆ construct_path()

◆ dijkstra_exploration()

◆ explore()

◆ get_tot_cost()

◆ getRestrictionCost()

◆ initialize_que()

◆ initialize_restrictions()

◆ process() [1/2]

◆ process() [2/2]

◆ process_trsp()

◆ renumber_edges()

Member Data Documentation

◆ current_node

◆ m_adjacency

◆ m_dCost

◆ m_edges

◆ m_end_vertex

◆ m_mapEdgeId2Index

◆ m_min_id

◆ m_parent

◆ m_path

◆ m_ruleTable

◆ m_start_vertex

◆ que