MSMoveReminder.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2003-2025 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
/****************************************************************************/
// Something on a lane to be noticed about vehicle movement
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <iostream>
#include <map>
#include <utils/common/SUMOTime.h>
#include <utils/common/StdDefs.h>
#include <utils/common/StringBijection.h>
#ifdef HAVE_FOX
#include <utils/foxtools/fxheader.h>
#endif
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class SUMOTrafficObject;
class OutputDevice;
class MSLane;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSMoveReminder {
public:
    MSMoveReminder(const std::string& description, MSLane* const lane = nullptr, const bool doAdd = true);
 
 
    virtual ~MSMoveReminder() {}
 
 
    const MSLane* getLane() const {
        return myLane;
    }
 
 
    enum Notification {
        NOTIFICATION_DEPARTED,
        NOTIFICATION_JUNCTION,
        NOTIFICATION_SEGMENT,
        NOTIFICATION_LANE_CHANGE,
        NOTIFICATION_LOAD_STATE,
        /* All notifications below must result in the vehicle not being on the net
         * (onLeaveLane sets amOnNet=false if reason>=NOTIFICATION_TELEPORT) */
        NOTIFICATION_TELEPORT,
        NOTIFICATION_TELEPORT_CONTINUATION,
        NOTIFICATION_PARKING,
        NOTIFICATION_REROUTE,
        NOTIFICATION_PARKING_REROUTE,
        NOTIFICATION_ARRIVED, // arrived and everything after is treated as permanent deletion from the net
        NOTIFICATION_TELEPORT_ARRIVED,
        NOTIFICATION_VAPORIZED_CALIBRATOR,
        NOTIFICATION_VAPORIZED_COLLISION,
        NOTIFICATION_VAPORIZED_TRACI,
        NOTIFICATION_VAPORIZED_GUI,
        NOTIFICATION_VAPORIZED_VAPORIZER,
        NOTIFICATION_VAPORIZED_BREAKDOWN,
        NOTIFICATION_NONE
    };
 
 
 
    virtual bool notifyEnter(SUMOTrafficObject& veh, Notification reason, const MSLane* enteredLane) {
        UNUSED_PARAMETER(reason);
        UNUSED_PARAMETER(&veh);
        UNUSED_PARAMETER(&enteredLane);
        return true;
    }
 
 
    virtual bool notifyMove(SUMOTrafficObject& veh,
                            double oldPos,
                            double newPos,
                            double newSpeed) {
        UNUSED_PARAMETER(oldPos);
        UNUSED_PARAMETER(newPos);
        UNUSED_PARAMETER(newSpeed);
        UNUSED_PARAMETER(&veh);
        return true;
    }
 
    virtual bool notifyIdle(SUMOTrafficObject& veh) {
        UNUSED_PARAMETER(&veh);
        return true;
    }
 
    virtual void notifyParking() {}
 
    virtual void notifyStopEnded() {}
 
    virtual bool notifyLeave(SUMOTrafficObject& veh, double lastPos, Notification reason, const MSLane* enteredLane = nullptr) {
        UNUSED_PARAMETER(&veh);
        UNUSED_PARAMETER(lastPos);
        UNUSED_PARAMETER(reason);
        UNUSED_PARAMETER(enteredLane);
        return true;
    }
 
    virtual bool notifyLeaveBack(SUMOTrafficObject& veh, Notification reason, const MSLane* leftLane) {
        UNUSED_PARAMETER(&veh);
        UNUSED_PARAMETER(reason);
        UNUSED_PARAMETER(leftLane);
        return true;
    }
 
    virtual bool notifyReroute(SUMOTrafficObject& veh) {
        UNUSED_PARAMETER(&veh);
        return true;
    }
 
    // TODO: Documentation
    void updateDetector(SUMOTrafficObject& veh, double entryPos, double leavePos,
                        SUMOTime entryTime, SUMOTime currentTime, SUMOTime leaveTime,
                        bool cleanUp);
 
 
    virtual 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) {
        UNUSED_PARAMETER(&veh);
        UNUSED_PARAMETER(frontOnLane);
        UNUSED_PARAMETER(timeOnLane);
        UNUSED_PARAMETER(meanSpeedFrontOnLane);
        UNUSED_PARAMETER(meanSpeedVehicleOnLane);
        UNUSED_PARAMETER(travelledDistanceFrontOnLane);
        UNUSED_PARAMETER(travelledDistanceVehicleOnLane);
        UNUSED_PARAMETER(meanLengthOnLane);
    }
 
    void setDescription(const std::string& description) {
        myDescription = description;
    }
 
    const std::string& getDescription() const {
        return myDescription;
    }
 
    // @brief return whether this moveReminder triggers parking reroute
    virtual bool isParkingRerouter() const {
        return false;
    }
 
    void saveReminderState(OutputDevice& out, const SUMOTrafficObject& veh);
 
    void loadReminderState(long long int numID, SUMOTime time, double pos);
 
    static StringBijection<Notification> Notifications;
 
protected:
    void removeFromVehicleUpdateValues(SUMOTrafficObject& veh);
 
protected:
 
    MSLane* myLane;
    std::string myDescription;
 
#ifdef HAVE_FOX
    mutable FXMutex myNotificationMutex;
#endif
 
private:
    std::map<long long int, std::pair<SUMOTime, double> > myLastVehicleUpdateValues;
    static StringBijection<Notification>::Entry NotificationValues[];
 
 
private:
    MSMoveReminder& operator=(const MSMoveReminder&); // just to avoid a compiler warning
 
};