NIVisumTL.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
/****************************************************************************/
// Intermediate class for storing visum traffic lights during their import
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <map>
#include <string>
#include <netbuild/NBConnectionDefs.h>
#include <netbuild/NBNodeCont.h>
#include <utils/common/SUMOTime.h>
 
class NBTrafficLightLogicCont;
class NBEdgeCont;
 
 
// ===========================================================================
// class declaration
// ===========================================================================
class NIVisumTL {
public:
    class TimePeriod {
    public:
        TimePeriod(SUMOTime startTime, SUMOTime endTime, SUMOTime yellowTime)
            : myStartTime(startTime), myEndTime(endTime), myYellowTime(yellowTime) {}
 
        ~TimePeriod() {}
 
        SUMOTime getStartTime() {
            return myStartTime;
        }
 
        SUMOTime getEndTime() {
            return myEndTime;
        }
 
        SUMOTime getYellowTime() {
            return myYellowTime;
        }
 
    private:
        const SUMOTime myStartTime;
        const SUMOTime myEndTime;
        const SUMOTime myYellowTime;
 
    private:
        TimePeriod& operator=(const TimePeriod& s) = delete;
    };
 
 
 
    class Phase : public TimePeriod {
    public:
        Phase(SUMOTime startTime, SUMOTime endTime, SUMOTime yellowTime) : NIVisumTL::TimePeriod(startTime, endTime, yellowTime) {}
 
        ~Phase() {}
 
    };
 
 
 
    class SignalGroup : public TimePeriod {
    public:
        SignalGroup(const std::string& name, SUMOTime startTime, SUMOTime endTime, SUMOTime yellowTime)
            : NIVisumTL::TimePeriod(startTime, endTime, yellowTime), myName(name) {}
 
        ~SignalGroup() {}
 
        NBConnectionVector& connections() {
            return myConnections;
        }
 
        std::map<std::string, Phase*>& phases() {
            return myPhases;
        }
 
    private:
        NBConnectionVector myConnections;
        std::map<std::string, Phase*> myPhases;
        std::string myName;
    };
 
 
 
public:
    NIVisumTL(const std::string& name, SUMOTime cycleTime, SUMOTime offset, SUMOTime intermediateTime,
              bool phaseDefined);
 
    ~NIVisumTL();
 
    void addNode(NBNode* n) {
        myNodes.push_back(n);
    }
 
    void addSignalGroup(const std::string& name, SUMOTime startTime, SUMOTime endTime, SUMOTime yellowTime);
 
    void addPhase(const std::string& name, SUMOTime startTime, SUMOTime endTime, SUMOTime yellowTime);
 
    std::map<std::string, Phase*>& getPhases() {
        return myPhases;
    }
 
    SignalGroup& getSignalGroup(const std::string& name);
 
    void build(NBEdgeCont& ec, NBTrafficLightLogicCont& tlc);
 
private:
    std::string myName;
 
    SUMOTime myCycleTime;
 
    SUMOTime myOffset;
 
    SUMOTime myIntermediateTime;
 
    bool myPhaseDefined;
 
    std::vector<NBNode*> myNodes;
 
    std::map<std::string, Phase*> myPhases;
 
    std::map<std::string, SignalGroup*> mySignalGroups;
 
 
};