MSRouteHandler.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
/****************************************************************************/
// Parser and container for routes during their loading
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <utils/common/SUMOTime.h>
#include <utils/common/MapMatcher.h>
#include <utils/vehicle/SUMORouteHandler.h>
#include <microsim/transportables/MSPerson.h>
#include <microsim/transportables/MSTransportable.h>
#include "MSVehicle.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSEdge;
class MSVehicleType;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSRouteHandler : public SUMORouteHandler, public MapMatcher<MSEdge, MSLane, MSJunction> {
public:
 
    enum class ObjectTypeEnum {
        PERSON,
        CONTAINER,
        UNDEFINED
    };
 
    MSRouteHandler(const std::string& file, bool addVehiclesDirectly);
 
    virtual ~MSRouteHandler();
 
    static SumoRNG* getParsingRNG() {
        return &myParsingRNG;
    }
 
 
protected:
 
 
    virtual void myStartElement(int element,
                                const SUMOSAXAttributes& attrs) override;
 
    void parseFromViaTo(SumoXMLTag tag, const SUMOSAXAttributes& attrs);
 
    void openVehicleTypeDistribution(const SUMOSAXAttributes& attrs) override;
 
    void closeVehicleTypeDistribution() override;
 
    void openRoute(const SUMOSAXAttributes& attrs) override;
 
    void openFlow(const SUMOSAXAttributes& attrs) override;
 
    void openRouteFlow(const SUMOSAXAttributes& attrs) override;
 
    void openTrip(const SUMOSAXAttributes& attrs) override;
 
    void closeRoute(const bool mayBeDisconnected = false) override;
 
    void openRouteDistribution(const SUMOSAXAttributes& attrs) override;
 
    void closeRouteDistribution() override;
 
    virtual void closeVehicle() override;
 
    void closeVType() override;
 
    void closePerson() override;
 
    void closePersonFlow() override;
 
    void closeContainer() override;
 
    void closeContainerFlow() override;
 
    void closeFlow() override;
 
    void closeTrip() override;
 
    MSStoppingPlace* retrieveStoppingPlace(const SUMOSAXAttributes& attrs, const std::string& errorSuffix, SUMOVehicleParameter::Stop* stopParam = nullptr);
 
    Parameterised* addStop(const SUMOSAXAttributes& attrs) override;
 
    void addPersonTrip(const SUMOSAXAttributes& attrs) override;
 
    void addWalk(const SUMOSAXAttributes& attrs) override;
 
    void addTransportable(const SUMOSAXAttributes& attrs, const bool isPerson) override;
 
    void addRide(const SUMOSAXAttributes& attrs) override;
 
    void addTranship(const SUMOSAXAttributes& attrs) override;
 
    void addTransport(const SUMOSAXAttributes& attrs) override;
 
    void parseWalkPositions(const SUMOSAXAttributes& attrs, const std::string& personID,
                            const MSEdge* fromEdge, const MSEdge*& toEdge,
                            double& departPos, double& arrivalPos, MSStoppingPlace*& bs,
                            const MSStage* const lastStage, bool& ok);
 
    void initLaneTree(NamedRTree* tree) override;
 
    MSEdge* retrieveEdge(const std::string& id) override;
 
    SumoRNG* getRNG() override;
 
protected:
    ConstMSEdgeVector myActiveRoute;
 
    int myActiveRouteRepeat;
    SUMOTime myActiveRoutePeriod;
 
    bool myActiveRoutePermanent;
 
    SUMOTime myActiveRouteReplacedAtTime;
 
    int myActiveRouteReplacedIndex;
 
    ObjectTypeEnum myActiveType;
 
    std::string myActiveTypeName;
 
    bool myHaveVia;
 
    MSTransportable::MSTransportablePlan* myActiveTransportablePlan;
 
    bool myAddVehiclesDirectly;
 
    RandomDistributor<MSVehicleType*>* myCurrentVTypeDistribution;
 
    std::string myCurrentVTypeDistributionID;
 
    RandomDistributor<ConstMSRoutePtr>* myCurrentRouteDistribution;
 
    std::string myCurrentRouteDistributionID;
 
    bool myAmLoadingState;
 
    std::string myScaleSuffix;
 
    bool myReplayRerouting;
 
    bool myStartTriggeredInFlow;
 
    static SumoRNG myParsingRNG;
 
private:
    void deleteActivePlanAndVehicleParameter();
 
    void resetActivePlanAndVehicleParameter();
 
    void closeTransportableFlow();
 
    void closeTransportable();
 
    int addFlowTransportable(SUMOTime depart, MSVehicleType* type, const std::string& baseID, int i);
 
    double interpretDepartPosLat(const std::string& value, int departLane, const std::string& element);
 
    ConstMSRoutePtr addVehicleStopsToImplicitRoute(ConstMSRoutePtr route, bool isPermanent);
 
    MSRouteHandler(const MSRouteHandler& s) = delete;
 
    MSRouteHandler& operator=(const MSRouteHandler& s) = delete;
 
    void addRideOrTransport(const SUMOSAXAttributes& attrs, const SumoXMLTag modeTag);
 
};