MSPhaseDefinition.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
/****************************************************************************/
// The definition of a single phase of a tls logic
/****************************************************************************/
#pragma once
#include <config.h>
 
#define TARGET_BIT 0
#define TRANSIENT_NOTDECISIONAL_BIT 1
#define COMMIT_BIT 2
#define UNDEFINED_BIT 3
#include <config.h>
 
#include <bitset>
#include <string>
#include <vector>
#include <utils/common/MsgHandler.h>
#include <utils/common/SUMOTime.h>
#include <utils/options/OptionsCont.h>
#include <utils/xml/SUMOXMLDefinitions.h>
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSPhaseDefinition {
public:
 
    static const SUMOTime UNSPECIFIED_DURATION = -1;
    static const SUMOTime OVERRIDE_DURATION = TIME2STEPS(-1);
 
    SUMOTime duration;
 
    SUMOTime lastDuration;
 
    SUMOTime minDuration;
 
    SUMOTime maxDuration;
 
    SUMOTime earliestEnd;
 
    SUMOTime latestEnd;
 
    std::string earlyTarget;
 
    std::string finalTarget;
 
    SUMOTime myLastSwitch;
 
    SUMOTime myLastEnd;
 
    std::vector<int> nextPhases;
 
    std::string name;
 
    SUMOTime yellow;
 
    SUMOTime red;
 
    SUMOTime vehext;
 
    bool myTransientNotDecisional;
 
    bool myCommit;
 
    bool myUndefined;
 
    /*
     * @brief The lanes-set
     * This array can be empty if this phase is not a target step,
     * otherwise, a bit is true if the corresponding lane belongs to a
     * set of input lanes.
     * SOTL traffic light logics choose the target step according to sensors
     * belonging to the lane-set.
     */
    std::vector<std::string> myTargetLaneSet;
 
private:
    std::string myState;
 
 
public:
    MSPhaseDefinition(SUMOTime _duration, const std::string& state, const std::string& _name = ""):
        duration(_duration),
        lastDuration(UNSPECIFIED_DURATION),
        minDuration(duration),
        maxDuration(duration),
        earliestEnd(UNSPECIFIED_DURATION),
        latestEnd(UNSPECIFIED_DURATION),
        myLastSwitch(UNSPECIFIED_DURATION),
        myLastEnd(UNSPECIFIED_DURATION),
        name(_name),
        yellow(UNSPECIFIED_DURATION),
        red(UNSPECIFIED_DURATION),
        vehext(UNSPECIFIED_DURATION),
        myTransientNotDecisional(false),
        myCommit(false),
        myUndefined(false),
        myState(state)
    {}
 
 
    virtual ~MSPhaseDefinition() { }
 
 
    const std::string& getState() const {
        return myState;
    }
 
    void setState(const std::string& _state) {
        myState = _state;
    }
 
    const std::vector<std::string>& getTargetLaneSet() const {
        return myTargetLaneSet;
    }
 
    const std::vector<int>& getNextPhases() const {
        return nextPhases;
    }
 
    const std::string& getName() const {
        return name;
    }
 
    void setName(const std::string& _name) {
        name = _name;
    }
 
    bool isGreenPhase() const {
        if (myState.find_first_of("gG") == std::string::npos) {
            return false;
        }
        if (myState.find_first_of("yY") != std::string::npos) {
            return false;
        }
        return true;
    }
 
 
    bool isAllRedPhase() const {
        return (int)myState.size() == (int)std::count(myState.begin(), myState.end(), 'r');
    }
 
 
    LinkState getSignalState(int pos) const {
        return (LinkState) myState[pos];
    }
 
    inline bool isActuated() const {
        return minDuration != maxDuration || minDuration == OVERRIDE_DURATION;
    }
 
    bool operator!=(const MSPhaseDefinition& pd) {
        return myState != pd.myState || name != pd.name;
    }
 
 
    /*
    * @return true if the phase type is undefined
    */
    bool isUndefined() const {
        return myUndefined;
    }
 
    /*
    * @return true if this is a target phase
    */
    bool isTarget() const {
        return !myTargetLaneSet.empty();
    }
 
    /*
    * @return true if this is a transient phase
    */
    bool isTransient() const {
        return myTransientNotDecisional;
    }
 
    /*
    * @return true if this is a decisional phase
    */
    bool isDecisional() const {
        return !myTransientNotDecisional;
    }
 
    /*
    * @return true if this is a commit phase
    */
    bool isCommit() const {
        return myCommit;
    }
 
};