NBRequest.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
/****************************************************************************/
// This class computes the logic of a junction
/****************************************************************************/
#ifndef NBRequest_h
#define NBRequest_h


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

#include <string>
#include <vector>
#include <map>
#include <bitset>
#include "NBConnectionDefs.h"
#include "NBContHelper.h"
#include <utils/common/UtilExceptions.h>


// ===========================================================================
// class declarations
// ===========================================================================
class NBEdge;
class NBJunctionTypeIO;
class NBTrafficLightLogic;
class OptionsCont;
class NBTrafficLightDefinition;
class NBEdgeCont;
class OutputDevice;


// ===========================================================================
// class definitions
// ===========================================================================
class NBRequest {
public:
    NBRequest(const NBEdgeCont& ec,
              NBNode* junction,
              const EdgeVector& all,
              const EdgeVector& incoming,
              const EdgeVector& outgoing,
              const NBConnectionProhibits& loadedProhibits);

    ~NBRequest();

    void buildBitfieldLogic();

    std::pair<int, int> getSizes() const;

    bool mustBrake(const NBEdge* const possProhibitorFrom, const NBEdge* const possProhibitorTo,
                   const NBEdge* const possProhibitedFrom, const NBEdge* const possProhibitedTo) const;


    bool mustBrake(const NBEdge* const from, const NBEdge* const to, int fromLane, int toLane, bool includePedCrossings) const;

    static bool mustBrakeForCrossing(const NBNode* node, const NBEdge* const from, const NBEdge* const to, const NBNode::Crossing& crossing);

    bool foes(const NBEdge* const from1, const NBEdge* const to1,
              const NBEdge* const from2, const NBEdge* const to2) const;


    bool forbids(const NBEdge* const possProhibitorFrom, const NBEdge* const possProhibitorTo,
                 const NBEdge* const possProhibitedFrom, const NBEdge* const possProhibitedTo,
                 bool regardNonSignalisedLowerPriority) const;

    void writeLogic(std::string key, OutputDevice& into, const bool checkLaneFoes) const;

    friend std::ostream& operator<<(std::ostream& os, const NBRequest& r);

    static void reportWarnings();

    bool mergeConflict(const NBEdge* from, const NBEdge::Connection& con,
                       const NBEdge* prohibitorFrom,  const NBEdge::Connection& prohibitorCon, bool foes) const;

    bool oppositeLeftTurnConflict(const NBEdge* from, const NBEdge::Connection& con,
                                  const NBEdge* prohibitorFrom,  const NBEdge::Connection& prohibitorCon, bool foes) const;


private:
    void setBlocking(NBEdge* from1, NBEdge* to1, NBEdge* from2, NBEdge* to2);

    int writeLaneResponse(OutputDevice& od, NBEdge* from, int lane,
                          int pos, const bool checkLaneFoes, bool padding) const;

    int writeCrossingResponse(OutputDevice& od, const NBNode::Crossing& crossing, int pos) const;

    std::string getResponseString(const NBEdge* const from, const NBEdge::Connection& c, const bool checkLaneFoes) const;


    std::string getFoesString(NBEdge* from, NBEdge* to,
                              int fromLane, int toLane, const bool checkLaneFoes) const;


    int getIndex(const NBEdge* const from, const NBEdge* const to) const;


    int distanceCounterClockwise(NBEdge* from, NBEdge* to);

    void computeRightOutgoingLinkCrossings(NBEdge* from, NBEdge* to);

    void computeLeftOutgoingLinkCrossings(NBEdge* from, NBEdge* to);


    void resetSignalised();

    void resetCooperating();

    bool checkLaneFoesByClass(const NBEdge::Connection& con,
                              const NBEdge* prohibitorFrom,  const NBEdge::Connection& prohibitorCon) const;

    bool laneConflict(const NBEdge* from, const NBEdge* to, int toLane, const NBEdge* prohibitorFrom, const NBEdge* prohibitorTo, int prohibitorToLane) const;


    inline int numLinks() const;

private:
    NBNode* myJunction;

    const EdgeVector& myAll;

    const EdgeVector& myIncoming;

    const EdgeVector& myOutgoing;

    typedef std::vector<bool> LinkInfoCont;

    typedef std::vector<LinkInfoCont> CombinationsCont;

    typedef std::map<NBEdge*, LaneVector> OccupiedLanes;

    CombinationsCont  myForbids;

    CombinationsCont  myDone;

private:
    static int myGoodBuilds, myNotBuild;

    NBRequest& operator=(const NBRequest& s) = delete;
};

#endif

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