NLJunctionControlBuilder.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
/****************************************************************************/
// Builder of microsim-junctions and tls
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <vector>
#include <microsim/MSJunction.h>
#include <microsim/MSRightOfWayJunction.h>
#include <microsim/MSJunctionControl.h>
#include <utils/geom/Position.h>
#include <utils/geom/PositionVector.h>
#include <microsim/traffic_lights/MSSimpleTrafficLightLogic.h>
#include <microsim/traffic_lights/MSActuatedTrafficLightLogic.h>
#include <microsim/traffic_lights/MSRailSignal.h>
#include <microsim/MSBitSetLogic.h>
#include <microsim/traffic_lights/MSTLLogicControl.h>
#include <utils/common/UtilExceptions.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class OptionsCont;
class NLDetectorBuilder;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NLJunctionControlBuilder {
private:
    typedef std::vector<MSLane*> LaneVector;
 
public:
    NLJunctionControlBuilder(MSNet& net, NLDetectorBuilder& db);
 
 
    virtual ~NLJunctionControlBuilder();
 
 
    void openJunction(const std::string& id, const std::string& key,
                      const SumoXMLNodeType type,
                      const Position pos,
                      const PositionVector& shape,
                      const std::vector<MSLane*>& incomingLanes,
                      const std::vector<MSLane*>& internalLanes,
                      const std::string& name);
 
 
    void closeJunction(const std::string& basePath);
 
 
    MSJunctionControl* build() const;
 
 
    void initJunctionLogic(const std::string& id);
 
 
    void addLogicItem(int request, const std::string& response,
                      const std::string& foes, bool cont);
 
    void initTrafficLightLogic(const std::string& id, const std::string& programID,
                               TrafficLightType type, SUMOTime offset);
 
    void addPhase(MSPhaseDefinition* phase);
 
    bool addCondition(const std::string& id, const std::string& value);
 
    void addAssignment(const std::string& id, const std::string& check, const std::string& value);
 
    void addFunction(const std::string& id, int nArgs);
 
    void closeFunction();
 
    MSTLLogicControl::TLSLogicVariants& getTLLogic(const std::string& id) const;
 
    MSTLLogicControl* buildTLLogics();
 
    virtual void closeTrafficLightLogic(const std::string& basePath);
 
    void addParam(const std::string& key, const std::string& value);
 
    const std::string& getActiveKey() const;
 
    const std::string& getActiveSubKey() const;
 
    MSTLLogicControl& getTLLogicControlToUse() const;
 
    void postLoadInitialization();
 
    MSJunction* retrieve(const std::string id);
 
    const MSSimpleTrafficLightLogic::Phases& getLoadedPhases() const {
        return myActivePhases;
    }
 
    void netIsLoaded() {
        myNetIsLoaded = true;
    }
 
protected:
 
    virtual MSJunction* buildNoLogicJunction();
 
    virtual MSJunction* buildLogicJunction(MSJunctionLogic* const logic);
 
    virtual MSJunction* buildInternalJunction();
 
protected:
    MSNet& myNet;
 
    NLDetectorBuilder& myDetectorBuilder;
 
    SUMOTime myOffset;
 
    TrafficLightType myLogicType;
 
    MSBitsetLogic::Logic myActiveLogic;
 
    MSBitsetLogic::Foes myActiveFoes;
 
    std::bitset<SUMO_MAX_CONNECTIONS> myActiveConts;
 
    MSSimpleTrafficLightLogic::Phases myActivePhases;
 
    MSActuatedTrafficLightLogic::ConditionMap myActiveConditions;
 
    MSActuatedTrafficLightLogic::AssignmentMap myActiveAssignments;
 
    MSActuatedTrafficLightLogic::FunctionMap myActiveFunctions;
 
    MSActuatedTrafficLightLogic::Function myActiveFunction;
 
    int myRequestSize;
 
    int myRequestItemNumber;
 
    mutable MSJunctionControl* myJunctions;
 
    LaneVector myActiveIncomingLanes;
 
    LaneVector myActiveInternalLanes;
 
    std::string myActiveID;
 
    std::string myActiveKey, myActiveProgram;
 
    SumoXMLNodeType myType;
 
    Position myPosition;
 
    SUMOTime myAbsDuration;
 
    PositionVector myShape;
 
    std::string myActiveName;
 
    typedef Parameterised::Map StringParameterMap;
 
    std::vector<MSTrafficLightLogic*> myNetworkLogics;
    std::vector<MSTrafficLightLogic*> myAdditionalLogics;
    std::vector<MSTrafficLightLogic*> myRailSignals;
    std::map<MSTrafficLightLogic*, StringParameterMap> myLogicParams;
 
    mutable MSTLLogicControl* myLogicControl;
 
    StringParameterMap myAdditionalParameter;
 
    bool myCurrentHasError;
 
private:
    NLJunctionControlBuilder(const NLJunctionControlBuilder& s);
 
    NLJunctionControlBuilder& operator=(const NLJunctionControlBuilder& s);
 
    static const int NO_REQUEST_SIZE;
 
    bool myNetIsLoaded;
 
 
};