LCOV - code coverage report
Current view: top level - src/netbuild - NBPTLine.h (source / functions) Coverage Total Hit
Test: lcov.info Lines: 83.3 % 12 10
Test Date: 2024-12-21 15:45:41 Functions: - 0 0

            Line data    Source code
       1              : /****************************************************************************/
       2              : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3              : // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
       4              : // This program and the accompanying materials are made available under the
       5              : // terms of the Eclipse Public License 2.0 which is available at
       6              : // https://www.eclipse.org/legal/epl-2.0/
       7              : // This Source Code may also be made available under the following Secondary
       8              : // Licenses when the conditions for such availability set forth in the Eclipse
       9              : // Public License 2.0 are satisfied: GNU General Public License, version 2
      10              : // or later which is available at
      11              : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
      12              : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
      13              : /****************************************************************************/
      14              : /// @file    NBPTLine.h
      15              : /// @author  Gregor Laemmel
      16              : /// @author  Nikita Cherednychek
      17              : /// @date    Tue, 20 Mar 2017
      18              : ///
      19              : // The representation of one direction of a single pt line
      20              : /****************************************************************************/
      21              : #pragma once
      22              : #include <config.h>
      23              : 
      24              : #include <memory>
      25              : #include <map>
      26              : #include <string>
      27              : #include <vector>
      28              : 
      29              : 
      30              : // ===========================================================================
      31              : // class declarations
      32              : // ===========================================================================
      33              : class OutputDevice;
      34              : class NBEdge;
      35              : class NBEdgeCont;
      36              : class NBPTStop;
      37              : class NBPTStopCont;
      38              : 
      39              : 
      40              : // ===========================================================================
      41              : // class definitions
      42              : // ===========================================================================
      43              : class NBPTLine {
      44              : public:
      45              :     NBPTLine(const std::string& id, const std::string& name,
      46              :              const std::string& type, const std::string& ref, int interval, const std::string& nightService,
      47              :              SUMOVehicleClass vClass, RGBColor color);
      48              : 
      49              :     void addPTStop(std::shared_ptr<NBPTStop> pStop);
      50              : 
      51              :     const std::string& getLineID() const {
      52         1102 :         return myPTLineId;
      53              :     }
      54              : 
      55              :     const std::string& getName() const {
      56              :         return myName;
      57              :     }
      58              : 
      59              :     const std::string& getType() const {
      60          452 :         return myType;
      61              :     }
      62              : 
      63              :     const std::vector<std::shared_ptr<NBPTStop> >& getStops();
      64              :     void write(OutputDevice& device);
      65              :     void addWayNode(long long int way, long long int node);
      66              : 
      67              :     void setNumOfStops(int numStops, int missingBefore, int missingAfter);
      68              : 
      69              :     /// @brief get line reference (not unique)
      70              :     const std::string& getRef() const {
      71         3314 :         return myRef;
      72              :     }
      73              : 
      74              :     void replaceStops(std::vector<std::shared_ptr<NBPTStop> > stops) {
      75          452 :         myPTStops = stops;
      76          452 :     }
      77              :     /// @brief get stop edges and stop ids
      78              :     std::vector<std::pair<NBEdge*, std::string> > getStopEdges(const NBEdgeCont& ec) const;
      79              : 
      80              :     /// @brief return first valid edge of myRoute (if it doest not lie after the first stop)
      81              :     NBEdge* getRouteStart(const NBEdgeCont& ec) const;
      82              : 
      83              :     /// @brief return last valid edge of myRoute (if it doest not lie before the last stop)
      84              :     NBEdge* getRouteEnd(const NBEdgeCont& ec) const;
      85              : 
      86              :     /// @brief return whether the mentioned edges appear in that order in the route
      87              :     bool isConsistent(std::vector<NBEdge*> stops) const;
      88              : 
      89              :     SUMOVehicleClass getVClass() const {
      90         9702 :         return myVClass;
      91              :     }
      92              : 
      93              :     /// @brief replace the given stop
      94              :     void replaceStop(std::shared_ptr<NBPTStop> oldStop, std::shared_ptr<NBPTStop> newStop);
      95              : 
      96              :     /// @brief replace the edge with the given edge list
      97              :     void replaceEdge(const std::string& edgeID, const std::vector<NBEdge*>& replacement);
      98              : 
      99              :     /// @brief remove invalid stops from the line
     100              :     void deleteInvalidStops(const NBEdgeCont& ec, const NBPTStopCont& sc);
     101              :     void deleteDuplicateStops();
     102              : 
     103              :     /// @brief remove invalid edges from the line
     104              :     void removeInvalidEdges(const NBEdgeCont& ec);
     105              : 
     106              :     void setName(const std::string& name) {
     107            3 :         myName = name;
     108            3 :     }
     109              : 
     110              :     void setRef(const std::string& line) {
     111            0 :         myRef = line;
     112            0 :     }
     113              : 
     114              :     void setPeriod(int intervalS) {
     115            1 :         myInterval = intervalS / 60;
     116            1 :     }
     117              : 
     118              :     inline const std::vector<std::string>& getWays() const {
     119              :         return myWays;
     120              :     }
     121              : 
     122              :     const std::vector<long long int>* getWayNodes(std::string wayId);
     123              : 
     124              : private:
     125              :     std::string myName;
     126              :     std::string myType;
     127              :     std::vector<std::shared_ptr<NBPTStop> > myPTStops;
     128              :     std::map<std::string, std::vector<long long int> > myWayNodes;
     129              :     std::vector<std::string> myWays;
     130              :     std::string myCurrentWay;
     131              :     std::string myPTLineId;
     132              :     std::string myRef;
     133              :     // official line color
     134              :     RGBColor myColor;
     135              : 
     136              :     // @brief the service interval in minutes
     137              :     int myInterval;
     138              : 
     139              :     std::string myNightService;
     140              :     SUMOVehicleClass myVClass;
     141              : 
     142              : public:
     143              :     void setEdges(const std::vector<NBEdge*>& edges);
     144              : private:
     145              :     // route of ptline
     146              :     std::vector<NBEdge*> myRoute;
     147              : public:
     148              :     const std::vector<NBEdge*>& getRoute() const;
     149              : private:
     150              : 
     151              :     int myNumOfStops;
     152              :     int myMissingStopsBefore;
     153              :     int myMissingStopsAfter;
     154              : };
        

Generated by: LCOV version 2.0-1