LCOV - code coverage report
Current view: top level - src/utils/vehicle - SUMORouteHandler.cpp (source / functions) Coverage Total Hit
Test: lcov.info Lines: 96.3 % 352 339
Test Date: 2026-10-12 15:53:19 Functions: 91.7 % 12 11

            Line data    Source code
       1              : /****************************************************************************/
       2              : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3              : // Copyright (C) 2001-2026 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    SUMORouteHandler.cpp
      15              : /// @author  Daniel Krajzewicz
      16              : /// @author  Jakob Erdmann
      17              : /// @author  Sascha Krieg
      18              : /// @author  Michael Behrisch
      19              : /// @date    Mon, 9 Jul 2001
      20              : ///
      21              : // Parser for routes during their loading
      22              : /****************************************************************************/
      23              : #include <config.h>
      24              : 
      25              : #include <utils/common/MsgHandler.h>
      26              : #include <utils/common/FileHelpers.h>
      27              : #include <utils/common/RandHelper.h>
      28              : #include <utils/options/OptionsCont.h>
      29              : #include <utils/vehicle/SUMOVTypeParameter.h>
      30              : #include <utils/vehicle/SUMOVehicleParserHelper.h>
      31              : #include <utils/xml/XMLSubSys.h>
      32              : 
      33              : #include "SUMORouteHandler.h"
      34              : 
      35              : // ===========================================================================
      36              : // static members
      37              : // ===========================================================================
      38              : SumoRNG SUMORouteHandler::myParsingRNG("routehandler");
      39              : 
      40              : // ===========================================================================
      41              : // method definitions
      42              : // ===========================================================================
      43              : 
      44        85686 : SUMORouteHandler::SUMORouteHandler(const std::string& file, const std::string& expectedRoot, const bool hardFail) :
      45              :     SUMOSAXHandler(file, expectedRoot),
      46        85686 :     myHardFail(hardFail),
      47        85686 :     myVehicleParameter(nullptr),
      48        85686 :     myLastDepart(-1),
      49        85686 :     myActiveRouteColor(nullptr),
      50        85686 :     myCurrentCosts(0.),
      51        85686 :     myCurrentVType(nullptr),
      52        85686 :     myCurrentVTypeProbability(-1),
      53       257056 :     myBeginDefault(OptionsCont::getOptions().exists("begin") ? string2time(OptionsCont::getOptions().getString("begin")) : 0),
      54       257056 :     myEndDefault(OptionsCont::getOptions().exists("end") ? string2time(OptionsCont::getOptions().getString("end")) : -1),
      55        85686 :     myFirstDepart(-1),
      56        85686 :     myInsertStopEdgesAt(-1),
      57       171372 :     myAllowInternalRoutes(false) {
      58        85686 : }
      59              : 
      60              : 
      61        85237 : SUMORouteHandler::~SUMORouteHandler() {
      62        85237 :     delete myVehicleParameter;
      63        85237 :     delete myCurrentVType;
      64        85237 : }
      65              : 
      66              : 
      67              : bool
      68       623735 : SUMORouteHandler::checkLastDepart() {
      69       623735 :     if (myVehicleParameter->departProcedure == DepartDefinition::GIVEN) {
      70       622781 :         if (myVehicleParameter->depart < myLastDepart) {
      71           16 :             WRITE_WARNINGF(TL("Route file should be sorted by departure time, ignoring '%'!"), myVehicleParameter->id);
      72            8 :             return false;
      73              :         }
      74              :     }
      75              :     return true;
      76              : }
      77              : 
      78              : 
      79              : void
      80       672707 : SUMORouteHandler::registerLastDepart() {
      81              :     // register only non public transport to parse all public transport lines in advance
      82       672707 :     if (myVehicleParameter && myVehicleParameter->line == "" && myVehicleParameter->departProcedure == DepartDefinition::GIVEN) {
      83       666651 :         myLastDepart = myVehicleParameter->depart;
      84       666651 :         if (myFirstDepart == -1) {
      85        43332 :             myFirstDepart = myLastDepart;
      86              :         }
      87              :     }
      88              :     // else: we don't know when this vehicle will depart. keep the previous known depart time
      89       672707 : }
      90              : 
      91              : 
      92              : void
      93     11873053 : SUMORouteHandler::myStartElement(int element, const SUMOSAXAttributes& attrs) {
      94     11873053 :     myElementStack.push_back(element);
      95     11873053 :     switch (element) {
      96       407620 :         case SUMO_TAG_VEHICLE:
      97              :         case SUMO_TAG_PERSON:
      98              :         case SUMO_TAG_CONTAINER:
      99              :             // if myVehicleParameter is nullptr this will do nothing
     100       407620 :             delete myVehicleParameter;
     101              :             // we set to nullptr to have a consistent state if the parsing fails
     102       407620 :             myVehicleParameter = nullptr;
     103       407620 :             myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(element, attrs, myHardFail, false, false, myAllowInternalRoutes);
     104       407301 :             myParamStack.push_back(myVehicleParameter);
     105       407301 :             if (element != SUMO_TAG_VEHICLE) {
     106        47547 :                 addTransportable(attrs, element == SUMO_TAG_PERSON);
     107              :             }
     108              :             break;
     109        22964 :         case SUMO_TAG_FLOW:
     110              :             // delete if myVehicleParameter isn't null
     111        22964 :             if (myVehicleParameter) {
     112            0 :                 delete myVehicleParameter;
     113            0 :                 myVehicleParameter = nullptr;
     114              :             }
     115              :             // parse vehicle parameters
     116              :             // might be called to parse vehicles from additional file in the
     117              :             // context of quickReload. In this case, rerouter flows must be ignored
     118        22964 :             if (myElementStack.size() == 1 || myElementStack[myElementStack.size() - 2] != SUMO_TAG_CALIBRATOR) {
     119        22964 :                 myVehicleParameter = SUMOVehicleParserHelper::parseFlowAttributes(SUMO_TAG_FLOW, attrs, myHardFail, true, myBeginDefault, myEndDefault, myAllowInternalRoutes);
     120              :             }
     121              :             // check if myVehicleParameter was successfully created
     122        22834 :             if (myVehicleParameter) {
     123              :                 // check tag
     124        22834 :                 if (myVehicleParameter->routeid.empty()) {
     125              :                     // open a route flow (It could be a flow with embedded route)
     126        13108 :                     openFlow(attrs);
     127              :                 } else {
     128              :                     // open a route flow
     129         9726 :                     openRouteFlow(attrs);
     130              :                 }
     131        22834 :                 myParamStack.push_back(myVehicleParameter);
     132              :             }
     133              :             break;
     134         2407 :         case SUMO_TAG_PERSONFLOW:
     135              :         case SUMO_TAG_CONTAINERFLOW:
     136              :             // delete if myVehicleParameter isn't null
     137         2407 :             if (myVehicleParameter) {
     138            0 :                 delete myVehicleParameter;
     139            0 :                 myVehicleParameter = nullptr;
     140              :             }
     141              :             // create a new flow
     142         2407 :             myVehicleParameter = SUMOVehicleParserHelper::parseFlowAttributes((SumoXMLTag)element, attrs, myHardFail, true, myBeginDefault, myEndDefault, myAllowInternalRoutes);
     143         2407 :             myParamStack.push_back(myVehicleParameter);
     144         2407 :             break;
     145        65563 :         case SUMO_TAG_VTYPE:
     146              :             // delete if myCurrentVType isn't null
     147        65563 :             if (myCurrentVType != nullptr) {
     148            5 :                 delete myCurrentVType;
     149            5 :                 myCurrentVType = nullptr;
     150              :             }
     151              :             // create a new vType
     152        65563 :             if (attrs.hasAttribute(SUMO_ATTR_REFID) && !attrs.hasAttribute(SUMO_ATTR_ID)) {
     153          132 :                 bool ok = true;
     154          264 :                 myCurrentVTypeRef = attrs.get<std::string>(SUMO_ATTR_REFID, nullptr, ok);
     155          132 :                 myCurrentVTypeProbability = attrs.getOpt<double>(SUMO_ATTR_PROB, myCurrentVTypeRef.c_str(), ok, -1);
     156              :             } else {
     157       130830 :                 myCurrentVType = SUMOVehicleParserHelper::beginVTypeParsing(attrs, myHardFail, getFileName(), getVTypeParameter(attrs.getStringSecure(SUMO_ATTR_REFID, "")));
     158              :             }
     159        65531 :             myParamStack.push_back(myCurrentVType);
     160        65531 :             break;
     161          644 :         case SUMO_TAG_VTYPE_DISTRIBUTION:
     162          644 :             openVehicleTypeDistribution(attrs);
     163          644 :             break;
     164       390900 :         case SUMO_TAG_ROUTE:
     165       390900 :             openRoute(attrs);
     166       390848 :             break;
     167        93325 :         case SUMO_TAG_ROUTE_DISTRIBUTION:
     168        93325 :             openRouteDistribution(attrs);
     169        93325 :             break;
     170        41938 :         case SUMO_TAG_STOP:
     171        41938 :             myParamStack.push_back(addStop(attrs));
     172        41869 :             break;
     173       243431 :         case SUMO_TAG_TRIP: {
     174              :             // delete if myVehicleParameter isn't null
     175       243431 :             if (myVehicleParameter) {
     176            0 :                 delete myVehicleParameter;
     177            0 :                 myVehicleParameter = nullptr;
     178              :             }
     179              :             // parse vehicle parameters
     180       243431 :             myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(element, attrs, myHardFail, false, false, myAllowInternalRoutes);
     181              :             // check if myVehicleParameter was successfully created
     182       243365 :             if (myVehicleParameter) {
     183       243365 :                 myVehicleParameter->parametersSet |= VEHPARS_FORCE_REROUTE;
     184       243365 :                 myActiveRouteID = "!" + myVehicleParameter->id;
     185              :                 // open trip
     186       243365 :                 openTrip(attrs);
     187       243365 :                 myParamStack.push_back(myVehicleParameter);
     188              :             }
     189              :             break;
     190              :         }
     191         5412 :         case SUMO_TAG_PERSONTRIP:
     192         5412 :             addPersonTrip(attrs);
     193         5396 :             break;
     194        40647 :         case SUMO_TAG_WALK:
     195        40647 :             addWalk(attrs);
     196        40627 :             break;
     197           28 :         case SUMO_TAG_INTERVAL: {
     198              :             bool ok;
     199           28 :             myBeginDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, nullptr, ok);
     200           28 :             myEndDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_END, nullptr, ok);
     201              :             break;
     202              :         }
     203         5576 :         case SUMO_TAG_RIDE:
     204         5576 :             addRide(attrs);
     205         5536 :             break;
     206         1881 :         case SUMO_TAG_TRANSPORT:
     207         1881 :             addTransport(attrs);
     208         1864 :             break;
     209         1590 :         case SUMO_TAG_TRANSHIP:
     210         1590 :             addTranship(attrs);
     211         1590 :             break;
     212        57805 :         case SUMO_TAG_PARAM:
     213        57805 :             addParam(attrs);
     214        57805 :             break;
     215     10491322 :         default:
     216              :             // parse embedded car following model information
     217     10491322 :             if (myCurrentVType != nullptr) {
     218           38 :                 WRITE_WARNINGF(TL("Defining car-following parameters in a nested element is deprecated in vType '%', use attributes instead!"), myCurrentVType->id);
     219           19 :                 if (!SUMOVehicleParserHelper::parseCFMParams(myCurrentVType, (SumoXMLTag)element, attrs, true)) {
     220            0 :                     if (myHardFail) {
     221            0 :                         throw ProcessError(TL("Invalid parsing embedded VType"));
     222              :                     } else {
     223            0 :                         WRITE_ERROR(TL("Invalid parsing embedded VType"));
     224              :                     }
     225              :                 }
     226              :             }
     227              :             break;
     228              :     }
     229     11872292 : }
     230              : 
     231              : 
     232              : void
     233     11864482 : SUMORouteHandler::myEndElement(int element) {
     234     11864482 :     switch (element) {
     235        41869 :         case SUMO_TAG_STOP:
     236              :             myParamStack.pop_back();
     237              :             break;
     238       390848 :         case SUMO_TAG_ROUTE:
     239       390848 :             closeRoute();
     240       390794 :             break;
     241        65526 :         case SUMO_TAG_VTYPE:
     242        65526 :             closeVType();
     243        65502 :             if (myCurrentVTypeRef.empty()) {
     244        65370 :                 delete myCurrentVType;
     245              :             }
     246        65502 :             myCurrentVType = nullptr;
     247        65502 :             myCurrentVTypeRef = "";
     248        65502 :             myCurrentVTypeProbability = -1;
     249              :             myParamStack.pop_back();
     250              :             break;
     251        45336 :         case SUMO_TAG_PERSON:
     252        45336 :             closePerson();
     253        45310 :             delete myVehicleParameter;
     254        45310 :             myVehicleParameter = nullptr;
     255              :             myParamStack.pop_back();
     256              :             break;
     257         2060 :         case SUMO_TAG_PERSONFLOW:
     258         2060 :             closePersonFlow();
     259         2048 :             delete myVehicleParameter;
     260         2048 :             myVehicleParameter = nullptr;
     261              :             myParamStack.pop_back();
     262              :             break;
     263         2104 :         case SUMO_TAG_CONTAINER:
     264         2104 :             closeContainer();
     265         2096 :             delete myVehicleParameter;
     266         2096 :             myVehicleParameter = nullptr;
     267              :             myParamStack.pop_back();
     268              :             break;
     269          335 :         case SUMO_TAG_CONTAINERFLOW:
     270          335 :             closeContainerFlow();
     271          335 :             delete myVehicleParameter;
     272          335 :             myVehicleParameter = nullptr;
     273              :             myParamStack.pop_back();
     274              :             break;
     275       359641 :         case SUMO_TAG_VEHICLE:
     276       359641 :             if (myVehicleParameter == nullptr) {
     277              :                 break;
     278              :             }
     279       359641 :             if (myVehicleParameter->repetitionNumber <= 0) {
     280       359641 :                 closeVehicle();
     281       359512 :                 delete myVehicleParameter;
     282       359512 :                 myVehicleParameter = nullptr;
     283              :                 myParamStack.pop_back();
     284              :                 break;
     285              :             }
     286            0 :             myVehicleParameter->repetitionNumber++; // for backwards compatibility
     287              :             // it is a flow, thus no break here
     288              :             FALLTHROUGH;
     289        22834 :         case SUMO_TAG_FLOW:
     290        22834 :             if (myVehicleParameter) {
     291        22834 :                 closeFlow();
     292        22827 :                 delete myVehicleParameter;
     293              :                 myParamStack.pop_back();
     294              :             }
     295        22827 :             myVehicleParameter = nullptr;
     296        22827 :             myInsertStopEdgesAt = -1;
     297        22827 :             break;
     298       243319 :         case SUMO_TAG_TRIP:
     299       243319 :             closeTrip();
     300       243301 :             delete myVehicleParameter;
     301       243301 :             myVehicleParameter = nullptr;
     302              :             myParamStack.pop_back();
     303       243301 :             myInsertStopEdgesAt = -1;
     304       243301 :             break;
     305          644 :         case SUMO_TAG_VTYPE_DISTRIBUTION:
     306          644 :             closeVehicleTypeDistribution();
     307          644 :             break;
     308        93291 :         case SUMO_TAG_ROUTE_DISTRIBUTION:
     309        93291 :             closeRouteDistribution();
     310        93289 :             break;
     311        55008 :         case SUMO_TAG_PERSONTRIP:
     312              :         case SUMO_TAG_RIDE:
     313              :         case SUMO_TAG_TRANSPORT:
     314              :         case SUMO_TAG_TRANSHIP:
     315              :         case SUMO_TAG_WALK:
     316        55008 :             if (myParamStack.size() == 2) {
     317              :                 myParamStack.pop_back();
     318              :             }
     319              :             break;
     320           28 :         case SUMO_TAG_INTERVAL:
     321           28 :             myBeginDefault = string2time(OptionsCont::getOptions().getString("begin"));
     322           28 :             myEndDefault = string2time(OptionsCont::getOptions().getString("end"));
     323           28 :             break;
     324              :         default:
     325              :             break;
     326              :     }
     327              :     myElementStack.pop_back();
     328     11864202 : }
     329              : 
     330              : 
     331              : SUMORouteHandler::StopPos
     332       103447 : SUMORouteHandler::checkStopPos(double& startPos, double& endPos, const double laneLength, const double minLength, const bool friendlyPos) {
     333       103447 :     if (minLength > laneLength) {
     334              :         return STOPPOS_INVALID_LANELENGTH;
     335              :     }
     336       103447 :     if (startPos < 0) {
     337          172 :         startPos += laneLength;
     338              :     }
     339       103447 :     if (endPos < 0) {
     340         1706 :         endPos += laneLength;
     341              :     }
     342       103447 :     if ((endPos < minLength) || (endPos > laneLength)) {
     343          121 :         if (!friendlyPos) {
     344              :             return STOPPOS_INVALID_ENDPOS;
     345              :         }
     346          116 :         if (endPos < minLength) {
     347            3 :             endPos = minLength;
     348              :         }
     349          116 :         if (endPos > laneLength) {
     350          113 :             endPos = laneLength;
     351              :         }
     352              :     }
     353       103442 :     if ((startPos < 0) || (startPos > (endPos - minLength))) {
     354           41 :         if (!friendlyPos) {
     355              :             return STOPPOS_INVALID_STARTPOS;
     356              :         }
     357           41 :         if (startPos < 0) {
     358           13 :             startPos = 0;
     359              :         }
     360           41 :         if (startPos > (endPos - minLength)) {
     361           28 :             startPos = endPos - minLength;
     362              :         }
     363              :     }
     364              :     return STOPPOS_VALID;
     365              : }
     366              : 
     367              : 
     368              : SUMOTime
     369       106467 : SUMORouteHandler::getFirstDepart() const {
     370       106467 :     return myFirstDepart;
     371              : }
     372              : 
     373              : 
     374              : SUMOTime
     375      3322207 : SUMORouteHandler::getLastDepart() const {
     376      3322207 :     return myLastDepart;
     377              : }
     378              : 
     379              : 
     380              : void
     381        57805 : SUMORouteHandler::addParam(const SUMOSAXAttributes& attrs) {
     382        57805 :     bool ok = true;
     383        57805 :     const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, ok);
     384              :     // only continue if key isn't empty
     385        57805 :     if (ok && (key.size() > 0)) {
     386              :         // circumventing empty string test
     387        57805 :         std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
     388              :         // check special params that must be interpreted as relative paths
     389        48843 :         if ((myVehicleParameter != nullptr || myCurrentVType != nullptr)
     390        64453 :                 && (key == "device.toc.file" || key == "device.ssm.file")) {
     391          786 :             val = FileHelpers::checkForRelativity(val, getFileName());
     392              :         }
     393              :         // add parameter in current created element
     394        57805 :         if (!myParamStack.empty()) {
     395        15610 :             if (!myCurrentVTypeRef.empty() && myParamStack.back() == myCurrentVType) {
     396            0 :                 WRITE_WARNINGF(TL("Ignoring param for referenced vType %"), myCurrentVType->id);
     397              :             } else {
     398        15610 :                 myParamStack.back()->setParameter(key, val);
     399              :             }
     400              :         }
     401              :     }
     402        57805 : }
     403              : 
     404              : 
     405              : bool
     406        41918 : SUMORouteHandler::parseStop(SUMOVehicleParameter::Stop& stop, const SUMOSAXAttributes& attrs, std::string errorSuffix, MsgHandler* const errorOutput) {
     407        41918 :     stop.parametersSet = 0;
     408        41918 :     if (attrs.hasAttribute(SUMO_ATTR_ARRIVAL)) {
     409          419 :         stop.parametersSet |= STOP_ARRIVAL_SET;
     410              :     }
     411        41918 :     if (attrs.hasAttribute(SUMO_ATTR_DURATION)) {
     412        23372 :         stop.parametersSet |= STOP_DURATION_SET;
     413              :     }
     414        41918 :     if (attrs.hasAttribute(SUMO_ATTR_UNTIL)) {
     415        20507 :         stop.parametersSet |= STOP_UNTIL_SET;
     416              :     }
     417        41918 :     if (attrs.hasAttribute(SUMO_ATTR_STARTED)) {
     418         6744 :         stop.parametersSet |= STOP_STARTED_SET;
     419              :     }
     420        41918 :     if (attrs.hasAttribute(SUMO_ATTR_ENDED)) {
     421         6226 :         stop.parametersSet |= STOP_ENDED_SET;
     422              :     }
     423        41918 :     if (attrs.hasAttribute(SUMO_ATTR_EXTENSION)) {
     424          464 :         stop.parametersSet |= STOP_EXTENSION_SET;
     425              :     }
     426        41918 :     if (attrs.hasAttribute(SUMO_ATTR_ENDPOS)) {
     427         9169 :         stop.parametersSet |= STOP_END_SET;
     428              :     }
     429        41918 :     if (attrs.hasAttribute(SUMO_ATTR_STARTPOS)) {
     430         1498 :         stop.parametersSet |= STOP_START_SET;
     431              :     }
     432        41918 :     if (attrs.hasAttribute(SUMO_ATTR_POSITION_LAT)) {
     433          128 :         stop.parametersSet |= STOP_POSLAT_SET;
     434              :     }
     435        41918 :     if (attrs.hasAttribute(SUMO_ATTR_TRIGGERED)) {
     436         1595 :         stop.parametersSet |= STOP_TRIGGER_SET;
     437              :     }
     438              :     // legacy attribute
     439        41918 :     if (attrs.hasAttribute(SUMO_ATTR_CONTAINER_TRIGGERED)) {
     440           56 :         stop.parametersSet |= STOP_TRIGGER_SET;
     441              :     }
     442        41918 :     if (attrs.hasAttribute(SUMO_ATTR_PARKING)) {
     443          989 :         stop.parametersSet |= STOP_PARKING_SET;
     444              :     }
     445        41918 :     if (attrs.hasAttribute(SUMO_ATTR_EXPECTED)) {
     446          243 :         stop.parametersSet |= STOP_EXPECTED_SET;
     447              :     }
     448        41918 :     if (attrs.hasAttribute(SUMO_ATTR_PERMITTED)) {
     449          369 :         stop.parametersSet |= STOP_PERMITTED_SET;
     450              :     }
     451        41918 :     if (attrs.hasAttribute(SUMO_ATTR_EXPECTED_CONTAINERS)) {
     452           77 :         stop.parametersSet |= STOP_EXPECTED_CONTAINERS_SET;
     453              :     }
     454        41918 :     if (attrs.hasAttribute(SUMO_ATTR_TRIP_ID)) {
     455          432 :         stop.parametersSet |= STOP_TRIP_ID_SET;
     456              :     }
     457        41918 :     if (attrs.hasAttribute(SUMO_ATTR_SPLIT)) {
     458          356 :         stop.parametersSet |= STOP_SPLIT_SET;
     459              :     }
     460        41918 :     if (attrs.hasAttribute(SUMO_ATTR_JOIN)) {
     461          116 :         stop.parametersSet |= STOP_JOIN_SET;
     462              :     }
     463        41918 :     if (attrs.hasAttribute(SUMO_ATTR_LINE)) {
     464          387 :         stop.parametersSet |= STOP_LINE_SET;
     465              :     }
     466        41918 :     if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
     467          673 :         stop.parametersSet |= STOP_SPEED_SET;
     468              :     }
     469        41918 :     if (attrs.hasAttribute(SUMO_ATTR_ONDEMAND)) {
     470          178 :         stop.parametersSet |= STOP_ONDEMAND_SET;
     471              :     }
     472        41918 :     if (attrs.hasAttribute(SUMO_ATTR_PRIORITY)) {
     473          354 :         stop.parametersSet |= STOP_PRIORITY_SET;
     474              :     }
     475        41918 :     if (attrs.hasAttribute(SUMO_ATTR_JUMP)) {
     476          551 :         stop.parametersSet |= STOP_JUMP_SET;
     477              :     }
     478        41918 :     if (attrs.hasAttribute(SUMO_ATTR_JUMP_UNTIL)) {
     479            7 :         stop.parametersSet |= STOP_JUMP_UNTIL_SET;
     480              :     }
     481        41918 :     bool ok = true;
     482        83836 :     stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, nullptr, ok, "");
     483        41918 :     stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_TRAIN_STOP, nullptr, ok, stop.busstop);
     484        41918 :     stop.chargingStation = attrs.getOpt<std::string>(SUMO_ATTR_CHARGING_STATION, nullptr, ok, "");
     485        41918 :     stop.overheadWireSegment = attrs.getOpt<std::string>(SUMO_ATTR_OVERHEAD_WIRE_SEGMENT, nullptr, ok, "");
     486        41918 :     stop.containerstop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, nullptr, ok, "");
     487        83836 :     stop.parkingarea = attrs.getOpt<std::string>(SUMO_ATTR_PARKING_AREA, nullptr, ok, "");
     488        41918 :     if (stop.busstop != "") {
     489        36429 :         errorSuffix = " at '" + stop.busstop + "'" + errorSuffix;
     490        29775 :     } else if (stop.chargingStation != "") {
     491         3681 :         errorSuffix = " at '" + stop.chargingStation + "'" + errorSuffix;
     492        28548 :     } else if (stop.overheadWireSegment != "") {
     493            0 :         errorSuffix = " at '" + stop.overheadWireSegment + "'" + errorSuffix;
     494        28548 :     } else if (stop.containerstop != "") {
     495         1914 :         errorSuffix = " at '" + stop.containerstop + "'" + errorSuffix;
     496        27910 :     } else if (stop.parkingarea != "") {
     497        47307 :         errorSuffix = " at '" + stop.parkingarea + "'" + errorSuffix;
     498        12141 :     } else if (attrs.hasAttribute(SUMO_ATTR_LANE)) {
     499        30372 :         errorSuffix = " on lane '" + attrs.get<std::string>(SUMO_ATTR_LANE, nullptr, ok) + "'" + errorSuffix;
     500         2017 :     } else if (attrs.hasAttribute(SUMO_ATTR_EDGE)) {
     501         5706 :         errorSuffix = " on edge '" + attrs.get<std::string>(SUMO_ATTR_EDGE, nullptr, ok) + "'" + errorSuffix;
     502              :     } else {
     503          230 :         errorSuffix = " at undefined location" + errorSuffix;
     504              :     }
     505              :     // speed for counting as stopped
     506        41918 :     stop.speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, nullptr, ok, 0);
     507        41918 :     if (stop.speed < 0) {
     508           12 :         errorOutput->inform(TLF("Speed cannot be negative for stop%.", errorSuffix));
     509            6 :         return false;
     510              :     }
     511              : 
     512              :     // get the standing duration
     513        41912 :     bool expectTrigger = !attrs.hasAttribute(SUMO_ATTR_DURATION) && !attrs.hasAttribute(SUMO_ATTR_UNTIL) && !attrs.hasAttribute(SUMO_ATTR_SPEED);
     514        41912 :     std::vector<std::string> triggers = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_TRIGGERED, nullptr, ok);
     515              :     // legacy
     516        41912 :     if (attrs.getOpt<bool>(SUMO_ATTR_CONTAINER_TRIGGERED, nullptr, ok, false)) {
     517          112 :         triggers.push_back(toString(SUMO_TAG_CONTAINER));
     518              :     }
     519        41912 :     SUMOVehicleParameter::parseStopTriggers(triggers, expectTrigger, stop);
     520        41912 :     stop.arrival = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ARRIVAL, nullptr, ok, -1);
     521        41912 :     if (attrs.hasAttribute(SUMO_ATTR_DURATION)) {
     522        23372 :         const std::string durationStr = attrs.get<std::string>(SUMO_ATTR_DURATION, nullptr, ok);
     523              :         std::string error;
     524        23372 :         if (!Distribution_Parameterized::isValidDescription(durationStr, error)) {
     525            0 :             errorOutput->inform(TLF("Invalid duration for a stop% (%).", errorSuffix, error));
     526              :             return false;
     527              :         }
     528        46744 :         stop.durationDist = Distribution_Parameterized(durationStr);
     529        46744 :         stop.duration = TIME2STEPS(stop.durationDist.sample(&myParsingRNG));
     530              :     }
     531        41912 :     stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, nullptr, ok, -1);
     532        41912 :     if (!expectTrigger && (!ok || (stop.duration < 0 && stop.until < 0 && stop.speed == 0))) {
     533           36 :         errorOutput->inform(TLF("Invalid duration or end time is given for a stop%.", errorSuffix));
     534           12 :         return false;
     535              :     }
     536        41900 :     if (triggers.size() > 0 && stop.speed > 0) {
     537            9 :         errorOutput->inform(TLF("Triggers and waypoints cannot be combined%.", errorSuffix));
     538            3 :         return false;
     539              :     }
     540        41897 :     stop.extension = attrs.getOptSUMOTimeReporting(SUMO_ATTR_EXTENSION, nullptr, ok, -1);
     541        41897 :     const bool defaultParking = (stop.triggered || stop.containerTriggered || stop.parkingarea != "");
     542        41897 :     stop.parking = attrs.getOpt<ParkingType>(SUMO_ATTR_PARKING, nullptr, ok, defaultParking ? ParkingType::OFFROAD : ParkingType::ONROAD);
     543        41897 :     if ((stop.parkingarea != "") && (stop.parking == ParkingType::ONROAD)) {
     544           21 :         WRITE_WARNINGF(TL("Stop at parkingArea overrides attribute 'parking' for stop%."), errorSuffix);
     545            7 :         stop.parking = ParkingType::OFFROAD;
     546              :     }
     547              : 
     548              :     // expected persons
     549        41897 :     const std::vector<std::string>& expected = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EXPECTED, nullptr, ok);
     550              :     stop.awaitedPersons.insert(expected.begin(), expected.end());
     551        41897 :     if (stop.awaitedPersons.size() > 0) {
     552          243 :         stop.triggered = true;
     553          243 :         if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
     554          124 :             stop.parking = ParkingType::OFFROAD;
     555              :         }
     556              :     }
     557              : 
     558              :     // permitted transportables
     559        41897 :     const std::vector<std::string>& permitted = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_PERMITTED, nullptr, ok);
     560              :     stop.permitted.insert(permitted.begin(), permitted.end());
     561              : 
     562              :     // expected containers
     563        41897 :     const std::vector<std::string>& expectedContainers = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EXPECTED_CONTAINERS, nullptr, ok);
     564              :     stop.awaitedContainers.insert(expectedContainers.begin(), expectedContainers.end());
     565        41897 :     if (stop.awaitedContainers.size() > 0) {
     566           77 :         stop.containerTriggered = true;
     567           77 :         if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
     568           67 :             stop.parking = ParkingType::OFFROAD;
     569              :         }
     570              :     }
     571              :     // public transport trip id
     572        41897 :     stop.tripId = attrs.getOpt<std::string>(SUMO_ATTR_TRIP_ID, nullptr, ok, "");
     573        41897 :     stop.split = attrs.getOpt<std::string>(SUMO_ATTR_SPLIT, nullptr, ok, "");
     574        41897 :     stop.join = attrs.getOpt<std::string>(SUMO_ATTR_JOIN, nullptr, ok, "");
     575        41897 :     stop.line = attrs.getOpt<std::string>(SUMO_ATTR_LINE, nullptr, ok, "");
     576              : 
     577        41897 :     const std::string idx = attrs.getOpt<std::string>(SUMO_ATTR_INDEX, nullptr, ok, "end");
     578        41897 :     if (idx == "end") {
     579        41645 :         stop.index = STOP_INDEX_END;
     580          252 :     } else if (idx == "fit") {
     581           14 :         stop.index = STOP_INDEX_FIT;
     582              :     } else {
     583          238 :         stop.index = attrs.get<int>(SUMO_ATTR_INDEX, nullptr, ok);
     584          238 :         if (!ok || stop.index < 0) {
     585           18 :             errorOutput->inform(TLF("Invalid 'index' for stop%.", errorSuffix));
     586            6 :             return false;
     587              :         }
     588              :     }
     589        41891 :     stop.started = attrs.getOptSUMOTimeReporting(SUMO_ATTR_STARTED, nullptr, ok, -1);
     590        41891 :     stop.ended = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ENDED, nullptr, ok, -1);
     591        41891 :     stop.posLat = attrs.getOpt<double>(SUMO_ATTR_POSITION_LAT, nullptr, ok, INVALID_DOUBLE);
     592        41891 :     stop.actType = attrs.getOpt<std::string>(SUMO_ATTR_ACTTYPE, nullptr, ok, "");
     593        41891 :     stop.onDemand = attrs.getOpt<bool>(SUMO_ATTR_ONDEMAND, nullptr, ok, false);
     594        41891 :     stop.priority = attrs.getOpt<double>(SUMO_ATTR_PRIORITY, nullptr, ok, -1);
     595        41891 :     stop.jump = attrs.getOptSUMOTimeReporting(SUMO_ATTR_JUMP, nullptr, ok, -1);
     596        41891 :     stop.jumpUntil = attrs.getOptSUMOTimeReporting(SUMO_ATTR_JUMP_UNTIL, nullptr, ok, -1);
     597        41891 :     stop.collision = attrs.getOpt<bool>(SUMO_ATTR_COLLISION, nullptr, ok, false);
     598        41891 :     return true;
     599        41912 : }
     600              : 
     601              : 
     602              : /****************************************************************************/
        

Generated by: LCOV version 2.0-1