NLHandler.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
/****************************************************************************/
// The XML-Handler for network loading
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <utils/geom/Boundary.h>
#include <utils/shapes/ShapeHandler.h>
#include <microsim/MSRouteHandler.h>
#include "NLDiscreteEventBuilder.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class NLContainer;
class NLDetectorBuilder;
class NLEdgeControlBuilder;
class NLJunctionControlBuilder;
class NLTriggerBuilder;
class MSTrafficLightLogic;
class MSRailSignal;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
 
 
class NLShapeHandler : public ShapeHandler {
public:
    NLShapeHandler(const std::string& file, ShapeContainer& sc) :
        ShapeHandler(file, sc) {}
 
    virtual ~NLShapeHandler() {}
 
    Position getLanePos(const std::string& poiID, const std::string& laneID, double lanePos, bool friendlyPos, double lanePosLat);
 
    virtual bool addLanePosParams() {
        return true;
    }
};
 
 
class NLHandler : public MSRouteHandler {
public:
    typedef std::vector<MSLane*> LaneVector;
 
public:
    NLHandler(const std::string& file, MSNet& net,
              NLDetectorBuilder& detBuilder, NLTriggerBuilder& triggerBuilder,
              NLEdgeControlBuilder& edgeBuilder,
              NLJunctionControlBuilder& junctionBuilder);
 
 
    virtual ~NLHandler();
 
    bool haveSeenInternalEdge() const {
        return myHaveSeenInternalEdge;
    }
 
    bool hasJunctionHigherSpeeds() const {
        return myHaveJunctionHigherSpeeds;
    }
 
    bool haveSeenDefaultLength() const {
        return myHaveSeenDefaultLength;
    }
 
    bool haveSeenNeighs() const {
        return myHaveSeenNeighs;
    }
 
    bool haveSeenAdditionalSpeedRestrictions() const {
        return myHaveSeenAdditionalSpeedRestrictions;
    }
 
    bool haveSeenMesoEdgeType() const {
        return myHaveSeenMesoEdgeType;
    }
 
    MMVersion networkVersion() const {
        return myNetworkVersion;
    }
 
    static Parameterised* addPredecessorConstraint(int element, const SUMOSAXAttributes& attrs, MSRailSignal* rs);
 
protected:
 
 
    virtual void myStartElement(int element,
                                const SUMOSAXAttributes& attrs);
 
 
    virtual void myEndElement(int element);
 
 
protected:
    void addParam(const SUMOSAXAttributes& attrs);
 
    virtual void addE1Detector(const SUMOSAXAttributes& attrs);
 
    virtual void addInstantE1Detector(const SUMOSAXAttributes& attrs);
 
    virtual void addE2Detector(const SUMOSAXAttributes& attrs);
 
    void beginE3Detector(const SUMOSAXAttributes& attrs);
 
    void addE3Entry(const SUMOSAXAttributes& attrs);
 
    void addE3Exit(const SUMOSAXAttributes& attrs);
 
    virtual void endE3Detector();
 
    virtual void addVTypeProbeDetector(const SUMOSAXAttributes& attrs);
 
    virtual void addRouteProbeDetector(const SUMOSAXAttributes& attrs);
 
    virtual void addEdgeLaneMeanData(const SUMOSAXAttributes& attrs, int objecttype);
 
    virtual void addMesoEdgeType(const SUMOSAXAttributes& attrs);
 
    virtual void closeEdge();
 
private:
    void beginEdgeParsing(const SUMOSAXAttributes& attrs);
 
    void addLane(const SUMOSAXAttributes& attrs);
 
    void addRequest(const SUMOSAXAttributes& attrs);
 
    void initJunctionLogic(const SUMOSAXAttributes& attrs);
 
    void initTrafficLightLogic(const SUMOSAXAttributes& attrs);
 
    void addPhase(const SUMOSAXAttributes& attrs);
 
    void addCondition(const SUMOSAXAttributes& attrs);
 
    void addAssignment(const SUMOSAXAttributes& attrs);
 
    void addFunction(const SUMOSAXAttributes& attrs);
 
    void closeFunction();
 
    virtual void openJunction(const SUMOSAXAttributes& attrs);
 
    void parseLanes(const std::string& junctionID, const std::string& def, std::vector<MSLane*>& into, bool& ok);
 
    void addConnection(const SUMOSAXAttributes& attrs);
 
    void addConflict(const SUMOSAXAttributes& attrs);
 
    virtual void openWAUT(const SUMOSAXAttributes& attrs);
    void addWAUTSwitch(const SUMOSAXAttributes& attrs);
    void addWAUTJunction(const SUMOSAXAttributes& attrs);
 
    void setLocation(const SUMOSAXAttributes& attrs);
 
    void addDistrict(const SUMOSAXAttributes& attrs);
 
 
    void addDistrictEdge(const SUMOSAXAttributes& attrs, bool isSource);
 
    void addRoundabout(const SUMOSAXAttributes& attrs);
 
 
    void closeWAUT();
 
    LinkDirection parseLinkDir(const std::string& dir);
 
    LinkState parseLinkState(const std::string& state);
 
protected:
    MSNet& myNet;
 
    NLDiscreteEventBuilder myActionBuilder;
 
    bool myCurrentIsInternalToSkip;
 
 
    NLDetectorBuilder& myDetectorBuilder;
 
    NLTriggerBuilder& myTriggerBuilder;
 
    NLEdgeControlBuilder& myEdgeControlBuilder;
 
    NLJunctionControlBuilder& myJunctionControlBuilder;
 
    std::string myCurrentDistrictID;
 
    bool myAmParsingTLLogicOrJunction;
 
    std::string myCurrentWAUTID;
 
    std::string myCurrentTypeID;
 
    Position myNetworkOffset;
 
    Boundary myOrigBoundary, myConvBoundary;
 
    bool myCurrentIsBroken;
 
    bool myHaveWarnedAboutInvalidTLType;
 
    Parameterised myLastEdgeParameters;
    std::vector<Parameterised*> myLastParameterised;
 
    bool myHaveSeenInternalEdge;
 
    bool myHaveJunctionHigherSpeeds;
 
    bool myHaveSeenDefaultLength;
 
    bool myHaveSeenNeighs;
 
    bool myHaveSeenAdditionalSpeedRestrictions;
 
    bool myHaveSeenMesoEdgeType;
 
    MMVersion myNetworkVersion;
 
    bool myNetIsLoaded;
 
    MSRailSignal* myConstrainedSignal;
 
    MSLink* myCurrentLink = nullptr;
 
    typedef std::map<std::string, std::pair<std::string, std::string> > JunctionGraph;
    JunctionGraph myJunctionGraph;
 
    int myPreviousEdgeIdx = 0;
 
private:
    NLHandler(const NLHandler& s);
 
    NLHandler& operator=(const NLHandler& s);
 
};