MSTLLogicControl.h

Go to the documentation of this file.

/****************************************************************************/
// A class that stores and controls tls and switching of their programs
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright 2001-2010 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 2 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef MSTLLogicControl_h
#define MSTLLogicControl_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <vector>
#include <map>
#include "MSTrafficLightLogic.h"
#include "MSSimpleTrafficLightLogic.h"
#include <utils/common/Command.h>
#include <utils/common/UtilExceptions.h>


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


        virtual void execute() throw() = 0;

    };



    class TLSLogicVariants {
    public:
        TLSLogicVariants() throw();


        ~TLSLogicVariants() throw();


        bool checkOriginalTLS() const throw();


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



        MSTrafficLightLogic* getLogic(const std::string &subid) const;
        void addSwitchCommand(OnSwitchAction *c);
        std::vector<MSTrafficLightLogic*> getAllLogics() const;
        void saveInitialStates();
        bool isActive(const MSTrafficLightLogic *tl) const;
        MSTrafficLightLogic* getActive() const;
        bool switchTo(MSTLLogicControl &tlc, const std::string &subid);
        bool setTrafficLightSignals();
        MSTrafficLightLogic*getLogicInstantiatingOff(MSTLLogicControl &tlc,
                const std::string &subid);
        void executeOnSwitchActions() const;
        void addLink(MSLink *link, MSLane *lane, unsigned int pos) throw();



    private:
        MSTrafficLightLogic *myCurrentProgram;

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

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

        std::vector<OnSwitchAction*> mySwitchActions;


    private:
        TLSLogicVariants(const TLSLogicVariants&);

        TLSLogicVariants& operator=(const TLSLogicVariants&);


    };


    MSTLLogicControl() throw();


    ~MSTLLogicControl() throw();


    bool closeNetworkReading() throw();


    void setTrafficLightSignals();


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


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


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


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

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


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


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

    bool isActive(const MSTrafficLightLogic *tl) const;

    bool switchTo(const std::string &id, const std::string &subid);



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


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


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


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



    void check2Switch(SUMOTime step);


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


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

        ~SwitchInitCommand() throw() { }



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



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

        unsigned int &getIndex() {
            return myIndex;
        }

    protected:
        MSTLLogicControl &myParent;

        std::string myWAUTID;

        unsigned 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;

        // checks, if the position of a signal programm is at the GSP ("GuenstigerUmschaltPunkt")
        bool isPosAtGSP(SUMOTime step, MSSimpleTrafficLightLogic *testLogic);

        unsigned int getDiffToStartOfPhase(MSSimpleTrafficLightLogic *givenLogic, unsigned int pos);

        // switches the given Logic directly to the given position
        void switchToPos(SUMOTime simStep, MSSimpleTrafficLightLogic *givenLogic, unsigned int toPos);

    protected:
        MSTrafficLightLogic *myFrom;

        MSTrafficLightLogic *myTo;

        bool mySwitchSynchron;

        WAUT &myWAUT;

        MSTLLogicControl &myControl;

        SUMOReal getGSPValue(MSTrafficLightLogic *from) const;

    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);

        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);

        void adaptLogic(SUMOTime step, SUMOReal position);

        // cuts (stauchen) the Logic to synchronize,
        // returns false if cutting was imposible
        void cutLogic(SUMOTime step, unsigned int pos, size_t deltaToCut);

        // stretchs the logic to synchronize
        void stretchLogic(SUMOTime step, unsigned int startPos, size_t deltaToStretch);

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

        };

        int getStretchBereicheNo(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

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