NBTrafficLightLogic.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
/****************************************************************************/
// A SUMO-compliant built logic for a traffic light
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <string>
#include <bitset>
#include <utility>
#include <set>
#include "NBConnectionDefs.h"
#include <utils/common/SUMOTime.h>
#include <utils/common/Named.h>
#include <utils/common/Parameterised.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class OutputDevice;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NBTrafficLightLogic : public Named, public Parameterised {
public:
    class PhaseDefinition {
 
    public:
        SUMOTime duration;
 
        std::string state;
 
        SUMOTime minDur;
 
        SUMOTime maxDur;
 
        SUMOTime earliestEnd;
 
        SUMOTime latestEnd;
 
        SUMOTime vehExt;
 
        SUMOTime yellow;
 
        SUMOTime red;
 
        std::vector<int> next;
 
        std::string name;
 
        PhaseDefinition(const SUMOTime duration_, const std::string& state_, const SUMOTime minDur_, const SUMOTime maxDur_,
                        const SUMOTime earliestEnd_, const SUMOTime latestEnd_, const SUMOTime vehExt_, const SUMOTime yellow_,
                        const SUMOTime red_, const std::vector<int>& next_, const std::string& name_) :
            duration(duration_),
            state(state_),
            minDur(minDur_),
            maxDur(maxDur_),
            earliestEnd(earliestEnd_),
            latestEnd(latestEnd_),
            vehExt(vehExt_),
            yellow(yellow_),
            red(red_),
            next(next_),
            name(name_)
        { }
 
        ~PhaseDefinition() { }
 
        bool operator!=(const PhaseDefinition& pd) const {
            return ((pd.duration != duration) ||
                    (pd.minDur != minDur) ||
                    (pd.maxDur != maxDur) ||
                    (pd.earliestEnd != earliestEnd) ||
                    (pd.latestEnd != latestEnd) ||
                    (pd.state != state) ||
                    (pd.next != next) ||
                    (pd.name != name));
        }
 
    };
 
 
    NBTrafficLightLogic(const std::string& id, const std::string& subid, int noLinks,
                        SUMOTime offset = 0, TrafficLightType type = TrafficLightType::STATIC);
 
 
    NBTrafficLightLogic(const NBTrafficLightLogic* logic);
 
 
    ~NBTrafficLightLogic();
 
 
    void addStep(const SUMOTime duration, const std::string& state, const std::vector<int>& next = std::vector<int>(),
                 const std::string& name = "", const int index = -1);
 
    void addStep(const SUMOTime duration, const std::string& state, const SUMOTime minDur, const SUMOTime maxDur, const SUMOTime earliestEnd,
                 const SUMOTime latestEnd,
                 const SUMOTime vehExt = -1, // UNSPECIFIED_DURATION
                 const SUMOTime yellow = -1, // UNSPECIFIED_DURATION
                 const SUMOTime red = -1, // UNSPECIFIED_DURATION
                 const std::string& name = "",
                 const std::vector<int>& next = std::vector<int>(),
                 int index = -1);
 
    void setPhaseState(int phaseIndex, int tlIndex, LinkState linkState);
 
    void setPhaseDuration(int phaseIndex, SUMOTime duration);
 
    void setPhaseMinDuration(int phaseIndex, SUMOTime duration);
 
    void setPhaseMaxDuration(int phaseIndex, SUMOTime duration);
 
    void setPhaseEarliestEnd(int phaseIndex, SUMOTime duration);
 
    void setPhaseLatestEnd(int phaseIndex, SUMOTime duration);
 
    void setPhaseVehExt(int phaseIndex, SUMOTime duration);
 
    void setPhaseYellow(int phaseIndex, SUMOTime duration);
 
    void setPhaseRed(int phaseIndex, SUMOTime duration);
 
    void setPhaseNext(int phaseIndex, const std::vector<int>& next);
 
    void setPhaseName(int phaseIndex, const std::string& name);
 
    void overrideState(int phaseIndex, const char c);
 
    /* @brief deletes the phase at the given index
     * @note throws InvalidArgument on out-of range index
     */
    void deletePhase(int index);
 
    /* @brief swap phases
     * @note throws InvalidArgument on out-of range index
     */
    void swapPhase(int indexPhaseA, int indexPhaseB);
 
    void swapfirstPhase();
 
    void swaplastPhase();
 
    /* @brief changes state size either by cutting of at the end or by adding
     * new states at the end
     */
    void setStateLength(int numLinks, LinkState fill = LINKSTATE_TL_RED);
 
    void deleteStateIndex(int index);
 
    void resetPhases();
 
    void closeBuilding(bool checkVarDurations = true);
 
    SUMOTime getDuration() const;
 
    void setOffset(SUMOTime offset) {
        myOffset = offset;
    }
 
    const std::string& getProgramID() const {
        return mySubID;
    };
 
    const std::vector<PhaseDefinition>& getPhases() const {
        return myPhases;
    }
 
    void copyPhase(const int origin, const int destination) {
        myPhases.at(destination) = myPhases.at(origin);
    }
 
    SUMOTime getOffset() const {
        return myOffset;
    };
 
    int getNumLinks() {
        return myNumLinks;
    }
 
    TrafficLightType getType() const {
        return myType;
    }
 
    void setType(TrafficLightType type) {
        myType = type;
    }
 
    void setProgramID(const std::string& programID) {
        mySubID = programID;
    }
 
private:
    int myNumLinks;
 
    std::string mySubID;
 
    SUMOTime myOffset;
 
    typedef std::vector<PhaseDefinition> PhaseDefinitionVector;
 
    PhaseDefinitionVector myPhases;
 
    TrafficLightType myType;
 
    NBTrafficLightLogic& operator=(const NBTrafficLightLogic& s) = delete;
};