MSTransportableControl.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Stores all persons or containers in the net and handles their waiting for cars.
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <map>
#include <microsim/MSVehicle.h>
#include <microsim/transportables/MSTransportable.h>
#include <microsim/devices/MSDevice_Vehroutes.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSNet;
class MSPModel;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSTransportableControl {
public:
    typedef std::vector<MSTransportable*> TransportableVector;
 
    typedef std::map<std::string, MSTransportable*>::const_iterator constVehIt;
 
 
public:
    MSTransportableControl(const bool isPerson);
 
 
    virtual ~MSTransportableControl();
 
 
    bool add(MSTransportable* transportable);
 
 
    MSTransportable* get(const std::string& id) const;
 
 
    virtual void erase(MSTransportable* transportable);
 
    void setWaitEnd(SUMOTime time, MSTransportable* transportable);
 
    void checkWaiting(MSNet* net, const SUMOTime time);
 
    void addWaiting(const MSEdge* edge, MSTransportable* person);
 
    void forceDeparture();
 
    bool hasAnyWaiting(const MSEdge* edge, SUMOVehicle* vehicle) const;
 
    bool loadAnyWaiting(const MSEdge* edge, SUMOVehicle* vehicle, SUMOTime& timeToLoadNext, SUMOTime& stopDuration);
 
    bool hasTransportables() const;
 
    bool hasNonWaiting() const;
 
    int getActiveCount();
 
    void abortAnyWaitingForVehicle();
 
    void abortWaitingForVehicle(MSTransportable* t);
 
    void abortWaiting(MSTransportable* t);
 
    virtual MSTransportable* buildPerson(const SUMOVehicleParameter* pars, MSVehicleType* vtype, MSTransportable::MSTransportablePlan* plan,
                                         SumoRNG* rng) const;
 
    virtual MSTransportable* buildContainer(const SUMOVehicleParameter* pars, MSVehicleType* vtype, MSTransportable::MSTransportablePlan* plan) const;
 
    constVehIt loadedBegin() const {
        return myTransportables.begin();
    }
 
 
    constVehIt loadedEnd() const {
        return myTransportables.end();
    }
 
 
    int size() const {
        return (int)myTransportables.size();
    }
 
    void registerJammed() {
        myJammedNumber++;
    }
 
    void registerTeleportAbortWait() {
        myTeleportsAbortWait++;
    }
 
    void registerTeleportWrongDest() {
        myTeleportsWrongDest++;
    }
 
    void fixLoadCount(const MSTransportable* transportable);
 
 
    int getLoadedNumber() const {
        return myLoadedNumber;
    }
 
    int getDepartedNumber() const;
 
    int getRunningNumber() const {
        return myRunningNumber;
    }
 
    int getJammedNumber() const {
        return myJammedNumber;
    }
 
    int getWaitingForVehicleNumber() const {
        return myWaitingForVehicleNumber;
    }
 
    int getWaitingUntilNumber() const {
        return myWaitingUntilNumber;
    }
 
    int getMovingNumber() const;
 
    int getRidingNumber() const;
 
    int getEndedNumber() const {
        return myEndedNumber;
    }
 
    int getArrivedNumber() const {
        return myArrivedNumber;
    }
 
    int getTeleportsAbortWait() const {
        return myTeleportsAbortWait;
    }
 
    int getTeleportsWrongDest() const {
        return myTeleportsWrongDest;
    }
 
    int getTeleportCount() const {
        return myTeleportsAbortWait + myTeleportsWrongDest;
    }
 
 
    inline MSPModel* getMovementModel() {
        return myMovementModel;
    }
 
    inline MSPModel* getNonInteractingModel() {
        return myNonInteractingModel;
    }
 
    void addArrived() {
        myArrivedNumber++;
    }
 
    void addDiscarded() {
        myLoadedNumber++;
        myDiscardedNumber++;
    }
 
    void startedAccess() {
        myAccessNumber++;
    }
 
    void endedAccess() {
        myAccessNumber--;
    }
 
    void saveState(OutputDevice& out);
 
    void loadState(const std::string& state);
 
    void clearState();
 
    const MSDevice_Vehroutes::SortedRouteInfo& getRouteInfo() {
        return myRouteInfos;
    }
 
protected:
    std::map<std::string, MSTransportable*> myTransportables;
 
    std::map<SUMOTime, TransportableVector> myWaiting4Departure;
 
    std::map<SUMOTime, TransportableVector> myWaitingUntil;
 
    std::map<const MSEdge*, TransportableVector, ComparatorNumericalIdLess> myWaiting4Vehicle;
 
    int myLoadedNumber;
 
    int myDiscardedNumber;
 
    int myRunningNumber;
 
    int myJammedNumber;
 
    int myWaitingForDepartureNumber;
 
    int myWaitingForVehicleNumber;
 
    int myWaitingUntilNumber;
 
    int myAccessNumber;
 
    int myEndedNumber;
 
    int myArrivedNumber;
 
    int myTeleportsAbortWait;
 
    int myTeleportsWrongDest;
 
    bool myHaveNewWaiting;
 
private:
    MSPModel* myMovementModel;
 
    MSPModel* myNonInteractingModel;
 
    MSDevice_Vehroutes::SortedRouteInfo myRouteInfos;
 
    SUMOTime myAbortWaitingTimeout;
 
private:
    MSTransportableControl& operator=(const MSTransportableControl& src) = delete;
};