Eclipse SUMO - Simulation of Urban MObility
GNENetHelper.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2022 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
18// Helper for GNENet
19//
20/****************************************************************************/
21#pragma once
22#include <config.h>
23
26#include <netbuild/NBEdge.h>
28#include <netbuild/NBVehicle.h>
32#include <utils/geom/Boundary.h>
39
40
41// ===========================================================================
42// class declarations
43// ===========================================================================
44
45class NBNetBuilder;
46class GNEAdditional;
47class GNEDataSet;
51class GNEConnection;
52class GNECrossing;
53class GNEJunction;
54class GNEEdgeType;
55class GNELaneType;
56class GNEEdge;
57class GNELane;
59class GNEPOI;
60class GNEPoly;
61class GNEUndoList;
62class GNEViewNet;
63
64// ===========================================================================
65// class definitions
66// ===========================================================================
67
69
72
75 friend class GNERouteHandler;
76 friend class GNEDataHandler;
77 friend class GNEChange_Junction;
78 friend class GNEChange_EdgeType;
79 friend class GNEChange_Edge;
81 friend class GNEChange_Shape;
84 friend class GNEChange_DataSet;
87
88 public:
91
94
97
100
103
109 GNEAttributeCarrier* retrieveAttributeCarrier(const GUIGlID id, bool hardFail = true) const;
110
114 std::vector<GNEAttributeCarrier*> retrieveAttributeCarriers(SumoXMLTag tag = SUMO_TAG_NOTHING);
115
117 std::vector<GNEAttributeCarrier*> retrieveAttributeCarriers(Supermode supermode, const bool onlySelected);
118
120 std::vector<GNEAttributeCarrier*> getSelectedAttributeCarriers(const bool ignoreCurrentSupermode);
121
123
126
131 GNEJunction* retrieveJunction(const std::string& id, bool hardFail = true) const;
132
134 const std::map<std::string, GNEJunction*>& getJunctions() const;
135
137 std::vector<GNEJunction*> getSelectedJunctions() const;
138
141
143 void clearJunctions();
144
146 void updateJunctionID(GNEJunction* junction, const std::string& newID);
147
150
152
155
160 GNECrossing* retrieveCrossing(GNEAttributeCarrier* AC, bool hardFail = true) const;
161
163 const std::set<GNECrossing*>& getCrossings() const;
164
166 std::vector<GNECrossing*> getSelectedCrossings() const;
167
169 void insertCrossing(GNECrossing* crossing);
170
172 void deleteCrossing(GNECrossing* crossing);
173
176
178
181
186 GNEWalkingArea* retrieveWalkingArea(GNEAttributeCarrier* AC, bool hardFail = true) const;
187
189 const std::set<GNEWalkingArea*>& getWalkingAreas() const;
190
192 std::vector<GNEWalkingArea*> getSelectedWalkingAreas() const;
193
195 void insertWalkingArea(GNEWalkingArea* walkingArea);
196
198 void deleteWalkingArea(GNEWalkingArea* walkingArea);
199
202
204
207
212 GNEEdgeType* retrieveEdgeType(const std::string& id, bool hardFail = true) const;
213
216
218 const std::map<std::string, GNEEdgeType*>& getEdgeTypes() const;
219
221 void clearEdgeTypes();
222
224 void updateEdgeTypeID(GNEEdgeType* edgeType, const std::string& newID);
225
227 std::string generateEdgeTypeID() const;
228
230
233
238 GNEEdge* retrieveEdge(const std::string& id, bool hardFail = true) const;
239
245 std::vector<GNEEdge*> retrieveEdges(GNEJunction* from, GNEJunction* to) const;
246
248 const std::map<std::string, GNEEdge*>& getEdges() const;
249
253 std::vector<GNEEdge*> getSelectedEdges() const;
254
257
259 void clearEdges();
260
262 void updateEdgeID(GNEEdge* edge, const std::string& newID);
263
265 int getNumberOfSelectedEdges() const;
266
269
275 GNELane* retrieveLane(const std::string& id, bool hardFail = true, bool checkVolatileChange = false) const;
276
282 GNELane* retrieveLane(GNEAttributeCarrier* AC, bool hardFail = true) const;
283
285 const std::set<GNELane*>& getLanes() const;
286
288 std::vector<GNELane*> getSelectedLanes() const;
289
291 void insertLane(GNELane* lane);
292
294 void deleteLane(GNELane* lane);
295
297 int getNumberOfSelectedLanes() const;
298
300
303
308 GNEConnection* retrieveConnection(const std::string& id, bool hardFail = true) const;
309
315 GNEConnection* retrieveConnection(GNEAttributeCarrier* AC, bool hardFail = true) const;
316
318 const std::set<GNEConnection*>& getConnections() const;
319
321 std::vector<GNEConnection*> getSelectedConnections() const;
322
324 void insertConnection(GNEConnection* connection);
325
327 void deleteConnection(GNEConnection* connection);
328
331
333
336
342 GNEAdditional* retrieveAdditional(SumoXMLTag type, const std::string& id, bool hardFail = true) const;
343
348 GNEAdditional* retrieveAdditional(GNEAttributeCarrier* AC, bool hardFail = true) const;
349
355 GNEAdditional* retrieveRerouterInterval(const std::string& rerouterID, const SUMOTime begin, const SUMOTime end) const;
356
358 const std::map<SumoXMLTag, std::set<GNEAdditional*> >& getAdditionals() const;
359
361 std::vector<GNEAdditional*> getSelectedAdditionals() const;
362
364 std::vector<GNEAdditional*> getSelectedShapes() const;
365
367 int getNumberOfAdditionals() const;
368
370 void clearAdditionals();
371
373 std::string generateAdditionalID(SumoXMLTag type) const;
374
377
380
382 int getNumberOfSelectedPolygons() const;
383
385 int getNumberOfSelectedPOIs() const;
386
388 int getNumberOfSelectedTAZs() const;
389
392
394 int getNumberOfSelectedTAZSinks() const;
395
397 int getNumberOfSelectedWires() const;
398
400
403
408 GNEDemandElement* retrieveDemandElement(SumoXMLTag type, const std::string& id, bool hardFail = true) const;
409
414 GNEDemandElement* retrieveDemandElement(GNEAttributeCarrier* AC, bool hardFail = true) const;
415
417 std::vector<GNEDemandElement*> getSelectedDemandElements() const;
418
420 const std::map<SumoXMLTag, std::set<GNEDemandElement*> >& getDemandElements() const;
421
423 int getNumberOfDemandElements() const;
424
426 std::string generateDemandElementID(SumoXMLTag tag) const;
427
430
432 void clearDemandElements();
433
435 void addDefaultVTypes();
436
438 int getStopIndex();
439
442
444 int getNumberOfSelectedRoutes() const;
445
447 int getNumberOfSelectedVehicles() const;
448
450 int getNumberOfSelectedPersons() const;
451
454
456 int getNumberOfSelectedWalks() const;
457
459 int getNumberOfSelectedRides() const;
460
463
466
469
471 int getNumberOfSelectedStops() const;
472
474
477
482 GNEDataSet* retrieveDataSet(const std::string& id, bool hardFail = true) const;
483
488 GNEDataSet* retrieveDataSet(GNEAttributeCarrier* AC, bool hardFail = true) const;
489
491 const std::set<GNEDataSet*>& getDataSets() const;
492
494 std::string generateDataSetID(const std::string& prefix) const;
495
497
500
504 GNEDataInterval* retrieveDataInterval(GNEAttributeCarrier* AC, bool hardFail = true) const;
505
507 const std::set<GNEDataInterval*>& getDataIntervals() const;
508
510 void insertDataInterval(GNEDataInterval* dataInterval);
511
513 void deleteDataInterval(GNEDataInterval* dataInterval);
514
516
519
523 GNEGenericData* retrieveGenericData(GNEAttributeCarrier* AC, bool hardFail = true) const;
524
526 std::vector<GNEGenericData*> getSelectedGenericDatas() const;
527
529 const std::map<SumoXMLTag, std::set<GNEGenericData*> >& getGenericDatas() const;
530
532 std::vector<GNEGenericData*> retrieveGenericDatas(const SumoXMLTag genericDataTag, const double begin, const double end);
533
536
539
542
544 void insertGenericData(GNEGenericData* genericData);
545
547 void deleteGenericData(GNEGenericData* genericData);
548
550 std::set<std::string> retrieveGenericDataParameters(const std::string& genericDataTag, const double begin, const double end) const;
551
553 std::set<std::string> retrieveGenericDataParameters(const std::string& dataSetID, const std::string& genericDataTag,
554 const std::string& beginStr, const std::string& endStr) const;
555
557
558 protected:
562 void insertJunction(GNEJunction* junction);
563
565 void deleteSingleJunction(GNEJunction* junction);
566
568
572 bool edgeTypeExist(const GNEEdgeType* edgeType) const;
573
575 void insertEdgeType(GNEEdgeType* edgeType);
576
578 void deleteEdgeType(GNEEdgeType* edgeType);
579
581
585 void insertEdge(GNEEdge* edge);
586
588 void deleteSingleEdge(GNEEdge* edge);
589
591
594
596 bool additionalExist(const GNEAdditional* additional) const;
597
601 void insertAdditional(GNEAdditional* additional);
602
606 void deleteAdditional(GNEAdditional* additional);
607
609
612
614 bool demandElementExist(GNEDemandElement* demandElement) const;
615
619 void insertDemandElement(GNEDemandElement* demandElement);
620
624 void deleteDemandElement(GNEDemandElement* demandElement);
625
627
630
632 bool dataSetExist(GNEDataSet* dataSet) const;
633
637 void insertDataSet(GNEDataSet* dataSet);
638
642 void deleteDataSet(GNEDataSet* dataSet);
643
645
646 private:
649
652
654 std::map<std::string, GNEJunction*> myJunctions;
655
657 std::set<GNECrossing*> myCrossings;
658
660 std::set<GNEWalkingArea*> myWalkingAreas;
661
663 std::map<std::string, GNEEdgeType*> myEdgeTypes;
664
666 std::map<std::string, GNEEdge*> myEdges;
667
669 std::set<GNELane*> myLanes;
670
672 std::set<GNEConnection*> myConnections;
673
675 std::map<SumoXMLTag, std::set<GNEAdditional*> > myAdditionals;
676
678 std::map<SumoXMLTag, std::set<GNEDemandElement*> > myDemandElements;
679
681 std::set<GNEDataSet*> myDataSets;
682
684 std::set<GNEDataInterval*> myDataIntervals;
685
687 std::map<SumoXMLTag, std::set<GNEGenericData*> > myGenericDatas;
688
691
694 };
695
698 FXDECLARE_ABSTRACT(GNEChange_ReplaceEdgeInTLS)
699
700 public:
703
706
708 void undo();
709
711 void redo();
712
714 std::string undoName() const;
715
717 std::string redoName() const;
718
720 bool trueChange();
721
722 private:
725
728
731 };
732};
Supermode
@brie enum for supermodes
long long int SUMOTime
Definition: GUI.h:36
unsigned int GUIGlID
Definition: GUIGlObject.h:43
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ SUMO_TAG_NOTHING
invalid tag
Builds additional objects for GNENet (busStops, chargingStations, detectors, etc.....
An Element which don't belong to GNENet but has influence in the simulation.
Definition: GNEAdditional.h:48
The main window of the Netedit.
the function-object for an editing operation (abstract base)
Definition: GNEChange.h:60
This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routete...
Definition: GNECrossing.h:42
An Element which don't belong to GNENet but has influence in the simulation.
An Element which don't belong to GNENet but has influence in the simulation.
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:53
An Element which don't belong to GNENet but has influence in the simulation.
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:46
struct used for saving all attribute carriers of net, in different formats
Definition: GNENetHelper.h:71
std::vector< GNEEdge * > retrieveEdges(GNEJunction *from, GNEJunction *to) const
get all edges by from and to GNEJunction
void insertWalkingArea(GNEWalkingArea *walkingArea)
insert walkingArea
GNEAttributeCarrier * retrieveAttributeCarrier(const GUIGlID id, bool hardFail=true) const
get a single attribute carrier based on a GLID
int getNumberOfSelectedAdditionals() const
get number of selected additionals (Including POIs, Polygons, TAZs and Wires)
const std::map< SumoXMLTag, std::set< GNEGenericData * > > & getGenericDatas() const
get all generic datas
const std::set< GNELane * > & getLanes() const
get lanes
const std::set< GNEConnection * > & getConnections() const
get connections
int getNumberOfSelectedConnections() const
get number of selected connections
void deleteDataSet(GNEDataSet *dataSet)
delete demand element element of GNENet container
void insertLane(GNELane *lane)
insert lane
int getNumberOfSelectedEdgeRelDatas() const
get number of selected edge rel datas
int getNumberOfSelectedCrossings() const
get number of selected crossings
GNEEdgeType * registerEdgeType(GNEEdgeType *edgeType)
registers a edge in GNENet containers
std::vector< GNEAdditional * > getSelectedShapes() const
get selected shapes
GNELane * retrieveLane(const std::string &id, bool hardFail=true, bool checkVolatileChange=false) const
get lane by id
std::map< SumoXMLTag, std::set< GNEDemandElement * > > myDemandElements
map with the tag and pointer to demand elements of net
Definition: GNENetHelper.h:678
const std::map< SumoXMLTag, std::set< GNEDemandElement * > > & getDemandElements() const
get demand elements
void insertDataSet(GNEDataSet *dataSet)
Insert a demand element element int GNENet container.
bool dataSetExist(GNEDataSet *dataSet) const
return true if given demand element exist
int getNumberOfSelectedRides() const
get number of selected rides
void clearDemandElements()
clear demand elements
void insertGenericData(GNEGenericData *genericData)
insert generic data
GNEEdge * registerEdge(GNEEdge *edge)
registers an edge with GNENet containers
bool demandElementExist(GNEDemandElement *demandElement) const
return true if given demand element exist
int getNumberOfSelectedPersonTrips() const
get number of selected person trips
std::string generateDemandElementID(SumoXMLTag tag) const
generate demand element id
void remapJunctionAndEdgeIds()
remap junction and edge IDs
std::vector< GNEAttributeCarrier * > retrieveAttributeCarriers(SumoXMLTag tag=SUMO_TAG_NOTHING)
get the attribute carriers based on Type
void clearEdgeTypes()
clear edgeTypes
std::map< std::string, GNEJunction * > myJunctions
map with the ID and pointer to junctions of net
Definition: GNENetHelper.h:654
int getNumberOfSelectedTranships() const
get number of selected tranships
int getNumberOfSelectedVehicles() const
get number of selected vehicles
int getNumberOfSelectedWalks() const
get number of selected walks
void deleteDemandElement(GNEDemandElement *demandElement)
delete demand element element of GNENet container
void deleteEdgeType(GNEEdgeType *edgeType)
deletes edgeType
std::string generateDataSetID(const std::string &prefix) const
generate data set id
void deleteConnection(GNEConnection *connection)
delete connection
void clearAdditionals()
clear additionals
GNEAdditional * retrieveAdditional(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named additional.
std::vector< GNEGenericData * > retrieveGenericDatas(const SumoXMLTag genericDataTag, const double begin, const double end)
retrieve generic datas within the given interval
int getStopIndex()
get (and update) stop index
std::set< std::string > retrieveGenericDataParameters(const std::string &genericDataTag, const double begin, const double end) const
return a set of parameters for the given data Interval
std::vector< GNEWalkingArea * > getSelectedWalkingAreas() const
return all selected walkingAreas
std::map< SumoXMLTag, std::set< GNEGenericData * > > myGenericDatas
map with the tag and pointer to all generic datas
Definition: GNENetHelper.h:687
GNENet * myNet
pointer to net
Definition: GNENetHelper.h:648
std::set< GNEConnection * > myConnections
set with connetions
Definition: GNENetHelper.h:672
void deleteSingleJunction(GNEJunction *junction)
deletes a single junction
GNEJunction * registerJunction(GNEJunction *junction)
registers a junction in GNENet containers
const std::set< GNEDataSet * > & getDataSets() const
get demand elements
int getNumberOfSelectedWalkingAreas() const
get number of selected walkingAreas
bool isNetworkElementAroundShape(GNEAttributeCarrier *AC, const PositionVector &shape) const
check if shape of given AC (network element) is around the given shape
GNEJunction * retrieveJunction(const std::string &id, bool hardFail=true) const
get junction by id
std::vector< GNEDemandElement * > getSelectedDemandElements() const
get selected demand elements
void updateJunctionID(GNEJunction *junction, const std::string &newID)
update junction ID in container
void deleteGenericData(GNEGenericData *genericData)
delete generic data
void insertCrossing(GNECrossing *crossing)
insert crossing
int getNumberOfSelectedWires() const
get number of selected Wires
GNEDataSet * retrieveDataSet(const std::string &id, bool hardFail=true) const
Returns the named data set.
int getNumberOfSelectedTAZs() const
get number of selected TAZs
void deleteWalkingArea(GNEWalkingArea *walkingArea)
delete walkingArea
int getNumberOfSelectedTransport() const
get number of selected transports
GNEDataInterval * retrieveDataInterval(GNEAttributeCarrier *AC, bool hardFail=true) const
Returns the data interval.
std::vector< GNELane * > getSelectedLanes() const
get selected lanes
void insertConnection(GNEConnection *connection)
insert connection
std::vector< GNEAdditional * > getSelectedAdditionals() const
get selected additionals
int getNumberOfSelectedJunctions() const
get number of selected junctions
const std::map< std::string, GNEEdge * > & getEdges() const
map with the ID and pointer to edges of net
int getNumberOfSelectedDemandElements() const
get number of selected demand elements
int getNumberOfSelectedPersons() const
get number of selected persons
int getNumberOfSelectedPureAdditionals() const
get number of selected pure additionals (Except POIs, Polygons, TAZs and Wires)
GNEEdgeType * retrieveEdgeType(const std::string &id, bool hardFail=true) const
get edge type by id
AttributeCarriers(const AttributeCarriers &)=delete
Invalidated copy constructor.
int getNumberOfSelectedRoutes() const
get number of selected routes
void addDefaultVTypes()
add default VTypes
int getNumberOfSelectedPOIs() const
get number of selected POIs
void deleteSingleEdge(GNEEdge *edge)
deletes a single edge
std::string generateAdditionalID(SumoXMLTag type) const
generate additional id
const std::set< GNEDataInterval * > & getDataIntervals() const
get all data intervals of network
void deleteAdditional(GNEAdditional *additional)
delete additional element of GNENet container
int getNumberOfDemandElements() const
Return the number of demand elements.
int getNumberOfSelectedPolygons() const
get number of selected polygons
std::vector< GNEJunction * > getSelectedJunctions() const
return selected junctions
int getNumberOfAdditionals() const
get number of additionals
const std::set< GNECrossing * > & getCrossings() const
get crossings
void insertDemandElement(GNEDemandElement *demandElement)
Insert a demand element element int GNENet container.
const std::map< SumoXMLTag, std::set< GNEAdditional * > > & getAdditionals() const
get additionals
void updateEdgeID(GNEEdge *edge, const std::string &newID)
update edge ID in container
std::map< std::string, GNEEdgeType * > myEdgeTypes
map with the ID and pointer to edgeTypes of net
Definition: GNENetHelper.h:663
std::vector< GNECrossing * > getSelectedCrossings() const
return all selected crossings
int getNumberOfSelectedLanes() const
get number of selected lanes
GNEAdditional * retrieveRerouterInterval(const std::string &rerouterID, const SUMOTime begin, const SUMOTime end) const
Returns the rerouter interval defined by given begin and end.
int getNumberOfSelectedEdgeDatas() const
get number of selected edge datas
void updateEdgeTypeID(GNEEdgeType *edgeType, const std::string &newID)
update edgeType ID in container
int getNumberOfSelectedTAZSources() const
get number of selected TAZSources
bool additionalExist(const GNEAdditional *additional) const
return true if given additional exist
void insertAdditional(GNEAdditional *additional)
Insert a additional element int GNENet container.
void insertEdgeType(GNEEdgeType *edgeType)
inserts a single edgeType into the net and into the underlying netbuild-container
GNEEdge * retrieveEdge(const std::string &id, bool hardFail=true) const
get edge by id
int getNumberOfSelectedEdgeTAZRel() const
get number of selected edge TAZ Rels
std::vector< GNEGenericData * > getSelectedGenericDatas() const
get selected generic datas
void deleteLane(GNELane *lane)
delete lane
std::set< GNELane * > myLanes
set with lanes
Definition: GNENetHelper.h:669
void insertJunction(GNEJunction *junction)
std::vector< GNEEdge * > getSelectedEdges() const
return all edges
std::map< SumoXMLTag, std::set< GNEAdditional * > > myAdditionals
map with the tag and pointer to additional elements of net
Definition: GNENetHelper.h:675
void insertDataInterval(GNEDataInterval *dataInterval)
insert data interval
int getNumberOfSelectedTAZSinks() const
get number of selected TAZSinks
const std::map< std::string, GNEJunction * > & getJunctions() const
get junctions
int getNumberOfSelectedEdges() const
get number of selected edges
const std::map< std::string, GNEEdgeType * > & getEdgeTypes() const
map with the ID and pointer to edgeTypes of net
GNECrossing * retrieveCrossing(GNEAttributeCarrier *AC, bool hardFail=true) const
get Crossing by AC
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
std::vector< GNEConnection * > getSelectedConnections() const
get selected connections
std::set< GNECrossing * > myCrossings
set with crossings
Definition: GNENetHelper.h:657
void clearJunctions()
clear junctions
std::set< GNEWalkingArea * > myWalkingAreas
set with walkingAreas
Definition: GNENetHelper.h:660
void deleteCrossing(GNECrossing *crossing)
delete crossing
GNEGenericData * retrieveGenericData(GNEAttributeCarrier *AC, bool hardFail=true) const
Returns the generic data.
GNEDemandElement * getDefaultType() const
get default type
bool edgeTypeExist(const GNEEdgeType *edgeType) const
std::map< std::string, GNEEdge * > myEdges
map with the ID and pointer to edges of net
Definition: GNENetHelper.h:666
GNEWalkingArea * retrieveWalkingArea(GNEAttributeCarrier *AC, bool hardFail=true) const
get WalkingArea by AC
AttributeCarriers & operator=(const AttributeCarriers &)=delete
Invalidated assignment operator.
std::set< GNEDataInterval * > myDataIntervals
set with all data intervals of network
Definition: GNENetHelper.h:684
std::vector< GNEAttributeCarrier * > getSelectedAttributeCarriers(const bool ignoreCurrentSupermode)
get all selected attribute carriers (or only relative to current supermode
std::set< GNEDataSet * > myDataSets
set with the ID and pointer to all datasets of net
Definition: GNENetHelper.h:681
int getNumberOfSelectedStops() const
get number of selected stops
AttributeCarriers(GNENet *net)
constructor
std::string generateEdgeTypeID() const
generate edgeType id
void deleteDataInterval(GNEDataInterval *dataInterval)
delete data interval
GNEConnection * retrieveConnection(const std::string &id, bool hardFail=true) const
get Connection by id
const std::set< GNEWalkingArea * > & getWalkingAreas() const
get walkingAreas
int getNumberOfSelectedContainers() const
get number of selected containers
class for GNEChange_ReplaceEdgeInTLS
Definition: GNENetHelper.h:697
std::string undoName() const
undo name
NBEdge * myBy
replaced by NBEdge
Definition: GNENetHelper.h:730
NBTrafficLightLogicCont & myTllcont
container for traffic light logic
Definition: GNENetHelper.h:724
GNEChange_ReplaceEdgeInTLS(NBTrafficLightLogicCont &tllcont, NBEdge *replaced, NBEdge *by)
constructor
std::string redoName() const
get Redo name
bool trueChange()
wether original and new value differ
A NBNetBuilder extended by visualisation and editing capabilities.
Definition: GNENet.h:42
Definition: GNEPOI.h:43
Builds trigger objects for GNENet (busStops, chargingStations, detectors, etc..)
This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routete...
The representation of a single edge during network building.
Definition: NBEdge.h:92
Instance responsible for building networks.
Definition: NBNetBuilder.h:107
A container for traffic light definitions and built programs.
A list of positions.