Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include <map>
       4             : #include <string>
       5             : 
       6             : #include "Static/SUMOAdapter.hpp"
       7             : #include "Static/Solution.hpp"
       8             : #include "Static/supply/BPRNetwork.hpp"
       9             : #include "data/SUMO/Network.hpp"
      10             : #include "data/SUMO/NetworkTAZ.hpp"
      11             : #include "data/SUMO/SUMO.hpp"
      12             : #include "utils/stringify.hpp"
      13             : 
      14             : namespace SUMO {
      15           0 : class EdgeData {
      16             :    public:
      17             :     template<typename T, typename... args>
      18             :     class Loader {
      19             :        public:
      20             :         EdgeData load(T var1, args... var2);
      21             :     };
      22             : 
      23           0 :     class Attributes {
      24             :         friend EdgeData;
      25             : 
      26             :         std::map<std::string, std::string> attributes;
      27             : 
      28             :        public:
      29             :         template<typename T>
      30           0 :         void setAttribute(const std::string &name, const T &value) {
      31           0 :             attributes[name] = utils::stringify::stringify<T>::toString(value);
      32           0 :         }
      33             : 
      34             :         template<typename T>
      35             :         T getAttribute(const std::string &name) const {
      36             :             return utils::stringify::stringify<T>::fromString(attributes.at(name));
      37             :         }
      38             :     };
      39             :     class Interval {
      40             :         friend EdgeData;
      41             : 
      42             :        public:
      43             :         typedef SUMO::ID ID;
      44             : 
      45             :         class Edge {
      46             :             friend EdgeData;
      47             : 
      48             :            public:
      49           0 :             class Lane {
      50             :                 friend EdgeData;
      51             : 
      52             :                public:
      53             :                 Attributes attributes;
      54             : 
      55             :                private:
      56             :                 Lane(SUMO::Network::Edge::Lane::ID id);
      57             :             };
      58             : 
      59             :             Attributes attributes;
      60             : 
      61             :            private:
      62             :             Edge(SUMO::Network::Edge::ID id);
      63             : 
      64             :             std::map<SUMO::Network::Edge::Lane::ID, Lane> lanes;
      65             : 
      66             :            public:
      67             :             bool  hasLane(SUMO::Network::Edge::Lane::ID id) const;
      68             :             Lane &createLane(SUMO::Network::Edge::Lane::ID id);
      69             :             Lane &getLane(SUMO::Network::Edge::Lane::ID id);
      70             :         };
      71             : 
      72             :         Attributes attributes;
      73             : 
      74             :        private:
      75             :         Interval(SUMO::Time begin, SUMO::Time end);
      76             :         Interval(SUMO::Time begin, SUMO::Time end, ID id);
      77             : 
      78             :         std::map<SUMO::Network::Edge::ID, Edge> edges;
      79             : 
      80             :        public:
      81             :         bool  hasEdge(SUMO::Network::Edge::ID id) const;
      82             :         Edge &createEdge(SUMO::Network::Edge::ID id);
      83             :         Edge &getEdge(SUMO::Network::Edge::ID id);
      84             :     };
      85             : 
      86             :    private:
      87             :     std::vector<Interval>          intervals;
      88             :     std::map<SUMO::ID, Interval *> idToInterval;
      89             : 
      90             :    public:
      91             :     Interval &createInterval(SUMO::Time begin, SUMO::Time end);
      92             :     Interval &createInterval(SUMO::Time begin, SUMO::Time end, SUMO::ID id);
      93             : 
      94             :     void saveToFile(const std::string &filename) const;
      95             : };
      96             : 
      97             : // clang-format off
      98             : template<>
      99             : class EdgeData::Loader<
     100             :     const NetworkTAZs&,
     101             :     const Static::BPRNetwork&,
     102             :     const Static::Solution&,
     103             :     const Static::SUMOAdapter&
     104             : > {
     105             :    public:
     106             :     EdgeData load(
     107             :         const NetworkTAZs &sumo,
     108             :         const Static::BPRNetwork &network,
     109             :         const Static::Solution &x,
     110             :         const Static::SUMOAdapter &adapter
     111             :     );
     112             : };
     113             : // clang-format on
     114             : 
     115             : }  // namespace SUMO