Line data    Source code

       1             : #include "Static/SUMOAdapter.hpp"
       2             : 
       3             : #include <stdexcept>
       4             : 
       5             : using namespace std;
       6             : using namespace Static;
       7             : 
       8             : typedef Network::Node               Node;
       9             : typedef Network::Edge::ID           Edge;
      10             : typedef SUMO::Network::Junction::ID SumoJunction;
      11             : typedef SUMO::TAZ::ID               TAZ;
      12             : typedef SUMO::Network::Edge::ID     SumoEdge;
      13             : 
      14             : // Node SUMOAdapter::addNode() {
      15             : //     Edge b = nextNode++;
      16             : //     return b;
      17             : // }
      18             : 
      19        7534 : pair<Edge, pair<Node, Node>> SUMOAdapter::addSumoEdge(const SumoEdge &a) {
      20        7534 :     Edge                         e = nextEdge++;
      21        7534 :     Node                         u = nextNode++, v = nextNode++;
      22        7534 :     pair<Edge, pair<Node, Node>> ret(e, {u, v});
      23             : 
      24        7534 :     edge2sumoEdge[ret.first]         = a;
      25        7534 :     sumoEdge2edge[a]                 = ret.first;
      26        7534 :     sumoEdge2nodes[a]                = ret.second;
      27        7534 :     node2sumoEdge[ret.second.first]  = a;
      28        7534 :     node2sumoEdge[ret.second.second] = a;
      29        7534 :     return ret;
      30             : }
      31         119 : pair<Node, Node> SUMOAdapter::addSumoTAZ(const TAZ &a) {
      32         119 :     Node b          = nextNode++;
      33         119 :     Node c          = nextNode++;
      34         119 :     node2sumoTAZ[b] = a;
      35         119 :     node2sumoTAZ[c] = a;
      36         119 :     sumoTAZ2node[a] = pair<Node, Node>(b, c);
      37             : 
      38         119 :     return pair<Node, Node>(b, c);
      39             : }
      40             : 
      41       13566 : Edge SUMOAdapter::addEdge() {
      42       13566 :     return nextEdge++;
      43             : }
      44             : 
      45           0 : bool SUMOAdapter::isEdge(const SumoEdge &a) const {
      46           0 :     return sumoEdge2edge.count(a);
      47             : }
      48             : 
      49       14618 : const pair<Node, Node> &SUMOAdapter::toTAZNode(const TAZ &a) const {
      50       14618 :     return sumoTAZ2node.at(a);
      51             : }
      52           0 : const TAZ &SUMOAdapter::toSumoTAZ(const Node &a) const {
      53           0 :     return node2sumoTAZ.at(a);
      54             : }
      55             : 
      56      185028 : const Edge &SUMOAdapter::toEdge(const SumoEdge &a) const {
      57      185028 :     try {
      58      185028 :         return sumoEdge2edge.at(a);
      59           0 :     } catch(const out_of_range &e) {
      60           0 :         throw out_of_range("SUMOAdapter::toEdge: Could not find SUMO edge " + a);
      61             :     }
      62             : }
      63       37614 : const SumoEdge &SUMOAdapter::toSumoEdge(const Edge &a) const {
      64       37614 :     return edge2sumoEdge.at(a);
      65             : }
      66       22812 : const pair<Node, Node> &SUMOAdapter::toNodes(const SumoEdge &a) const {
      67       22812 :     return sumoEdge2nodes.at(a);
      68             : }
      69             : 
      70      188982 : bool SUMOAdapter::isSumoEdge(const Edge &a) const {
      71      188982 :     return edge2sumoEdge.count(a) > 0;
      72             : }
      73             : 
      74           0 : vector<SumoEdge> SUMOAdapter::getSumoEdges() const {
      75           0 :     vector<SumoEdge> ret;
      76           0 :     ret.reserve(sumoEdge2edge.size());
      77           0 :     for(const auto &p: sumoEdge2edge) {
      78           0 :         ret.push_back(p.first);
      79             :     }
      80           0 :     return ret;
      81             : }
      82             : 
      83       14442 : SumoEdge SUMOAdapter::fromNodeToSumoEdge(const Node &a) const {
      84       14442 :     return node2sumoEdge.at(a);
      85             : }
      86             : 
      87           3 : void SUMOAdapter::clear() {
      88           3 :     edge2sumoEdge.clear();
      89           3 :     sumoEdge2edge.clear();
      90           3 :     sumoEdge2nodes.clear();
      91           3 :     node2sumoTAZ.clear();
      92           3 :     sumoTAZ2node.clear();
      93           3 :     nextNode = 0;
      94           3 :     nextEdge = 0;
      95           3 : }
      96             : 
      97           0 : void SUMOAdapter::dump(ostream &os) const {
      98           0 :     stringstream ss;
      99           0 :     ss << "SUMOAdapter::dump()" << endl;
     100           0 :     ss << "edge2sumoEdge:" << endl;
     101           0 :     for(const auto &[edgeID, sumoEdgeID]: edge2sumoEdge) {
     102           0 :         const auto &[u, v] = sumoEdge2nodes.at(sumoEdgeID);
     103           0 :         ss << "Edge " << edgeID
     104           0 :            << " (nodes " << u << ", " << v
     105           0 :            << ") → SUMO edge " << sumoEdgeID << endl;
     106             :     }
     107           0 :     os << ss.rdbuf();
     108           0 : }