LCOV - code coverage report
Current view: top level - src/utils/common - SUMOVehicleClass.cpp (source / functions) Coverage Total Hit
Test: lcov.info Lines: 82.4 % 205 169
Test Date: 2026-10-12 15:53:19 Functions: 76.9 % 39 30

            Line data    Source code
       1              : /****************************************************************************/
       2              : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3              : // Copyright (C) 2001-2026 German Aerospace Center (DLR) and others.
       4              : // This program and the accompanying materials are made available under the
       5              : // terms of the Eclipse Public License 2.0 which is available at
       6              : // https://www.eclipse.org/legal/epl-2.0/
       7              : // This Source Code may also be made available under the following Secondary
       8              : // Licenses when the conditions for such availability set forth in the Eclipse
       9              : // Public License 2.0 are satisfied: GNU General Public License, version 2
      10              : // or later which is available at
      11              : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
      12              : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
      13              : /****************************************************************************/
      14              : /// @file    SUMOVehicleClass.cpp
      15              : /// @author  Daniel Krajzewicz
      16              : /// @author  Jakob Erdmann
      17              : /// @author  Michael Behrisch
      18              : /// @author  Walter Bamberger
      19              : /// @author  Laura Bieker-Walz
      20              : /// @date    2006-01-24
      21              : ///
      22              : // Definitions of SUMO vehicle classes and helper functions
      23              : /****************************************************************************/
      24              : #include <config.h>
      25              : 
      26              : #include <string>
      27              : #include <map>
      28              : #include "SUMOVehicleClass.h"
      29              : #include <utils/common/StringUtils.h>
      30              : #include <utils/common/ToString.h>
      31              : #include <utils/common/MsgHandler.h>
      32              : #include <utils/common/StringTokenizer.h>
      33              : #include <utils/iodevices/OutputDevice.h>
      34              : #include <utils/xml/SUMOSAXAttributes.h>
      35              : 
      36              : 
      37              : // ===========================================================================
      38              : // static members
      39              : // ===========================================================================
      40              : 
      41              : static StringBijection<SUMOVehicleClass>::Entry sumoVehicleClassStringInitializer[] = {
      42              :     {"ignoring",          SVC_IGNORING},
      43              :     {"private",           SVC_PRIVATE},
      44              :     {"public_emergency",  SVC_EMERGENCY}, // !!! deprecated
      45              :     {"emergency",         SVC_EMERGENCY},
      46              :     {"public_authority",  SVC_AUTHORITY}, // !!! deprecated
      47              :     {"authority",         SVC_AUTHORITY},
      48              :     {"public_army",       SVC_ARMY}, // !!! deprecated
      49              :     {"army",              SVC_ARMY},
      50              :     {"vip",               SVC_VIP},
      51              :     {"pedestrian",        SVC_PEDESTRIAN},
      52              :     {"passenger",         SVC_PASSENGER},
      53              :     {"hov",               SVC_HOV},
      54              :     {"taxi",              SVC_TAXI},
      55              :     {"public_transport",  SVC_BUS}, // !!! deprecated
      56              :     {"bus",               SVC_BUS},
      57              :     {"coach",             SVC_COACH},
      58              :     {"delivery",          SVC_DELIVERY},
      59              :     {"transport",         SVC_TRUCK}, // !!! deprecated
      60              :     {"truck",             SVC_TRUCK},
      61              :     {"trailer",           SVC_TRAILER},
      62              :     {"motorcycle",        SVC_MOTORCYCLE},
      63              :     {"moped",             SVC_MOPED},
      64              :     {"bicycle",           SVC_BICYCLE},
      65              :     {"evehicle",          SVC_E_VEHICLE},
      66              :     {"lightrail",         SVC_TRAM}, // !!! deprecated
      67              :     {"tram",              SVC_TRAM},
      68              :     {"cityrail",          SVC_RAIL_URBAN}, // !!! deprecated
      69              :     {"rail_urban",        SVC_RAIL_URBAN},
      70              :     {"rail_slow",         SVC_RAIL}, // !!! deprecated
      71              :     {"rail",              SVC_RAIL},
      72              :     {"rail_electric",     SVC_RAIL_ELECTRIC},
      73              :     {"rail_fast",         SVC_RAIL_FAST},
      74              :     {"ship",              SVC_SHIP},
      75              :     {"container",         SVC_CONTAINER},
      76              :     {"cable_car",         SVC_CABLE_CAR},
      77              :     {"subway",            SVC_SUBWAY},
      78              :     {"aircraft",          SVC_AIRCRAFT},
      79              :     {"wheelchair",        SVC_WHEELCHAIR},
      80              :     {"scooter",           SVC_SCOOTER},
      81              :     {"drone",             SVC_DRONE},
      82              :     {"custom1",           SVC_CUSTOM1},
      83              :     {"custom2",           SVC_CUSTOM2}
      84              : };
      85              : 
      86              : 
      87              : StringBijection<SUMOVehicleClass> SumoVehicleClassStrings(
      88              :     sumoVehicleClassStringInitializer, SVC_CUSTOM2, false);
      89              : 
      90              : // count only non-deprecated classes
      91              : const int NUM_VCLASSES = SumoVehicleClassStrings.size() - 8;
      92              : 
      93              : std::set<std::string> deprecatedVehicleClassesSeen;
      94              : 
      95              : 
      96              : static StringBijection<SUMOVehicleShape>::Entry sumoVehicleShapeStringInitializer[] = {
      97              :     {"pedestrian",            SUMOVehicleShape::PEDESTRIAN},
      98              :     {"bicycle",               SUMOVehicleShape::BICYCLE},
      99              :     {"moped",                 SUMOVehicleShape::MOPED},
     100              :     {"motorcycle",            SUMOVehicleShape::MOTORCYCLE},
     101              :     {"passenger",             SUMOVehicleShape::PASSENGER},
     102              :     {"passenger/sedan",       SUMOVehicleShape::PASSENGER_SEDAN},
     103              :     {"passenger/hatchback",   SUMOVehicleShape::PASSENGER_HATCHBACK},
     104              :     {"passenger/wagon",       SUMOVehicleShape::PASSENGER_WAGON},
     105              :     {"passenger/van",         SUMOVehicleShape::PASSENGER_VAN},
     106              :     {"taxi",                  SUMOVehicleShape::TAXI},
     107              :     {"delivery",              SUMOVehicleShape::DELIVERY},
     108              :     {"transport",             SUMOVehicleShape::TRUCK}, // !!! deprecated
     109              :     {"truck",                 SUMOVehicleShape::TRUCK},
     110              :     {"transport/semitrailer", SUMOVehicleShape::TRUCK_SEMITRAILER}, // !!! deprecated
     111              :     {"truck/semitrailer",     SUMOVehicleShape::TRUCK_SEMITRAILER},
     112              :     {"transport/trailer",     SUMOVehicleShape::TRUCK_1TRAILER}, // !!! deprecated
     113              :     {"truck/trailer",         SUMOVehicleShape::TRUCK_1TRAILER},
     114              :     {"bus/city",              SUMOVehicleShape::BUS}, // !!! deprecated
     115              :     {"bus",                   SUMOVehicleShape::BUS},
     116              :     {"bus/overland",          SUMOVehicleShape::BUS_COACH}, // !!! deprecated
     117              :     {"bus/coach",             SUMOVehicleShape::BUS_COACH},
     118              :     {"bus/flexible",          SUMOVehicleShape::BUS_FLEXIBLE},
     119              :     {"bus/trolley",           SUMOVehicleShape::BUS_TROLLEY},
     120              :     {"rail/slow",             SUMOVehicleShape::RAIL}, // !!! deprecated
     121              :     {"rail/fast",             SUMOVehicleShape::RAIL}, // !!! deprecated
     122              :     {"rail",                  SUMOVehicleShape::RAIL},
     123              :     {"rail/light",            SUMOVehicleShape::RAIL_CAR}, // !!! deprecated
     124              :     {"rail/city",             SUMOVehicleShape::RAIL_CAR}, // !!! deprecated
     125              :     {"rail/railcar",          SUMOVehicleShape::RAIL_CAR},
     126              :     {"rail/cargo",            SUMOVehicleShape::RAIL_CARGO},
     127              :     {"evehicle",              SUMOVehicleShape::E_VEHICLE},
     128              :     {"ant",                   SUMOVehicleShape::ANT},
     129              :     {"ship",                  SUMOVehicleShape::SHIP},
     130              :     {"emergency",             SUMOVehicleShape::EMERGENCY},
     131              :     {"firebrigade",           SUMOVehicleShape::FIREBRIGADE},
     132              :     {"police",                SUMOVehicleShape::POLICE},
     133              :     {"rickshaw",              SUMOVehicleShape::RICKSHAW },
     134              :     {"scooter",               SUMOVehicleShape::SCOOTER},
     135              :     {"aircraft",              SUMOVehicleShape::AIRCRAFT},
     136              :     {"",                      SUMOVehicleShape::UNKNOWN}
     137              : };
     138              : 
     139              : 
     140              : StringBijection<SUMOVehicleShape> SumoVehicleShapeStrings(
     141              :     sumoVehicleShapeStringInitializer, SUMOVehicleShape::UNKNOWN, false);
     142              : 
     143              : // ===========================================================================
     144              : // static values used for cached
     145              : // ===========================================================================
     146              : 
     147              : static std::map<SVCPermissions, std::vector<std::string> > vehicleClassNamesListCached;
     148              : static std::map<std::string, SVCPermissions> parseVehicleClassesCached;
     149              : static std::map<SVCPermissions, std::string> getVehicleClassNamesCached;
     150              : static std::string VehicleClassNameAll = "all";
     151              : 
     152              : // ===========================================================================
     153              : // additional constants
     154              : // ===========================================================================
     155              : 
     156              : const SUMOVehicleClass SUMOVehicleClass_MAX = SVC_CUSTOM2;
     157              : 
     158              : const SVCPermissions SVCAll = 2 * (long long int)SUMOVehicleClass_MAX - 1; // all relevant bits set to 1
     159              : 
     160              : const SVCPermissions SVC_UNSPECIFIED = -1;
     161              : 
     162              : const SUMOEmissionClass EMISSION_CLASS_UNSPECIFIED = -1;
     163              : 
     164              : const std::string DEFAULT_VTYPE_ID("DEFAULT_VEHTYPE");
     165              : const std::string DEFAULT_PEDTYPE_ID("DEFAULT_PEDTYPE");
     166              : const std::string DEFAULT_BIKETYPE_ID("DEFAULT_BIKETYPE");
     167              : const std::string DEFAULT_CONTAINERTYPE_ID("DEFAULT_CONTAINERTYPE");
     168              : const std::string DEFAULT_TAXITYPE_ID("DEFAULT_TAXITYPE");
     169              : const std::string DEFAULT_RAILTYPE_ID("DEFAULT_RAILTYPE");
     170              : 
     171              : const std::set<std::string> DEFAULT_VTYPES({DEFAULT_VTYPE_ID, DEFAULT_PEDTYPE_ID, DEFAULT_BIKETYPE_ID, DEFAULT_CONTAINERTYPE_ID, DEFAULT_TAXITYPE_ID, DEFAULT_RAILTYPE_ID});
     172              : 
     173              : const double DEFAULT_VEH_PROB(1.);
     174              : const double DEFAULT_VEH_MASS(1500.);
     175              : const double DEFAULT_VEH_WIDTH(1.8);
     176              : const double DEFAULT_VEH_HEIGHT(1.5);
     177              : const double DEFAULT_VEH_SHUT_OFF_STOP(300.);
     178              : 
     179              : const double DEFAULT_PEDESTRIAN_SPEED(5. / 3.6);
     180              : 
     181              : const double DEFAULT_BICYCLE_SPEED(20. / 3.6);
     182              : 
     183              : const double DEFAULT_CONTAINER_TRANSHIP_SPEED(5. / 3.6);
     184              : 
     185              : 
     186              : // ===========================================================================
     187              : // method definitions
     188              : // ===========================================================================
     189              : 
     190              : // Stop Offset
     191              : 
     192      2854043 : StopOffset::StopOffset() :
     193      2854043 :     myPermissions(SVCAll),
     194      2854043 :     myOffset(0) {
     195      2854043 : }
     196              : 
     197              : 
     198         2229 : StopOffset::StopOffset(const SUMOSAXAttributes& attrs, bool& ok) :
     199         2229 :     myPermissions(SVC_IGNORING),
     200         2229 :     myOffset(0) {
     201              :     // first check conditions
     202         2229 :     if (attrs.hasAttribute(SUMO_ATTR_VCLASSES) && attrs.hasAttribute(SUMO_ATTR_EXCEPTIONS)) {
     203            0 :         WRITE_ERROR(TL("Simultaneous specification of vClasses and exceptions is not allowed"));
     204            0 :         ok = false;
     205              :     }
     206         2229 :     if (!attrs.hasAttribute(SUMO_ATTR_VALUE)) {
     207            2 :         WRITE_ERROR(TL("StopOffset requires an offset value"));
     208            2 :         ok = false;
     209              :     }
     210              :     // parse elements
     211         2229 :     const std::string vClasses = attrs.getOpt<std::string>(SUMO_ATTR_VCLASSES, nullptr, ok, "");
     212         2229 :     const std::string exceptions = attrs.getOpt<std::string>(SUMO_ATTR_EXCEPTIONS, nullptr, ok, "");
     213              :     // parse permissions
     214         2229 :     if (attrs.hasAttribute(SUMO_ATTR_VCLASSES)) {
     215         1212 :         myPermissions = parseVehicleClasses(vClasses);
     216         1017 :     } else if (attrs.hasAttribute(SUMO_ATTR_EXCEPTIONS)) {
     217         1001 :         myPermissions = ~parseVehicleClasses(exceptions);
     218              :     } else {
     219              :         // no vClasses specified, thus apply to all
     220           16 :         myPermissions = parseVehicleClasses("all");
     221              :     }
     222              :     // parse offset
     223         2229 :     myOffset = attrs.getOpt<double>(SUMO_ATTR_VALUE, nullptr, ok, 0);
     224         2229 : }
     225              : 
     226              : 
     227              : bool
     228   2517055524 : StopOffset::isDefined() const {
     229   2517055524 :     return myOffset != 0;
     230              : }
     231              : 
     232              : 
     233              : void
     234      1830523 : StopOffset::reset() {
     235      1830523 :     myPermissions = SVC_IGNORING;
     236      1830523 :     myOffset = 0;
     237      1830523 : }
     238              : 
     239              : 
     240              : SVCPermissions
     241        94197 : StopOffset::getPermissions() const {
     242        94197 :     return myPermissions;
     243              : }
     244              : 
     245              : 
     246              : std::string
     247            0 : StopOffset::getExceptions() const {
     248            0 :     return getVehicleClassNames(~myPermissions);
     249              : }
     250              : 
     251              : 
     252              : double
     253       129275 : StopOffset::getOffset() const {
     254       129275 :     return myOffset;
     255              : }
     256              : 
     257              : 
     258              : void
     259            0 : StopOffset::setPermissions(const SVCPermissions permissions) {
     260            0 :     myPermissions = permissions;
     261            0 : }
     262              : 
     263              : 
     264              : void
     265            0 : StopOffset::setExceptions(const std::string permissions) {
     266            0 :     myPermissions = ~parseVehicleClasses(permissions);
     267            0 : }
     268              : 
     269              : 
     270              : void
     271            0 : StopOffset::setOffset(const double offset) {
     272            0 :     myOffset = offset;
     273            0 : }
     274              : 
     275              : 
     276              : bool
     277            0 : StopOffset::operator==(StopOffset const& other) const {
     278            0 :     return ((myPermissions == other.myPermissions) &&
     279            0 :             (myOffset == other.myOffset));
     280              : }
     281              : 
     282              : 
     283              : bool
     284       131767 : StopOffset::operator!=(StopOffset const& other) const {
     285       131767 :     return ((myPermissions != other.myPermissions) ||
     286       131744 :             (myOffset != other.myOffset));
     287              : }
     288              : 
     289              : // Conversion of SUMOVehicleClass
     290              : 
     291              : const std::string&
     292       868631 : getVehicleClassNames(SVCPermissions permissions, bool expand) {
     293       868631 :     if ((permissions & SVCAll) == SVCAll && !expand) {
     294              :         return VehicleClassNameAll;
     295              :     }
     296              :     // check if previously was cached
     297              :     if (getVehicleClassNamesCached.count(permissions) == 0) {
     298        10966 :         getVehicleClassNamesCached[permissions] = joinToString(getVehicleClassNamesList(permissions), ' ');
     299              :     }
     300       419790 :     return getVehicleClassNamesCached.at(permissions);
     301              : }
     302              : 
     303              : 
     304              : const std::vector<std::string>&
     305         5681 : getVehicleClassNamesList(SVCPermissions permissions) {
     306              :     // first check if it's cached
     307              :     if (vehicleClassNamesListCached.count(permissions) == 0) {
     308         5634 :         const std::vector<std::string> classNames = SumoVehicleClassStrings.getStrings();
     309              :         std::vector<std::string> result;
     310       197190 :         for (std::vector<std::string>::const_iterator it = classNames.begin(); it != classNames.end(); it++) {
     311       191556 :             const SVCPermissions svc = (SVCPermissions)SumoVehicleClassStrings.get(*it);
     312       191556 :             if ((svc & permissions) == svc && svc != SVC_IGNORING) {
     313        19151 :                 result.push_back(*it);
     314              :             }
     315              :         }
     316              :         // add it into vehicleClassNamesListCached
     317         5634 :         vehicleClassNamesListCached[permissions] = result;
     318         5634 :     }
     319         5681 :     return vehicleClassNamesListCached.at(permissions);
     320              : }
     321              : 
     322              : 
     323              : SUMOVehicleClass
     324       584047 : getVehicleClassID(const std::string& name) {
     325              :     if (SumoVehicleClassStrings.hasString(name)) {
     326       584032 :         return SumoVehicleClassStrings.get(name);
     327              :     }
     328           45 :     throw InvalidArgument("Unknown vehicle class '" + name + "'.");
     329              : }
     330              : 
     331              : 
     332              : SVCPermissions
     333            0 : getVehicleClassCompoundID(const std::string& name) {
     334              :     SVCPermissions ret = SVC_IGNORING;
     335            0 :     const std::vector<std::string> names = SumoVehicleClassStrings.getStrings();
     336            0 :     for (std::vector<std::string>::const_iterator it = names.begin(); it != names.end(); it++) {
     337            0 :         if (name.find(*it) != std::string::npos) {
     338            0 :             ret = ret | (SVCPermissions) SumoVehicleClassStrings.get(*it);
     339              :         }
     340              :     }
     341            0 :     return ret;
     342            0 : }
     343              : 
     344              : 
     345              : SVCPermissions
     346      1646086 : parseVehicleClasses(const std::string& allowedS) {
     347      1646086 :     if (allowedS == VehicleClassNameAll) {
     348              :         return SVCAll;
     349              :     }
     350              :     // check  if allowedS was previously cached
     351              :     if (parseVehicleClassesCached.count(allowedS) == 0) {
     352              :         SVCPermissions result = 0;
     353      1220004 :         StringTokenizer sta(allowedS, " ");
     354       889342 :         while (sta.hasNext()) {
     355       482674 :             const std::string s = sta.next();
     356       482674 :             if (!SumoVehicleClassStrings.hasString(s)) {
     357           24 :                 if (!SUMOXMLDefinitions::isValidNetID(s)) {
     358           24 :                     WRITE_ERRORF(TL("Invalid character in vehicle class '%' encountered."), s);
     359           16 :                 } else if (gIgnoreUnknownVClass) {
     360           27 :                     WRITE_WARNINGF(TL("Unknown vehicle class '%' ignored."), s);
     361              :                 } else {
     362           21 :                     WRITE_ERRORF(TL("Unknown vehicle class '%' encountered."), s);
     363              :                 }
     364              :             } else {
     365       482650 :                 const SUMOVehicleClass vc = getVehicleClassID(s);
     366       482650 :                 const std::string& realName = SumoVehicleClassStrings.getString(vc);
     367       482650 :                 if (realName != s) {
     368              :                     deprecatedVehicleClassesSeen.insert(s);
     369              :                 }
     370       482650 :                 result |= vc;
     371              :             }
     372              :         }
     373              :         // save parsed vehicle class cached
     374       406668 :         parseVehicleClassesCached[allowedS] = result;
     375       406668 :     }
     376      1633666 :     return parseVehicleClassesCached.at(allowedS);
     377              : }
     378              : 
     379              : 
     380              : void
     381            0 : clearParseVehicleClassesCache() {
     382              :     parseVehicleClassesCached.clear();
     383            0 : }
     384              : 
     385              : bool
     386            0 : canParseVehicleClasses(const std::string& classes) {
     387            0 :     if (classes == VehicleClassNameAll) {
     388              :         return true;
     389              :     }
     390              :     // check if was previously cached
     391              :     if (parseVehicleClassesCached.count(classes) != 0) {
     392            0 :         return true;
     393              :     }
     394            0 :     StringTokenizer sta(classes, " ");
     395            0 :     while (sta.hasNext()) {
     396            0 :         if (!SumoVehicleClassStrings.hasString(sta.next())) {
     397              :             return false;
     398              :         }
     399              :     }
     400              :     return true;
     401            0 : }
     402              : 
     403              : 
     404              : SVCPermissions
     405      7174693 : parseVehicleClasses(const std::string& allowedS, const std::string& disallowedS, const MMVersion& networkVersion) {
     406      7174693 :     if (allowedS.size() == 0 && disallowedS.size() == 0) {
     407              :         return SVCAll;
     408      1289143 :     } else if (allowedS.size() > 0 && disallowedS.size() > 0) {
     409            1 :         WRITE_WARNING(TL("SVCPermissions must be specified either via 'allow' or 'disallow'. Ignoring 'disallow'"));
     410            1 :         return parseVehicleClasses(allowedS);
     411      1289142 :     } else if (allowedS.size() > 0) {
     412       766747 :         return parseVehicleClasses(allowedS);
     413              :     } else {
     414       522395 :         return invertPermissions(extraDisallowed(parseVehicleClasses(disallowedS), networkVersion));
     415              :     }
     416              : }
     417              : 
     418              : SVCPermissions
     419       522395 : extraDisallowed(SVCPermissions disallowed, const MMVersion& networkVersion) {
     420              :     if (networkVersion < MMVersion(1, 3)) {
     421        33348 :         disallowed |= SVC_RAIL_FAST;
     422              :     }
     423              :     if (networkVersion < MMVersion(1, 20)) {
     424       263178 :         if ((disallowed & SVC_RAIL_URBAN) != 0) {
     425              :             disallowed |= SVC_SUBWAY;
     426        54382 :             disallowed |= SVC_CABLE_CAR;
     427              :         }
     428              :     }
     429       522395 :     return disallowed;
     430              : }
     431              : 
     432              : 
     433              : SVCPermissions
     434       522487 : invertPermissions(SVCPermissions permissions) {
     435       522487 :     return SVCAll & ~permissions;
     436              : }
     437              : 
     438              : 
     439              : SVCPermissions
     440        15876 : parseVehicleClasses(const std::vector<std::string>& allowedS) {
     441              :     SVCPermissions result = 0;
     442        15876 :     if (std::find(allowedS.begin(), allowedS.end(), VehicleClassNameAll) != allowedS.end()) {
     443              :         return SVCAll;
     444              :     }
     445        47458 :     for (std::vector<std::string>::const_iterator i = allowedS.begin(); i != allowedS.end(); ++i) {
     446        31590 :         const SUMOVehicleClass vc = getVehicleClassID(*i);
     447        31583 :         const std::string& realName = SumoVehicleClassStrings.getString(vc);
     448        31583 :         if (realName != *i) {
     449            0 :             WRITE_WARNINGF(TL("The vehicle class '%' is deprecated, use '%' instead."), (*i), realName);
     450              :         }
     451        31583 :         result |= getVehicleClassID(*i);
     452              :     }
     453              :     return result;
     454              : }
     455              : 
     456              : 
     457              : void
     458       481734 : writePermissions(OutputDevice& into, SVCPermissions permissions) {
     459       481734 :     if (permissions == SVCAll || permissions == SVC_UNSPECIFIED) {
     460       318520 :         into.writeOptionalAttr(SUMO_ATTR_ALLOW, "", true);
     461       318520 :         into.writeOptionalAttr(SUMO_ATTR_DISALLOW, "", true);
     462       318520 :         return;
     463              :     }
     464       163214 :     if (permissions == 0) {
     465          927 :         into.writeOptionalAttr(SUMO_ATTR_ALLOW, "", true);
     466          927 :         into.writeAttr(SUMO_ATTR_DISALLOW, VehicleClassNameAll);
     467          927 :         return;
     468              :     }
     469              :     int num_allowed = 0;
     470      5517758 :     for (SVCPermissions mask = 1; mask <= SUMOVehicleClass_MAX; mask = mask << 1) {
     471      5355471 :         if ((mask & permissions) == mask) {
     472      1864683 :             ++num_allowed;
     473              :         }
     474              :     }
     475       162287 :     if (num_allowed <= (NUM_VCLASSES - num_allowed) && num_allowed > 0) {
     476        87601 :         into.writeAttr(SUMO_ATTR_ALLOW, getVehicleClassNames(permissions));
     477        87601 :         into.writeOptionalAttr(SUMO_ATTR_DISALLOW, "", true);
     478              :     } else {
     479        74686 :         into.writeOptionalAttr(SUMO_ATTR_ALLOW, "", true);
     480        74686 :         into.writeAttr(SUMO_ATTR_DISALLOW, getVehicleClassNames(~permissions));
     481              :     }
     482              : }
     483              : 
     484              : 
     485              : void
     486       256287 : writePreferences(OutputDevice& into, SVCPermissions preferred) {
     487       256287 :     into.writeOptionalAttr(SUMO_ATTR_PREFER, getVehicleClassNames(preferred), preferred == SVCAll || preferred == 0);
     488       256287 : }
     489              : 
     490              : 
     491              : SUMOVehicleShape
     492           16 : getVehicleShapeID(const std::string& name) {
     493              :     if (SumoVehicleShapeStrings.hasString(name)) {
     494           16 :         return SumoVehicleShapeStrings.get(name);
     495              :     } else {
     496            0 :         throw InvalidArgument("Unknown vehicle shape '" + name + "'.");
     497              :     }
     498              : }
     499              : 
     500              : 
     501              : bool
     502            0 : canParseVehicleShape(const std::string& shape) {
     503            0 :     return SumoVehicleShapeStrings.hasString(shape);
     504              : }
     505              : 
     506              : 
     507              : std::string
     508          183 : getVehicleShapeName(SUMOVehicleShape id) {
     509          183 :     return SumoVehicleShapeStrings.getString(id);
     510              : }
     511              : 
     512              : 
     513   6317512075 : bool isRailway(SVCPermissions permissions) {
     514   6317512075 :     return (permissions & SVC_RAIL_CLASSES) != 0 && (permissions & ~(SVC_RAIL_CLASSES | SVC_TAXI)) == 0;
     515              : }
     516              : 
     517       124998 : bool isRailwayOrShared(SVCPermissions permissions) {
     518              :     // basically check that it isn't SVC_ALL
     519       124998 :     return (permissions & SVC_RAIL_CLASSES) != 0 && (permissions & SVC_NON_ROAD_RAIL) == 0;
     520              : }
     521              : 
     522         2439 : bool isTram(SVCPermissions permissions) {
     523         2439 :     return (permissions & SVC_RAIL_CLASSES) == SVC_TRAM && (permissions & SVC_PASSENGER) == 0;
     524              : }
     525              : 
     526       110069 : bool isBikepath(SVCPermissions permissions) {
     527       110069 :     return (permissions & SVC_BICYCLE) == SVC_BICYCLE && (permissions & SVC_ROAD_MOTOR_CLASSES) == 0;
     528              : }
     529              : 
     530              : 
     531              : bool
     532     51966265 : isWaterway(SVCPermissions permissions) {
     533     51966265 :     return permissions == SVC_SHIP;
     534              : }
     535              : 
     536              : bool
     537      6237064 : isAirway(SVCPermissions permissions) {
     538      6237064 :     return permissions == SVC_AIRCRAFT || permissions == SVC_DRONE;
     539              : }
     540              : 
     541              : bool
     542       142954 : isForbidden(SVCPermissions permissions) {
     543       142954 :     return (permissions & SVCAll) == 0;
     544              : }
     545              : 
     546              : 
     547              : bool
     548        25651 : isSidewalk(SVCPermissions permissions) {
     549        25651 :     return (permissions & SVCAll) == SVC_PEDESTRIAN;
     550              : }
     551              : 
     552              : 
     553              : bool
     554         1853 : isForVulnerableModes(SVCPermissions permissions) {
     555         1853 :     return ((permissions & SVC_VULNERABLE) != 0 && (permissions & ~SVC_VULNERABLE) == 0);
     556              : }
     557              : 
     558              : 
     559              : bool
     560        18629 : noVehicles(SVCPermissions permissions) {
     561        18629 :     return isForbidden(permissions) || isSidewalk(permissions);
     562              : }
     563              : 
     564              : 
     565              : double
     566       387018 : getDefaultVehicleLength(const SUMOVehicleClass vc) {
     567       387018 :     switch (vc) {
     568              :         case SVC_PEDESTRIAN:
     569              :             return 0.215;
     570              :         case SVC_WHEELCHAIR:
     571              :             return 1.2;
     572        49708 :         case SVC_BICYCLE:
     573        49708 :             return 1.6;
     574              :         case SVC_SCOOTER:
     575              :             return 1.2;
     576          118 :         case SVC_MOPED:
     577          118 :             return 2.1;
     578          139 :         case SVC_MOTORCYCLE:
     579          139 :             return 2.2;
     580          545 :         case SVC_TRUCK:
     581          545 :             return 7.1;
     582           71 :         case SVC_TRAILER:
     583           71 :             return 16.5;
     584         1481 :         case SVC_BUS:
     585         1481 :             return 12.;
     586           41 :         case SVC_COACH:
     587           41 :             return 14.;
     588          438 :         case SVC_TRAM:
     589          438 :             return 22.;
     590         1056 :         case SVC_RAIL_URBAN:
     591              :         case SVC_SUBWAY:
     592         1056 :             return 36.5 * 3;
     593        51239 :         case SVC_RAIL:
     594        51239 :             return 67.5 * 2;
     595           48 :         case SVC_RAIL_ELECTRIC:
     596              :         case SVC_RAIL_FAST:
     597           48 :             return 25. * 8;
     598          359 :         case SVC_DELIVERY:
     599              :         case SVC_EMERGENCY:
     600          359 :             return 6.5;
     601          339 :         case SVC_SHIP:
     602          339 :             return 17;
     603        43724 :         case SVC_CONTAINER:
     604        43724 :             return 6.096;
     605           24 :         case SVC_DRONE:
     606           24 :             return 0.5;
     607           26 :         case SVC_AIRCRAFT:
     608           26 :             return 72.7;
     609       136202 :         default:
     610       136202 :             return 5; /*4.3*/
     611              :     }
     612              : }
     613              : 
     614              : 
     615              : 
     616              : /****************************************************************************/
        

Generated by: LCOV version 2.0-1