Eclipse SUMO - Simulation of Urban MObility
MSStateHandler.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2012-2023 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/****************************************************************************/
20// Parser and output filter for routes and vehicles state saving and loading
21/****************************************************************************/
22#include <config.h>
23
24#ifdef HAVE_VERSION_H
25#include <version.h>
26#endif
27
28#include <sstream>
34#include <utils/xml/XMLSubSys.h>
44#include <microsim/MSEdge.h>
45#include <microsim/MSLane.h>
46#include <microsim/MSLink.h>
47#include <microsim/MSGlobals.h>
48#include <microsim/MSNet.h>
52#include <microsim/MSRoute.h>
55#include <netload/NLHandler.h>
56#include "MSStateHandler.h"
57
58#include <mesosim/MESegment.h>
59#include <mesosim/MELoop.h>
60
61
62// ===========================================================================
63// MSStateTimeHandler method definitions
64// ===========================================================================
65
67MSStateHandler::MSStateTimeHandler::getTime(const std::string& fileName) {
68 // build handler and parser
69 MSStateTimeHandler handler;
70 handler.setFileName(fileName);
71 handler.myTime = -1;
72 SUMOSAXReader* parser = XMLSubSys::getSAXReader(handler);
73 try {
74 if (!parser->parseFirst(fileName)) {
75 delete parser;
76 throw ProcessError(TLF("Can not read XML-file '%'.", fileName));
77 }
78 } catch (ProcessError&) {
79 delete parser;
80 throw;
81 }
82 // parse
83 while (parser->parseNext() && handler.myTime != -1);
84 // clean up
85 if (handler.myTime == -1) {
86 delete parser;
87 throw ProcessError(TLF("Could not parse time from state file '%'", fileName));
88 }
89 delete parser;
90 return handler.myTime;
91}
92
93void
95 if (element == SUMO_TAG_SNAPSHOT) {
97 }
98}
99
100// ===========================================================================
101// method definitions
102// ===========================================================================
103MSStateHandler::MSStateHandler(const std::string& file, const SUMOTime offset) :
104 MSRouteHandler(file, true),
105 myOffset(offset),
106 mySegment(nullptr),
107 myCurrentLane(nullptr),
108 myCurrentLink(nullptr),
109 myAttrs(nullptr),
110 myVCAttrs(nullptr),
111 myLastParameterised(nullptr),
112 myRemoved(0),
113 myConstrainedSignal(nullptr) {
114 myAmLoadingState = true;
115 const std::vector<std::string> vehIDs = OptionsCont::getOptions().getStringVector("load-state.remove-vehicles");
116 myVehiclesToRemove.insert(vehIDs.begin(), vehIDs.end());
117}
118
119
121 delete myVCAttrs;
122}
123
124
125void
126MSStateHandler::saveState(const std::string& file, SUMOTime step, bool usePrefix) {
127 OutputDevice& out = OutputDevice::getDevice(file, usePrefix);
128 out.setPrecision(OptionsCont::getOptions().getInt("save-state.precision"));
130 out.writeAttr("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance").writeAttr("xsi:noNamespaceSchemaLocation", "http://sumo.dlr.de/xsd/state_file.xsd");
131 out.writeAttr(SUMO_ATTR_VERSION, VERSION_STRING);
133 out.writeAttr(SUMO_ATTR_TYPE, MSGlobals::gUseMesoSim ? "meso" : "micro");
134 if (OptionsCont::getOptions().getBool("save-state.constraints")) {
136 }
137 if (OptionsCont::getOptions().getBool("save-state.rng")) {
138 saveRNGs(out);
141 }
142 }
146 if (OptionsCont::getOptions().getBool("save-state.transportables")) {
147 if (MSNet::getInstance()->hasPersons()) {
150 out.closeTag();
151 }
152 if (MSNet::getInstance()->hasContainers()) {
155 out.closeTag();
156 }
157 }
159 for (MSEdge* const edge : MSEdge::getAllEdges()) {
161 for (MESegment* s = MSGlobals::gMesoNet->getSegmentForEdge(*edge); s != nullptr; s = s->getNextSegment()) {
162 s->saveState(out);
163 }
164 } else {
165 for (MSLane* const lane : edge->getLanes()) {
166 lane->saveState(out);
167 }
168 }
169 }
171 out.close();
172}
173
174
175void
177 MSRouteHandler::myStartElement(element, attrs);
179 switch (element) {
180 case SUMO_TAG_SNAPSHOT: {
182 const std::string& version = attrs.getString(SUMO_ATTR_VERSION);
183 if (version != VERSION_STRING) {
184 WRITE_WARNINGF(TL("State was written with sumo version % (present: %)!"), version, VERSION_STRING);
185 }
186 bool ok;
187 if (attrs.getOpt<bool>(SUMO_ATTR_CONSTRAINTS, nullptr, ok, false)) {
189 }
190 break;
191 }
192 case SUMO_TAG_RNGSTATE: {
193 if (attrs.hasAttribute(SUMO_ATTR_DEFAULT)) {
195 }
198 }
201 }
204 }
207 }
210 }
213 }
214 break;
215 }
216 case SUMO_TAG_RNGLANE: {
217 const int index = attrs.getInt(SUMO_ATTR_INDEX);
218 const std::string state = attrs.getString(SUMO_ATTR_STATE);
219 MSLane::loadRNGState(index, state);
220 break;
221 }
223 bool ok;
224 std::list<MSLane*> activeLanes;
225 const std::vector<std::string>& laneIDs = attrs.get<std::vector<std::string> >(SUMO_ATTR_LANES, nullptr, ok, false);
226 for (const std::string& laneID : laneIDs) {
227 MSLane* lane = MSLane::dictionary(laneID);
228 if (lane == nullptr) {
229 throw ProcessError(TLF("Unknown lane '%' in loaded state.", laneID));
230 }
231 activeLanes.push_back(lane);
232 }
234 break;
235 }
236 case SUMO_TAG_DELAY: {
237 if (myVCAttrs != nullptr) {
238 delete myVCAttrs;
239 }
240 myVCAttrs = attrs.clone();
241 break;
242 }
243 case SUMO_TAG_FLOWSTATE: {
244 bool ok;
246 pars->repetitionsDone = attrs.get<int>(SUMO_ATTR_DONE, pars->id.c_str(), ok);
247 pars->repetitionTotalOffset = attrs.getOptSUMOTimeReporting(SUMO_ATTR_NEXT, pars->id.c_str(), ok, 0);
248 int index = attrs.getInt(SUMO_ATTR_INDEX);
250 break;
251 }
252 case SUMO_TAG_VTYPE: {
254 break;
255 }
256 case SUMO_TAG_VEHICLE: {
258 myAttrs = attrs.clone();
259 break;
260 }
261 case SUMO_TAG_DEVICE: {
262 myDeviceAttrs.push_back(attrs.clone());
263 break;
264 }
267 break;
268 }
269 case SUMO_TAG_SEGMENT: {
270 const std::string& segmentID = attrs.getString(SUMO_ATTR_ID);
271 const MSEdge* const edge = MSEdge::dictionary(segmentID.substr(0, segmentID.rfind(":")));
272 int idx = StringUtils::toInt(segmentID.substr(segmentID.rfind(":") + 1));
274 while (idx-- > 0) {
276 }
277 myQueIndex = 0;
278 break;
279 }
280 case SUMO_TAG_LANE: {
281 bool ok;
282 const std::string laneID = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
284 if (myCurrentLane == nullptr) {
285 throw ProcessError(TLF("Unknown lane '%' in loaded state.", laneID));
286 }
287 break;
288 }
290 bool ok;
291 const std::vector<std::string>& vehIDs = attrs.get<std::vector<std::string> >(SUMO_ATTR_VALUE, nullptr, ok, false);
294 } else {
296 }
297 myQueIndex++;
298 break;
299 }
300 case SUMO_TAG_LINK: {
301 bool ok;
302 myCurrentLink = nullptr;
303 const std::string toLaneID = attrs.get<std::string>(SUMO_ATTR_TO, nullptr, ok);
304 for (MSLink* link : myCurrentLane->getLinkCont()) {
305 if (link->getViaLaneOrLane()->getID() == toLaneID) {
306 myCurrentLink = link;
307 }
308 }
309 if (myCurrentLink == nullptr) {
310 throw ProcessError("Unknown link from lane '" + myCurrentLane->getID() + "' to lane '" + toLaneID + "' in loaded state");
311 }
312 break;
313 }
315 bool ok;
316 const std::string vehID = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
317 const SUMOTime arrivalTime = attrs.get<SUMOTime>(SUMO_ATTR_ARRIVALTIME, nullptr, ok);
318 const double arrivalSpeed = attrs.get<double>(SUMO_ATTR_ARRIVALSPEED, nullptr, ok);
319 const double leaveSpeed = attrs.get<double>(SUMO_ATTR_DEPARTSPEED, nullptr, ok);
320 const bool setRequest = attrs.get<bool>(SUMO_ATTR_REQUEST, nullptr, ok);
321 const double arrivalSpeedBraking = attrs.get<double>(SUMO_ATTR_ARRIVALSPEEDBRAKING, nullptr, ok);
322 const SUMOTime waitingTime = attrs.get<SUMOTime>(SUMO_ATTR_WAITINGTIME, nullptr, ok);
323 const double dist = attrs.get<double>(SUMO_ATTR_DISTANCE, nullptr, ok);
324 const double latOffset = attrs.getOpt<double>(SUMO_ATTR_POSITION_LAT, nullptr, ok, 0);
325 SUMOVehicle* veh = vc.getVehicle(vehID);
326 myCurrentLink->setApproaching(veh, arrivalTime, arrivalSpeed, leaveSpeed, setRequest, arrivalSpeedBraking, waitingTime, dist, latOffset);
328 MSVehicle* microVeh = dynamic_cast<MSVehicle*>(veh);
329 microVeh->loadPreviousApproaching(myCurrentLink, setRequest, arrivalTime, arrivalSpeed, arrivalSpeedBraking, dist, leaveSpeed);
330 }
331 break;
332 }
335 break;
336 }
337 case SUMO_TAG_PARAM: {
338 bool ok;
339 const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, ok);
340 // circumventing empty string test
341 const std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
342 assert(myLastParameterised != 0);
343 if (myLastParameterised != nullptr) {
345 }
346 break;
347 }
349 if (attrs.getString(SUMO_ATTR_TYPE) == "person") {
351 }
352 if (attrs.getString(SUMO_ATTR_TYPE) == "container") {
354 }
355 break;
356 case SUMO_TAG_PERSON:
358 myAttrs = attrs.clone();
359 break;
361 bool ok = true;
362 const std::string signalID = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
363 if (!MSNet::getInstance()->getTLSControl().knows(signalID)) {
364 throw InvalidArgument("Rail signal '" + signalID + "' in railSignalConstraints loaded from state is not known");
365 }
367 if (myConstrainedSignal == nullptr) {
368 throw InvalidArgument("Traffic light '" + signalID + "' is not a rail signal");
369 }
370 break;
371 }
372 case SUMO_TAG_PREDECESSOR: // intended fall-through
373 case SUMO_TAG_INSERTION_PREDECESSOR: // intended fall-through
374 case SUMO_TAG_FOE_INSERTION: // intended fall-through
375 case SUMO_TAG_INSERTION_ORDER: // intended fall-through
378 break;
379 case SUMO_TAG_TLLOGIC: {
380 bool ok;
381 const std::string tlID = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
382 const std::string programID = attrs.get<std::string>(SUMO_ATTR_PROGRAMID, tlID.c_str(), ok);
383 const int phase = attrs.get<int>(SUMO_ATTR_PHASE, tlID.c_str(), ok);
384 const SUMOTime spentDuration = attrs.get<SUMOTime>(SUMO_ATTR_DURATION, tlID.c_str(), ok);
386 MSTrafficLightLogic* tl = tlc.get(tlID, programID);
387 if (tl == nullptr) {
388 if (programID == "online") {
389 WRITE_WARNINGF(TL("Ignoring program '%' for traffic light '%' in loaded state"), programID, tlID);
390 return;
391 } else {
392 throw ProcessError("Unknown program '" + programID + "' for traffic light '" + tlID + "'");
393 }
394 }
395 if (phase >= tl->getPhaseNumber()) {
396 throw ProcessError("Invalid phase '" + toString(phase) + "' for traffic light '" + tlID + "'");
397 }
398 // might not be set if the phase happens to match and there are multiple programs
399 tl->loadState(tlc, myTime, phase, spentDuration);
400 break;
401 }
402 default:
403 break;
404 }
405}
406
407
408void
411 switch (element) {
412 case SUMO_TAG_PERSON:
413 case SUMO_TAG_CONTAINER: {
415 MSTransportable* transportable = tc.get(myAttrs->getString(SUMO_ATTR_ID));
416 transportable->loadState(myAttrs->getString(SUMO_ATTR_STATE));
417 tc.fixLoadCount(transportable);
418 delete myAttrs;
419 myAttrs = nullptr;
420 break;
421 }
422 case SUMO_TAG_SNAPSHOT: {
423 if (myVCAttrs == nullptr) {
424 throw ProcessError(TL("Could not load vehicle control state"));
425 }
432 if (myRemoved > 0) {
433 WRITE_MESSAGEF(TL("Removed % vehicles while loading state."), toString(myRemoved));
435 }
436 break;
437 }
438 default:
439 break;
440 }
441 if (element != SUMO_TAG_PARAM && myVehicleParameter == nullptr && myCurrentVType == nullptr) {
442 myLastParameterised = nullptr;
443 }
444}
445
446
447void
449 assert(myVehicleParameter != nullptr);
451 // the vehicle was already counted in MSVehicleControl::setState
453 // make a copy because myVehicleParameter is reset in closeVehicle()
454 const std::string vehID = myVehicleParameter->id;
455 if (myVehiclesToRemove.count(vehID) == 0) {
457 SUMOVehicle* v = vc.getVehicle(vehID);
458 if (v == nullptr) {
459 throw ProcessError(TLF("Could not load vehicle '%' from state", vehID));
460 }
463 if (v->hasDeparted()) {
464 // vehicle already departed: disable pre-insertion rerouting and enable regular routing behavior
465 MSDevice_Routing* routingDevice = static_cast<MSDevice_Routing*>(v->getDevice(typeid(MSDevice_Routing)));
466 if (routingDevice != nullptr) {
468 }
471 // register route for deadlock prevention (vehicleStateChanged would not be called otherwise)
473 }
474 vc.handleTriggeredDepart(v, false);
475 }
476 while (!myDeviceAttrs.empty()) {
477 const std::string attrID = myDeviceAttrs.back()->getString(SUMO_ATTR_ID);
478 for (MSVehicleDevice* const dev : v->getDevices()) {
479 if (dev->getID() == attrID) {
480 dev->loadState(*myDeviceAttrs.back());
481 }
482 }
483 delete myDeviceAttrs.back();
484 myDeviceAttrs.pop_back();
485 }
486 } else {
487 delete myVehicleParameter;
488 myVehicleParameter = nullptr;
489 myRemoved++;
490 }
491 delete myAttrs;
492}
493
494
495void
500 out.writeAttr(SUMO_ATTR_RNG_INSERTIONCONTROL, RandHelper::saveState(MSNet::getInstance()->getInsertionControl().getFlowRNG()));
506 out.closeTag();
507
508}
509
510
511/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:271
#define WRITE_MESSAGEF(...)
Definition: MsgHandler.h:273
#define TL(string)
Definition: MsgHandler.h:287
#define TLF(string,...)
Definition: MsgHandler.h:288
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition: SUMOTime.cpp:46
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
Definition: SUMOTime.cpp:69
@ SUMO_TAG_RAILSIGNAL_CONSTRAINTS
Constraints on switching a rail signal.
@ SUMO_TAG_BIDI_PREDECESSOR
Predecessor constraint for rail signal before bidirectional section.
@ SUMO_TAG_LINK
Link information for state-saving.
@ SUMO_TAG_TRANSPORTABLES
@ SUMO_TAG_APPROACHING
Link-approaching vehicle information for state-saving.
@ SUMO_TAG_INSERTION_PREDECESSOR
Predecessor constraint on insertion before rail signal.
@ SUMO_TAG_DEVICE
@ SUMO_TAG_VTYPE
description of a vehicle/person/container type
@ SUMO_TAG_RNGLANE
@ SUMO_TAG_EDGECONTROL
the internal state for edge control
@ SUMO_TAG_FLOWSTATE
a flow state definition (used when saving and loading simulatino state)
@ SUMO_TAG_VEHICLE
description of a vehicle
@ SUMO_TAG_RAILSIGNAL_CONSTRAINT_TRACKER
Saved state for constraint tracker.
@ SUMO_TAG_RNGSTATE
@ SUMO_TAG_DELAY
@ SUMO_TAG_TLLOGIC
a traffic light logic
@ SUMO_TAG_FOE_INSERTION
Predecessor constraint on switching a rail signal.
@ SUMO_TAG_CONTAINER
@ SUMO_TAG_VIEWSETTINGS_VEHICLES
@ SUMO_TAG_SNAPSHOT
@ SUMO_TAG_LANE
begin/end of the description of a single lane
@ SUMO_TAG_SEGMENT
segment of a lane
@ SUMO_TAG_PARAM
parameter associated to a certain key
@ SUMO_TAG_INSERTION_ORDER
Predecessor constraint on insertion before rail signal.
@ SUMO_TAG_PERSON
@ SUMO_TAG_VEHICLETRANSFER
@ SUMO_TAG_PREDECESSOR
Predecessor constraint on switching a rail signal.
@ SUMO_ATTR_DONE
@ SUMO_ATTR_NUMBER
@ SUMO_ATTR_ARRIVALSPEED
@ SUMO_ATTR_CONSTRAINTS
@ SUMO_ATTR_DEPART
@ SUMO_ATTR_RNG_INSERTIONCONTROL
@ SUMO_ATTR_ARRIVALTIME
@ SUMO_ATTR_WAITINGTIME
@ SUMO_ATTR_VALUE
@ SUMO_ATTR_RNG_DRIVERSTATE
@ SUMO_ATTR_BEGIN
weights: time range begin
@ SUMO_ATTR_POSITION_LAT
@ SUMO_ATTR_PHASE
@ SUMO_ATTR_LANES
@ SUMO_ATTR_DEFAULT
@ SUMO_ATTR_ARRIVALSPEEDBRAKING
@ SUMO_ATTR_NEXT
succesor phase index
@ SUMO_ATTR_RNG_DEVICE_TOC
@ SUMO_ATTR_INDEX
@ SUMO_ATTR_DEPARTSPEED
@ SUMO_ATTR_TO
@ SUMO_ATTR_END
weights: time range end
@ SUMO_ATTR_RNG_DEVICE_BT
@ SUMO_ATTR_DISTANCE
@ SUMO_ATTR_SPEEDFACTOR
@ SUMO_ATTR_TYPE
@ SUMO_ATTR_VERSION
@ SUMO_ATTR_ID
@ SUMO_ATTR_PROGRAMID
@ SUMO_ATTR_RNG_ROUTEHANDLER
@ SUMO_ATTR_DURATION
@ SUMO_ATTR_RNG_DEVICE
@ SUMO_ATTR_REQUEST
@ SUMO_ATTR_KEY
@ SUMO_ATTR_STATE
The state of a link.
@ SUMO_ATTR_TIME
trigger: the time of the step
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
void setFileName(const std::string &name)
Sets the current file name.
MESegment * getSegmentForEdge(const MSEdge &e, double pos=0)
Get the segment for a given edge at a given position.
Definition: MELoop.cpp:325
A single mesoscopic segment (cell)
Definition: MESegment.h:49
void loadState(const std::vector< std::string > &vehIDs, MSVehicleControl &vc, const SUMOTime blockTime, const int queIdx)
Loads the state of this segment with the given parameters.
Definition: MESegment.cpp:782
MESegment * getNextSegment() const
Returns the following segment on the same edge (0 if it is the last).
Definition: MESegment.h:234
static SumoRNG * getRNG()
A device that performs vehicle rerouting based on current edge speeds.
bool notifyEnter(SUMOTrafficObject &veh, MSMoveReminder::Notification reason, const MSLane *enteredLane=0)
Computes a new route on vehicle insertion.
static SumoRNG * getResponseTimeRNG()
Definition: MSDevice_ToC.h:176
static SumoRNG * getEquipmentRNG()
Definition: MSDevice.h:88
void setActiveLanes(std::list< MSLane * > lanes)
Reconstruct the current state.
void saveState(OutputDevice &out)
Saves the current state into the given stream.
A road/street connecting two junctions.
Definition: MSEdge.h:77
static const MSEdgeVector & getAllEdges()
Returns all edges with a numerical id.
Definition: MSEdge.cpp:984
static bool dictionary(const std::string &id, MSEdge *edge)
Inserts edge into the static dictionary Returns true if the key id isn't already in the dictionary....
Definition: MSEdge.cpp:945
static bool gUseMesoSim
Definition: MSGlobals.h:103
static MELoop * gMesoNet
mesoscopic simulation infrastructure
Definition: MSGlobals.h:109
bool addFlow(SUMOVehicleParameter *const pars, int index=-1)
Adds parameter for a vehicle flow for departure.
void alreadyDeparted(SUMOVehicle *veh)
stops trying to emit the given vehicle (because it already departed)
SumoRNG * getFlowRNG()
retrieve internal RNG
void saveState(OutputDevice &out)
Saves the current state into the given stream.
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
static void saveRNGStates(OutputDevice &out)
save random number generator states to the given output device
Definition: MSLane.cpp:4406
static void loadRNGState(int index, const std::string &state)
load random number generator state for the given rng index
Definition: MSLane.cpp:4416
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
Definition: MSLane.cpp:2325
const std::vector< MSLink * > & getLinkCont() const
returns the container with all links !!!
Definition: MSLane.h:707
void loadState(const std::vector< std::string > &vehIDs, MSVehicleControl &vc)
Loads the state of this segment with the given parameters.
Definition: MSLane.cpp:3546
@ NOTIFICATION_DEPARTED
The vehicle has departed (was inserted into the network)
@ NEWROUTE
The vehicle got a new route.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:183
MSTLLogicControl & getTLSControl()
Returns the tls logics control.
Definition: MSNet.h:453
virtual MSTransportableControl & getContainerControl()
Returns the container control.
Definition: MSNet.cpp:1181
MSInsertionControl & getInsertionControl()
Returns the insertion control.
Definition: MSNet.h:433
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:380
virtual MSTransportableControl & getPersonControl()
Returns the person control.
Definition: MSNet.cpp:1172
MSEdgeControl & getEdgeControl()
Returns the edge control.
Definition: MSNet.h:423
static void loadState(const SUMOSAXAttributes &attrs)
loads the constraint state from the given attrs
static void clearAll()
Remove all constraints before quick-loading state.
void vehicleStateChanged(const SUMOVehicle *const vehicle, MSNet::VehicleState to, const std::string &info="")
Called if a vehicle changes its state.
static MSRailSignalControl & getInstance()
A signal for rails.
Definition: MSRailSignal.h:46
Parser and container for routes during their loading.
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
bool myAmLoadingState
whether a state file is being loaded
virtual void closeVehicle()
Ends the processing of a vehicle (note: is virtual because is reimplemented in MSStateHandler)
static SumoRNG * getParsingRNG()
get parsing RNG
static void dict_saveState(OutputDevice &out)
Saves all known routes into the given stream.
Definition: MSRoute.cpp:261
handler to read only the simulation time from a state
static SUMOTime getTime(const std::string &fileName)
parse time from state file
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Callback method for an opening tag to implement by derived classes.
MSRailSignal * myConstrainedSignal
rail signal for which constraints are being loaded
SUMOSAXAttributes * myAttrs
cached attrs (used when loading vehicles or transportables)
MSStateHandler(const std::string &file, const SUMOTime offset)
standard constructor
static void saveState(const std::string &file, SUMOTime step, bool usePrefix=true)
Saves the current state.
int myQueIndex
que index
SUMOTime myTime
time
std::set< std::string > myVehiclesToRemove
vehicles that shall be removed when loading state
int myRemoved
vehicles that were removed when loading state
MSLink * myCurrentLink
current link being loaded
MESegment * mySegment
segment
MSLane * myCurrentLane
current lane being loaded
static void saveRNGs(OutputDevice &out)
save the state of random number generators
const SUMOTime myOffset
offset
Parameterised * myLastParameterised
the last object that potentially carries parameters
void closeVehicle()
Ends the processing of a vehicle.
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
std::vector< SUMOSAXAttributes * > myDeviceAttrs
cached device attrs (used when loading vehicles)
SUMOSAXAttributes * myVCAttrs
cached attrs for delayed loading of MSVehicleControl state
void myEndElement(int element)
Called when a closing tag occurs.
virtual ~MSStateHandler()
standard destructor
MSTrafficLightLogic * getDefault() const
return the default program (that last used program except TRACI_PROGRAM)
A class that stores and controls tls and switching of their programs.
bool knows(const std::string &id) const
Returns the information whether the named tls is stored.
void saveState(OutputDevice &out)
Saves the current tls states into the given stream.
TLSLogicVariants & get(const std::string &id) const
Returns the variants of a named tls.
The parent class for traffic light logics.
virtual int getPhaseNumber() const =0
Returns the number of phases.
virtual void loadState(MSTLLogicControl &tlcontrol, SUMOTime t, int step, SUMOTime spentDuration)
restores the tls state
void loadState(const std::string &state)
Reconstruct the current state.
void fixLoadCount(const MSTransportable *transportable)
decrement counter to avoid double counting transportables loaded from state
void saveState(OutputDevice &out)
Saves the current state into the given stream.
MSTransportable * get(const std::string &id) const
Returns the named transportable, if existing.
void loadState(const std::string &state)
Reconstructs the current state.
The class responsible for building and deletion of vehicles.
void setState(int runningVehNo, int loadedVehNo, int endedVehNo, double totalDepartureDelay, double totalTravelTime)
Sets the current state variables as loaded from the stream.
void discountStateRemoved(int n)
discount vehicles that were removed during state loading
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
void handleTriggeredDepart(SUMOVehicle *v, bool add)
register / unregister depart-triggered vehicles with edges
void saveState(OutputDevice &out)
Saves the current state into the given stream.
Abstract in-vehicle device.
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77
void loadPreviousApproaching(MSLink *link, bool setRequest, SUMOTime arrivalTime, double arrivalSpeed, double arrivalSpeedBraking, double dist, double leaveSpeed)
Definition: MSVehicle.cpp:7474
static MSVehicleTransfer * getInstance()
Returns the instance of this object.
void saveState(OutputDevice &out)
Saves the current state into the given stream.
void loadState(const SUMOSAXAttributes &attrs, const SUMOTime offset, MSVehicleControl &vc)
Loads one transfer vehicle state from the given descriptionn.
static Parameterised * addPredecessorConstraint(int element, const SUMOSAXAttributes &attrs, MSRailSignal *rs)
Definition: NLHandler.cpp:1770
const std::string & getID() const
Returns the id.
Definition: Named.h:74
static SumoRNG * getRNG()
Definition: MSDriverState.h:78
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
const StringVector & getStringVector(const std::string &name) const
Returns the list of string-value of the named option (only for Option_StringVector)
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:60
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:254
void close()
Closes the device and removes it from the dictionary.
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
void setPrecision(int precision=gPrecision)
Sets the precision or resets it to default.
bool writeHeader(const SumoXMLTag &rootElement)
Definition: OutputDevice.h:199
static OutputDevice & getDevice(const std::string &name, bool usePrefix=true)
Returns the described OutputDevice.
virtual void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
static void loadState(const std::string &state, SumoRNG *rng=nullptr)
load rng state from string
Definition: RandHelper.h:224
static std::string saveState(SumoRNG *rng=nullptr)
save rng state to string
Definition: RandHelper.h:210
SUMOVehicleParameter * myVehicleParameter
Parameter of the current vehicle, trip, person, container or flow.
SUMOVTypeParameter * myCurrentVType
The currently parsed vehicle type.
virtual void myEndElement(int element)
Called when a closing tag occurs.
Encapsulated SAX-Attributes.
virtual std::string getString(int id, bool *isPresent=nullptr) const =0
Returns the string-value of the named (by its enum-value) attribute.
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue=T(), bool report=true) const
Tries to read given attribute assuming it is an int.
SUMOTime getOptSUMOTimeReporting(int attr, const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
virtual SUMOSAXAttributes * clone() const =0
return a new deep-copy attributes object
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
int getInt(int id) const
Returns the int-value of the named (by its enum-value) attribute.
double getFloat(int id) const
Returns the double-value of the named (by its enum-value) attribute.
SAX-reader encapsulation containing binary reader.
Definition: SUMOSAXReader.h:53
bool parseFirst(std::string systemID)
Start parsing the given file using parseFirst of myXMLReader.
bool parseNext()
Continue a progressive parse started by parseFirst.
Representation of a vehicle.
Definition: SUMOVehicle.h:62
virtual void setChosenSpeedFactor(const double factor)=0
virtual const std::vector< MSVehicleDevice * > & getDevices() const =0
Returns this vehicle's devices.
virtual bool hasDeparted() const =0
Returns whether this vehicle has departed.
virtual void loadState(const SUMOSAXAttributes &attrs, const SUMOTime offset)=0
Loads the state of this vehicle from the given description.
virtual MSVehicleDevice * getDevice(const std::type_info &type) const =0
Returns a device of the given type if it exists or 0.
Structure representing possible vehicle parameter.
int repetitionsDone
The number of times the vehicle was already inserted.
SUMOTime repetitionTotalOffset
The offset between depart and the time for the next vehicle insertions.
std::string id
The vehicle's id.
static SUMOVehicleParameter * parseFlowAttributes(SumoXMLTag tag, const SUMOSAXAttributes &attrs, const bool hardFail, const bool needID, const SUMOTime beginDefault, const SUMOTime endDefault)
Parses a flow's attributes.
static long long int toLong(const std::string &sData)
converts a string into the long value described by it by calling the char-type converter,...
static int toInt(const std::string &sData)
converts a string into the integer value described by it by calling the char-type converter,...
static SUMOSAXReader * getSAXReader(SUMOSAXHandler &handler, const bool isNet=false, const bool isRoute=false)
Builds a reader and assigns the handler to it.
Definition: XMLSubSys.cpp:141