Eclipse SUMO - Simulation of Urban MObility
MSTransportableControl.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2022 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/****************************************************************************/
21// Stores all persons or containers in the net and handles their waiting for cars.
22/****************************************************************************/
23#pragma once
24#include <config.h>
25
26#include <vector>
27#include <map>
28#include <microsim/MSVehicle.h>
31
32
33// ===========================================================================
34// class declarations
35// ===========================================================================
36class MSNet;
37class MSPModel;
38
39
40// ===========================================================================
41// class definitions
42// ===========================================================================
52public:
54 typedef std::vector<MSTransportable*> TransportableVector;
55
57 typedef std::map<std::string, MSTransportable*>::const_iterator constVehIt;
58
59
60public:
62 MSTransportableControl(const bool isPerson);
63
64
67
68
73 bool add(MSTransportable* transportable);
74
75
80 MSTransportable* get(const std::string& id) const;
81
82
84 virtual void erase(MSTransportable* transportable);
85
87 void setWaitEnd(SUMOTime time, MSTransportable* transportable);
88
90 void checkWaiting(MSNet* net, const SUMOTime time);
91
93 void addWaiting(const MSEdge* edge, MSTransportable* person);
94
96 void forceDeparture();
97
99 bool hasAnyWaiting(const MSEdge* edge, SUMOVehicle* vehicle) const;
100
109 bool loadAnyWaiting(const MSEdge* edge, SUMOVehicle* vehicle, SUMOTime& timeToLoadNext, SUMOTime& stopDuration);
110
112 bool hasTransportables() const;
113
115 bool hasNonWaiting() const;
116
118 int getActiveCount();
119
122
125
128
136 SumoRNG* rng) const;
137
144
149 return myTransportables.begin();
150 }
151
152
157 return myTransportables.end();
158 }
159
160
164 int size() const {
165 return (int)myTransportables.size();
166 }
167
171 }
172
174 void fixLoadCount(const MSTransportable* transportable);
175
178
182 int getLoadedNumber() const {
183 return myLoadedNumber;
184 }
185
186 int getDepartedNumber() const;
187
191 int getRunningNumber() const {
192 return myRunningNumber;
193 }
194
198 int getJammedNumber() const {
199 return myJammedNumber;
200 }
201
206 }
207
213 }
214
217 int getMovingNumber() const;
218
221 int getRidingNumber() const;
222
225 int getEndedNumber() const {
226 return myEndedNumber;
227 }
228
232 int getArrivedNumber() const {
233 return myArrivedNumber;
234 }
235
237
242 return myMovementModel;
243 }
244
250 }
251
252 void addArrived() {
254 }
255
259 }
260
263 void saveState(OutputDevice& out);
264
267 void loadState(const std::string& state);
268
270 void clearState();
271
272protected:
274 std::map<std::string, MSTransportable*> myTransportables;
275
277 std::map<SUMOTime, TransportableVector> myWaiting4Departure;
278
280 std::map<SUMOTime, TransportableVector> myWaitingUntil;
281
283 std::map<const MSEdge*, TransportableVector> myWaiting4Vehicle;
284
287
290
293
296
299
302
305
308
311
314
315private:
317
319
322
325
326private:
329};
long long int SUMOTime
Definition: GUI.h:36
A road/street connecting two junctions.
Definition: MSEdge.h:77
The simulated network and simulation perfomer.
Definition: MSNet.h:88
The pedestrian (and also sometimes container) movement model.
Definition: MSPModel.h:51
void loadState(const std::string &state)
Reconstruct the current state.
int getRunningNumber() const
Returns the number of build and inserted, but not yet deleted transportables.
void setWaitEnd(SUMOTime time, MSTransportable *transportable)
sets the arrival time for a waiting transportable
bool hasTransportables() const
checks whether any transportable waits to finish her plan
constVehIt loadedBegin() const
Returns the begin of the internal transportables map.
int myWaitingForDepartureNumber
The number of transportables waiting for departure.
int getWaitingForVehicleNumber() const
Returns the number of transportables waiting for a ride.
int getEndedNumber() const
Returns the number of transportables that exited the simulation.
void forceDeparture()
register forced (traci) departure
void fixLoadCount(const MSTransportable *transportable)
decrement counter to avoid double counting transportables loaded from state
void checkWaiting(MSNet *net, const SUMOTime time)
checks whether any transportables waiting time is over
int size() const
Returns the number of known transportables.
int getArrivedNumber() const
Returns the number of transportables that arrived at their destination.
void saveState(OutputDevice &out)
Saves the current state into the given stream.
MSTransportableControl(const bool isPerson)
Constructor.
int getLoadedNumber() const
Returns the number of build transportables.
bool hasAnyWaiting(const MSEdge *edge, SUMOVehicle *vehicle) const
check whether any transportables are waiting for the given vehicle
int getWaitingUntilNumber() const
Returns the number of transportables waiting for a specified amount of time.
int myLoadedNumber
The number of build transportables.
constVehIt loadedEnd() const
Returns the end of the internal transportables map.
std::map< std::string, MSTransportable * > myTransportables
all currently created transportables by id
std::map< std::string, MSTransportable * >::const_iterator constVehIt
Definition of the internal transportables map iterator.
void abortWaiting(MSTransportable *t)
aborts waiting stage of transportable
void abortWaitingForVehicle(MSTransportable *t)
let the given transportable abort waiting for a vehicle (when removing stage via TraCI)
void abortAnyWaitingForVehicle()
aborts the plan for any transportable that is still waiting for a ride
MSPModel * getNonInteractingModel()
Returns the non interacting movement model (for tranship and "beaming")
bool hasNonWaiting() const
checks whether any transportable is still engaged in walking / stopping
virtual MSTransportable * buildContainer(const SUMOVehicleParameter *pars, MSVehicleType *vtype, MSTransportable::MSTransportablePlan *plan) const
Builds a new container.
MSPModel * getMovementModel()
Returns the default movement model for this kind of transportables.
int myArrivedNumber
The number of transportables that arrived at their destination.
virtual MSTransportable * buildPerson(const SUMOVehicleParameter *pars, MSVehicleType *vtype, MSTransportable::MSTransportablePlan *plan, SumoRNG *rng) const
Builds a new person.
int getMovingNumber() const
Returns the number of transportables moving by themselvs (i.e. walking)
void addWaiting(const MSEdge *edge, MSTransportable *person)
adds a transportable to the list of transportables waiting for a vehicle on the specified edge
SUMOTime myAbortWaitingTimeout
The time until waiting for a ride is aborted.
int myEndedNumber
The number of transportables that exited the simulation.
bool loadAnyWaiting(const MSEdge *edge, SUMOVehicle *vehicle, SUMOTime &timeToLoadNext, SUMOTime &stopDuration)
load any applicable transportables Loads any person / container that is waiting on that edge for the ...
int getJammedNumber() const
Returns the number of times a transportables was jammed.
std::map< const MSEdge *, TransportableVector > myWaiting4Vehicle
the lists of waiting transportables
int myWaitingUntilNumber
The number of transportables waiting for a specified time.
void clearState()
Resets transportables when quick-loading state.
virtual void erase(MSTransportable *transportable)
removes a single transportable
int myDiscardedNumber
The number of discarded transportables.
std::map< SUMOTime, TransportableVector > myWaitingUntil
the lists of walking / stopping transportables
bool add(MSTransportable *transportable)
Adds a single transportable, returns false if an id clash occurred.
bool myHaveNewWaiting
whether a new transportable waiting for a vehicle has been added in the last step
virtual ~MSTransportableControl()
Destructor.
int myJammedNumber
The number of jammed transportables.
std::map< SUMOTime, TransportableVector > myWaiting4Departure
Transportables waiting for departure.
MSTransportableControl & operator=(const MSTransportableControl &src)=delete
invalidated assignment operator
void registerJammed()
register a jammed transportable
std::vector< MSTransportable * > TransportableVector
Definition of a list of transportables.
int myRunningNumber
The number of transportables within the network (build and inserted but not removed)
int myWaitingForVehicleNumber
The number of transportables waiting for vehicles.
MSTransportable * get(const std::string &id) const
Returns the named transportable, if existing.
MSDevice_Vehroutes::SortedRouteInfo myRouteInfos
Information needed to sort transportable output by departure time.
int getActiveCount()
return the number of active transportable objects
int getRidingNumber() const
Returns the number of transportables riding a vehicle.
std::vector< MSStage * > MSTransportablePlan
the structure holding the plan of a transportable
The car-following model and parameter.
Definition: MSVehicleType.h:63
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
Representation of a vehicle.
Definition: SUMOVehicle.h:60
Structure representing possible vehicle parameter.
Information needed to sort vehicle / transportable output by departure time.