MSLink.h

Go to the documentation of this file.

/****************************************************************************/
// A connnection between lanes
/****************************************************************************/
// 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 MSLink_h
#define MSLink_h


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

#include "MSLogicJunction.h"


// ===========================================================================
// class declarations
// ===========================================================================
class MSVehicle;
class MSTrafficLightLogic;


// ===========================================================================
// class definitions
// ===========================================================================
class MSLink {
public:
    enum LinkState {
        LINKSTATE_TL_GREEN_MAJOR = 'G',
        LINKSTATE_TL_GREEN_MINOR = 'g',
        LINKSTATE_TL_RED = 'r',
        LINKSTATE_TL_YELLOW_MAJOR = 'Y',
        LINKSTATE_TL_YELLOW_MINOR = 'y',
        LINKSTATE_TL_OFF_BLINKING = 'b',
        LINKSTATE_TL_OFF_NOSIGNAL = 'O',
        LINKSTATE_MAJOR = 'M',
        LINKSTATE_MINOR = 'm',
        LINKSTATE_EQUAL = '=',
        LINKSTATE_DEADEND = '-'
    };


    enum LinkDirection {
        LINKDIR_STRAIGHT = 0,
        LINKDIR_TURN,
        LINKDIR_LEFT,
        LINKDIR_RIGHT,
        LINKDIR_PARTLEFT,
        LINKDIR_PARTRIGHT,
        LINKDIR_NODIR
    };


#ifndef HAVE_INTERNAL_LANES

    MSLink(MSLane* succLane,
           bool yield, LinkDirection dir, LinkState state, SUMOReal length) throw();
#else

    MSLink(MSLane* succLane, MSLane *via,
           bool yield, LinkDirection dir, LinkState state, bool internalEnd,
           SUMOReal length) throw();
#endif

    ~MSLink() throw();


    void setRequestInformation(MSLogicJunction::Request *request, unsigned int requestIdx,
                               MSLogicJunction::Respond *respond, unsigned int respondIdx,
                               const MSLogicJunction::LinkFoes &foes, bool isCrossing, bool isCont,
                               const std::vector<MSLink*> &foeLinks, const std::vector<MSLane*> &foeLanes) throw();


    void setApproaching(MSVehicle *approaching, SUMOTime arrivalTime, SUMOReal speed) throw();

    void removeApproaching(MSVehicle *veh);

    MSVehicle *getApproaching() const throw() {
        return myApproaching;
    };


    void setPriority(bool prio) throw();


    bool opened(SUMOTime arrivalTime, SUMOReal arrivalSpeed) const throw();

    bool blockedAtTime(SUMOTime arrivalTime, SUMOTime leaveTime) const throw();


    bool hasApproachingFoe(SUMOTime arrivalTime, SUMOTime leaveTime) const throw();


    void deleteRequest() throw();


    LinkState getState() const throw() {
        return myState;
    }


    LinkDirection getDirection() const throw();


    void setTLState(LinkState state) throw();


    MSLane *getLane() const throw();


    unsigned int getRespondIndex() const throw();


    bool havePriority() const throw() {
        return myPrio;
    }


    SUMOReal getLength() const throw() {
        return myLength;
    }

    bool isCrossing() const throw() {
        return myIsCrossing;
    }


#ifdef HAVE_INTERNAL_LANES

    MSLane * const getViaLane() const throw();


    void resetInternalPriority() throw();

#endif

private:
    MSLane* myLane;

    bool myPrio;

    MSVehicle *myApproaching;

    MSLogicJunction::Request *myRequest;
    MSJunction::LinkApproachingVehicles myApproachingVehicles;

    unsigned int myRequestIdx;

    MSLogicJunction::Respond *myRespond;

    unsigned int myRespondIdx;

    LinkState myState;

    LinkDirection myDirection;

    SUMOReal myLength;

    MSLogicJunction::LinkFoes myFoes;

    bool myIsCrossing;

    bool myAmCont;

#ifdef HAVE_INTERNAL_LANES
    MSLane * const myJunctionInlane;

    bool myIsInternalEnd;
#endif

    std::vector<MSLink*> myFoeLinks;
    std::vector<MSLane*> myFoeLanes;


private:
    MSLink(const MSLink &s);

    MSLink &operator=(const MSLink &s);

};


#endif

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