MSTLLogicControl.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-2018 German Aerospace Center (DLR) and others.
// This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v20.html
// SPDX-License-Identifier: EPL-2.0
/****************************************************************************/
// A class that stores and controls tls and switching of their programs
/****************************************************************************/
#ifndef MSTLLogicControl_h
#define MSTLLogicControl_h


// ===========================================================================
// included modules
// ===========================================================================
#include <config.h>

#include <vector>
#include <map>
#include <utils/xml/SUMOXMLDefinitions.h>
#include <utils/common/Command.h>


// ===========================================================================
// class declarations
// ===========================================================================
class MSTrafficLightLogic;
class MSLink;
class MSLane;
class MSPhaseDefinition;


// ===========================================================================
// class definitions
// ===========================================================================
class MSTLLogicControl {
public:
    class OnSwitchAction {
    public:
        virtual ~OnSwitchAction() {};


        virtual void execute() = 0;

    };



    class TLSLogicVariants {
    public:
        TLSLogicVariants();


        ~TLSLogicVariants();


        bool checkOriginalTLS() const;


        bool addLogic(const std::string& programID, MSTrafficLightLogic* logic, bool netWasLoaded,
                      bool isNewDefault = true);



        MSTrafficLightLogic* getLogic(const std::string& programID) const;
        void addSwitchCommand(OnSwitchAction* c);
        std::vector<MSTrafficLightLogic*> getAllLogics() const;
        void saveInitialStates();
        bool isActive(const MSTrafficLightLogic* tl) const;
        MSTrafficLightLogic* getActive() const;
        void switchTo(MSTLLogicControl& tlc, const std::string& programID);

        /* @brief get logic by programID. For the special case "off"
         * instantiate an MSOffTrafficLightLogic */
        MSTrafficLightLogic* getLogicInstantiatingOff(MSTLLogicControl& tlc,
                const std::string& programID);

        /* @brief sets the state to the given string get for the special program "online"
         * this program is instantiated only once */
        void setStateInstantiatingOnline(MSTLLogicControl& tlc,
                                         const std::string& state);


        void executeOnSwitchActions() const;
        void addLink(MSLink* link, MSLane* lane, int pos);


    private:
        MSTrafficLightLogic* myCurrentProgram;

        std::map<std::string, MSTrafficLightLogic*> myVariants;

        std::map<MSLink*, LinkState> myOriginalLinkStates;

        std::vector<OnSwitchAction*> mySwitchActions;


    private:
        TLSLogicVariants(const TLSLogicVariants&);

        TLSLogicVariants& operator=(const TLSLogicVariants&);


    };



    MSTLLogicControl();


    ~MSTLLogicControl();


    bool closeNetworkReading();


    void setTrafficLightSignals(SUMOTime t) const;


    std::vector<MSTrafficLightLogic*> getAllLogics() const;


    TLSLogicVariants& get(const std::string& id) const;


    MSTrafficLightLogic* get(const std::string& id, const std::string& programID) const;


    MSTrafficLightLogic* getActive(const std::string& id) const;


    std::vector<std::string> getAllTLIds() const;


    bool add(const std::string& id, const std::string& programID,
             MSTrafficLightLogic* logic, bool newDefault = true);



    bool knows(const std::string& id) const;


    bool isActive(const MSTrafficLightLogic* tl) const;


    void switchTo(const std::string& id, const std::string& programID);




    void addWAUT(SUMOTime refTime, const std::string& id,
                 const std::string& startProg);


    void addWAUTSwitch(const std::string& wautid, SUMOTime when,
                       const std::string& to);


    void addWAUTJunction(const std::string& wautid, const std::string& tls,
                         const std::string& proc, bool synchron);


    void closeWAUT(const std::string& wautid);



    void check2Switch(SUMOTime step);


    std::pair<SUMOTime, MSPhaseDefinition> getPhaseDef(const std::string& tlid) const;

    void switchOffAll();



protected:
    class SwitchInitCommand : public Command {
    public:
        SwitchInitCommand(MSTLLogicControl& p, const std::string& wautid, int index)
            : myParent(p), myWAUTID(wautid), myIndex(index) { }


        ~SwitchInitCommand() { }




        SUMOTime execute(SUMOTime) {
            return myParent.initWautSwitch(*this);
        }



        const std::string& getWAUTID() const {
            return myWAUTID;
        }


        int& getIndex() {
            return myIndex;
        }


    protected:
        MSTLLogicControl& myParent;

        std::string myWAUTID;

        int myIndex;


    private:
        SwitchInitCommand(const SwitchInitCommand&);

        SwitchInitCommand& operator=(const SwitchInitCommand&);

    };



public:
    SUMOTime initWautSwitch(SwitchInitCommand& cmd);


protected:
    struct WAUTSwitch {
        SUMOTime when;
        std::string to;
    };


    struct WAUTJunction {
        std::string junction;
        std::string procedure;
        bool synchron;
    };


    struct WAUT {
        std::string id;
        std::string startProg;
        SUMOTime refTime;
        std::vector<WAUTSwitch> switches;
        std::vector<WAUTJunction> junctions;
    };


    class WAUTSwitchProcedure {
    public:
        WAUTSwitchProcedure(MSTLLogicControl& control, WAUT& waut,
                            MSTrafficLightLogic* from, MSTrafficLightLogic* to,
                            bool synchron)
            : myFrom(from), myTo(to), mySwitchSynchron(synchron), myWAUT(waut), myControl(control) { }


        virtual ~WAUTSwitchProcedure() { }


        virtual bool trySwitch(SUMOTime step) = 0;


    protected:
        bool isPosAtGSP(SUMOTime currentTime, const MSTrafficLightLogic& logic);


        SUMOTime getDiffToStartOfPhase(MSTrafficLightLogic& logic, SUMOTime toTime);


        void switchToPos(SUMOTime simStep, MSTrafficLightLogic& logic, SUMOTime toTime);


        int getGSPValue(const MSTrafficLightLogic& logic) const;


    protected:
        MSTrafficLightLogic* myFrom;

        MSTrafficLightLogic* myTo;

        bool mySwitchSynchron;

        WAUT& myWAUT;

        MSTLLogicControl& myControl;


    private:
        WAUTSwitchProcedure(const WAUTSwitchProcedure&);

        WAUTSwitchProcedure& operator=(const WAUTSwitchProcedure&);

    };


    class WAUTSwitchProcedure_JustSwitch : public WAUTSwitchProcedure {
    public:
        WAUTSwitchProcedure_JustSwitch(MSTLLogicControl& control, WAUT& waut,
                                       MSTrafficLightLogic* from, MSTrafficLightLogic* to,
                                       bool synchron);


        ~WAUTSwitchProcedure_JustSwitch();


        bool trySwitch(SUMOTime step);


    private:
        WAUTSwitchProcedure_JustSwitch(const WAUTSwitchProcedure_JustSwitch&);

        WAUTSwitchProcedure_JustSwitch& operator=(const WAUTSwitchProcedure_JustSwitch&);

    };



    class WAUTSwitchProcedure_GSP : public WAUTSwitchProcedure {
    public:
        WAUTSwitchProcedure_GSP(MSTLLogicControl& control, WAUT& waut,
                                MSTrafficLightLogic* from, MSTrafficLightLogic* to,
                                bool synchron);

        ~WAUTSwitchProcedure_GSP();


        bool trySwitch(SUMOTime step);


    protected:
        void adaptLogic(SUMOTime step);


    private:
        WAUTSwitchProcedure_GSP(const WAUTSwitchProcedure_GSP&);

        WAUTSwitchProcedure_GSP& operator=(const WAUTSwitchProcedure_GSP&);

    };


    class WAUTSwitchProcedure_Stretch : public WAUTSwitchProcedure {
    public:
        WAUTSwitchProcedure_Stretch(MSTLLogicControl& control, WAUT& waut,
                                    MSTrafficLightLogic* from, MSTrafficLightLogic* to,
                                    bool synchron);


        ~WAUTSwitchProcedure_Stretch();


        bool trySwitch(SUMOTime step);


    protected:
        void adaptLogic(SUMOTime step);


        void stretchLogic(SUMOTime step, SUMOTime startPos, SUMOTime allStretchTime);


        void cutLogic(SUMOTime step, SUMOTime startPos, SUMOTime allCutTime);


    protected:
        struct StretchBereichDef {
            double begin;
            double end;
            double fac;

        };


        int getStretchAreaNo(MSTrafficLightLogic* from) const;


        StretchBereichDef getStretchBereichDef(MSTrafficLightLogic* from, int index) const;


    private:
        WAUTSwitchProcedure_Stretch(const WAUTSwitchProcedure_Stretch&);

        WAUTSwitchProcedure_Stretch& operator=(const WAUTSwitchProcedure_Stretch&);

    };


    struct WAUTSwitchProcess {
        std::string junction;
        MSTrafficLightLogic* from;
        MSTrafficLightLogic* to;
        WAUTSwitchProcedure* proc;
    };


    std::map<std::string, WAUT*> myWAUTs;

    std::vector<WAUTSwitchProcess> myCurrentlySwitched;

    std::map<std::string, TLSLogicVariants*> myLogics;

    bool myNetWasLoaded;


private:
    MSTLLogicControl(const MSTLLogicControl&);

    MSTLLogicControl& operator=(const MSTLLogicControl&);

};


#endif

/****************************************************************************/