MSLink.h

Go to the documentation of this file.

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


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

#include <vector>
#include <set>
#include <utils/common/SUMOTime.h>
#include <utils/xml/SUMOXMLDefinitions.h>


// ===========================================================================
// class declarations
// ===========================================================================
class MSLane;
class SUMOVehicle;


// ===========================================================================
// class definitions
// ===========================================================================
class MSLink {
public:
#ifndef HAVE_INTERNAL_LANES

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

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

    ~MSLink() throw();


    void setRequestInformation(unsigned int requestIdx, unsigned int respondIdx, bool isCrossing, bool isCont,
                               const std::vector<MSLink*> &foeLinks, const std::vector<MSLane*> &foeLanes) throw();


    void setApproaching(SUMOVehicle* approaching, SUMOTime arrivalTime, SUMOReal speed, bool setRequest) throw();

    void addBlockedLink(MSLink* link) throw();



    void removeApproaching(SUMOVehicle* veh);



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

    bool blockedAtTime(SUMOTime arrivalTime, SUMOTime leaveTime) const throw();
    bool isBlockingAnyone() const throw() {
        return myApproachingVehicles.size()!=0;
    }

    bool willHaveBlockedFoe() const throw();



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


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


    LinkDirection getDirection() const throw();


    void setTLState(LinkState state, SUMOTime t) throw();


    MSLane* getLane() const throw();


    unsigned int getRespondIndex() const throw();


    bool havePriority() const throw() {
        return myState>='A'&&myState<='Z';
    }


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

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


    bool isCont() const throw() {
        return myAmCont;
    }

#ifdef HAVE_INTERNAL_LANES

    MSLane* getViaLane() const throw();
#endif

private:
    struct ApproachingVehicleInformation {
        ApproachingVehicleInformation(const SUMOTime _arrivalTime, const SUMOTime _leavingTime, SUMOVehicle* _vehicle, const bool _willPass)
            : arrivalTime(_arrivalTime), leavingTime(_leavingTime), vehicle(_vehicle), willPass(_willPass) {}
        SUMOTime arrivalTime;
        SUMOTime leavingTime;
        SUMOVehicle* vehicle;
        bool willPass;
    };

    typedef std::vector<ApproachingVehicleInformation> LinkApproachingVehicles;

    class vehicle_in_request_finder {
    public:
        explicit vehicle_in_request_finder(const SUMOVehicle* const v) : myVehicle(v) { }
        bool operator()(const ApproachingVehicleInformation& vo) {
            return vo.vehicle == myVehicle;
        }
    private:
        vehicle_in_request_finder& operator=(const vehicle_in_request_finder&); // just to avoid a compiler warning
    private:
        const SUMOVehicle* const myVehicle;

    };


private:
    MSLane* myLane;

    LinkApproachingVehicles myApproachingVehicles;
    std::set<MSLink*> myBlockedFoeLinks;

    unsigned int myRequestIdx;

    unsigned int myRespondIdx;

    LinkState myState;

    LinkDirection myDirection;

    SUMOReal myLength;

    bool myIsCrossing;

    bool myAmCont;

#ifdef HAVE_INTERNAL_LANES

    MSLane* const myJunctionInlane;
#endif

    std::vector<MSLink*> myFoeLinks;
    std::vector<MSLane*> myFoeLanes;
    static SUMOTime myLookaheadTime;


private:
    MSLink(const MSLink& s);

    MSLink& operator=(const MSLink& s);

};


#endif

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