MSRailSignalConstraint.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2002-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
/****************************************************************************/
// A constraint on rail signal switching
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <utils/common/Parameterised.h>
#include <microsim/MSMoveReminder.h>
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSRailSignal;
class SUMOVehicle;
class SUMOSAXAttributes;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSRailSignalConstraint : public Parameterised {
public:
 
    enum ConstraintType {
        PREDECESSOR = 0, // swaps to PREDECESSOR
        INSERTION_PREDECESSOR = 1, // swaps to FOE_INSERTION
        FOE_INSERTION = 2, // swaps to INSERTION_PREDECESSOR
        INSERTION_ORDER = 3, // swaps to INSERTION_ORDER
        BIDI_PREDECESSOR = 4 // swaps to BIDI_PREDECESSOR
    };
 
    MSRailSignalConstraint(ConstraintType type) : myType(type) {};
 
    virtual ~MSRailSignalConstraint() {};
 
    virtual bool cleared() const = 0;
 
    virtual void setActive(bool active) = 0;
 
    virtual bool isActive() const = 0;
 
    virtual std::string getDescription() const {
        return "RailSignalConstraint";
    }
 
    virtual const SUMOVehicle* getFoe() const {
        return nullptr;
    }
 
    virtual void write(OutputDevice& out, const std::string& tripId) const = 0;
 
    ConstraintType getType() const {
        return myType;
    }
 
    SumoXMLTag getTag() const {
        switch (myType) {
            case INSERTION_PREDECESSOR:
                return SUMO_TAG_INSERTION_PREDECESSOR;
            case FOE_INSERTION:
                return SUMO_TAG_FOE_INSERTION;
            case INSERTION_ORDER:
                return SUMO_TAG_INSERTION_ORDER;
            case BIDI_PREDECESSOR:
                return SUMO_TAG_BIDI_PREDECESSOR;
            default:
                return SUMO_TAG_PREDECESSOR;
        }
    }
 
    ConstraintType getSwappedType() const {
        switch (myType) {
            case INSERTION_PREDECESSOR:
                return FOE_INSERTION;
            case FOE_INSERTION:
                return INSERTION_PREDECESSOR;
            default:
                return myType;
        }
    }
 
    bool isInsertionConstraint() const {
        return myType == INSERTION_PREDECESSOR || myType == INSERTION_ORDER;
    }
 
    static void storeTripId(const std::string& tripId, const std::string& vehID);
 
    static const std::string& lookupVehId(const std::string& tripId);
 
    static void cleanup();
 
    static void saveState(OutputDevice& out);
 
    static void clearState();
 
    static void clearAll();
 
protected:
    static const SUMOVehicle* getVeh(const std::string& tripID, bool checkID = false);
 
    ConstraintType myType;
 
    static std::map<std::string, std::string> myTripIdLookup;
};
 
 
class MSRailSignalConstraint_Predecessor : public MSRailSignalConstraint {
public:
    MSRailSignalConstraint_Predecessor(ConstraintType type, const MSRailSignal* signal, const std::string& tripId, int limit, bool active);
 
    ~MSRailSignalConstraint_Predecessor() {};
 
    void write(OutputDevice& out, const std::string& tripId) const;
 
    static void cleanup();
 
    static void saveState(OutputDevice& out);
 
    static void loadState(const SUMOSAXAttributes& attrs);
 
    static void clearState();
 
    bool cleared() const;
 
    void setActive(bool active) {
        myAmActive = active;
    }
 
    bool isActive() const {
        return myAmActive;
    }
 
    std::string getDescription() const;
 
    const SUMOVehicle* getFoe() const;
 
    class PassedTracker : public MSMoveReminder {
    public:
        PassedTracker(MSLane* lane);
 
 
 
        bool notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
 
        void raiseLimit(int limit);
 
        bool hasPassed(const std::string& tripId, int limit) const;
 
        void clearState();
 
        void saveState(OutputDevice& out);
 
        void loadState(int index, const std::vector<std::string>& tripIDs);
 
        std::vector<std::string> myPassed;
 
        int myLastIndex;
    };
 
    std::vector<PassedTracker*> myTrackers;
 
    const std::string myTripId;
 
    const int myLimit;
 
    bool myAmActive;
 
    const MSRailSignal* myFoeSignal;
 
 
    static std::map<const MSLane*, PassedTracker*, ComparatorNumericalIdLess> myTrackerLookup;
 
private:
    MSRailSignalConstraint_Predecessor& operator=(const MSRailSignalConstraint_Predecessor& s) = delete;
};