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 
45 class NBNetBuilder;
46 class GNEAdditional;
47 class GNEDataSet;
48 class GNEDemandElement;
51 class GNEConnection;
52 class GNECrossing;
53 class GNEJunction;
54 class GNEEdgeType;
55 class GNELaneType;
56 class GNEEdge;
57 class GNELane;
58 class GNENetworkElement;
59 class GNEPOI;
60 class GNEPoly;
61 class GNEShape;
62 class GNETAZElement;
63 class GNEUndoList;
64 class GNEViewNet;
65 
66 // ===========================================================================
67 // class definitions
68 // ===========================================================================
69 
70 struct GNENetHelper {
71 
74 
76  friend class GNEAdditionalHandler;
77  friend class GNERouteHandler;
78  friend class GNEDataHandler;
79  friend class GNEChange_Junction;
80  friend class GNEChange_EdgeType;
81  friend class GNEChange_Edge;
82  friend class GNEChange_Additional;
83  friend class GNEChange_Shape;
84  friend class GNEChange_TAZElement;
86  friend class GNEChange_DataSet;
87  friend class GNEChange_DataInterval;
88  friend class GNEChange_GenericData;
89 
90  public:
93 
96 
99 
101  bool isNetworkElementAroundShape(GNEAttributeCarrier* AC, const PositionVector& shape) const;
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 updateJunctionID(GNEJunction* junction, const std::string& newID);
149 
151  int getNumberOfSelectedJunctions() const;
152 
154 
157 
162  GNECrossing* retrieveCrossing(GNEAttributeCarrier* AC, bool hardFail = true) const;
163 
165  const std::set<GNECrossing*>& getCrossings() const;
166 
168  std::vector<GNECrossing*> getSelectedCrossings() const;
169 
171  void insertCrossing(GNECrossing* crossing);
172 
174  void deleteCrossing(GNECrossing* crossing);
175 
177  int getNumberOfSelectedCrossings() const;
178 
180 
183 
188  GNEEdgeType* retrieveEdgeType(const std::string& id, bool hardFail = true) const;
189 
192 
194  const std::map<std::string, GNEEdgeType*>& getEdgeTypes() const;
195 
197  void clearEdgeTypes();
198 
200  void updateEdgeTypeID(GNEEdgeType* edgeType, const std::string& newID);
201 
203  std::string generateEdgeTypeID() const;
204 
206 
209 
214  GNEEdge* retrieveEdge(const std::string& id, bool hardFail = true) const;
215 
221  GNEEdge* retrieveEdge(GNEJunction* from, GNEJunction* to, bool hardFail = true) const;
222 
224  const std::map<std::string, GNEEdge*>& getEdges() const;
225 
229  std::vector<GNEEdge*> getSelectedEdges() const;
230 
232  GNEEdge* registerEdge(GNEEdge* edge);
233 
235  void clearEdges();
236 
238  void updateEdgeID(GNEEdge* edge, const std::string& newID);
239 
241  int getNumberOfSelectedEdges() const;
242 
245 
251  GNELane* retrieveLane(const std::string& id, bool hardFail = true, bool checkVolatileChange = false) const;
252 
258  GNELane* retrieveLane(GNEAttributeCarrier* AC, bool hardFail = true) const;
259 
261  const std::set<GNELane*>& getLanes() const;
262 
264  std::vector<GNELane*> getSelectedLanes() const;
265 
267  void insertLane(GNELane* lane);
268 
270  void deleteLane(GNELane* lane);
271 
273  int getNumberOfSelectedLanes() const;
274 
276 
279 
284  GNEConnection* retrieveConnection(const std::string& id, bool hardFail = true) const;
285 
291  GNEConnection* retrieveConnection(GNEAttributeCarrier* AC, bool hardFail = true) const;
292 
294  const std::set<GNEConnection*>& getConnections() const;
295 
297  std::vector<GNEConnection*> getSelectedConnections() const;
298 
300  void insertConnection(GNEConnection* connection);
301 
303  void deleteConnection(GNEConnection* connection);
304 
306  int getNumberOfSelectedConnections() const;
307 
309 
312 
318  GNEAdditional* retrieveAdditional(SumoXMLTag type, const std::string& id, bool hardFail = true) const;
319 
324  GNEAdditional* retrieveAdditional(GNEAttributeCarrier* AC, bool hardFail = true) const;
325 
331  GNEAdditional* retrieveRerouterInterval(const std::string& rerouterID, const SUMOTime begin, const SUMOTime end) const;
332 
334  const std::map<SumoXMLTag, std::set<GNEAdditional*> >& getAdditionals() const;
335 
337  std::vector<GNEAdditional*> getSelectedAdditionals() const;
338 
340  int getNumberOfAdditionals() const;
341 
343  void clearAdditionals();
344 
346  int getNumberOfSelectedAdditionals() const;
347 
349  std::string generateAdditionalID(SumoXMLTag type) const;
350 
352 
355 
360  GNEShape* retrieveShape(SumoXMLTag, const std::string& id, bool hardFail = true) const;
361 
366  GNEShape* retrieveShape(GNEAttributeCarrier* AC, bool hardFail = true) const;
367 
369  std::vector<GNEShape*> getSelectedShapes();
370 
372  const std::map<SumoXMLTag, std::set<GNEShape*> >& getShapes() const;
373 
375  std::string generateShapeID(SumoXMLTag shapeTag) const;
376 
378  int getNumberOfShapes() const;
379 
381  void clearShapes();
382 
384  int getNumberOfSelectedPolygons() const;
385 
387  int getNumberOfSelectedPOIs() const;
388 
390 
393 
398  GNETAZElement* retrieveTAZElement(SumoXMLTag type, const std::string& id, bool hardFail = true) const;
399 
404  GNETAZElement* retrieveTAZElement(GNEAttributeCarrier* AC, bool hardFail = true) const;
405 
407  std::vector<GNETAZElement*> getSelectedTAZElements() const;
408 
410  const std::map<SumoXMLTag, std::set<GNETAZElement*> >& getTAZElements() const;
411 
413  void clearTAZElements();
414 
419  int getNumberOfTAZElements() const;
420 
422  int getNumberOfSelectedTAZs() const;
423 
425  bool TAZElementExist(const GNETAZElement* TAZElement) const;
426 
428  std::string generateTAZElementID(SumoXMLTag TAZElementTag) const;
429 
431 
434 
439  GNEDemandElement* retrieveDemandElement(SumoXMLTag type, const std::string& id, bool hardFail = true) const;
440 
445  GNEDemandElement* retrieveDemandElement(GNEAttributeCarrier* AC, bool hardFail = true) const;
446 
448  std::vector<GNEDemandElement*> getSelectedDemandElements() const;
449 
451  const std::map<SumoXMLTag, std::set<GNEDemandElement*> >& getDemandElements() const;
452 
454  int getNumberOfDemandElements() const;
455 
457  std::string generateDemandElementID(SumoXMLTag tag) const;
458 
461 
463  void clearDemandElements();
464 
466  void addDefaultVTypes();
467 
470 
472  int getNumberOfSelectedRoutes() const;
473 
475  int getNumberOfSelectedVehicles() const;
476 
478  int getNumberOfSelectedPersons() const;
479 
481  int getNumberOfSelectedPersonTrips() const;
482 
484  int getNumberOfSelectedWalks() const;
485 
487  int getNumberOfSelectedRides() const;
488 
490  int getNumberOfSelectedContainers() const;
491 
493  int getNumberOfSelectedTransport() const;
494 
496  int getNumberOfSelectedTranships() const;
497 
499  int getNumberOfSelectedStops() const;
500 
502 
505 
510  GNEDataSet* retrieveDataSet(const std::string& id, bool hardFail = true) const;
511 
516  GNEDataSet* retrieveDataSet(GNEAttributeCarrier* AC, bool hardFail = true) const;
517 
519  const std::set<GNEDataSet*>& getDataSets() const;
520 
522  std::string generateDataSetID(const std::string& prefix) const;
523 
525 
528 
532  GNEDataInterval* retrieveDataInterval(GNEAttributeCarrier* AC, bool hardFail = true) const;
533 
535  const std::set<GNEDataInterval*>& getDataIntervals() const;
536 
538  void insertDataInterval(GNEDataInterval* dataInterval);
539 
541  void deleteDataInterval(GNEDataInterval* dataInterval);
542 
544 
547 
551  GNEGenericData* retrieveGenericData(GNEAttributeCarrier* AC, bool hardFail = true) const;
552 
554  std::vector<GNEGenericData*> getSelectedGenericDatas() const;
555 
557  const std::map<SumoXMLTag, std::set<GNEGenericData*> >& getGenericDatas() const;
558 
560  std::vector<GNEGenericData*> retrieveGenericDatas(const SumoXMLTag genericDataTag, const double begin, const double end);
561 
563  int getNumberOfSelectedEdgeDatas() const;
564 
567 
569  int getNumberOfSelectedEdgeTAZRel() const;
570 
572  void insertGenericData(GNEGenericData* genericData);
573 
575  void deleteGenericData(GNEGenericData* genericData);
576 
578  std::set<std::string> retrieveGenericDataParameters(const std::string& genericDataTag, const double begin, const double end) const;
579 
581  std::set<std::string> retrieveGenericDataParameters(const std::string& dataSetID, const std::string& genericDataTag,
582  const std::string& beginStr, const std::string& endStr) const;
583 
585 
586  protected:
590  void insertJunction(GNEJunction* junction);
591 
593  void deleteSingleJunction(GNEJunction* junction);
594 
596 
600  bool edgeTypeExist(const GNEEdgeType* edgeType) const;
601 
603  void insertEdgeType(GNEEdgeType* edgeType);
604 
606  void deleteEdgeType(GNEEdgeType* edgeType);
607 
609 
613  void insertEdge(GNEEdge* edge);
614 
616  void deleteSingleEdge(GNEEdge* edge);
617 
619 
622 
624  bool additionalExist(const GNEAdditional* additional) const;
625 
629  void insertAdditional(GNEAdditional* additional);
630 
634  void deleteAdditional(GNEAdditional* additional);
635 
637 
640 
642  bool shapeExist(const GNEShape* shape) const;
643 
647  void insertShape(GNEShape* shape);
648 
652  void deleteShape(GNEShape* shape);
653 
656 
660  void insertTAZElement(GNETAZElement* TAZElement);
661 
665  void deleteTAZElement(GNETAZElement* TAZElement);
666 
668 
671 
673  bool demandElementExist(GNEDemandElement* demandElement) const;
674 
678  void insertDemandElement(GNEDemandElement* demandElement);
679 
683  void deleteDemandElement(GNEDemandElement* demandElement);
684 
686 
689 
691  bool dataSetExist(GNEDataSet* dataSet) const;
692 
696  void insertDataSet(GNEDataSet* dataSet);
697 
701  void deleteDataSet(GNEDataSet* dataSet);
702 
704 
705  private:
708 
710  std::map<std::string, GNEJunction*> myJunctions;
711 
713  std::set<GNECrossing*> myCrossings;
714 
716  std::map<std::string, GNEEdgeType*> myEdgeTypes;
717 
719  std::map<std::string, GNEEdge*> myEdges;
720 
722  std::set<GNELane*> myLanes;
723 
725  std::set<GNEConnection*> myConnections;
726 
728  std::map<SumoXMLTag, std::set<GNEAdditional*> > myAdditionals;
729 
731  std::map<SumoXMLTag, std::set<GNEShape*> > myShapes;
732 
734  std::map<SumoXMLTag, std::set<GNETAZElement*> > myTAZElements;
735 
737  std::map<SumoXMLTag, std::set<GNEDemandElement*> > myDemandElements;
738 
740  std::set<GNEDataSet*> myDataSets;
741 
743  std::set<GNEDataInterval*> myDataIntervals;
744 
746  std::map<SumoXMLTag, std::set<GNEGenericData*> > myGenericDatas;
747 
750 
753  };
754 
757  FXDECLARE_ABSTRACT(GNEChange_ReplaceEdgeInTLS)
758 
759  public:
762 
765 
767  void undo();
768 
770  void redo();
771 
773  std::string undoName() const;
774 
776  std::string redoName() const;
777 
779  bool trueChange();
780 
781  private:
784 
787 
790  };
791 };
Supermode
@brie enum for supermodes
unsigned int GUIGlID
Definition: GUIGlObject.h:40
long long int SUMOTime
Definition: SUMOTime.h:32
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 belongs to GNENet but has influency 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:64
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 belongs to GNENet but has influency in the simulation.
An Element which don't belongs to GNENet but has influency in the simulation.
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:53
An Element which don't belongs to GNENet but has influency 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:73
AttributeCarriers & operator=(const AttributeCarriers &)=delete
Invalidated assignment operator.
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
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
GNETAZElement * retrieveTAZElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named TAZElement.
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
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:737
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 getNumberOfTAZElements() const
Returns the number of TAZElements of the net.
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
GNEShape * retrieveShape(SumoXMLTag, const std::string &id, bool hardFail=true) const
Returns the named shape.
void deleteShape(GNEShape *shape)
delete shape element of GNENet container
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:710
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
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::map< SumoXMLTag, std::set< GNEGenericData * > > myGenericDatas
map with the tag and pointer to all generic datas
Definition: GNENetHelper.h:746
GNENet * myNet
pointer to net
Definition: GNENetHelper.h:707
std::set< GNEConnection * > myConnections
set with connetions
Definition: GNENetHelper.h:725
void deleteSingleJunction(GNEJunction *junction)
deletes a single junction
void insertShape(GNEShape *shape)
Insert a shape element int GNENet container.
GNEJunction * registerJunction(GNEJunction *junction)
registers a junction in GNENet containers
const std::set< GNEDataSet * > & getDataSets() const
get demand elements
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
GNEDataSet * retrieveDataSet(const std::string &id, bool hardFail=true) const
Returns the named data set.
int getNumberOfSelectedTAZs() const
get number of selected TAZs
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
void deleteTAZElement(GNETAZElement *TAZElement)
delete TAZElement element of GNENet container
std::string generateTAZElementID(SumoXMLTag TAZElementTag) const
generate TAZElement ID
int getNumberOfSelectedDemandElements() const
get number of selected demand elements
int getNumberOfSelectedPersons() const
get number of selected persons
GNEEdgeType * retrieveEdgeType(const std::string &id, bool hardFail=true) const
get edge type by id
std::map< SumoXMLTag, std::set< GNEShape * > > myShapes
map with the tag and pointer to shape elements of net
Definition: GNENetHelper.h:731
AttributeCarriers(const AttributeCarriers &)=delete
Invalidated copy constructor.
int getNumberOfSelectedRoutes() const
get number of selected routes
void addDefaultVTypes()
add default VTypes
int getNumberOfShapes() const
Returns the number of shapes.
int getNumberOfSelectedPOIs() const
get number of selected POIs
void deleteSingleEdge(GNEEdge *edge)
deletes a single edge
const std::map< SumoXMLTag, std::set< GNETAZElement * > > & getTAZElements() const
get TAZElements
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
std::vector< GNETAZElement * > getSelectedTAZElements() const
get selected TAZElements
std::string generateShapeID(SumoXMLTag shapeTag) const
generate Shape ID
const std::map< SumoXMLTag, std::set< GNEShape * > > & getShapes() const
get shapes
int getNumberOfAdditionals() const
get number of additonals
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
std::vector< GNEShape * > getSelectedShapes()
get selected shapes
void clearTAZElements()
clear TAZElements
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:716
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
std::map< SumoXMLTag, std::set< GNETAZElement * > > myTAZElements
map with the tag and pointer to TAZElement elements of net
Definition: GNENetHelper.h:734
bool additionalExist(const GNEAdditional *additional) const
return true if given additional exist
bool shapeExist(const GNEShape *shape) const
return true if given shape exist
void insertTAZElement(GNETAZElement *TAZElement)
Insert a TAZElement element int GNENet container.
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:722
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:728
void insertDataInterval(GNEDataInterval *dataInterval)
insert data interval
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
bool TAZElementExist(const GNETAZElement *TAZElement) const
return true if given TAZElement exist
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:713
void clearJunctions()
clear junctions
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:719
std::set< GNEDataInterval * > myDataIntervals
set with all data intervals of network
Definition: GNENetHelper.h:743
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:740
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
int getNumberOfSelectedContainers() const
get number of selected containers
class for GNEChange_ReplaceEdgeInTLS
Definition: GNENetHelper.h:756
std::string undoName() const
undo name
NBEdge * myBy
replaced by NBEdge
Definition: GNENetHelper.h:789
NBTrafficLightLogicCont & myTllcont
container for traffic light logic
Definition: GNENetHelper.h:783
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..)
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNETAZElement.h:45
The representation of a single edge during network building.
Definition: NBEdge.h:91
Instance responsible for building networks.
Definition: NBNetBuilder.h:107
A container for traffic light definitions and built programs.
A list of positions.