Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
GNENetHelper.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 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 GNEMeanData;
57class GNEEdge;
58class GNELane;
60class GNEPOI;
61class GNEPoly;
62class GNEUndoList;
63class GNEViewNet;
64
65// ===========================================================================
66// class definitions
67// ===========================================================================
68
70
73
76 friend class GNERouteHandler;
77 friend class GNEDataHandler;
78 friend class GNEChange_Junction;
79 friend class GNEChange_EdgeType;
80 friend class GNEChange_Edge;
82 friend class GNEChange_Shape;
85 friend class GNEChange_DataSet;
88 friend class GNEChange_MeanData;
89
90 public:
93
96
99
102
105
111 GNEAttributeCarrier* retrieveAttributeCarrier(const GUIGlID id, bool hardFail = true) const;
112
116 std::vector<GNEAttributeCarrier*> retrieveAttributeCarriers(SumoXMLTag tag = SUMO_TAG_NOTHING);
117
119 std::vector<GNEAttributeCarrier*> retrieveAttributeCarriers(Supermode supermode, const bool onlySelected);
120
122 std::vector<GNEAttributeCarrier*> getSelectedAttributeCarriers(const bool ignoreCurrentSupermode);
123
125
128
133 GNEJunction* retrieveJunction(const std::string& id, bool hardFail = true) const;
134
136 const std::map<std::string, GNEJunction*>& getJunctions() const;
137
139 std::vector<GNEJunction*> getSelectedJunctions() const;
140
143
145 void clearJunctions();
146
148 void addPrefixToJunctions(const std::string& prefix);
149
151 void updateJunctionID(GNEJunction* junction, const std::string& newID);
152
155
157
160
165 GNECrossing* retrieveCrossing(GNEAttributeCarrier* AC, bool hardFail = true) const;
166
168 const std::set<GNECrossing*>& getCrossings() const;
169
171 std::vector<GNECrossing*> getSelectedCrossings() const;
172
174 void insertCrossing(GNECrossing* crossing);
175
177 void deleteCrossing(GNECrossing* crossing);
178
181
183
186
191 GNEWalkingArea* retrieveWalkingArea(GNEAttributeCarrier* AC, bool hardFail = true) const;
192
194 const std::set<GNEWalkingArea*>& getWalkingAreas() const;
195
197 std::vector<GNEWalkingArea*> getSelectedWalkingAreas() const;
198
200 void insertWalkingArea(GNEWalkingArea* walkingArea);
201
203 void deleteWalkingArea(GNEWalkingArea* walkingArea);
204
207
209
212
217 GNEEdgeType* retrieveEdgeType(const std::string& id, bool hardFail = true) const;
218
221
223 const std::map<std::string, GNEEdgeType*>& getEdgeTypes() const;
224
226 void clearEdgeTypes();
227
229 void updateEdgeTypeID(GNEEdgeType* edgeType, const std::string& newID);
230
232 std::string generateEdgeTypeID() const;
233
235
238
243 GNEEdge* retrieveEdge(const std::string& id, bool hardFail = true) const;
244
250 std::vector<GNEEdge*> retrieveEdges(GNEJunction* from, GNEJunction* to) const;
251
253 const std::map<std::string, GNEEdge*>& getEdges() const;
254
258 std::vector<GNEEdge*> getSelectedEdges() const;
259
262
264 void clearEdges();
265
267 void addPrefixToEdges(const std::string& prefix);
268
270 void updateEdgeID(GNEEdge* edge, const std::string& newID);
271
273 int getNumberOfSelectedEdges() const;
274
276
279
285 GNELane* retrieveLane(const std::string& id, bool hardFail = true, bool checkVolatileChange = false) const;
286
292 GNELane* retrieveLane(GNEAttributeCarrier* AC, bool hardFail = true) const;
293
295 const std::set<GNELane*>& getLanes() const;
296
298 std::vector<GNELane*> getSelectedLanes() const;
299
301 void insertLane(GNELane* lane);
302
304 void deleteLane(GNELane* lane);
305
307 int getNumberOfSelectedLanes() const;
308
310
313
318 GNEConnection* retrieveConnection(const std::string& id, bool hardFail = true) const;
319
325 GNEConnection* retrieveConnection(GNEAttributeCarrier* AC, bool hardFail = true) const;
326
328 const std::set<GNEConnection*>& getConnections() const;
329
331 std::vector<GNEConnection*> getSelectedConnections() const;
332
334 void insertConnection(GNEConnection* connection);
335
337 void deleteConnection(GNEConnection* connection);
338
341
343
346
352 GNEAdditional* retrieveAdditional(SumoXMLTag type, const std::string& id, bool hardFail = true) const;
353
358 GNEAdditional* retrieveAdditional(GNEAttributeCarrier* AC, bool hardFail = true) const;
359
365 GNEAdditional* retrieveRerouterInterval(const std::string& rerouterID, const SUMOTime begin, const SUMOTime end) const;
366
368 const std::map<SumoXMLTag, std::set<GNEAdditional*> >& getAdditionals() const;
369
371 std::vector<GNEAdditional*> getSelectedAdditionals() const;
372
374 std::vector<GNEAdditional*> getSelectedShapes() const;
375
377 int getNumberOfAdditionals() const;
378
380 void clearAdditionals();
381
383 std::string generateAdditionalID(SumoXMLTag type) const;
384
387
390
392 int getNumberOfSelectedPolygons() const;
393
395 int getNumberOfSelectedPOIs() const;
396
398 int getNumberOfSelectedTAZs() const;
399
402
404 int getNumberOfSelectedTAZSinks() const;
405
407 int getNumberOfSelectedWires() const;
408
410
413
418 GNEDemandElement* retrieveDemandElement(SumoXMLTag type, const std::string& id, bool hardFail = true) const;
419
424 GNEDemandElement* retrieveDemandElement(GNEAttributeCarrier* AC, bool hardFail = true) const;
425
430
432 std::vector<GNEDemandElement*> getSelectedDemandElements() const;
433
435 const std::map<SumoXMLTag, std::set<GNEDemandElement*> >& getDemandElements() const;
436
438 int getNumberOfDemandElements() const;
439
441 std::string generateDemandElementID(SumoXMLTag tag) const;
442
445
447 void clearDemandElements();
448
450 void addDefaultVTypes();
451
453 int getStopIndex();
454
457
459 int getNumberOfSelectedRoutes() const;
460
462 int getNumberOfSelectedVehicles() const;
463
465 int getNumberOfSelectedPersons() const;
466
469
471 int getNumberOfSelectedWalks() const;
472
474 int getNumberOfSelectedRides() const;
475
478
481
484
486 int getNumberOfSelectedStops() const;
487
489
492
497 GNEDataSet* retrieveDataSet(const std::string& id, bool hardFail = true) const;
498
503 GNEDataSet* retrieveDataSet(GNEAttributeCarrier* AC, bool hardFail = true) const;
504
506 const std::set<GNEDataSet*>& getDataSets() const;
507
509 std::string generateDataSetID(const std::string& prefix) const;
510
512
515
519 GNEDataInterval* retrieveDataInterval(GNEAttributeCarrier* AC, bool hardFail = true) const;
520
522 const std::set<GNEDataInterval*>& getDataIntervals() const;
523
525 void insertDataInterval(GNEDataInterval* dataInterval);
526
528 void deleteDataInterval(GNEDataInterval* dataInterval);
529
531
534
538 GNEGenericData* retrieveGenericData(GNEAttributeCarrier* AC, bool hardFail = true) const;
539
541 std::vector<GNEGenericData*> getSelectedGenericDatas() const;
542
544 const std::map<SumoXMLTag, std::set<GNEGenericData*> >& getGenericDatas() const;
545
547 std::vector<GNEGenericData*> retrieveGenericDatas(const SumoXMLTag genericDataTag, const double begin, const double end);
548
550 int getNumberOfGenericDatas() const;
551
554
557
560
562 void insertGenericData(GNEGenericData* genericData);
563
565 void deleteGenericData(GNEGenericData* genericData);
566
568 std::set<std::string> retrieveGenericDataParameters(const std::string& genericDataTag, const double begin, const double end) const;
569
571 std::set<std::string> retrieveGenericDataParameters(const std::string& dataSetID, const std::string& genericDataTag,
572 const std::string& beginStr, const std::string& endStr) const;
573
575
578
584 GNEMeanData* retrieveMeanData(SumoXMLTag type, const std::string& id, bool hardFail = true) const;
585
590 GNEMeanData* retrieveMeanData(GNEAttributeCarrier* AC, bool hardFail = true) const;
591
593 const std::map<SumoXMLTag, std::set<GNEMeanData*> >& getMeanDatas() const;
594
596 int getNumberOfMeanDatas() const;
597
599 void clearMeanDatas();
600
602 std::string generateMeanDataID(SumoXMLTag type) const;
603
605
606 protected:
610 void insertJunction(GNEJunction* junction);
611
613 void deleteSingleJunction(GNEJunction* junction);
614
616
620 bool edgeTypeExist(const GNEEdgeType* edgeType) const;
621
623 void insertEdgeType(GNEEdgeType* edgeType);
624
626 void deleteEdgeType(GNEEdgeType* edgeType);
627
629
633 void insertEdge(GNEEdge* edge);
634
636 void deleteSingleEdge(GNEEdge* edge);
637
639
642
644 bool additionalExist(const GNEAdditional* additional) const;
645
649 void insertAdditional(GNEAdditional* additional);
650
654 void deleteAdditional(GNEAdditional* additional);
655
657
660
662 bool demandElementExist(GNEDemandElement* demandElement) const;
663
667 void insertDemandElement(GNEDemandElement* demandElement);
668
672 void deleteDemandElement(GNEDemandElement* demandElement, const bool updateFrames);
673
675
678
680 bool dataSetExist(GNEDataSet* dataSet) const;
681
685 void insertDataSet(GNEDataSet* dataSet);
686
690 void deleteDataSet(GNEDataSet* dataSet);
691
693
696
698 bool meanDataExist(const GNEMeanData* meanData) const;
699
703 void insertMeanData(GNEMeanData* meanData);
704
708 void deleteMeanData(GNEMeanData* meanData);
709
711
713 void updateDemandElementFrames(const GNETagProperties& tagProperty);
714
715 private:
718
721
723 std::map<std::string, GNEJunction*> myJunctions;
724
726 std::set<GNECrossing*> myCrossings;
727
729 std::set<GNEWalkingArea*> myWalkingAreas;
730
732 std::map<std::string, GNEEdgeType*> myEdgeTypes;
733
735 std::map<std::string, GNEEdge*> myEdges;
736
738 std::set<GNELane*> myLanes;
739
741 std::set<GNEConnection*> myConnections;
742
744 std::map<SumoXMLTag, std::set<GNEAdditional*> > myAdditionals;
745
747 std::map<SumoXMLTag, std::set<GNEDemandElement*> > myDemandElements;
748
750 std::set<GNEDataSet*> myDataSets;
751
753 std::set<GNEDataInterval*> myDataIntervals;
754
756 std::map<SumoXMLTag, std::set<GNEGenericData*> > myGenericDatas;
757
759 std::map<SumoXMLTag, std::set<GNEMeanData*> > myMeanDatas;
760
763
766 };
767
770
771 public:
773 SavingStatus();
774
777
780
782 void SumoConfigSaved();
783
785 bool isSumoConfigSaved() const;
786
788
791
794
796 void neteditConfigSaved();
797
799 bool isNeteditConfigSaved() const;
800
802
805
807 void requireSaveNetwork();
808
810 void networkSaved();
811
813 bool isNetworkSaved() const;
814
816
819
821 void requireSaveTLS();
822
824 void TLSSaved();
825
827 bool isTLSSaved() const;
828
830
833
835 void requireSaveEdgeType();
836
838 void edgeTypeSaved();
839
841 bool isEdgeTypeSaved() const;
842
844
847
850
852 void additionalsSaved();
853
855 bool isAdditionalsSaved() const;
856
858
861
864
866 void demandElementsSaved();
867
869 bool isDemandElementsSaved() const;
870
872
875
878
880 void dataElementsSaved();
881
883 bool isDataElementsSaved() const;
884
886
889
892
894 void meanDatasSaved();
895
897 bool isMeanDatasSaved() const;
898
900
901 private:
903 bool mySumoConfigSaved = true;
904
907
909 bool myNetworkSaved = true;
910
912 bool myTLSSaved = true;
913
915 bool myEdgeTypeSaved = true;
916
918 bool myAdditionalSaved = true;
919
922
925
928
930 SavingStatus(const SavingStatus&) = delete;
931
934 };
935
938 FXDECLARE_ABSTRACT(GNEChange_ReplaceEdgeInTLS)
939
940 public:
943
946
948 void undo();
949
951 void redo();
952
954 std::string undoName() const;
955
957 std::string redoName() const;
958
960 bool trueChange();
961
962 private:
965
968
971 };
972};
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.
The main window of Netedit.
the function-object for an editing operation (abstract base)
Definition GNEChange.h:56
This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routete...
Definition GNECrossing.h:44
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
An Element which don't belong to GNENet but has influence in the simulation.
Definition GNEMeanData.h:33
struct used for saving all attribute carriers of net, in different formats
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 addPrefixToJunctions(const std::string &prefix)
add prefix to all junctions
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
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
void deleteDemandElement(GNEDemandElement *demandElement, const bool updateFrames)
delete demand element element of GNENet container
int getNumberOfSelectedPersonTrips() const
get number of selected person trips
std::string generateDemandElementID(SumoXMLTag tag) const
generate demand element id
int getNumberOfMeanDatas() const
get number of meanDatas
void addPrefixToEdges(const std::string &prefix)
add prefix to all edges
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
int getNumberOfSelectedTranships() const
get number of selected tranships
const std::map< SumoXMLTag, std::set< GNEMeanData * > > & getMeanDatas() const
get meanDatas
int getNumberOfSelectedVehicles() const
get number of selected vehicles
int getNumberOfSelectedWalks() const
get number of selected walks
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
GNENet * myNet
pointer to net
std::set< GNEConnection * > myConnections
set with connetions
void deleteSingleJunction(GNEJunction *junction)
deletes a single junction
GNEMeanData * retrieveMeanData(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named meanData.
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
GNEDemandElement * retrieveFirstDemandElement(SumoXMLTag type) const
Returns the first demand element sorted by ID (or null if type is empty)
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
std::string generateMeanDataID(SumoXMLTag type) const
generate meanData id
void insertMeanData(GNEMeanData *meanData)
Insert a meanData element int GNENet container.
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 getNumberOfGenericDatas() const
Return the number of generic datas.
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.
void deleteMeanData(GNEMeanData *meanData)
delete meanData element of GNENet container
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
std::vector< GNECrossing * > getSelectedCrossings() const
return all selected crossings
std::map< SumoXMLTag, std::set< GNEMeanData * > > myMeanDatas
map with the tag and pointer to meanData elements of net
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
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
void insertDataInterval(GNEDataInterval *dataInterval)
insert data interval
int getNumberOfSelectedTAZSinks() const
get number of selected TAZSinks
void updateDemandElementFrames(const GNETagProperties &tagProperty)
update demand element frames (called after insert/delete demand element)
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
void clearMeanDatas()
clear meanDatas
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
void clearJunctions()
clear junctions
std::set< GNEWalkingArea * > myWalkingAreas
set with walkingAreas
bool meanDataExist(const GNEMeanData *meanData) const
return true if given meanData exist
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
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
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
int getNumberOfSelectedStops() const
get number of selected stops
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
std::string undoName() const
undo name
NBTrafficLightLogicCont & myTllcont
container for traffic light logic
std::string redoName() const
get Redo name
bool trueChange()
wether original and new value differ
modul for Saving status
void requireSaveTLS()
inform that TLS has to be saved
void dataElementsSaved()
mark demand elements as saved
SavingStatus & operator=(const SavingStatus &)=delete
Invalidated assignment operator.
bool isEdgeTypeSaved() const
check if edgeType are saved
bool myNetworkSaved
flag for network saved
void requireSaveNetwork()
inform that network has to be saved
void requireSaveEdgeType()
inform that edgeType has to be saved
bool isTLSSaved() const
check if TLS are saved
void demandElementsSaved()
mark demand elements as saved
bool myAdditionalSaved
flag for additional elements saved
bool myTLSSaved
flag for TLS saved
bool myNeteditConfigSaved
flag for netedit config saved
bool myDataElementSaved
flag for data elements saved
void SumoConfigSaved()
mark SumoConfig as saved
bool myEdgeTypeSaved
flag for edgeType saved
void additionalsSaved()
mark additionals as saved
void requireSaveNeteditConfig()
inform that netedit config has to be saved
void requireSaveSumoConfig()
inform that SumoConfig has to be saved
bool mySumoConfigSaved
flag for SumoConfigSumoConfig saved
SavingStatus(const SavingStatus &)=delete
Invalidated copy constructor.
void TLSSaved()
mark TLS as saved
bool myMeanDataElementSaved
flag for meanData elements saved
bool isSumoConfigSaved() const
check if SumoConfig is saved
void neteditConfigSaved()
mark netedit config as saved
void requireSaveMeanDatas()
inform that mean data elements has to be saved
void meanDatasSaved()
mark mean data elements as saved
bool isDemandElementsSaved() const
check if demand elements are saved
void requireSaveAdditionals()
inform that additionals has to be saved
bool myDemandElementSaved
flag for demand elements saved
bool isDataElementsSaved() const
check if data elements are saved
bool isNetworkSaved() const
check if network is saved
bool isMeanDatasSaved() const
check if mean data elements are saved
void requireSaveDataElements()
inform that data elements has to be saved
bool isNeteditConfigSaved() const
check if netedit config is saved
void networkSaved()
mark network as saved
bool isAdditionalsSaved() const
check if additionals are saved
void requireSaveDemandElements()
inform that demand elements has to be saved
void edgeTypeSaved()
mark edgeType as saved
A NBNetBuilder extended by visualisation and editing capabilities.
Definition GNENet.h:42
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.
A container for traffic light definitions and built programs.
A list of positions.