MSDevice_Taxi.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2013-2026 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
/****************************************************************************/
// A device which controls a taxi
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <utils/common/SUMOTime.h>
#include <utils/common/WrappingCommand.h>
#include "MSVehicleDevice.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class SUMOTrafficObject;
class MSDispatch;
class MSIdling;
class MSDevice_Routing;
struct Reservation;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSDevice_Taxi : public MSVehicleDevice {
public:
 
    enum TaxiState {
        EMPTY = 0, // empty (available for servicing customers)
        PICKUP = 1, // driving to pick up customer
        OCCUPIED = 2 // occupied with customer
    };
 
    static void insertOptions(OptionsCont& oc);
 
 
    static void buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into);
 
    static bool isReservation(const std::set<std::string>& lines);
 
    static void addReservation(MSTransportable* person,
                               const std::set<std::string>& lines,
                               SUMOTime reservationTime,
                               SUMOTime pickupTime,
                               SUMOTime earliestPickupTime,
                               const MSEdge* from, double fromPos,
                               const MSStoppingPlace* fromStop,
                               const MSEdge* to, double toPos,
                               const MSStoppingPlace* toStop,
                               const std::string& group);
 
    static void removeReservation(MSTransportable* person,
                                  const std::set<std::string>& lines,
                                  const MSEdge* from, double fromPos,
                                  const MSEdge* to, double toPos,
                                  const std::string& group);
 
    static void updateReservationFromPos(MSTransportable* person,
                                         const std::set<std::string>& lines,
                                         const MSEdge* from, double fromPos,
                                         const MSEdge* to, double toPos,
                                         const std::string& group, double newFromPos);
 
    static SUMOTime triggerDispatch(SUMOTime currentTime);
 
    static bool hasServableReservations();
 
    static void cleanup();
 
    static MSDispatch* getDispatchAlgorithm() {
        return myDispatcher;
    }
 
    static const std::vector<MSDevice_Taxi*>& getFleet() {
        return myFleet;
    }
 
public:
    ~MSDevice_Taxi();
 
 
    bool notifyMove(SUMOTrafficObject& veh, double oldPos,
                    double newPos, double newSpeed);
 
 
    bool notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
 
 
    const std::string deviceName() const {
        return "taxi";
    }
 
    bool isEmpty();
 
    int getState() const {
        return myState;
    }
 
    static bool hasFleet();
 
    void dispatch(const Reservation& res);
 
    void dispatchShared(std::vector<const Reservation*> reservations);
 
    void cancelCurrentCustomers();
 
    bool cancelCustomer(const MSTransportable* t);
 
    void addCustomer(const MSTransportable* t, const Reservation* res);
 
    bool allowsBoarding(const MSTransportable* t) const;
 
    void customerEntered(const MSTransportable* t);
 
    void customerArrived(const MSTransportable* person);
 
    void saveState(OutputDevice& out) const;
 
    void loadState(const SUMOSAXAttributes& attrs);
 
    static void finalizeLoadState();
 
    std::string getParameter(const std::string& key) const;
 
    void setParameter(const std::string& key, const std::string& value);
 
    void generateOutput(OutputDevice* tripinfoOut) const;
 
    bool compatibleLine(const Reservation* res);
 
    static bool compatibleLine(const std::string& taxiLine, const std::string& rideLine);
 
    static void allCustomersErased();
 
    static const std::map<SUMOVehicleClass, std::string>& getTaxiTypes();
 
    static SUMOTime getNextDispatchTime();
 
    static void initDispatch(SUMOTime next = -1);
 
protected:
    void notifyMoveInternal(const SUMOTrafficObject& veh,
                            const double frontOnLane,
                            const double timeOnLane,
                            const double meanSpeedFrontOnLane,
                            const double meanSpeedVehicleOnLane,
                            const double travelledDistanceFrontOnLane,
                            const double travelledDistanceVehicleOnLane,
                            const double meanLengthOnLane);
 
private:
    MSDevice_Taxi(SUMOVehicle& holder, const std::string& id);
 
    void updateMove(const SUMOTime traveltime, const double travelledDist);
 
    void prepareStop(ConstMSEdgeVector& edges,
                     StopParVector& stops,
                     double& lastPos, const MSEdge* stopEdge, double stopPos,
                     const MSStoppingPlace* stopPlace,
                     const std::string& action, const Reservation* res, const bool isPickup);
 
    MSLane* getStopLane(const MSEdge* edge, const std::string& action);
 
    bool hasFuturePickup();
 
    void checkTaskSwap();
 
private:
 
    int myState = EMPTY;
    int myCustomersServed = 0;
    double myOccupiedDistance = 0;
    SUMOTime myOccupiedTime = 0;
    SUMOTime myServiceEnd = SUMOTime_MAX;
    bool myIsStopped = false;
    std::set<const MSTransportable*> myCustomers;
 
    MSIdling* myIdleAlgorithm;
 
    bool myReachedServiceEnd = false;
 
    std::set<const Reservation*> myCurrentReservations;
 
    MSDevice_Routing* myRoutingDevice = nullptr;
 
    static SUMOTime myDispatchPeriod;
    static MSDispatch* myDispatcher;
    static Command* myDispatchCommand;
    std::vector<const Reservation*> myLastDispatch;
    // @brief the list of available taxis
    static std::vector<MSDevice_Taxi*> myFleet;
    // @brief the maximum personCapacity in the fleet
    static int myMaxCapacity;
    // @brief the maximum container capacity in the fleet
    static int myMaxContainerCapacity;
 
    static std::map<SUMOVehicleClass, std::string> myTaxiTypes;
 
    static SUMOTime myNextDispatchTime;
 
    static std::map<std::string, MSDevice_Taxi*> myStateLoadedCustomers;
    static std::map<std::string, MSDevice_Taxi*> myStateLoadedReservations;
private:
    MSDevice_Taxi(const MSDevice_Taxi&);
 
    MSDevice_Taxi& operator=(const MSDevice_Taxi&);
 
 
};