LCOV - code coverage report
Current view: top level - src/utils/vehicle - SUMOVehicleParserHelper.cpp (source / functions) Coverage Total Hit
Test: lcov.info Lines: 85.5 % 1171 1001
Test Date: 2026-10-12 15:53:19 Functions: 100.0 % 20 20

            Line data    Source code
       1              : /****************************************************************************/
       2              : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3              : // Copyright (C) 2008-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    SUMOVehicleParserHelper.cpp
      15              : /// @author  Daniel Krajzewicz
      16              : /// @author  Jakob Erdmann
      17              : /// @author  Axel Wegener
      18              : /// @author  Michael Behrisch
      19              : /// @author  Laura Bieker
      20              : /// @author  Mirko Barthauer
      21              : /// @date    Mon, 07.04.2008
      22              : ///
      23              : // Helper methods for parsing vehicle attributes
      24              : /****************************************************************************/
      25              : #include <config.h>
      26              : 
      27              : #include <utils/common/FileHelpers.h>
      28              : #include <utils/common/MsgHandler.h>
      29              : #include <utils/common/RandHelper.h>
      30              : #include <utils/common/StringTokenizer.h>
      31              : #include <utils/common/StringUtils.h>
      32              : #include <utils/common/ToString.h>
      33              : #include <utils/common/UtilExceptions.h>
      34              : #include <utils/options/OptionsCont.h>
      35              : #include <utils/emissions/PollutantsInterface.h>
      36              : #include <utils/router/IntermodalNetwork.h>
      37              : #include <utils/vehicle/SUMOVTypeParameter.h>
      38              : #include <utils/xml/SUMOSAXAttributes.h>
      39              : 
      40              : #include "SUMOVehicleParserHelper.h"
      41              : 
      42              : 
      43              : // ===========================================================================
      44              : // static members
      45              : // ===========================================================================
      46              : 
      47              : SUMOVehicleParserHelper::CFAttrMap SUMOVehicleParserHelper::allowedCFModelAttrs;
      48              : SUMOVehicleParserHelper::LCAttrMap SUMOVehicleParserHelper::allowedLCModelAttrs;
      49              : 
      50              : 
      51              : // ===========================================================================
      52              : // method definitions
      53              : // ===========================================================================
      54              : 
      55              : SUMOVehicleParameter*
      56        25711 : SUMOVehicleParserHelper::parseFlowAttributes(SumoXMLTag tag, const SUMOSAXAttributes& attrs, const bool hardFail, const bool needID,
      57              :         const SUMOTime beginDefault, const SUMOTime endDefault, const bool allowInternalRoutes) {
      58              :     // first parse ID
      59        25711 :     const std::string id = attrs.hasAttribute(SUMO_ATTR_ID) ? parseID(attrs, tag) : "";
      60              :     // check if ID is valid
      61        25711 :     if (!needID || !id.empty()) {
      62        25704 :         if (needID && !SUMOXMLDefinitions::isValidVehicleID(id)) {
      63            0 :             return handleVehicleError(hardFail, nullptr, "Invalid flow id '" + id + "'.");
      64              :         }
      65              :         // declare flags
      66        25704 :         const bool hasPeriod = attrs.hasAttribute(SUMO_ATTR_PERIOD);
      67        25704 :         const bool hasVPH = attrs.hasAttribute(SUMO_ATTR_VEHSPERHOUR);
      68        25704 :         const bool hasPPH = attrs.hasAttribute(SUMO_ATTR_PERSONSPERHOUR);
      69        25704 :         const bool hasCPH = attrs.hasAttribute(SUMO_ATTR_CONTAINERSPERHOUR);
      70        25704 :         const bool hasPH = attrs.hasAttribute(SUMO_ATTR_PERHOUR);
      71        25704 :         const bool hasXPH = hasVPH || hasPPH || hasCPH || hasPH;
      72        25704 :         const bool hasProb = attrs.hasAttribute(SUMO_ATTR_PROB);
      73        25704 :         const bool hasNumber = attrs.hasAttribute(SUMO_ATTR_NUMBER);
      74        25704 :         const bool hasBegin = attrs.hasAttribute(SUMO_ATTR_BEGIN);
      75        25704 :         const bool hasEnd = attrs.hasAttribute(SUMO_ATTR_END);
      76              :         SumoXMLAttr PERHOUR = SUMO_ATTR_PERHOUR;
      77        25704 :         if (hasVPH) {
      78              :             PERHOUR = SUMO_ATTR_VEHSPERHOUR;
      79              :         }
      80        25704 :         if (hasPPH) {
      81              :             PERHOUR = SUMO_ATTR_PERSONSPERHOUR;
      82              :         }
      83        25704 :         if (hasCPH) {
      84              :             PERHOUR = SUMO_ATTR_CONTAINERSPERHOUR;
      85              :         }
      86        25704 :         if (hasXPH && !(hasVPH ^ hasPPH ^ hasCPH ^ hasPH)) {
      87            0 :             return handleVehicleError(hardFail, nullptr,
      88            0 :                                       "At most one of '" + attrs.getName(SUMO_ATTR_PERHOUR) +
      89            0 :                                       "', '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
      90            0 :                                       "', '" + attrs.getName(SUMO_ATTR_PERSONSPERHOUR) +
      91            0 :                                       "' and '" + attrs.getName(SUMO_ATTR_CONTAINERSPERHOUR) +
      92            0 :                                       "' has to be given in the definition of " + toString(tag) + " '" + id + "'.");
      93              :         }
      94         4108 :         if (hasPeriod && hasXPH) {
      95            7 :             return handleVehicleError(hardFail, nullptr,
      96           14 :                                       "At most one of '" + attrs.getName(SUMO_ATTR_PERIOD) +
      97           21 :                                       "' and '" + attrs.getName(PERHOUR) +
      98              :                                       "' has to be given in the definition of "
      99           14 :                                       + toString(tag) + " '" + id + "'.");
     100              :         }
     101        25697 :         if (hasPeriod && hasProb) {
     102            0 :             return handleVehicleError(hardFail, nullptr,
     103            0 :                                       "At most one of '" + attrs.getName(SUMO_ATTR_PERIOD) +
     104            0 :                                       "' and '" + attrs.getName(SUMO_ATTR_PROB) +
     105              :                                       "' has to be given in the definition of "
     106            0 :                                       + toString(tag) + " '" + id + "'.");
     107              :         }
     108        25697 :         if (hasProb && hasXPH) {
     109            0 :             return handleVehicleError(hardFail, nullptr,
     110            0 :                                       "At most one of '" + attrs.getName(SUMO_ATTR_PROB) +
     111            0 :                                       "' and '" + attrs.getName(PERHOUR) +
     112              :                                       "' has to be given in the definition of "
     113            0 :                                       + toString(tag) + " '" + id + "'.");
     114              :         }
     115        25697 :         if (hasPeriod || hasXPH || hasProb) {
     116        20557 :             if (hasEnd && hasNumber) {
     117            7 :                 return handleVehicleError(hardFail, nullptr,
     118           14 :                                           "If '" + attrs.getName(SUMO_ATTR_PERIOD) +
     119           21 :                                           "', '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
     120           21 :                                           "', '" + attrs.getName(SUMO_ATTR_PERSONSPERHOUR) +
     121           21 :                                           "', '" + attrs.getName(SUMO_ATTR_CONTAINERSPERHOUR) +
     122           21 :                                           "', '" + attrs.getName(SUMO_ATTR_PERHOUR) +
     123           21 :                                           "' or '" + attrs.getName(SUMO_ATTR_PROB) +
     124           21 :                                           "' are given at most one of '" + attrs.getName(SUMO_ATTR_END) +
     125           21 :                                           "' and '" + attrs.getName(SUMO_ATTR_NUMBER) +
     126              :                                           "' are allowed in "
     127           14 :                                           + toString(tag) + " '" + id + "'.");
     128              :             }
     129              :         } else {
     130         5140 :             if (!hasNumber) {
     131            7 :                 return handleVehicleError(hardFail, nullptr,
     132           14 :                                           "At least one of '" + attrs.getName(SUMO_ATTR_PERIOD) +
     133           21 :                                           "', '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
     134           21 :                                           "', '" + attrs.getName(SUMO_ATTR_PERSONSPERHOUR) +
     135           21 :                                           "', '" + attrs.getName(SUMO_ATTR_CONTAINERSPERHOUR) +
     136           21 :                                           "', '" + attrs.getName(SUMO_ATTR_PERHOUR) +
     137           21 :                                           "', '" + attrs.getName(SUMO_ATTR_PROB) +
     138           21 :                                           "', and '" + attrs.getName(SUMO_ATTR_NUMBER) +
     139              :                                           "' is needed in "
     140           14 :                                           + toString(tag) + " '" + id + "'.");
     141              :             }
     142              :         }
     143              :         // declare flow
     144        25683 :         SUMOVehicleParameter* flowParameter = new SUMOVehicleParameter();
     145              :         // set tag
     146        25683 :         flowParameter->tag = tag;
     147              :         // set id
     148        25683 :         flowParameter->id = id;
     149        25683 :         if (tag == SUMO_TAG_PERSONFLOW) {
     150         2070 :             flowParameter->vtypeid = DEFAULT_PEDTYPE_ID;
     151              :         }
     152        25683 :         if (tag == SUMO_TAG_CONTAINERFLOW) {
     153          337 :             flowParameter->vtypeid = DEFAULT_CONTAINERTYPE_ID;
     154              :         }
     155              :         // parse common vehicle attributes
     156              :         try {
     157        25683 :             parseCommonAttributes(attrs, flowParameter, tag, allowInternalRoutes);
     158           60 :         } catch (ProcessError& attributeError) {
     159              :             // check if continue handling another vehicles or stop handling
     160           60 :             if (hardFail) {
     161          120 :                 throw ProcessError(attributeError.what());
     162              :             } else {
     163              :                 return nullptr;
     164              :             }
     165           60 :         }
     166              :         // parse period
     167              :         bool poissonFlow = false;
     168        25623 :         if (hasPeriod) {
     169        11756 :             bool ok = true;
     170        11756 :             const std::string description = attrs.get<std::string>(SUMO_ATTR_PERIOD, id.c_str(), ok);
     171        11756 :             const std::string distName = description.substr(0, description.find('('));
     172        11756 :             if (distName == "exp") {
     173              :                 // declare rate
     174              :                 double rate = -1;
     175              :                 // parse rate
     176              :                 try {
     177          968 :                     rate = StringUtils::toDouble(description.substr(distName.size() + 1, description.size() - distName.size() - 2));
     178            0 :                 } catch (ProcessError& attributeError) {
     179              :                     // check if continue handling another vehicles or stop handling
     180            0 :                     if (hardFail) {
     181            0 :                         throw ProcessError(attributeError.what());
     182              :                     } else {
     183              :                         return nullptr;
     184              :                     }
     185            0 :                 }
     186          968 :                 if (rate <= 0) {
     187           14 :                     return handleVehicleError(hardFail, flowParameter, "Invalid rate parameter for exponentially distributed period in the definition of " + toString(tag) + " '" + id + "'.");
     188              :                 }
     189          961 :                 flowParameter->poissonRate = rate;
     190              :                 poissonFlow = true;
     191              :             } else {
     192        10788 :                 flowParameter->repetitionOffset = attrs.getSUMOTimeReporting(SUMO_ATTR_PERIOD, id.c_str(), ok);
     193              :             }
     194        11749 :             if (!ok) {
     195            7 :                 return handleVehicleError(hardFail, flowParameter);
     196              :             } else {
     197        11749 :                 flowParameter->parametersSet |= VEHPARS_PERIOD_SET;
     198              :             }
     199              :         }
     200              :         // parse vehicle/person/container/etc per hour
     201        25616 :         if (hasXPH) {
     202         4101 :             bool ok = true;
     203         4101 :             const double vph = attrs.get<double>(PERHOUR, id.c_str(), ok);
     204         4101 :             if (!ok) {
     205            0 :                 return handleVehicleError(hardFail, flowParameter);
     206         4101 :             } else if (vph <= 0) {
     207            0 :                 return handleVehicleError(hardFail, flowParameter, "Invalid repetition rate in the definition of " + toString(tag) + " '" + id + "'.");
     208              :             } else {
     209              :                 if (vph != 0) {
     210         4101 :                     flowParameter->repetitionOffset = TIME2STEPS(3600. / vph);
     211              :                 }
     212         4101 :                 flowParameter->parametersSet |= VEHPARS_VPH_SET;
     213              :             }
     214              :         }
     215              :         // parse probability
     216        25616 :         if (hasProb) {
     217         4693 :             bool ok = true;
     218         4693 :             flowParameter->repetitionProbability = attrs.get<double>(SUMO_ATTR_PROB, id.c_str(), ok);
     219         4693 :             if (!ok) {
     220            0 :                 return handleVehicleError(hardFail, flowParameter);
     221         4693 :             } else if (flowParameter->repetitionProbability <= 0 || flowParameter->repetitionProbability > 1) {
     222            0 :                 return handleVehicleError(hardFail, flowParameter, "Invalid repetition probability in the definition of " + toString(tag) + " '" + id + "'.");
     223              :             } else {
     224         4693 :                 flowParameter->parametersSet |= VEHPARS_PROB_SET;
     225              :             }
     226              :         }
     227              :         // set default begin
     228        25616 :         flowParameter->depart = beginDefault;
     229              :         // parse begin
     230        25616 :         if (hasBegin) {
     231              :             // first get begin
     232        25392 :             bool ok = true;
     233        25392 :             const std::string begin = attrs.get<std::string>(SUMO_ATTR_BEGIN, id.c_str(), ok);
     234        25392 :             if (!ok) {
     235            7 :                 return handleVehicleError(hardFail, flowParameter);
     236              :             } else {
     237              :                 // parse begin
     238              :                 std::string errorMsg;
     239        50784 :                 if (!SUMOVehicleParameter::parseDepart(begin, toString(tag), id, flowParameter->depart, flowParameter->departProcedure, errorMsg, "begin")) {
     240           14 :                     return handleVehicleError(hardFail, flowParameter, errorMsg);
     241              :                 }
     242              :             }
     243              :         }
     244        25609 :         if (flowParameter->depart < 0) {
     245            0 :             return handleVehicleError(hardFail, flowParameter, "Negative begin time in the definition of " + toString(tag) + " '" + id + "'.");
     246              :         }
     247              :         // set default end
     248        25609 :         flowParameter->repetitionEnd = endDefault;
     249        25609 :         if (flowParameter->repetitionEnd < 0) {
     250        21028 :             flowParameter->repetitionEnd = SUMOTime_MAX;
     251              :         }
     252              :         // parse end
     253        25609 :         if (hasEnd) {
     254        22526 :             bool ok = true;
     255        22526 :             flowParameter->repetitionEnd = attrs.getSUMOTimeReporting(SUMO_ATTR_END, id.c_str(), ok);
     256        22526 :             if (!ok) {
     257            0 :                 return handleVehicleError(hardFail, flowParameter);
     258              :             } else {
     259        22526 :                 flowParameter->parametersSet |= VEHPARS_END_SET;
     260              :             }
     261         3083 :         } else if (flowParameter->departProcedure == DepartDefinition::TRIGGERED) {
     262           55 :             if (!hasNumber) {
     263            0 :                 return handleVehicleError(hardFail, flowParameter, toString(tag) + " '" + id + "' with triggered begin must define 'number'.");
     264              :             } else {
     265           55 :                 flowParameter->repetitionEnd = flowParameter->depart;
     266              :             }
     267         3028 :         } else if ((endDefault == SUMOTime_MAX || endDefault < 0) && (!hasNumber || (!hasProb && !hasPeriod && !hasXPH))) {
     268          177 :             WRITE_WARNINGF(TL("Undefined end for % '%', defaulting to 24hour duration."), toString(tag), id);
     269           59 :             flowParameter->repetitionEnd = flowParameter->depart + TIME2STEPS(24 * 3600);
     270              :         }
     271        25609 :         if (flowParameter->repetitionEnd < flowParameter->depart) {
     272            7 :             std::string flow = toString(tag);
     273            7 :             flow[0] = (char)::toupper((char)flow[0]);
     274           21 :             return handleVehicleError(hardFail, flowParameter, flow + " '" + id + "' ends before its begin time.");
     275              :         }
     276              :         // parse number
     277        25602 :         if (hasNumber) {
     278         7832 :             bool ok = true;
     279         7832 :             flowParameter->repetitionNumber = attrs.get<long long int>(SUMO_ATTR_NUMBER, id.c_str(), ok);
     280         7832 :             if (!ok) {
     281            0 :                 return handleVehicleError(hardFail, flowParameter);
     282              :             } else {
     283         7832 :                 flowParameter->parametersSet |= VEHPARS_NUMBER_SET;
     284         7832 :                 if (flowParameter->repetitionNumber == 0) {
     285            9 :                     std::string flow = toString(tag);
     286            9 :                     flow[0] = (char)::toupper((char)flow[0]);
     287           18 :                     WRITE_WARNING(flow + " '" + id + "' has no instances; will skip it.");
     288            9 :                     flowParameter->repetitionEnd = flowParameter->depart;
     289              :                 } else {
     290         7823 :                     if (flowParameter->repetitionNumber < 0) {
     291           14 :                         return handleVehicleError(hardFail, flowParameter, "Negative repetition number in the definition of " + toString(tag) + " '" + id + "'.");
     292              :                     }
     293         7816 :                     if (flowParameter->repetitionOffset < 0 && !hasProb) {
     294         5204 :                         if (poissonFlow) {
     295          140 :                             flowParameter->repetitionEnd = SUMOTime_MAX;
     296              :                         } else {
     297         5064 :                             flowParameter->repetitionOffset = (flowParameter->repetitionEnd - flowParameter->depart) / flowParameter->repetitionNumber;
     298              :                         }
     299              :                     }
     300              :                 }
     301              :             }
     302              :         } else {
     303              :             // interpret repetitionNumber
     304        17770 :             if (flowParameter->repetitionProbability > 0) {
     305         4650 :                 flowParameter->repetitionNumber = std::numeric_limits<long long int>::max();
     306              :             } else {
     307        13120 :                 if (flowParameter->repetitionOffset <= 0) {
     308          835 :                     if (poissonFlow) {
     309              :                         // number is random but flow has a fixed end time
     310          821 :                         flowParameter->repetitionNumber = std::numeric_limits<long long int>::max();
     311              :                     } else {
     312           28 :                         return handleVehicleError(hardFail, flowParameter, "Invalid repetition rate in the definition of " + toString(tag) + " '" + id + "'.");
     313              :                     }
     314              :                 } else {
     315        12285 :                     if (flowParameter->repetitionEnd == SUMOTime_MAX) {
     316            0 :                         flowParameter->repetitionNumber = std::numeric_limits<long long int>::max();
     317              :                     } else {
     318        12285 :                         const SUMOTime repLength = flowParameter->repetitionEnd - flowParameter->depart;
     319        12285 :                         flowParameter->repetitionNumber = (long long int)ceil((double)repLength / (double)flowParameter->repetitionOffset);
     320              :                     }
     321              :                 }
     322              :             }
     323              :         }
     324              :         // all ok, then return flow parameter
     325        25581 :         return flowParameter;
     326              :     } else {
     327          144 :         return handleVehicleError(hardFail, nullptr, toString(tag) + " cannot be created");
     328              :     }
     329              : }
     330              : 
     331              : 
     332              : SUMOVehicleParameter*
     333       652845 : SUMOVehicleParserHelper::parseVehicleAttributes(int element, const SUMOSAXAttributes& attrs, const bool hardFail, const bool optionalID, const bool skipDepart, const bool allowInternalRoutes) {
     334              :     // declare vehicle ID
     335              :     std::string id;
     336              :     // for certain vehicles, ID can be optional
     337       652845 :     if (optionalID) {
     338          696 :         bool ok = true;
     339          696 :         id = attrs.getOpt<std::string>(SUMO_ATTR_ID, nullptr, ok, "");
     340          696 :         if (!ok) {
     341            0 :             return handleVehicleError(hardFail, nullptr);
     342              :         }
     343              :     } else {
     344              :         // parse ID
     345      1304298 :         id = parseID(attrs, (SumoXMLTag)element);
     346              :     }
     347              :     // only continue if id is valid, or if is optional
     348       652845 :     if (optionalID || !id.empty()) {
     349              :         // declare vehicle parameter
     350       652825 :         SUMOVehicleParameter* vehicleParameter = new SUMOVehicleParameter();
     351       652825 :         vehicleParameter->id = id;
     352       652825 :         if (element == SUMO_TAG_PERSON) {
     353        45423 :             vehicleParameter->vtypeid = DEFAULT_PEDTYPE_ID;
     354       607402 :         } else if (element == SUMO_TAG_CONTAINER) {
     355         2124 :             vehicleParameter->vtypeid = DEFAULT_CONTAINERTYPE_ID;
     356              :         }
     357              :         // parse common attributes
     358              :         try {
     359       652825 :             parseCommonAttributes(attrs, vehicleParameter, (SumoXMLTag)element, allowInternalRoutes);
     360          335 :         } catch (ProcessError& attributeError) {
     361              :             // check if continue handling another vehicles or stop handling
     362          335 :             if (hardFail) {
     363          670 :                 throw ProcessError(attributeError.what());
     364              :             } else {
     365              :                 return nullptr;
     366              :             }
     367          335 :         }
     368              :         // check depart
     369       652490 :         if (!skipDepart) {
     370       651794 :             bool ok = true;
     371       651794 :             const std::string helper = attrs.get<std::string>(SUMO_ATTR_DEPART, vehicleParameter->id.c_str(), ok);
     372       651794 :             if (!ok) {
     373           50 :                 return handleVehicleError(hardFail, vehicleParameter);
     374              :             }
     375              :             // now parse depart
     376              :             std::string departErrorMsg;
     377      1303548 :             if (!SUMOVehicleParameter::parseDepart(helper, "vehicle", vehicleParameter->id, vehicleParameter->depart, vehicleParameter->departProcedure, departErrorMsg)) {
     378           20 :                 return handleVehicleError(hardFail, vehicleParameter, departErrorMsg);
     379              :             }
     380              :         }
     381              :         // set tag
     382       652460 :         vehicleParameter->tag = (SumoXMLTag)element;
     383              :         // all ok, then return vehicleParameter
     384       652460 :         return vehicleParameter;
     385              :     } else {
     386          425 :         return handleVehicleError(hardFail, nullptr, toString((SumoXMLTag)element) + " cannot be created");
     387              :     }
     388              : }
     389              : 
     390              : 
     391              : std::string
     392       743284 : SUMOVehicleParserHelper::parseID(const SUMOSAXAttributes& attrs, const SumoXMLTag element) {
     393       743284 :     bool ok = true;
     394              :     std::string id;
     395              :     // first check if attrs contain an ID
     396       743284 :     if (attrs.hasAttribute(SUMO_ATTR_ID)) {
     397       743269 :         id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
     398       743269 :         if (SUMOXMLDefinitions::isValidVehicleID(id)) {
     399       743259 :             return id;
     400           10 :         } else if (id.empty()) {
     401              :             // add extra information for empty IDs
     402           30 :             WRITE_ERRORF(TL("Invalid % id '%'."), toString(element), id);
     403              :         } else {
     404            0 :             WRITE_ERRORF(TL("Invalid % id '%'. Contains invalid characters."), toString(element), id);
     405              :         }
     406              :     } else {
     407           45 :         WRITE_ERROR("Attribute '" + toString(SUMO_ATTR_ID) + "' is missing in definition of " + toString(element));
     408              :     }
     409              :     // return empty (invalid) ID
     410           25 :     return "";
     411              : }
     412              : 
     413              : 
     414              : void
     415       678508 : SUMOVehicleParserHelper::parseCommonAttributes(const SUMOSAXAttributes& attrs, SUMOVehicleParameter* ret, SumoXMLTag tag, const bool allowInternalRoutes) {
     416       678508 :     const std::string element = toString(tag);
     417              :     //ret->refid = attrs.getStringSecure(SUMO_ATTR_REFID, "");
     418              :     // parse route information
     419       678508 :     if (attrs.hasAttribute(SUMO_ATTR_ROUTE)) {
     420       168959 :         bool ok = true;
     421       168959 :         std::string routeID = attrs.get<std::string>(SUMO_ATTR_ROUTE, ret->id.c_str(), ok);
     422       168959 :         if (!allowInternalRoutes && isInternalRouteID(routeID)) {
     423            0 :             WRITE_WARNINGF(TL("Internal routes receive an ID starting with '!' and must not be referenced in other vehicle or flow definitions. Please remove all references to route '%' in case it is internal."), routeID);
     424              :         }
     425       168959 :         ret->routeid = routeID;
     426       168959 :         if (ok) {
     427       168948 :             ret->parametersSet |= VEHPARS_ROUTE_SET; // !!! needed?
     428              :         } else {
     429           22 :             handleVehicleError(true, ret);
     430              :         }
     431              :     }
     432              :     // parse type information
     433       678497 :     if (attrs.hasAttribute(SUMO_ATTR_TYPE)) {
     434       222757 :         bool ok = true;
     435       222757 :         ret->vtypeid = attrs.get<std::string>(SUMO_ATTR_TYPE, ret->id.c_str(), ok);
     436       222757 :         if (ok) {
     437       222757 :             ret->parametersSet |= VEHPARS_VTYPE_SET; // !!! needed?
     438              :         } else {
     439            0 :             handleVehicleError(true, ret);
     440              :         }
     441              :     }
     442              :     // parse line information
     443       678497 :     if (attrs.hasAttribute(SUMO_ATTR_LINE)) {
     444         3497 :         bool ok = true;
     445         3497 :         ret->line = attrs.get<std::string>(SUMO_ATTR_LINE, ret->id.c_str(), ok);
     446         3497 :         if (ok) {
     447         3491 :             ret->parametersSet |= VEHPARS_LINE_SET; // !!! needed?
     448              :         } else {
     449            6 :             handleVehicleError(true, ret);
     450              :         }
     451              :     }
     452              :     // parse zone information
     453       678491 :     if (attrs.hasAttribute(SUMO_ATTR_FROM_TAZ)) {
     454        21626 :         bool ok = true;
     455        21626 :         ret->fromTaz = attrs.get<std::string>(SUMO_ATTR_FROM_TAZ, ret->id.c_str(), ok);
     456        21626 :         if (ok) {
     457        21626 :             ret->parametersSet |= VEHPARS_FROM_TAZ_SET;
     458              :         } else {
     459            0 :             handleVehicleError(true, ret);
     460              :         }
     461              :     }
     462       678491 :     if (attrs.hasAttribute(SUMO_ATTR_TO_TAZ)) {
     463        21632 :         bool ok = true;
     464        21632 :         ret->toTaz = attrs.get<std::string>(SUMO_ATTR_TO_TAZ, ret->id.c_str(), ok);
     465        21632 :         if (ok) {
     466        21632 :             ret->parametersSet |= VEHPARS_TO_TAZ_SET;
     467              :         } else {
     468            0 :             handleVehicleError(true, ret);
     469              :         }
     470              :     }
     471              :     // parse reroute information
     472       678491 :     if (attrs.hasAttribute(SUMO_ATTR_REROUTE)) {
     473         3726 :         bool ok = true;
     474         3726 :         if (attrs.get<bool>(SUMO_ATTR_REROUTE, ret->id.c_str(), ok)) {
     475         3726 :             if (ok) {
     476         3726 :                 ret->parametersSet |= VEHPARS_FORCE_REROUTE;
     477              :             } else {
     478            0 :                 handleVehicleError(true, ret);
     479              :             }
     480              :         }
     481              :     }
     482              :     // parse depart lane information
     483       678491 :     if (attrs.hasAttribute(SUMO_ATTR_DEPARTLANE)) {
     484       112169 :         bool ok = true;
     485       112169 :         const std::string departLaneStr = attrs.get<std::string>(SUMO_ATTR_DEPARTLANE, ret->id.c_str(), ok);
     486              :         int lane;
     487              :         DepartLaneDefinition dld;
     488              :         std::string error;
     489       112169 :         if (SUMOVehicleParameter::parseDepartLane(departLaneStr, element, ret->id, lane, dld, error)) {
     490       112109 :             ret->parametersSet |= VEHPARS_DEPARTLANE_SET;
     491       112109 :             ret->departLane = lane;
     492       112109 :             ret->departLaneProcedure = dld;
     493              :         } else {
     494          120 :             handleVehicleError(true, ret, error);
     495              :         }
     496              :     }
     497              :     // parse depart position information
     498       678431 :     if (attrs.hasAttribute(SUMO_ATTR_DEPARTPOS)) {
     499        92078 :         bool ok = true;
     500        92078 :         const std::string departPosStr = attrs.get<std::string>(SUMO_ATTR_DEPARTPOS, ret->id.c_str(), ok);
     501              :         double pos;
     502              :         DepartPosDefinition dpd;
     503              :         std::string error;
     504        92078 :         if (SUMOVehicleParameter::parseDepartPos(departPosStr, element, ret->id, pos, dpd, error)) {
     505        92018 :             ret->parametersSet |= VEHPARS_DEPARTPOS_SET;
     506        92018 :             ret->departPos = pos;
     507        92018 :             ret->departPosProcedure = dpd;
     508              :         } else {
     509          120 :             handleVehicleError(true, ret, error);
     510              :         }
     511              :     }
     512              :     // parse lateral depart position information
     513       678371 :     if (attrs.hasAttribute(SUMO_ATTR_DEPARTPOS_LAT)) {
     514         8719 :         bool ok = true;
     515         8719 :         const std::string departPosLatStr = attrs.get<std::string>(SUMO_ATTR_DEPARTPOS_LAT, ret->id.c_str(), ok);
     516              :         double pos;
     517              :         DepartPosLatDefinition dpd;
     518              :         std::string error;
     519         8719 :         if (SUMOVehicleParameter::parseDepartPosLat(departPosLatStr, element, ret->id, pos, dpd, error)) {
     520         8719 :             ret->parametersSet |= VEHPARS_DEPARTPOSLAT_SET;
     521         8719 :             ret->departPosLat = pos;
     522         8719 :             ret->departPosLatProcedure = dpd;
     523              :         } else {
     524            0 :             handleVehicleError(true, ret, error);
     525              :         }
     526              :     }
     527              :     // parse depart speed information
     528       678371 :     if (attrs.hasAttribute(SUMO_ATTR_DEPARTSPEED)) {
     529       244098 :         bool ok = true;
     530       244098 :         const std::string departSpeed = attrs.get<std::string>(SUMO_ATTR_DEPARTSPEED, ret->id.c_str(), ok);
     531              :         double speed;
     532              :         DepartSpeedDefinition dsd;
     533              :         std::string error;
     534       244098 :         if (SUMOVehicleParameter::parseDepartSpeed(departSpeed, element, ret->id, speed, dsd, error)) {
     535       244038 :             ret->parametersSet |= VEHPARS_DEPARTSPEED_SET;
     536       244038 :             ret->departSpeed = speed;
     537       244038 :             ret->departSpeedProcedure = dsd;
     538              :         } else {
     539          120 :             handleVehicleError(true, ret, error);
     540              :         }
     541              :     }
     542              :     // parse depart edge information
     543       678311 :     if (attrs.hasAttribute(SUMO_ATTR_DEPARTEDGE)) {
     544          301 :         bool ok = true;
     545          301 :         const std::string departEdgeStr = attrs.get<std::string>(SUMO_ATTR_DEPARTEDGE, ret->id.c_str(), ok);
     546              :         int edgeIndex;
     547              :         RouteIndexDefinition rid;
     548              :         std::string error;
     549          301 :         if (SUMOVehicleParameter::parseRouteIndex(departEdgeStr, element, ret->id, SUMO_ATTR_DEPARTEDGE, edgeIndex, rid, error)) {
     550          294 :             ret->parametersSet |= VEHPARS_DEPARTEDGE_SET;
     551          294 :             ret->departEdge = edgeIndex;
     552          294 :             ret->departEdgeProcedure = rid;
     553              :         } else {
     554           14 :             handleVehicleError(true, ret, error);
     555              :         }
     556              :     }
     557              :     // parse arrival lane information
     558       678304 :     if (attrs.hasAttribute(SUMO_ATTR_ARRIVALLANE)) {
     559         3348 :         bool ok = true;
     560         3348 :         const std::string arrivalLaneStr = attrs.get<std::string>(SUMO_ATTR_ARRIVALLANE, ret->id.c_str(), ok);
     561              :         int lane;
     562              :         ArrivalLaneDefinition ald;
     563              :         std::string error;
     564         3348 :         if (SUMOVehicleParameter::parseArrivalLane(arrivalLaneStr, element, ret->id, lane, ald, error)) {
     565         3288 :             ret->parametersSet |= VEHPARS_ARRIVALLANE_SET;
     566         3288 :             ret->arrivalLane = lane;
     567         3288 :             ret->arrivalLaneProcedure = ald;
     568              :         } else {
     569          120 :             handleVehicleError(true, ret, error);
     570              :         }
     571              :     }
     572              :     // parse arrival position information
     573       678244 :     if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS)) {
     574         8458 :         bool ok = true;
     575         8458 :         const std::string arrivalPosStr = attrs.get<std::string>(SUMO_ATTR_ARRIVALPOS, ret->id.c_str(), ok);
     576              :         double pos;
     577              :         ArrivalPosDefinition apd;
     578              :         std::string error;
     579         8458 :         if (SUMOVehicleParameter::parseArrivalPos(arrivalPosStr, element, ret->id, pos, apd, error)) {
     580         8398 :             ret->parametersSet |= VEHPARS_ARRIVALPOS_SET;
     581         8398 :             ret->arrivalPos = pos;
     582         8398 :             ret->arrivalPosProcedure = apd;
     583              :         } else {
     584          120 :             handleVehicleError(true, ret, error);
     585              :         }
     586              :     }
     587              :     // parse lateral arrival position information
     588       678184 :     if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS_LAT)) {
     589         1072 :         bool ok = true;
     590         1072 :         const std::string arrivalPosLatStr = attrs.get<std::string>(SUMO_ATTR_ARRIVALPOS_LAT, ret->id.c_str(), ok);
     591              :         double pos;
     592              :         ArrivalPosLatDefinition apd;
     593              :         std::string error;
     594         1072 :         if (SUMOVehicleParameter::parseArrivalPosLat(arrivalPosLatStr, element, ret->id, pos, apd, error)) {
     595         1072 :             ret->parametersSet |= VEHPARS_ARRIVALPOSLAT_SET;
     596         1072 :             ret->arrivalPosLat = pos;
     597         1072 :             ret->arrivalPosLatProcedure = apd;
     598              :         } else {
     599            0 :             handleVehicleError(true, ret, error);
     600              :         }
     601              :     }
     602              :     // parse arrival speed information
     603       678184 :     if (attrs.hasAttribute(SUMO_ATTR_ARRIVALSPEED)) {
     604         3852 :         bool ok = true;
     605         3852 :         std::string arrivalSpeedStr = attrs.get<std::string>(SUMO_ATTR_ARRIVALSPEED, ret->id.c_str(), ok);
     606              :         double speed;
     607              :         ArrivalSpeedDefinition asd;
     608              :         std::string error;
     609         3852 :         if (SUMOVehicleParameter::parseArrivalSpeed(arrivalSpeedStr, element, ret->id, speed, asd, error)) {
     610         3792 :             ret->parametersSet |= VEHPARS_ARRIVALSPEED_SET;
     611         3792 :             ret->arrivalSpeed = speed;
     612         3792 :             ret->arrivalSpeedProcedure = asd;
     613              :         } else {
     614          120 :             handleVehicleError(true, ret, error);
     615              :         }
     616              :     }
     617              :     // parse arrival edge information
     618       678124 :     if (attrs.hasAttribute(SUMO_ATTR_ARRIVALEDGE)) {
     619          111 :         bool ok = true;
     620          111 :         std::string arrivalEdgeStr = attrs.get<std::string>(SUMO_ATTR_ARRIVALEDGE, ret->id.c_str(), ok);
     621              :         int edgeIndex;
     622              :         RouteIndexDefinition rid;
     623              :         std::string error;
     624          111 :         if (SUMOVehicleParameter::parseRouteIndex(arrivalEdgeStr, element, ret->id, SUMO_ATTR_ARRIVALEDGE, edgeIndex, rid, error)) {
     625          104 :             ret->parametersSet |= VEHPARS_ARRIVALEDGE_SET;
     626          104 :             ret->arrivalEdge = edgeIndex;
     627          104 :             ret->arrivalEdgeProcedure = rid;
     628              :         } else {
     629           14 :             handleVehicleError(true, ret, error);
     630              :         }
     631              :     }
     632              :     // parse color
     633       678117 :     if (attrs.hasAttribute(SUMO_ATTR_COLOR)) {
     634        10412 :         bool ok = true;
     635        10412 :         ret->color = attrs.get<RGBColor>(SUMO_ATTR_COLOR, ret->id.c_str(), ok);
     636        10412 :         if (ok) {
     637        10412 :             ret->parametersSet |= VEHPARS_COLOR_SET;
     638              :         } else {
     639            0 :             handleVehicleError(true, ret, "Invalid RGBColor format");
     640              :         }
     641              :     } else {
     642       667705 :         ret->color = RGBColor::DEFAULT_COLOR;
     643              :     }
     644              :     // parse person number
     645       678117 :     if (attrs.hasAttribute(SUMO_ATTR_PERSON_NUMBER)) {
     646          982 :         bool ok = true;
     647          982 :         int personNumber = attrs.get<int>(SUMO_ATTR_PERSON_NUMBER, ret->id.c_str(), ok);
     648          982 :         if (!ok) {
     649            0 :             handleVehicleError(true, ret);
     650          982 :         } else if (personNumber >= 0) {
     651          982 :             ret->parametersSet |= VEHPARS_PERSON_NUMBER_SET;
     652          982 :             ret->personNumber = personNumber;
     653              :         } else {
     654            0 :             handleVehicleError(true, ret, toString(SUMO_ATTR_PERSON_NUMBER) + " cannot be negative");
     655              :         }
     656              :     }
     657              :     // parse container number
     658       678117 :     if (attrs.hasAttribute(SUMO_ATTR_CONTAINER_NUMBER)) {
     659          976 :         bool ok = true;
     660          976 :         int containerNumber = attrs.get<int>(SUMO_ATTR_CONTAINER_NUMBER, ret->id.c_str(), ok);
     661          976 :         if (!ok) {
     662            0 :             handleVehicleError(true, ret);
     663          976 :         } else if (containerNumber >= 0) {
     664          976 :             ret->parametersSet |= VEHPARS_CONTAINER_NUMBER_SET;
     665          976 :             ret->containerNumber = containerNumber;
     666              :         } else {
     667            0 :             handleVehicleError(true, ret, toString(SUMO_ATTR_CONTAINER_NUMBER) + " cannot be negative");
     668              :         }
     669              :     }
     670              :     // parse individual speedFactor
     671       678117 :     if (attrs.hasAttribute(SUMO_ATTR_SPEEDFACTOR)) {
     672        11424 :         bool ok = true;
     673        11424 :         double speedFactor = attrs.get<double>(SUMO_ATTR_SPEEDFACTOR, ret->id.c_str(), ok);
     674        11424 :         if (!ok) {
     675            0 :             handleVehicleError(true, ret);
     676        11424 :         } else if (speedFactor > 0) {
     677        11424 :             ret->parametersSet |= VEHPARS_SPEEDFACTOR_SET;
     678        11424 :             ret->speedFactor = speedFactor;
     679              :         } else {
     680            0 :             handleVehicleError(true, ret, toString(SUMO_ATTR_SPEEDFACTOR) + " must be positive");
     681              :         }
     682              :     }
     683              :     // parse insertion checks
     684       678117 :     if (attrs.hasAttribute(SUMO_ATTR_INSERTIONCHECKS)) {
     685         1013 :         ret->parametersSet |= VEHPARS_INSERTION_CHECKS_SET;
     686         1013 :         bool ok = true;
     687         1013 :         std::string checks = attrs.get<std::string>(SUMO_ATTR_INSERTIONCHECKS, ret->id.c_str(), ok);
     688         1013 :         if (!ok) {
     689            4 :             handleVehicleError(true, ret);
     690              :         } else {
     691              :             try {
     692         1013 :                 ret->insertionChecks = SUMOVehicleParameter::parseInsertionChecks(checks);
     693            4 :             } catch (InvalidArgument& e) {
     694            4 :                 handleVehicleError(true, ret, e.what());
     695            4 :             }
     696              :         }
     697              :     }
     698              :     // parse parking access rights
     699       678113 :     if (attrs.hasAttribute(SUMO_ATTR_PARKING_BADGES)) {
     700            7 :         bool ok = true;
     701            7 :         std::vector<std::string> badges = attrs.get<std::vector<std::string>>(SUMO_ATTR_PARKING_BADGES, ret->id.c_str(), ok);
     702            7 :         if (!ok) {
     703            0 :             handleVehicleError(true, ret);
     704              :         } else {
     705            7 :             ret->parametersSet |= VEHPARS_PARKING_BADGES_SET;
     706            7 :             ret->parkingBadges = badges;
     707              :         }
     708            7 :     }
     709              :     // parse modes (transportables only)
     710       678113 :     ret->modes = 0;
     711       678113 :     if (attrs.hasAttribute(SUMO_ATTR_MODES)) {
     712            5 :         bool ok = true;
     713            5 :         const std::string modeString = attrs.get<std::string>(SUMO_ATTR_MODES, ret->id.c_str(), ok);
     714            5 :         if (!ok) {
     715            0 :             handleVehicleError(true, ret);
     716              :         } else {
     717              :             std::string errorMsg;
     718           10 :             if (!SUMOVehicleParameter::parsePersonModes(modeString, toString(tag), ret->id, ret->modes, errorMsg)) {
     719            0 :                 handleVehicleError(true, ret, errorMsg);
     720              :             }
     721              :         }
     722              :     }
     723              :     // parse usable vehicle types (transportables only)
     724       678113 :     if (attrs.hasAttribute(SUMO_ATTR_VTYPES)) {
     725            0 :         bool ok = true;
     726            0 :         ret->vTypes = attrs.get<std::string>(SUMO_ATTR_VTYPES, ret->id.c_str(), ok);
     727            0 :         if (!ok) {
     728            0 :             handleVehicleError(true, ret);
     729              :         }
     730              :     }
     731              :     // parse speed (only used by calibrators flow)
     732              :     // also used by vehicle in saved state but this is parsed elsewhere
     733       678113 :     if (tag == SUMO_TAG_FLOW && attrs.hasAttribute(SUMO_ATTR_SPEED)) {
     734          223 :         bool ok = true;
     735          223 :         double calibratorSpeed = attrs.get<double>(SUMO_ATTR_SPEED, ret->id.c_str(), ok);
     736          223 :         if (!ok) {
     737            0 :             handleVehicleError(true, ret);
     738          223 :         } else if (calibratorSpeed >= 0 || calibratorSpeed == -1) {
     739          223 :             ret->parametersSet |= VEHPARS_CALIBRATORSPEED_SET;
     740          223 :             ret->calibratorSpeed = calibratorSpeed;
     741              :         } else {
     742          395 :             handleVehicleError(true, ret, toString(SUMO_ATTR_SPEED) + " may not be negative");
     743              :         }
     744              :     }
     745              :     /*/ parse via
     746              :     if (attrs.hasAttribute(SUMO_ATTR_VIA)) {
     747              :         ret->setParameter |= VEHPARS_VIA_SET;
     748              :         SUMOSAXAttributes::parseStringVector(attrs.get<std::string>(SUMO_ATTR_VIA, ret->id.c_str(), ok), ret->via);
     749              :     }
     750              :     */
     751       678113 : }
     752              : 
     753              : 
     754              : SUMOVTypeParameter*
     755        65431 : SUMOVehicleParserHelper::beginVTypeParsing(const SUMOSAXAttributes& attrs, const bool hardFail, const std::string& file, const SUMOVTypeParameter* const base) {
     756        65431 :     const std::string id = (attrs.hasAttribute(SUMO_ATTR_ID) || base == nullptr) ? parseID(attrs, SUMO_TAG_VTYPE) : "";
     757        65431 :     if (!id.empty()) {
     758              :         // create vType
     759        65426 :         SUMOVehicleClass vClass = base == nullptr ? SVC_PASSENGER : base->vehicleClass;
     760        65426 :         if (attrs.hasAttribute(SUMO_ATTR_VCLASS)) {
     761        37517 :             vClass = parseVehicleClass(attrs, id);
     762              :         }
     763              :         SUMOVTypeParameter* vType;
     764        65426 :         if (base == nullptr) {
     765        65372 :             vType = new SUMOVTypeParameter(id, vClass);
     766              :         } else {
     767           54 :             vType = new SUMOVTypeParameter(*base);
     768           54 :             vType->id = id;
     769           54 :             vType->vehicleClass = vClass;
     770              :         }
     771              :         // parse attributes
     772        65426 :         if (attrs.hasAttribute(SUMO_ATTR_VCLASS)) {
     773        37517 :             vType->parametersSet |= VTYPEPARS_VEHICLECLASS_SET;
     774              :         }
     775        65426 :         if (attrs.hasAttribute(SUMO_ATTR_LENGTH)) {
     776        38573 :             bool ok = true;
     777        38573 :             const double length = attrs.get<double>(SUMO_ATTR_LENGTH, vType->id.c_str(), ok);
     778        38573 :             if (!ok) {
     779            0 :                 return handleVehicleTypeError(hardFail, vType);
     780        38573 :             } else if (length <= 0) {
     781            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_LENGTH) + " must be greater than 0");
     782              :             } else {
     783        38573 :                 vType->length = length;
     784        38573 :                 vType->parametersSet |= VTYPEPARS_LENGTH_SET;
     785              :             }
     786              :         }
     787        65426 :         if (attrs.hasAttribute(SUMO_ATTR_MINGAP)) {
     788        36336 :             bool ok = true;
     789        36336 :             const double minGap = attrs.get<double>(SUMO_ATTR_MINGAP, vType->id.c_str(), ok);
     790        36336 :             if (!ok) {
     791            0 :                 return handleVehicleTypeError(hardFail, vType);
     792        36336 :             } else if (minGap < 0) {
     793            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MINGAP) + " must be equal or greater than 0");
     794              :             } else {
     795        36336 :                 vType->minGap = minGap;
     796        36336 :                 vType->parametersSet |= VTYPEPARS_MINGAP_SET;
     797              :             }
     798              :         }
     799        65426 :         if (attrs.hasAttribute(SUMO_ATTR_MAXSPEED)) {
     800        37788 :             bool ok = true;
     801        37788 :             const double maxSpeed = attrs.get<double>(SUMO_ATTR_MAXSPEED, vType->id.c_str(), ok);
     802        37788 :             if (!ok) {
     803            0 :                 return handleVehicleTypeError(hardFail, vType);
     804        37788 :             } else if (maxSpeed <= 0) {
     805            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MAXSPEED) + " must be greater than 0");
     806              :             } else {
     807        37788 :                 vType->maxSpeed = maxSpeed;
     808        37788 :                 vType->parametersSet |= VTYPEPARS_MAXSPEED_SET;
     809              :             }
     810              :         }
     811        65426 :         if (attrs.hasAttribute(SUMO_ATTR_DESIRED_MAXSPEED)) {
     812           89 :             bool ok = true;
     813           89 :             const double desiredMaxSpeed = attrs.get<double>(SUMO_ATTR_DESIRED_MAXSPEED, vType->id.c_str(), ok);
     814           89 :             if (!ok) {
     815            0 :                 return handleVehicleTypeError(hardFail, vType);
     816           89 :             } else if (desiredMaxSpeed <= 0) {
     817            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_DESIRED_MAXSPEED) + " must be greater than 0");
     818              :             } else {
     819           89 :                 vType->desiredMaxSpeed = desiredMaxSpeed;
     820           89 :                 vType->parametersSet |= VTYPEPARS_DESIRED_MAXSPEED_SET;
     821              :             }
     822        65337 :         } else if (attrs.hasAttribute(SUMO_ATTR_MAXSPEED)) {
     823        37767 :             if (vClass == SVC_PEDESTRIAN) {
     824              :                 // backward compatibility because pedestrian maxSpeed was subject to speedFactor up to 1.14.1
     825        25883 :                 vType->desiredMaxSpeed = vType->maxSpeed;;
     826        77644 :                 vType->maxSpeed = MAX2(vType->maxSpeed, SUMOVTypeParameter::VClassDefaultValues(vClass).maxSpeed);
     827        11884 :             } else if (vClass == SVC_BICYCLE) {
     828              :                 // backward compatibility because default desired speed did not exist up to 1.14.1
     829          192 :                 vType->desiredMaxSpeed = MAX2(vType->maxSpeed, vType->desiredMaxSpeed);
     830              :             }
     831              :         }
     832              : 
     833        65426 :         if (attrs.hasAttribute(SUMO_ATTR_SPEEDFACTOR)) {
     834         2520 :             bool ok = true;
     835         2520 :             vType->speedFactor.parse(attrs.get<std::string>(SUMO_ATTR_SPEEDFACTOR, vType->id.c_str(), ok), hardFail);
     836         2520 :             if (!ok) {
     837            0 :                 return handleVehicleTypeError(hardFail, vType);
     838              :             } else {
     839         2520 :                 vType->parametersSet |= VTYPEPARS_SPEEDFACTOR_SET;
     840              :             }
     841              :         }
     842        65426 :         if (attrs.hasAttribute(SUMO_ATTR_SPEEDDEV)) {
     843         2684 :             bool ok = true;
     844         2684 :             const double speedDev = attrs.get<double>(SUMO_ATTR_SPEEDDEV, vType->id.c_str(), ok);
     845         2684 :             if (!ok) {
     846            0 :                 return handleVehicleTypeError(hardFail, vType);
     847         2684 :             } else if (speedDev < 0) {
     848            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_SPEEDDEV) + " must be equal or greater than 0");
     849              :             } else {
     850         2684 :                 vType->speedFactor.setParameter(1, speedDev);
     851         2684 :                 vType->parametersSet |= VTYPEPARS_SPEEDFACTOR_SET;
     852              :             }
     853              :         }
     854              :         // validate speed distribution
     855        65426 :         const std::string& error = vType->speedFactor.isValid();
     856        65426 :         if (error != "") {
     857           14 :             return handleVehicleTypeError(hardFail, vType, "Invalid speed distribution when parsing vType '" + vType->id + "' (" + error + ")");
     858              :         }
     859        65419 :         if (attrs.hasAttribute(SUMO_ATTR_ACTIONSTEPLENGTH)) {
     860          227 :             bool ok = true;
     861          227 :             const double actionStepLengthSecs = attrs.get<double>(SUMO_ATTR_ACTIONSTEPLENGTH, vType->id.c_str(), ok);
     862          227 :             if (!ok) {
     863            0 :                 return handleVehicleTypeError(hardFail, vType);
     864              :             } else {
     865              :                 // processActionStepLength(...) function includes warnings
     866          227 :                 vType->actionStepLength = processActionStepLength(actionStepLengthSecs);
     867          227 :                 vType->parametersSet |= VTYPEPARS_ACTIONSTEPLENGTH_SET;
     868              :             }
     869              :         }
     870        65419 :         if (attrs.hasAttribute(SUMO_ATTR_EMISSIONCLASS)) {
     871         1884 :             bool ok = true;
     872         1884 :             const std::string parsedEmissionClass = attrs.getOpt<std::string>(SUMO_ATTR_EMISSIONCLASS, id.c_str(), ok, "");
     873              :             // check if emission class is correct
     874              :             try {
     875         1884 :                 vType->emissionClass = PollutantsInterface::getClassByName(parsedEmissionClass);
     876         1884 :                 vType->parametersSet |= VTYPEPARS_EMISSIONCLASS_SET;
     877            0 :             } catch (...) {
     878            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_EMISSIONCLASS) + " with name '" + parsedEmissionClass + "' doesn't exist.");
     879            0 :             }
     880              :         }
     881        65419 :         if (attrs.hasAttribute(SUMO_ATTR_MASS)) {
     882          341 :             bool ok = true;
     883          341 :             const double mass = attrs.get<double>(SUMO_ATTR_MASS, vType->id.c_str(), ok);
     884          341 :             if (!ok) {
     885            0 :                 return handleVehicleTypeError(hardFail, vType);
     886          341 :             } else if (mass < 0) {
     887            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MASS) + " must be equal or greater than 0");
     888              :             } else {
     889          341 :                 vType->mass = mass;
     890          341 :                 vType->parametersSet |= VTYPEPARS_MASS_SET;
     891              :             }
     892              :         }
     893        65419 :         if (attrs.hasAttribute(SUMO_ATTR_IMPATIENCE)) {
     894          247 :             bool ok = true;
     895          247 :             const std::string impatienceStr = attrs.get<std::string>(SUMO_ATTR_IMPATIENCE, vType->id.c_str(), ok);
     896          247 :             if (!ok) {
     897            0 :                 return handleVehicleTypeError(hardFail, vType);
     898          247 :             } else if (impatienceStr == "off") {
     899           12 :                 vType->impatience = -std::numeric_limits<double>::max();
     900              :             } else {
     901          235 :                 const double impatienceDouble = attrs.get<double>(SUMO_ATTR_IMPATIENCE, vType->id.c_str(), ok);
     902          235 :                 if (!ok) {
     903            0 :                     return handleVehicleTypeError(hardFail, vType);
     904              :                 } else {
     905          235 :                     vType->impatience = impatienceDouble;
     906          235 :                     vType->parametersSet |= VTYPEPARS_IMPATIENCE_SET;
     907              :                 }
     908              :             }
     909              :         }
     910        65419 :         if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
     911        26765 :             bool ok = true;
     912        26765 :             const double width = attrs.get<double>(SUMO_ATTR_WIDTH, vType->id.c_str(), ok);
     913        26765 :             if (!ok) {
     914            0 :                 return handleVehicleTypeError(hardFail, vType);
     915        26765 :             } else if (width <= 0) {
     916            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_WIDTH) + " must be greater than 0");
     917              :             } else {
     918        26765 :                 vType->width = width;
     919        26765 :                 vType->parametersSet |= VTYPEPARS_WIDTH_SET;
     920        26765 :                 if (vClass == SVC_PEDESTRIAN
     921        52872 :                         && OptionsCont::getOptions().exists("pedestrian.striping.stripe-width")
     922        78979 :                         && OptionsCont::getOptions().getString("pedestrian.model") == "striping"
     923        82160 :                         && OptionsCont::getOptions().getFloat("pedestrian.striping.stripe-width") < vType->width) {
     924           12 :                     WRITE_WARNINGF(TL("Pedestrian vType '%' width % is larger than pedestrian.striping.stripe-width and this may cause collisions with vehicles."), id, vType->width);
     925              :                 }
     926              :             }
     927              :         }
     928        65419 :         if (attrs.hasAttribute(SUMO_ATTR_HEIGHT)) {
     929          357 :             bool ok = true;
     930          357 :             const double height = attrs.get<double>(SUMO_ATTR_HEIGHT, vType->id.c_str(), ok);
     931          357 :             if (!ok) {
     932            0 :                 return handleVehicleTypeError(hardFail, vType);
     933          357 :             } else if (height < 0) {
     934            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_HEIGHT) + " must be equal or greater than 0");
     935              :             } else {
     936          357 :                 vType->height = height;
     937          357 :                 vType->parametersSet |= VTYPEPARS_HEIGHT_SET;
     938              :             }
     939              :         }
     940        65419 :         if (attrs.hasAttribute(SUMO_ATTR_GUISHAPE)) {
     941        27212 :             vType->shape = parseGuiShape(attrs, vType->id);
     942        27212 :             if (vType->shape != SUMOVehicleShape::UNKNOWN) {
     943        27212 :                 vType->parametersSet |= VTYPEPARS_SHAPE_SET;
     944              :             }
     945              :         }
     946        65419 :         if (attrs.hasAttribute(SUMO_ATTR_OSGFILE)) {
     947           21 :             bool ok = true;
     948           21 :             const std::string osgFile = attrs.get<std::string>(SUMO_ATTR_OSGFILE, vType->id.c_str(), ok);
     949           21 :             if (!ok) {
     950            0 :                 return handleVehicleTypeError(hardFail, vType);
     951              :             } else {
     952           21 :                 vType->osgFile = osgFile;
     953           21 :                 vType->parametersSet |= VTYPEPARS_OSGFILE_SET;
     954              :             }
     955              :         }
     956        65419 :         if (attrs.hasAttribute(SUMO_ATTR_IMGFILE)) {
     957           28 :             bool ok = true;
     958           28 :             std::string imgFile = attrs.get<std::string>(SUMO_ATTR_IMGFILE, vType->id.c_str(), ok);
     959           28 :             if (!ok) {
     960            0 :                 return handleVehicleTypeError(hardFail, vType);
     961              :             } else {
     962              :                 // check relative path
     963           28 :                 if ((imgFile != "") && !FileHelpers::isAbsolute(imgFile)) {
     964           56 :                     imgFile = FileHelpers::getConfigurationRelative(file, imgFile);
     965              :                 }
     966           28 :                 vType->imgFile = imgFile;
     967           28 :                 vType->parametersSet |= VTYPEPARS_IMGFILE_SET;
     968              :             }
     969              :         }
     970        65419 :         if (attrs.hasAttribute(SUMO_ATTR_COLOR)) {
     971        22949 :             bool ok = true;
     972        22949 :             const RGBColor color = attrs.get<RGBColor>(SUMO_ATTR_COLOR, vType->id.c_str(), ok);
     973        22949 :             if (!ok) {
     974            8 :                 return handleVehicleTypeError(hardFail, vType);
     975              :             } else {
     976        22941 :                 vType->color = color;
     977        22941 :                 vType->parametersSet |= VTYPEPARS_COLOR_SET;
     978              :             }
     979              :         } else {
     980        42470 :             vType->color = RGBColor::YELLOW;
     981              :         }
     982        65411 :         if (attrs.hasAttribute(SUMO_ATTR_PROB)) {
     983          732 :             bool ok = true;
     984          732 :             const double defaultProbability = attrs.get<double>(SUMO_ATTR_PROB, vType->id.c_str(), ok);
     985          732 :             if (!ok) {
     986            0 :                 return handleVehicleTypeError(hardFail, vType);
     987          732 :             } else if (defaultProbability < 0) {
     988            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_PROB) + " must be equal or greater than 0");
     989              :             } else {
     990          732 :                 vType->defaultProbability = defaultProbability;
     991          732 :                 vType->parametersSet |= VTYPEPARS_PROBABILITY_SET;
     992              :             }
     993              :         }
     994        65411 :         if (attrs.hasAttribute(SUMO_ATTR_LANE_CHANGE_MODEL)) {
     995          476 :             bool ok = true;
     996          476 :             std::string lcmS = attrs.get<std::string>(SUMO_ATTR_LANE_CHANGE_MODEL, vType->id.c_str(), ok);
     997          476 :             if (!ok) {
     998            0 :                 return handleVehicleTypeError(hardFail, vType);
     999          476 :             } else if (lcmS == "JE2013") {
    1000            0 :                 WRITE_WARNING(TL("Lane change model 'JE2013' is deprecated. Using default model instead."));
    1001              :                 lcmS = "default";
    1002              :             }
    1003              :             if (SUMOXMLDefinitions::LaneChangeModels.hasString(lcmS)) {
    1004          471 :                 vType->lcModel = SUMOXMLDefinitions::LaneChangeModels.get(lcmS);
    1005          471 :                 vType->parametersSet |= VTYPEPARS_LANE_CHANGE_MODEL_SET;
    1006              :             } else {
    1007           15 :                 return handleVehicleTypeError(hardFail, vType, "Unknown lane change model '" + lcmS + "' when parsing vType '" + vType->id + "'");
    1008              :             }
    1009              :         }
    1010        65406 :         if (attrs.hasAttribute(SUMO_ATTR_CAR_FOLLOW_MODEL)) {
    1011         1348 :             bool ok = true;
    1012         1348 :             const std::string cfmValue = attrs.get<std::string>(SUMO_ATTR_CAR_FOLLOW_MODEL, vType->id.c_str(), ok);
    1013         1348 :             if (!ok) {
    1014            0 :                 return handleVehicleTypeError(hardFail, vType);
    1015              :             } else if (SUMOXMLDefinitions::CarFollowModels.hasString(cfmValue)) {
    1016         1341 :                 vType->cfModel = SUMOXMLDefinitions::CarFollowModels.get(cfmValue);
    1017         1341 :                 vType->parametersSet |= VTYPEPARS_CAR_FOLLOW_MODEL;
    1018              :             } else {
    1019           21 :                 return handleVehicleTypeError(hardFail, vType, "Unknown car following model '" + cfmValue + "' when parsing vType '" + vType->id + "'");
    1020              :             }
    1021              :         }
    1022        65399 :         if (attrs.hasAttribute(SUMO_ATTR_PERSON_CAPACITY)) {
    1023          413 :             bool ok = true;
    1024          413 :             const int personCapacity = attrs.get<int>(SUMO_ATTR_PERSON_CAPACITY, vType->id.c_str(), ok);
    1025          413 :             if (!ok) {
    1026            0 :                 return handleVehicleTypeError(hardFail, vType);
    1027          413 :             } else if (personCapacity < 0) {
    1028            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_PERSON_CAPACITY) + " must be equal or greater than 0");
    1029              :             } else {
    1030          413 :                 vType->personCapacity = personCapacity;
    1031          413 :                 vType->parametersSet |= VTYPEPARS_PERSON_CAPACITY;
    1032              :             }
    1033              :         }
    1034        65399 :         if (attrs.hasAttribute(SUMO_ATTR_CONTAINER_CAPACITY)) {
    1035          380 :             bool ok = true;
    1036          380 :             const int containerCapacity = attrs.get<int>(SUMO_ATTR_CONTAINER_CAPACITY, vType->id.c_str(), ok);
    1037          380 :             if (!ok) {
    1038            0 :                 return handleVehicleTypeError(hardFail, vType);
    1039          380 :             } else if (containerCapacity < 0) {
    1040            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_CONTAINER_CAPACITY) + " must be equal or greater than 0");
    1041              :             } else {
    1042          380 :                 vType->containerCapacity = containerCapacity;
    1043          380 :                 vType->parametersSet |= VTYPEPARS_CONTAINER_CAPACITY;
    1044              :             }
    1045              :         }
    1046        65399 :         if (attrs.hasAttribute(SUMO_ATTR_BOARDING_DURATION)) {
    1047          124 :             bool ok = true;
    1048          124 :             const SUMOTime boardingDuration = attrs.getSUMOTimeReporting(SUMO_ATTR_BOARDING_DURATION, vType->id.c_str(), ok);
    1049          124 :             if (!ok) {
    1050            0 :                 return handleVehicleTypeError(hardFail, vType);
    1051          124 :             } else if (boardingDuration < 0) {
    1052            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_BOARDING_DURATION) + " must be equal or greater than 0");
    1053              :             } else {
    1054          124 :                 vType->boardingDuration = boardingDuration;
    1055          124 :                 vType->parametersSet |= VTYPEPARS_BOARDING_DURATION;
    1056              :             }
    1057              :         }
    1058        65399 :         if (attrs.hasAttribute(SUMO_ATTR_LOADING_DURATION)) {
    1059           86 :             bool ok = true;
    1060           86 :             const SUMOTime loadingDuration = attrs.getSUMOTimeReporting(SUMO_ATTR_LOADING_DURATION, vType->id.c_str(), ok);
    1061           86 :             if (!ok) {
    1062            0 :                 return handleVehicleTypeError(hardFail, vType);
    1063           86 :             } else if (loadingDuration < 0) {
    1064            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_LOADING_DURATION) + " must be equal or greater than 0");
    1065              :             } else {
    1066           86 :                 vType->loadingDuration = loadingDuration;
    1067           86 :                 vType->parametersSet |= VTYPEPARS_LOADING_DURATION;
    1068              :             }
    1069              :         }
    1070        65399 :         if (attrs.hasAttribute(SUMO_ATTR_SCALE)) {
    1071           40 :             bool ok = true;
    1072           40 :             const double scale = attrs.get<double>(SUMO_ATTR_SCALE, id.c_str(), ok);
    1073           40 :             if (!ok) {
    1074            0 :                 return handleVehicleTypeError(hardFail, vType);
    1075           40 :             } else if (scale < 0) {
    1076            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_SCALE) + " may be not be negative");
    1077              :             } else {
    1078           40 :                 vType->scale = scale;
    1079           40 :                 vType->parametersSet |= VTYPEPARS_SCALE_SET;
    1080              :             }
    1081              :         }
    1082        65399 :         if (attrs.hasAttribute(SUMO_ATTR_TIME_TO_TELEPORT)) {
    1083           27 :             bool ok = true;
    1084           27 :             const SUMOTime ttt = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME_TO_TELEPORT, vType->id.c_str(), ok);
    1085           27 :             if (!ok) {
    1086            0 :                 return handleVehicleTypeError(hardFail, vType);
    1087              :             } else {
    1088           27 :                 vType->timeToTeleport = ttt;
    1089           27 :                 vType->parametersSet |= VTYPEPARS_TTT_SET;
    1090              :             }
    1091              :         }
    1092        65399 :         if (attrs.hasAttribute(SUMO_ATTR_TIME_TO_TELEPORT_BIDI)) {
    1093            5 :             bool ok = true;
    1094            5 :             const SUMOTime tttb = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME_TO_TELEPORT_BIDI, vType->id.c_str(), ok);
    1095            5 :             if (!ok) {
    1096            0 :                 return handleVehicleTypeError(hardFail, vType);
    1097              :             } else {
    1098            5 :                 vType->timeToTeleportBidi = tttb;
    1099            5 :                 vType->parametersSet |= VTYPEPARS_TTT_BIDI_SET;
    1100              :             }
    1101              :         }
    1102        65399 :         if (attrs.hasAttribute(SUMO_ATTR_SPEEDFACTOR_PREMATURE)) {
    1103           63 :             bool ok = true;
    1104           63 :             const double sfp = attrs.get<double>(SUMO_ATTR_SPEEDFACTOR_PREMATURE, id.c_str(), ok);
    1105           63 :             if (!ok) {
    1106            0 :                 return handleVehicleTypeError(hardFail, vType);
    1107              :             } else {
    1108           63 :                 vType->speedFactorPremature = sfp;
    1109           63 :                 vType->parametersSet |= VTYPEPARS_SPEEDFACTOR_PREMATURE_SET;
    1110              :             }
    1111              :         }
    1112        65399 :         if (attrs.hasAttribute(SUMO_ATTR_BOARDING_FACTOR)) {
    1113            8 :             bool ok = true;
    1114            8 :             const double bf = attrs.get<double>(SUMO_ATTR_BOARDING_FACTOR, id.c_str(), ok);
    1115            8 :             if (!ok) {
    1116            0 :                 return handleVehicleTypeError(hardFail, vType);
    1117            8 :             } else if (bf < 0) {
    1118            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_BOARDING_FACTOR) + " must be equal or greater than 0");
    1119              :             } else {
    1120            8 :                 vType->boardingFactor = bf;
    1121            8 :                 vType->parametersSet |= VTYPEPARS_BOARDING_FACTOR_SET;
    1122              :             }
    1123              :         }
    1124        65399 :         if (attrs.hasAttribute(SUMO_ATTR_MAXSPEED_LAT)) {
    1125           73 :             bool ok = true;
    1126           73 :             const double maxSpeedLat = attrs.get<double>(SUMO_ATTR_MAXSPEED_LAT, vType->id.c_str(), ok);
    1127           73 :             if (!ok) {
    1128            0 :                 return handleVehicleTypeError(hardFail, vType);
    1129           73 :             } else if (maxSpeedLat <= 0) {
    1130            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MAXSPEED_LAT) + " must be greater than 0");
    1131              :             } else {
    1132           73 :                 vType->maxSpeedLat = maxSpeedLat;
    1133           73 :                 vType->parametersSet |= VTYPEPARS_MAXSPEED_LAT_SET;
    1134              :             }
    1135              :         }
    1136        65399 :         if (attrs.hasAttribute(SUMO_ATTR_MINGAP_LAT)) {
    1137          594 :             bool ok = true;
    1138          594 :             const double minGapLat = attrs.get<double>(SUMO_ATTR_MINGAP_LAT, vType->id.c_str(), ok);
    1139          594 :             if (!ok) {
    1140            0 :                 return handleVehicleTypeError(hardFail, vType);
    1141          594 :             } else if (minGapLat < 0) {
    1142            0 :                 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MINGAP_LAT) + " must be equal or greater than 0");
    1143              :             } else {
    1144          594 :                 vType->minGapLat = minGapLat;
    1145          594 :                 vType->parametersSet |= VTYPEPARS_MINGAP_LAT_SET;
    1146              :             }
    1147              :         }
    1148        65399 :         if (attrs.hasAttribute(SUMO_ATTR_LATALIGNMENT)) {
    1149         1705 :             bool ok = true;
    1150         1705 :             const std::string alignS = attrs.get<std::string>(SUMO_ATTR_LATALIGNMENT, vType->id.c_str(), ok);
    1151         1705 :             if (!ok) {
    1152            0 :                 return handleVehicleTypeError(hardFail, vType);
    1153              :             } else {
    1154              :                 double lao;
    1155              :                 LatAlignmentDefinition lad;
    1156         1705 :                 if (SUMOVTypeParameter::parseLatAlignment(alignS, lao, lad)) {
    1157         1705 :                     vType->latAlignmentOffset = lao;
    1158         1705 :                     vType->latAlignmentProcedure = lad;
    1159         1705 :                     vType->parametersSet |= VTYPEPARS_LATALIGNMENT_SET;
    1160              :                 } else {
    1161            0 :                     return handleVehicleTypeError(hardFail, vType, "Unknown lateral alignment '" + alignS + "' when parsing vType '" + vType->id + "';\n must be one of (\"right\", \"center\", \"arbitrary\", \"nice\", \"compact\", \"left\" or a float)");
    1162              :                 }
    1163              :             }
    1164              :         }
    1165        65399 :         if (attrs.hasAttribute(SUMO_ATTR_MANEUVER_ANGLE_TIMES)) {
    1166            6 :             bool ok = true;
    1167            6 :             const std::string angleTimesS = attrs.get<std::string>(SUMO_ATTR_MANEUVER_ANGLE_TIMES, vType->id.c_str(), ok);
    1168            6 :             if (!ok) {
    1169            0 :                 return handleVehicleTypeError(hardFail, vType);
    1170           12 :             } else if (parseAngleTimesMap(vType, angleTimesS)) {
    1171            6 :                 vType->parametersSet |= VTYPEPARS_MANEUVER_ANGLE_TIMES_SET;
    1172              :             } else {
    1173            0 :                 return handleVehicleTypeError(hardFail, vType, "Invalid manoeuver angle times map for vType '" + vType->id + "'");
    1174              :             }
    1175              :         }
    1176        65399 :         if (attrs.hasAttribute(SUMO_ATTR_PARKING_BADGES)) {
    1177           13 :             bool ok = true;
    1178           13 :             std::vector<std::string> badges = attrs.get<std::vector<std::string>>(SUMO_ATTR_PARKING_BADGES, vType->id.c_str(), ok);
    1179           13 :             if (!ok) {
    1180            0 :                 return handleVehicleTypeError(hardFail, vType);
    1181              :             } else {
    1182           13 :                 vType->parametersSet |= VTYPEPARS_PARKING_BADGES_SET;
    1183           13 :                 vType->parkingBadges = badges;
    1184              :             }
    1185           13 :         }
    1186              :         // try to parse Car Following Model params
    1187        65399 :         if (!parseCFMParams(vType, vType->cfModel, attrs, false)) {
    1188            0 :             return handleVehicleTypeError(hardFail, vType, "Invalid parsing embedded VType");
    1189              :         }
    1190              :         // try to parse Lane Change Model params
    1191        65399 :         if (!parseLCParams(vType, vType->lcModel, attrs)) {
    1192            0 :             return handleVehicleTypeError(hardFail, vType, "Invalid Lane Change Model Parameters");
    1193              :         }
    1194              :         // try to Junction Model params
    1195        65399 :         if (!parseJMParams(vType, attrs)) {
    1196           27 :             return handleVehicleTypeError(hardFail, vType, "Invalid Junction Model Parameters");
    1197              :         }
    1198              :         // all ok, then return vType
    1199              :         return vType;
    1200            5 :     } else if (base != nullptr) {
    1201              :         return const_cast<SUMOVTypeParameter*>(base);
    1202              :     } else {
    1203           37 :         return handleVehicleTypeError(hardFail, nullptr, "VType cannot be created");
    1204              :     }
    1205              : }
    1206              : 
    1207              : 
    1208              : bool
    1209            6 : SUMOVehicleParserHelper::parseAngleTimesMap(SUMOVTypeParameter* vtype, const std::string atm) {
    1210           18 :     StringTokenizer st(atm, ",");
    1211              :     std::map<int, std::pair<SUMOTime, SUMOTime>> angleTimesMap;
    1212              :     int tripletCount = 0;
    1213           36 :     while (st.hasNext()) {
    1214           30 :         StringTokenizer pos(st.next());
    1215           30 :         if (pos.size() != 3) {
    1216            0 :             WRITE_ERRORF(TL("maneuverAngleTimes format for vType '%' % contains an invalid triplet."), vtype->id, atm);
    1217            0 :             return false;
    1218              :         } else {
    1219              :             try {
    1220           30 :                 const int angle = StringUtils::toInt(pos.next());
    1221           30 :                 const SUMOTime t1 = string2time(pos.next());
    1222           30 :                 const SUMOTime t2 = string2time(pos.next());
    1223           30 :                 angleTimesMap[angle] = std::make_pair(t1, t2);
    1224            0 :             } catch (...) {
    1225            0 :                 WRITE_ERRORF(TL("Triplet '%' for vType '%' maneuverAngleTimes cannot be parsed as 'int double double'"), st.get(tripletCount), vtype->id);
    1226              :                 return false;
    1227            0 :             }
    1228           30 :             tripletCount++;
    1229              :         }
    1230           30 :     }
    1231            6 :     if (angleTimesMap.size() > 0) {
    1232              :         vtype->myManoeuverAngleTimes.clear();
    1233           36 :         for (const auto& angleTime : angleTimesMap) {
    1234              :             vtype->myManoeuverAngleTimes.insert(angleTime);
    1235              :         }
    1236              :         angleTimesMap.clear();
    1237            6 :         return true;
    1238              :     } else {
    1239              :         return false;
    1240              :     }
    1241            6 : }
    1242              : 
    1243              : 
    1244              : bool
    1245        65418 : SUMOVehicleParserHelper::parseCFMParams(SUMOVTypeParameter* into, const SumoXMLTag element, const SUMOSAXAttributes& attrs, const bool nestedCFM) {
    1246        65418 :     const CFAttrMap& allowedCFM = getAllowedCFModelAttrs();
    1247              :     CFAttrMap::const_iterator cf_it = allowedCFM.find(element);
    1248              :     // check if given CFM is allowed
    1249        65418 :     if (cf_it == allowedCFM.end()) {
    1250            0 :         if (SUMOXMLDefinitions::Tags.has((int)element)) {
    1251            0 :             WRITE_ERRORF(TL("Unknown car-following model % when parsing vType '%'"), toString(element), into->id);
    1252              :         } else {
    1253            0 :             WRITE_ERRORF(TL("Unknown car-following model when parsing vType '%'"), into->id);
    1254              :         }
    1255            0 :         return false;
    1256              :     }
    1257              :     // check if we're parsing a nested CFM
    1258        65418 :     if (nestedCFM) {
    1259           19 :         into->cfModel = cf_it->first;
    1260           19 :         into->parametersSet |= VTYPEPARS_CAR_FOLLOW_MODEL;
    1261              :     }
    1262              :     // set CFM values
    1263       861812 :     for (const auto& it : cf_it->second) {
    1264       796394 :         if (attrs.hasAttribute(it)) {
    1265              :             // first obtain  CFM attribute in string format
    1266        48532 :             bool ok = true;
    1267        48532 :             std::string parsedCFMAttribute = attrs.get<std::string>(it, into->id.c_str(), ok);
    1268              :             // check CFM Attribute
    1269        48532 :             if (!ok) {
    1270              :                 return false;
    1271        48532 :             } else if (it == SUMO_ATTR_TRAIN_TYPE) {
    1272              :                 // check if train value is valid
    1273          271 :                 if (!SUMOXMLDefinitions::TrainTypes.hasString(parsedCFMAttribute)) {
    1274            0 :                     WRITE_ERROR("Invalid train type '" + parsedCFMAttribute + "' used in Car-Following-Attribute " + toString(it));
    1275            0 :                     return false;
    1276              :                 }
    1277              :                 // add parsedCFMAttribute to cfParameter
    1278          271 :                 into->cfParameter[it] = parsedCFMAttribute;
    1279        48261 :             } else if (it == SUMO_ATTR_SPEED_TABLE || it == SUMO_ATTR_TRACTION_TABLE || it == SUMO_ATTR_RESISTANCE_TABLE) {
    1280           52 :                 into->cfParameter[it] = parsedCFMAttribute;
    1281        48209 :             } else if (it == SUMO_ATTR_CF_IDM_STEPPING) {
    1282              :                 // declare a int in which save CFM int attribute
    1283              :                 double CFMDoubleAttribute = -1;
    1284              :                 try {
    1285              :                     // obtain CFM attribute in int format
    1286            6 :                     CFMDoubleAttribute = StringUtils::toDouble(parsedCFMAttribute);
    1287            0 :                 } catch (...) {
    1288            0 :                     WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Cannot be parsed to float"), toString(it));
    1289              :                     return false;
    1290            0 :                 }
    1291            6 :                 if (CFMDoubleAttribute <= 0) {
    1292            0 :                     WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Must be greater than 0"), toString(it));
    1293            0 :                     return false;
    1294              :                 }
    1295              :                 // add parsedCFMAttribute to cfParameter
    1296            6 :                 into->cfParameter[it] = parsedCFMAttribute;
    1297        48203 :             } else if (it == SUMO_ATTR_MAXACCEL_PROFILE || it == SUMO_ATTR_DESACCEL_PROFILE) {
    1298           32 :                 if (validProfile(into, parsedCFMAttribute, it)) {
    1299           16 :                     into->cfParameter[it] = parsedCFMAttribute;
    1300              :                 } else {
    1301            0 :                     WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Cannot be parsed as a vector of <speed accel> pairs"), toString(it));
    1302            0 :                     return false;
    1303              :                 }
    1304              :             } else {
    1305              :                 // declare a double in which save CFM float attribute
    1306              :                 double CFMDoubleAttribute = -1;
    1307              :                 try {
    1308              :                     // obtain CFM attribute in double format
    1309        48187 :                     CFMDoubleAttribute = StringUtils::toDouble(parsedCFMAttribute);
    1310            0 :                 } catch (...) {
    1311            0 :                     WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Cannot be parsed to float"), toString(it));
    1312              :                     return false;
    1313            0 :                 }
    1314              :                 // check attributes of type "positiveFloatType" (> 0)
    1315        48187 :                 switch (it) {
    1316        22114 :                     case SUMO_ATTR_ACCEL:
    1317              :                     case SUMO_ATTR_DECEL:
    1318              :                     case SUMO_ATTR_APPARENTDECEL:
    1319              :                     case SUMO_ATTR_EMERGENCYDECEL:
    1320              :                     case SUMO_ATTR_TAU:
    1321        22114 :                         if (CFMDoubleAttribute <= 0) {
    1322            0 :                             WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Must be greater than 0"), toString(it));
    1323            0 :                             return false;
    1324              :                         }
    1325              :                         break;
    1326              :                     default:
    1327              :                         break;
    1328              :                 }
    1329              :                 // check attributes restricted to [0-1]
    1330        48187 :                 switch (it) {
    1331        25431 :                     case SUMO_ATTR_SIGMA:
    1332        25431 :                         if ((CFMDoubleAttribute < 0) || (CFMDoubleAttribute > 1)) {
    1333            0 :                             WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Only values between [0-1] are allowed"), toString(it));
    1334            0 :                             return false;
    1335              :                         }
    1336              :                         break;
    1337              :                     default:
    1338              :                         break;
    1339              :                 }
    1340              :                 // add parsedCFMAttribute to cfParameter
    1341        48187 :                 into->cfParameter[it] = parsedCFMAttribute;
    1342              :             }
    1343              :         }
    1344              :     }
    1345              :     // all CFM successfully parsed, then return true
    1346              :     return true;
    1347              : }
    1348              : 
    1349              : 
    1350              : const SUMOVehicleParserHelper::CFAttrMap&
    1351        65418 : SUMOVehicleParserHelper::getAllowedCFModelAttrs() {
    1352              :     // init on first use
    1353        65418 :     if (allowedCFModelAttrs.size() == 0) {
    1354              :         std::set<SumoXMLAttr> genericParams;
    1355        28276 :         genericParams.insert(SUMO_ATTR_TAU);
    1356        28276 :         genericParams.insert(SUMO_ATTR_ACCEL);
    1357        28276 :         genericParams.insert(SUMO_ATTR_DECEL);
    1358        28276 :         genericParams.insert(SUMO_ATTR_APPARENTDECEL);
    1359        28276 :         genericParams.insert(SUMO_ATTR_EMERGENCYDECEL);
    1360        28276 :         genericParams.insert(SUMO_ATTR_SPEED_TABLE);
    1361        28276 :         genericParams.insert(SUMO_ATTR_MAXACCEL_PROFILE);
    1362        28276 :         genericParams.insert(SUMO_ATTR_DESACCEL_PROFILE);
    1363        28276 :         genericParams.insert(SUMO_ATTR_COLLISION_MINGAP_FACTOR);
    1364        28276 :         genericParams.insert(SUMO_ATTR_STARTUP_DELAY);
    1365              :         // Krauss
    1366              :         std::set<SumoXMLAttr> kraussParams(genericParams);
    1367        28276 :         kraussParams.insert(SUMO_ATTR_SIGMA);
    1368        28276 :         kraussParams.insert(SUMO_ATTR_SIGMA_STEP);
    1369        28276 :         allowedCFModelAttrs[SUMO_TAG_CF_KRAUSS] = kraussParams;
    1370        28276 :         allowedCFModelAttrs[SUMO_TAG_CF_KRAUSS_ORIG1] = kraussParams;
    1371        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_KRAUSS_PLUS_SLOPE] = kraussParams;
    1372              :         std::set<SumoXMLAttr> allParams(kraussParams);
    1373              :         // KraussX
    1374              :         std::set<SumoXMLAttr> kraussXParams(kraussParams);
    1375        28276 :         kraussXParams.insert(SUMO_ATTR_TMP1);
    1376        28276 :         kraussXParams.insert(SUMO_ATTR_TMP2);
    1377        28276 :         kraussXParams.insert(SUMO_ATTR_TMP3);
    1378        28276 :         kraussXParams.insert(SUMO_ATTR_TMP4);
    1379        28276 :         kraussXParams.insert(SUMO_ATTR_TMP5);
    1380        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_KRAUSSX] = kraussXParams;
    1381        28276 :         allParams.insert(kraussXParams.begin(), kraussXParams.end());
    1382              :         // SmartSK
    1383              :         std::set<SumoXMLAttr> smartSKParams(genericParams);
    1384        28276 :         smartSKParams.insert(SUMO_ATTR_SIGMA);
    1385        28276 :         smartSKParams.insert(SUMO_ATTR_TMP1);
    1386        28276 :         smartSKParams.insert(SUMO_ATTR_TMP2);
    1387        28276 :         smartSKParams.insert(SUMO_ATTR_TMP3);
    1388        28276 :         smartSKParams.insert(SUMO_ATTR_TMP4);
    1389        28276 :         smartSKParams.insert(SUMO_ATTR_TMP5);
    1390        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_SMART_SK] = smartSKParams;
    1391        28276 :         allParams.insert(smartSKParams.begin(), smartSKParams.end());
    1392              :         // Daniel
    1393              :         std::set<SumoXMLAttr> daniel1Params(genericParams);
    1394        28276 :         daniel1Params.insert(SUMO_ATTR_SIGMA);
    1395        28276 :         daniel1Params.insert(SUMO_ATTR_TMP1);
    1396        28276 :         daniel1Params.insert(SUMO_ATTR_TMP2);
    1397        28276 :         daniel1Params.insert(SUMO_ATTR_TMP3);
    1398        28276 :         daniel1Params.insert(SUMO_ATTR_TMP4);
    1399        28276 :         daniel1Params.insert(SUMO_ATTR_TMP5);
    1400        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_DANIEL1] = daniel1Params;
    1401        28276 :         allParams.insert(daniel1Params.begin(), daniel1Params.end());
    1402              :         // Peter Wagner
    1403              :         std::set<SumoXMLAttr> pwagParams(genericParams);
    1404        28276 :         pwagParams.insert(SUMO_ATTR_SIGMA);
    1405        28276 :         pwagParams.insert(SUMO_ATTR_CF_PWAGNER2009_TAULAST);
    1406        28276 :         pwagParams.insert(SUMO_ATTR_CF_PWAGNER2009_APPROB);
    1407        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_PWAGNER2009] = pwagParams;
    1408        28276 :         allParams.insert(pwagParams.begin(), pwagParams.end());
    1409              :         // IDM params
    1410              :         std::set<SumoXMLAttr> idmParams(genericParams);
    1411        28276 :         idmParams.insert(SUMO_ATTR_CF_IDM_DELTA);
    1412        28276 :         idmParams.insert(SUMO_ATTR_CF_IDM_STEPPING);
    1413        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_IDM] = idmParams;
    1414        28276 :         allParams.insert(idmParams.begin(), idmParams.end());
    1415              :         // EIDM
    1416              :         std::set<SumoXMLAttr> eidmParams(genericParams);
    1417        28276 :         eidmParams.insert(SUMO_ATTR_CF_IDM_DELTA);
    1418        28276 :         eidmParams.insert(SUMO_ATTR_CF_IDM_STEPPING);
    1419        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD);
    1420        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE);
    1421        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_T_REACTION);
    1422        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE);
    1423        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_C_COOLNESS);
    1424        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_SIG_LEADER);
    1425        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_SIG_GAP);
    1426        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_SIG_ERROR);
    1427        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_JERK_MAX);
    1428        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_EPSILON_ACC);
    1429        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_T_ACC_MAX);
    1430        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_M_FLATNESS);
    1431        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_M_BEGIN);
    1432        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS);
    1433        28276 :         eidmParams.insert(SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW);
    1434        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_EIDM] = eidmParams;
    1435        28276 :         allParams.insert(eidmParams.begin(), eidmParams.end());
    1436              :         // IDMM
    1437              :         std::set<SumoXMLAttr> idmmParams(genericParams);
    1438        28276 :         idmmParams.insert(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR);
    1439        28276 :         idmmParams.insert(SUMO_ATTR_CF_IDMM_ADAPT_TIME);
    1440        28276 :         idmmParams.insert(SUMO_ATTR_CF_IDM_STEPPING);
    1441        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_IDMM] = idmmParams;
    1442        28276 :         allParams.insert(idmmParams.begin(), idmmParams.end());
    1443              :         // Bieker
    1444              :         std::set<SumoXMLAttr> bkernerParams(genericParams);
    1445        28276 :         bkernerParams.insert(SUMO_ATTR_K);
    1446        28276 :         bkernerParams.insert(SUMO_ATTR_CF_KERNER_PHI);
    1447        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_BKERNER] = bkernerParams;
    1448        28276 :         allParams.insert(bkernerParams.begin(), bkernerParams.end());
    1449              :         // Wiedemann
    1450              :         std::set<SumoXMLAttr> wiedemannParams(genericParams);
    1451        28276 :         wiedemannParams.insert(SUMO_ATTR_CF_WIEDEMANN_SECURITY);
    1452        28276 :         wiedemannParams.insert(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION);
    1453        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_WIEDEMANN] = wiedemannParams;
    1454        28276 :         allParams.insert(wiedemannParams.begin(), wiedemannParams.end());
    1455              :         // W99
    1456              :         std::set<SumoXMLAttr> w99Params(genericParams);
    1457        28276 :         w99Params.insert(SUMO_ATTR_CF_W99_CC1);
    1458        28276 :         w99Params.insert(SUMO_ATTR_CF_W99_CC2);
    1459        28276 :         w99Params.insert(SUMO_ATTR_CF_W99_CC3);
    1460        28276 :         w99Params.insert(SUMO_ATTR_CF_W99_CC4);
    1461        28276 :         w99Params.insert(SUMO_ATTR_CF_W99_CC5);
    1462        28276 :         w99Params.insert(SUMO_ATTR_CF_W99_CC6);
    1463        28276 :         w99Params.insert(SUMO_ATTR_CF_W99_CC7);
    1464        28276 :         w99Params.insert(SUMO_ATTR_CF_W99_CC8);
    1465        28276 :         w99Params.insert(SUMO_ATTR_CF_W99_CC9);
    1466        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_W99] = w99Params;
    1467        28276 :         allParams.insert(w99Params.begin(), w99Params.end());
    1468              :         // Rail
    1469              :         std::set<SumoXMLAttr> railParams(genericParams);
    1470        28276 :         railParams.insert(SUMO_ATTR_TRAIN_TYPE);
    1471        28276 :         railParams.insert(SUMO_ATTR_TRACTION_TABLE);
    1472        28276 :         railParams.insert(SUMO_ATTR_RESISTANCE_TABLE);
    1473        28276 :         railParams.insert(SUMO_ATTR_MASSFACTOR);
    1474        28276 :         railParams.insert(SUMO_ATTR_MAXPOWER);
    1475        28276 :         railParams.insert(SUMO_ATTR_MAXTRACTION);
    1476        28276 :         railParams.insert(SUMO_ATTR_RESISTANCE_COEFFICIENT_CONSTANT);
    1477        28276 :         railParams.insert(SUMO_ATTR_RESISTANCE_COEFFICIENT_LINEAR);
    1478        28276 :         railParams.insert(SUMO_ATTR_RESISTANCE_COEFFICIENT_QUADRATIC);
    1479        28276 :         railParams.insert(SUMO_ATTR_CURVE_RESISTANCE);
    1480        28276 :         railParams.insert(SUMO_ATTR_CURVE_INTEGRATION);
    1481        28276 :         railParams.insert(SUMO_ATTR_ROECKL_SHARP_RADIUS);
    1482        28276 :         railParams.insert(SUMO_ATTR_ROECKL_NUMERATOR);
    1483        28276 :         railParams.insert(SUMO_ATTR_ROECKL_NUMERATOR_SHARP);
    1484        28276 :         railParams.insert(SUMO_ATTR_ROECKL_OFFSET);
    1485        28276 :         railParams.insert(SUMO_ATTR_ROECKL_OFFSET_SHARP);
    1486        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_RAIL] = railParams;
    1487        28276 :         allParams.insert(railParams.begin(), railParams.end());
    1488              :         // ACC
    1489              :         std::set<SumoXMLAttr> ACCParams(genericParams);
    1490        28276 :         ACCParams.insert(SUMO_ATTR_SC_GAIN);
    1491        28276 :         ACCParams.insert(SUMO_ATTR_GCC_GAIN_SPEED);
    1492        28276 :         ACCParams.insert(SUMO_ATTR_GCC_GAIN_SPACE);
    1493        28276 :         ACCParams.insert(SUMO_ATTR_GC_GAIN_SPEED);
    1494        28276 :         ACCParams.insert(SUMO_ATTR_GC_GAIN_SPACE);
    1495        28276 :         ACCParams.insert(SUMO_ATTR_CA_GAIN_SPEED);
    1496        28276 :         ACCParams.insert(SUMO_ATTR_CA_GAIN_SPACE);
    1497        28276 :         ACCParams.insert(SUMO_ATTR_CA_OVERRIDE);
    1498        28276 :         ACCParams.insert(SUMO_ATTR_APPLYDRIVERSTATE);
    1499        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_ACC] = ACCParams;
    1500        28276 :         allParams.insert(ACCParams.begin(), ACCParams.end());
    1501              :         // CACC
    1502              :         std::set<SumoXMLAttr> CACCParams(genericParams);
    1503        28276 :         CACCParams.insert(SUMO_ATTR_SC_GAIN_CACC);
    1504        28276 :         CACCParams.insert(SUMO_ATTR_GCC_GAIN_GAP_CACC);
    1505        28276 :         CACCParams.insert(SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC);
    1506        28276 :         CACCParams.insert(SUMO_ATTR_GC_GAIN_GAP_CACC);
    1507        28276 :         CACCParams.insert(SUMO_ATTR_GC_GAIN_GAP_DOT_CACC);
    1508        28276 :         CACCParams.insert(SUMO_ATTR_CA_GAIN_GAP_CACC);
    1509        28276 :         CACCParams.insert(SUMO_ATTR_CA_GAIN_GAP_DOT_CACC);
    1510        28276 :         CACCParams.insert(SUMO_ATTR_GCC_GAIN_SPEED);
    1511        28276 :         CACCParams.insert(SUMO_ATTR_GCC_GAIN_SPACE);
    1512        28276 :         CACCParams.insert(SUMO_ATTR_GC_GAIN_SPEED);
    1513        28276 :         CACCParams.insert(SUMO_ATTR_GC_GAIN_SPACE);
    1514        28276 :         CACCParams.insert(SUMO_ATTR_CA_GAIN_SPEED);
    1515        28276 :         CACCParams.insert(SUMO_ATTR_CA_GAIN_SPACE);
    1516        28276 :         CACCParams.insert(SUMO_ATTR_CA_OVERRIDE);
    1517        28276 :         CACCParams.insert(SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC);
    1518        28276 :         CACCParams.insert(SUMO_ATTR_APPLYDRIVERSTATE);
    1519        28276 :         CACCParams.insert(SUMO_ATTR_SC_MIN_GAP);
    1520        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_CACC] = CACCParams;
    1521        28276 :         allParams.insert(CACCParams.begin(), CACCParams.end());
    1522              :         // CC
    1523              :         std::set<SumoXMLAttr> ccParams(genericParams);
    1524        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_C1);
    1525        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_CCDECEL);
    1526        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_CONSTSPACING);
    1527        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_KP);
    1528        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_LAMBDA);
    1529        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_OMEGAN);
    1530        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_TAU);
    1531        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_XI);
    1532        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_LANES_COUNT);
    1533        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_CCACCEL);
    1534        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_PLOEG_KP);
    1535        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_PLOEG_KD);
    1536        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_PLOEG_H);
    1537        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_KA);
    1538        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_KV);
    1539        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_KP);
    1540        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_D);
    1541        28276 :         ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_H);
    1542        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_CC] = ccParams;
    1543        28276 :         allParams.insert(ccParams.begin(), ccParams.end());
    1544              :         // NaSch
    1545              :         std::set<SumoXMLAttr> naschParams(genericParams);
    1546        28276 :         naschParams.insert(SUMO_ATTR_SIGMA);
    1547        56552 :         allowedCFModelAttrs[SUMO_TAG_CF_NASCH] = naschParams;
    1548        28276 :         allParams.insert(naschParams.begin(), naschParams.end());
    1549              :         // last element
    1550        56552 :         allowedCFModelAttrs[SUMO_TAG_NOTHING] = allParams;
    1551              :     }
    1552        65418 :     return allowedCFModelAttrs;
    1553              : }
    1554              : 
    1555              : 
    1556              : bool
    1557        65399 : SUMOVehicleParserHelper::parseLCParams(SUMOVTypeParameter* into, LaneChangeModel model, const SUMOSAXAttributes& attrs) {
    1558        65399 :     if (allowedLCModelAttrs.size() == 0) {
    1559              :         // lc2013
    1560              :         std::set<SumoXMLAttr> lc2013Params;
    1561        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_STRATEGIC_PARAM);
    1562        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_PARAM);
    1563        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAIN_PARAM);
    1564        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_KEEPRIGHT_PARAM);
    1565        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_OPPOSITE_PARAM);
    1566        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_LOOKAHEADLEFT);
    1567        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAINRIGHT);
    1568        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_MAXSPEEDLATSTANDING);
    1569        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_MAXSPEEDLATFACTOR);
    1570        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_MAXDISTLATSTANDING);
    1571        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_ASSERTIVE);
    1572        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_STRATEGIC_LOOKAHEAD);
    1573        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAIN_LOOKAHEAD);
    1574        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAIN_REMAIN_TIME);
    1575        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAIN_URGENCY);
    1576        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_ROUNDABOUT);
    1577        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_SPEED);
    1578        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_HELPTIME);
    1579        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_HELPTHRESHOLD);
    1580        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_MINSPEED);
    1581        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_OVERTAKE_RIGHT);
    1582        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_SIGMA);
    1583        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME);
    1584        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR);
    1585        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_CONTRIGHT);
    1586        28276 :         lc2013Params.insert(SUMO_ATTR_LCA_EXPERIMENTAL1);
    1587        56552 :         allowedLCModelAttrs[LaneChangeModel::LC2013] = lc2013Params;
    1588              :         // sl2015 (extension of lc2013)
    1589              :         std::set<SumoXMLAttr> sl2015Params = lc2013Params;
    1590        28276 :         sl2015Params.insert(SUMO_ATTR_LCA_PUSHY);
    1591        28276 :         sl2015Params.insert(SUMO_ATTR_LCA_PUSHYGAP);
    1592        28276 :         sl2015Params.insert(SUMO_ATTR_LCA_SUBLANE_PARAM);
    1593        28276 :         sl2015Params.insert(SUMO_ATTR_LCA_IMPATIENCE);
    1594        28276 :         sl2015Params.insert(SUMO_ATTR_LCA_TIME_TO_IMPATIENCE);
    1595        28276 :         sl2015Params.insert(SUMO_ATTR_LCA_ACCEL_LAT);
    1596        28276 :         sl2015Params.insert(SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE);
    1597        28276 :         sl2015Params.insert(SUMO_ATTR_LCA_LANE_DISCIPLINE);
    1598        56552 :         allowedLCModelAttrs[LaneChangeModel::SL2015] = sl2015Params;
    1599              :         // DK2008
    1600              :         std::set<SumoXMLAttr> noParams;
    1601        28276 :         allowedLCModelAttrs[LaneChangeModel::DK2008] = noParams;
    1602              :         // default model may be either LC2013 or SL2015
    1603              :         // we allow both sets (sl2015 is a superset of lc2013Params)
    1604        56552 :         allowedLCModelAttrs[LaneChangeModel::DEFAULT] = sl2015Params;
    1605              :     }
    1606        65399 :     std::set<SumoXMLAttr> allowed = allowedLCModelAttrs[model];
    1607              :     // iterate over LCM attributes
    1608      2288139 :     for (const auto& it : allowed) {
    1609      2222740 :         if (attrs.hasAttribute(it)) {
    1610              :             // first obtain  CFM attribute in string format
    1611         4165 :             bool ok = true;
    1612         4165 :             std::string parsedLCMAttribute = attrs.get<std::string>(it, into->id.c_str(), ok);
    1613         4165 :             if (!ok) {
    1614              :                 return false;
    1615              :             }
    1616              :             // declare a double in which save CFM attribute
    1617              :             double LCMAttribute = -1;
    1618              :             try {
    1619              :                 // obtain CFM attribute in double format
    1620         4165 :                 LCMAttribute = StringUtils::toDouble(parsedLCMAttribute);
    1621            0 :             } catch (...) {
    1622            0 :                 WRITE_ERRORF(TL("Invalid Lane-Change-Model Attribute %. Cannot be parsed to float"), toString(it));
    1623              :                 return false;
    1624            0 :             }
    1625              :             // check attributes of type "nonNegativeFloatType" (>= 0)
    1626         4165 :             switch (it) {
    1627         1446 :                 case SUMO_ATTR_LCA_PUSHYGAP:
    1628              :                 case SUMO_ATTR_LCA_MAXSPEEDLATSTANDING:
    1629              :                 case SUMO_ATTR_LCA_IMPATIENCE:
    1630              :                 case SUMO_ATTR_LCA_OVERTAKE_RIGHT:
    1631              :                 case SUMO_ATTR_LCA_ASSERTIVE:
    1632              :                 case SUMO_ATTR_LCA_LOOKAHEADLEFT:
    1633              :                 case SUMO_ATTR_LCA_SPEEDGAINRIGHT:
    1634              :                 case SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE:
    1635              :                 case SUMO_ATTR_LCA_TIME_TO_IMPATIENCE:
    1636              :                 case SUMO_ATTR_LCA_LANE_DISCIPLINE:
    1637              :                 case SUMO_ATTR_LCA_SIGMA:
    1638         1446 :                     if (LCMAttribute < 0) {
    1639            0 :                         WRITE_ERRORF(TL("Invalid Lane-Change-Model Attribute %. Must be equal or greater than 0"), toString(it));
    1640            0 :                         return false;
    1641              :                     }
    1642              :                     break;
    1643              :                 default:
    1644              :                     break;
    1645              :             }
    1646              :             // check attributes of type "positiveFloatType" (> 0)
    1647         4165 :             switch (it) {
    1648           10 :                 case SUMO_ATTR_LCA_ACCEL_LAT:
    1649           10 :                     if (LCMAttribute <= 0) {
    1650            0 :                         WRITE_ERRORF(TL("Invalid Lane-Change-Model Attribute %. Must be greater than 0"), toString(it));
    1651            0 :                         return false;
    1652              :                     }
    1653              :                     break;
    1654              :                 default:
    1655              :                     break;
    1656              :             }
    1657              :             // check limits of attributes
    1658         4165 :             switch (it) {
    1659           90 :                 case SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR:
    1660           90 :                     if (LCMAttribute < -1 || LCMAttribute > 1) {
    1661            0 :                         WRITE_ERRORF(TL("Invalid Lane-Change-Model Attribute %. Must be between -1 and 1"), toString(it));
    1662            0 :                         return false;
    1663              :                     }
    1664              :                     break;
    1665              :                 default:
    1666              :                     break;
    1667              :             }
    1668              :             // add parsedLCMAttribute to cfParameter
    1669         4165 :             into->lcParameter[it] = parsedLCMAttribute;
    1670              :         }
    1671              :     }
    1672              :     // all LCM parsed ok, then return true
    1673              :     return true;
    1674              : }
    1675              : 
    1676              : 
    1677              : bool
    1678        65399 : SUMOVehicleParserHelper::parseJMParams(SUMOVTypeParameter* into, const SUMOSAXAttributes& attrs) {
    1679      1111783 :     for (const auto& it : SUMOVTypeParameter::AllowedJMAttrs) {
    1680      1046384 :         if (attrs.hasAttribute(it)) {
    1681              :             // first obtain  CFM attribute in string format
    1682         1081 :             bool ok = true;
    1683         1081 :             std::string parsedJMAttribute = attrs.get<std::string>(it, into->id.c_str(), ok);
    1684         1081 :             if (!ok) {
    1685              :                 return false;
    1686              :             }
    1687              :             // declare a double in which save CFM attribute
    1688              :             double JMAttribute = INVALID_DOUBLE;
    1689              :             try {
    1690              :                 // obtain CFM attribute in double format
    1691         1081 :                 JMAttribute = StringUtils::toDouble(parsedJMAttribute);
    1692            0 :             } catch (...) {
    1693            0 :                 WRITE_ERRORF(TL("Invalid Junction-Model Attribute %. Cannot be parsed to float"), toString(it));
    1694              :                 return false;
    1695            0 :             }
    1696              :             // now continue checking other properties (-1 is the default value)
    1697         1081 :             if (JMAttribute != INVALID_DOUBLE) {
    1698              :                 // special case for sigma minor
    1699         1081 :                 if (it == SUMO_ATTR_JM_SIGMA_MINOR) {
    1700              :                     // check attributes sigma minor
    1701          126 :                     if ((JMAttribute < 0) || (JMAttribute > 1)) {
    1702            0 :                         WRITE_ERRORF(TL("Invalid Junction-Model Attribute %. Only values between [0-1] are allowed"), toString(it));
    1703            0 :                         return false;
    1704              :                     }
    1705          955 :                 } else if (JMAttribute < 0
    1706           25 :                            && it != SUMO_ATTR_JM_TIMEGAP_MINOR
    1707           18 :                            && it != SUMO_ATTR_JM_EXTRA_GAP) {
    1708              :                     // attributes with error value
    1709           18 :                     if (JMAttribute != -1 || (it != SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME
    1710              :                                               && it != SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME
    1711           18 :                                               && it != SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME)) {
    1712              :                         // check attributes of type "nonNegativeFloatType" (>= 0)
    1713            0 :                         WRITE_ERRORF(TL("Invalid Junction-Model Attribute %. Must be equal or greater than 0"), toString(it));
    1714            0 :                         return false;
    1715              :                     }
    1716              :                 }
    1717              :                 // add parsedJMAttribute to cfParameter
    1718         1081 :                 into->jmParameter[it] = parsedJMAttribute;
    1719              :             }
    1720              :         }
    1721              :     }
    1722              :     // all JM parameters successfully parsed, then return true
    1723              :     return true;
    1724              : }
    1725              : 
    1726              : 
    1727              : SUMOVehicleClass
    1728        37517 : SUMOVehicleParserHelper::parseVehicleClass(const SUMOSAXAttributes& attrs, const std::string& id) {
    1729              :     SUMOVehicleClass vclass = SVC_IGNORING;
    1730        37517 :     bool ok = true;
    1731        37517 :     std::string vclassS = attrs.getOpt<std::string>(SUMO_ATTR_VCLASS, id.c_str(), ok, "");
    1732        37517 :     if (vclassS == "") {
    1733              :         return vclass;
    1734              :     }
    1735              :     try {
    1736        37487 :         const SUMOVehicleClass result = getVehicleClassID(vclassS);
    1737        37479 :         const std::string& realName = SumoVehicleClassStrings.getString(result);
    1738        37479 :         if (realName != vclassS) {
    1739           15 :             WRITE_WARNING("The vehicle class '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is deprecated, use '" + realName + "' instead.");
    1740              :         }
    1741              :         return result;
    1742            8 :     } catch (...) {
    1743           24 :         WRITE_ERRORF(TL("The vehicle class '%' for % '%' is not known."), vclassS, attrs.getObjectType(), id);
    1744            8 :     }
    1745              :     return vclass;
    1746              : }
    1747              : 
    1748              : 
    1749              : SUMOVehicleShape
    1750        27212 : SUMOVehicleParserHelper::parseGuiShape(const SUMOSAXAttributes& attrs, const std::string& id) {
    1751        27212 :     bool ok = true;
    1752        54424 :     std::string vclassS = attrs.getOpt<std::string>(SUMO_ATTR_GUISHAPE, id.c_str(), ok, "");
    1753              :     if (SumoVehicleShapeStrings.hasString(vclassS)) {
    1754        27212 :         const SUMOVehicleShape result = SumoVehicleShapeStrings.get(vclassS);
    1755        27212 :         const std::string& realName = SumoVehicleShapeStrings.getString(result);
    1756        27212 :         if (realName != vclassS) {
    1757            0 :             WRITE_WARNING("The shape '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is deprecated, use '" + realName + "' instead.");
    1758              :         }
    1759        27212 :         return result;
    1760              :     } else {
    1761            0 :         WRITE_ERRORF(TL("The shape '%' for % '%' is not known."), vclassS, attrs.getObjectType(), id);
    1762            0 :         return SUMOVehicleShape::UNKNOWN;
    1763              :     }
    1764              : }
    1765              : 
    1766              : 
    1767              : double
    1768        32018 : SUMOVehicleParserHelper::parseWalkPos(SumoXMLAttr attr, const bool hardFail, const std::string& id, double maxPos, const std::string& val, SumoRNG* rng) {
    1769              :     double result;
    1770              :     std::string error;
    1771        32018 :     ArrivalPosDefinition proc = ArrivalPosDefinition::DEFAULT;
    1772              :     // only supports 'random' and 'max'
    1773        64036 :     if (!SUMOVehicleParameter::parseArrivalPos(val, toString(SUMO_TAG_WALK), id, result, proc, error)) {
    1774            0 :         handleVehicleError(hardFail, nullptr, error);
    1775              :     }
    1776        32018 :     if (proc == ArrivalPosDefinition::RANDOM) {
    1777         1079 :         result = RandHelper::rand(maxPos, rng);
    1778        30939 :     } else if (proc == ArrivalPosDefinition::CENTER) {
    1779            0 :         result = maxPos / 2.;
    1780        30939 :     } else if (proc == ArrivalPosDefinition::MAX) {
    1781            0 :         result = maxPos;
    1782              :     }
    1783        64036 :     return SUMOVehicleParameter::interpretEdgePos(result, maxPos, attr, id);
    1784              : }
    1785              : 
    1786              : 
    1787              : SUMOTime
    1788       495276 : SUMOVehicleParserHelper::processActionStepLength(double given) {
    1789       495276 :     const std::string defaultError = "The parameter action-step-length must be a non-negative multiple of the simulation step-length. ";
    1790       495276 :     SUMOTime result = TIME2STEPS(given);
    1791       495276 :     if (result <= 0) {
    1792        43048 :         if (result < 0) {
    1793           36 :             WRITE_WARNING(defaultError + "Ignoring given value (=" + toString(STEPS2TIME(result)) + " s.)");
    1794              :         }
    1795        43048 :         result = DELTA_T;
    1796       452258 :     } else if (result % DELTA_T != 0 && OptionsCont::getOptions().exists("step-length")) {
    1797           25 :         result = (SUMOTime)((double)DELTA_T * floor(double(result) / double(DELTA_T)));
    1798              :         result = MAX2(DELTA_T, result);
    1799           25 :         if (fabs(given * 1000. - double(result)) > NUMERICAL_EPS) {
    1800          100 :             WRITE_WARNING(defaultError + "Parsing given value (" + toString(given) + " s.) to the adjusted value " + toString(STEPS2TIME(result)) + " s.");
    1801              :         }
    1802              :     }
    1803       495276 :     return result;
    1804              : }
    1805              : 
    1806              : 
    1807              : bool
    1808       186901 : SUMOVehicleParserHelper::isInternalRouteID(const std::string& id) {
    1809       186901 :     return id.substr(0, 1) == "!";
    1810              : }
    1811              : 
    1812              : 
    1813              : bool
    1814           16 : SUMOVehicleParserHelper::validProfile(SUMOVTypeParameter* vtype, const std::string data, const SumoXMLAttr attr) {
    1815           68 :     for (std::string value : StringTokenizer(data).getVector()) {
    1816              :         try {
    1817           36 :             double v = StringUtils::toDouble(value);
    1818           36 :             if (v < 0.) {
    1819            0 :                 WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. An acceleration profile value cannot be negative"), toString(attr));
    1820            0 :                 return false;
    1821              :             }
    1822            0 :         } catch (...) {
    1823            0 :             WRITE_ERRORF(TL("Entry '%' of % table for vType '%' cannot be parsed as 'double'"), value, toString(attr), vtype->id);
    1824              :             return false;
    1825            0 :         }
    1826           16 :     }
    1827           16 :     return true;
    1828              : }
    1829              : 
    1830              : 
    1831              : int
    1832        15335 : SUMOVehicleParserHelper::parseCarWalkTransfer(const OptionsCont& oc, const bool hasTaxi) {
    1833              :     int carWalk = 0;
    1834        46005 :     for (const std::string& opt : oc.getStringVector("persontrip.transfer.car-walk")) {
    1835        15335 :         if (opt == "parkingAreas") {
    1836        15113 :             carWalk |= ModeChangeOptions::PARKING_AREAS;
    1837          222 :         } else if (opt == "ptStops") {
    1838          166 :             carWalk |= ModeChangeOptions::PT_STOPS;
    1839           56 :         } else if (opt == "allJunctions") {
    1840           56 :             carWalk |= ModeChangeOptions::ALL_JUNCTIONS;
    1841              :         } else {
    1842            0 :             WRITE_ERRORF(TL("Invalid transfer option '%'. Must be one of 'parkingAreas', 'ptStops' and 'allJunctions'"), opt);
    1843              :         }
    1844              :     }
    1845        15335 :     const StringVector taxiDropoff = oc.getStringVector("persontrip.transfer.taxi-walk");
    1846        30670 :     const StringVector taxiPickup = oc.getStringVector("persontrip.transfer.walk-taxi");
    1847        15335 :     if (taxiDropoff.empty() && hasTaxi) {
    1848         4217 :         carWalk |= ModeChangeOptions::TAXI_DROPOFF_ANYWHERE;
    1849              :     } else {
    1850        11324 :         for (const std::string& opt : taxiDropoff) {
    1851          206 :             if (opt == "parkingAreas") {
    1852           15 :                 carWalk |= ModeChangeOptions::TAXI_DROPOFF_PARKING_AREAS;
    1853          191 :             } else if (opt == "ptStops") {
    1854          143 :                 carWalk |= ModeChangeOptions::TAXI_DROPOFF_PT;
    1855           48 :             } else if (opt == "allJunctions") {
    1856           48 :                 carWalk |= ModeChangeOptions::TAXI_DROPOFF_ANYWHERE;
    1857              :             } else {
    1858            0 :                 WRITE_ERRORF(TL("Invalid transfer option '%'. Must be one of 'parkingAreas', 'ptStops' and 'allJunctions'"), opt);
    1859              :             }
    1860              :         }
    1861              :     }
    1862        15335 :     if (taxiPickup.empty() && hasTaxi) {
    1863         4199 :         carWalk |= ModeChangeOptions::TAXI_PICKUP_ANYWHERE;
    1864              :     } else {
    1865        11360 :         for (const std::string& opt : taxiPickup) {
    1866          224 :             if (opt == "parkingAreas") {
    1867           15 :                 carWalk |= ModeChangeOptions::TAXI_PICKUP_PARKING_AREAS;
    1868          209 :             } else if (opt == "ptStops") {
    1869          156 :                 carWalk |= ModeChangeOptions::TAXI_PICKUP_PT;
    1870           53 :             } else if (opt == "allJunctions") {
    1871           53 :                 carWalk |= ModeChangeOptions::TAXI_PICKUP_ANYWHERE;
    1872              :             } else {
    1873            0 :                 WRITE_ERRORF(TL("Invalid transfer option '%'. Must be one of 'parkingAreas', 'ptStops' and 'allJunctions'"), opt);
    1874              :             }
    1875              :         }
    1876              :     }
    1877        15335 :     return carWalk;
    1878        15335 : }
    1879              : 
    1880              : 
    1881              : bool
    1882        96175 : SUMOVehicleParserHelper::parseStopTag(const SUMOSAXAttributes& attrs, const SUMOVehicleParameter::Stop* stopParam, SumoXMLTag& tag, std::string& id) {
    1883        96175 :     bool ok = true;
    1884              :     // dummy stop parameter to hold the attributes
    1885        96175 :     SUMOVehicleParameter::Stop stop;
    1886        96175 :     if (stopParam != nullptr) {
    1887        41891 :         stop = *stopParam;
    1888              :     } else {
    1889       108568 :         stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, nullptr, ok, "");
    1890        54284 :         stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_TRAIN_STOP, nullptr, ok, stop.busstop); // alias
    1891        54284 :         stop.chargingStation = attrs.getOpt<std::string>(SUMO_ATTR_CHARGING_STATION, nullptr, ok, "");
    1892        54284 :         stop.overheadWireSegment = attrs.getOpt<std::string>(SUMO_ATTR_OVERHEAD_WIRE_SEGMENT, nullptr, ok, "");
    1893        54284 :         stop.containerstop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, nullptr, ok, "");
    1894       108568 :         stop.parkingarea = attrs.getOpt<std::string>(SUMO_ATTR_PARKING_AREA, nullptr, ok, "");
    1895              :     }
    1896        96175 :     if (stop.busstop != "") {
    1897        16016 :         tag = SUMO_TAG_BUS_STOP;
    1898              :         id = stop.busstop;
    1899        80159 :     } else if (stop.containerstop != "") {
    1900         1589 :         tag = SUMO_TAG_CONTAINER_STOP;
    1901              :         id = stop.containerstop;
    1902        78570 :     } else if (stop.parkingarea != "") {
    1903        16680 :         tag = SUMO_TAG_PARKING_AREA;
    1904              :         id = stop.parkingarea;
    1905        61890 :     } else if (stop.chargingStation != "") {
    1906         2063 :         tag = SUMO_TAG_CHARGING_STATION;
    1907              :         id = stop.chargingStation;
    1908        59827 :     } else if (stop.overheadWireSegment != "") {
    1909            0 :         tag = SUMO_TAG_OVERHEAD_WIRE_SEGMENT;
    1910              :         id = stop.overheadWireSegment;
    1911              :     }
    1912        96175 :     return ok;
    1913        96175 : }
    1914              : 
    1915              : 
    1916              : SUMOVehicleParameter*
    1917          515 : SUMOVehicleParserHelper::handleVehicleError(const bool hardFail, SUMOVehicleParameter* vehicleParameter, const std::string message) {
    1918          515 :     if (vehicleParameter) {
    1919          467 :         delete vehicleParameter;
    1920              :     }
    1921          515 :     if (hardFail) {
    1922          515 :         throw ProcessError(message);
    1923            0 :     } else if (message.size() > 0) {
    1924            0 :         WRITE_ERROR(message);
    1925              :     }
    1926            0 :     return nullptr;
    1927              : }
    1928              : 
    1929              : 
    1930              : SUMOVTypeParameter*
    1931           32 : SUMOVehicleParserHelper::handleVehicleTypeError(const bool hardFail, SUMOVTypeParameter* vehicleTypeParameter, const std::string message) {
    1932           32 :     if (vehicleTypeParameter) {
    1933           27 :         delete vehicleTypeParameter;
    1934              :     }
    1935           32 :     if (hardFail) {
    1936           32 :         throw ProcessError(message);
    1937            0 :     } else if (message.size() > 0) {
    1938            0 :         WRITE_ERROR(message);
    1939              :     }
    1940            0 :     return nullptr;
    1941              : }
    1942              : 
    1943              : /****************************************************************************/
        

Generated by: LCOV version 2.0-1