NBLoadedSUMOTLDef.h

Go to the documentation of this file.

/****************************************************************************/
// A complete traffic light logic loaded from a sumo-net. (opted to reimplement
// since NBLoadedTLDef is quite vissim specific)
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright (C) 2001-2011 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 NBLoadedSUMOTLDef_h
#define NBLoadedSUMOTLDef_h


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

#include <vector>
#include <string>
#include <set>
#include "NBNode.h"
#include "NBEdgeCont.h"
#include "NBTrafficLightDefinition.h"
#include "NBTrafficLightLogic.h"
#include <utils/common/SUMOTime.h>


// ===========================================================================
// class definitions
// ===========================================================================
class NBLoadedSUMOTLDef : public NBTrafficLightDefinition {
public:

    NBLoadedSUMOTLDef(const std::string& id, const std::string& programID, SUMOTime offset);

    NBLoadedSUMOTLDef(NBTrafficLightDefinition* def, NBTrafficLightLogic* logic);


    ~NBLoadedSUMOTLDef() throw();

    void setTLControllingInformation(const NBEdgeCont& ec) const throw();

    void remapRemoved(NBEdge* removed,
                      const EdgeVector& incoming, const EdgeVector& outgoing) throw();


    void replaceRemoved(NBEdge* removed, int removedLane,
                        NBEdge* by, int byLane) throw();

    void addPhase(SUMOTime duration, const std::string& state);


    void addConnection(NBEdge* from, NBEdge* to, int fromLane, int toLane, int linkIndex);


    void removeConnection(const NBConnection& conn, bool reconstruct=true);

    NBTrafficLightLogic* getLogic() {
        return myTLLogic;
    }


protected:
    void collectLinks() throw(ProcessError) {}


    NBTrafficLightLogic* myCompute(const NBEdgeCont& ec,
                                   unsigned int brakingTime) throw();

    bool amInvalid() const;

private:

    NBTrafficLightLogic* myTLLogic;

    std::set<NBNode*> myOriginalNodes;

    void setTLControllingInformation() const;

private:
    class connection_equal {
    public:
        connection_equal(const NBConnection& c) : myC(c) {}

        bool operator()(const NBConnection& c) const {
            return c.getFrom() == myC.getFrom() && c.getTo() == myC.getTo() &&
                   c.getFromLane() == myC.getFromLane() && c.getToLane() == myC.getToLane();
        }
    private:
        const NBConnection& myC;
    private:
        connection_equal& operator=(const connection_equal& s);

    };

};


#endif

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