NBRequest.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// This class computes the logic of a junction
/****************************************************************************/
#pragma once
#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 computeLogic(const bool checkLaneFoes);
 
    void writeLogic(OutputDevice& into) const;
 
    const std::string& getFoes(int linkIndex) const;
    const std::string& getResponse(int linkIndex) const;
 
    friend std::ostream& operator<<(std::ostream& os, const NBRequest& r);
 
    static void reportWarnings();
 
    bool rightTurnConflict(const NBEdge* from, const NBEdge::Connection& con,
                           const NBEdge* prohibitorFrom, const NBEdge::Connection& prohibitorCon) const;
 
    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;
 
    bool indirectLeftTurnConflict(const NBEdge* from, const NBEdge::Connection& con,
                                  const NBEdge* prohibitorFrom,  const NBEdge::Connection& prohibitorCon, bool foes) const;
 
    bool bidiConflict(const NBEdge* from, const NBEdge::Connection& con,
                      const NBEdge* prohibitorFrom,  const NBEdge::Connection& prohibitorCon, bool foes) const;
 
 
    bool hasConflict() const;
 
    bool hasConflictAtLink(int linkIndex) const;
 
private:
    void setBlocking(NBEdge* from1, NBEdge* to1, NBEdge* from2, NBEdge* to2);
 
    int computeLaneResponse(NBEdge* from, int lane, int pos, const bool checkLaneFoes);
 
    int computeCrossingResponse(const NBNode::Crossing& crossing, int pos);
 
    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 checkLaneFoesByCooperation(const NBEdge* from, 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;
 
    CombinationsCont  myForbids;
 
    CombinationsCont  myDone;
 
    std::vector<std::string> myFoes;
    std::vector<std::string> myResponse;
    std::vector<bool> myHaveVia;
 
private:
    static int myGoodBuilds, myNotBuild;
 
    NBRequest& operator=(const NBRequest& s) = delete;
};