Eclipse SUMO - Simulation of Urban MObility
GNEChange_Edge.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
14 // A network change in which a single junction is created or deleted
15 /****************************************************************************/
16 
17 // ===========================================================================
18 // included modules
19 // ===========================================================================
20 #include <config.h>
21 
22 #include <netedit/GNENet.h>
28 
29 
30 #include "GNEChange_Edge.h"
31 
32 // ===========================================================================
33 // FOX-declarations
34 // ===========================================================================
35 FXIMPLEMENT_ABSTRACT(GNEChange_Edge, GNEChange, nullptr, 0)
36 
37 // ===========================================================================
38 // member method definitions
39 // ===========================================================================
40 
41 
42 GNEChange_Edge::GNEChange_Edge(GNEEdge* edge, bool forward):
44  GNEChange(edge->getNet(), forward),
45  myEdge(edge),
46  myEdgeParentShapes(edge->getParentShapes()),
47  myEdgeParentAdditionals(edge->getParentAdditionals()),
48  myEdgeParentDemandElements(edge->getParentDemandElements()),
49  myChildEdgeShapes(edge->getChildShapes()),
50  myChildEdgeAdditionals(edge->getChildAdditionals()),
51  myChildEdgeDemandElements(edge->getChildDemandElements()) {
52  // now save all hierarchical elements of edge's lane
53  for (const auto& i : edge->getLanes()) {
54  myLaneParentShapes.push_back(i->getParentShapes());
55  myLaneParentAdditionals.push_back(i->getParentAdditionals());
56  myLaneParentDemandElements.push_back(i->getParentDemandElements());
57  myChildLaneShapes.push_back(i->getChildShapes());
58  myChildLaneAdditionals.push_back(i->getChildAdditionals());
59  myChildLaneDemandElements.push_back(i->getChildDemandElements());
60  }
61 
62  edge->incRef("GNEChange_Edge");
63 }
64 
65 
67  assert(myEdge);
68  myEdge->decRef("GNEChange_Edge");
69  if (myEdge->unreferenced()) {
70  // show extra information for tests
71  WRITE_DEBUG("Deleting unreferenced " + myEdge->getTagStr() + " '" + myEdge->getID() + "' GNEChange_Edge");
72  delete myEdge;
73  }
74 }
75 
76 
77 void
79  if (myForward) {
80  // show extra information for tests
81  WRITE_DEBUG("Removing " + myEdge->getTagStr() + " '" + myEdge->getID() + "' from " + toString(SUMO_TAG_NET));
82  // Remove edge from parent elements
83  for (const auto& i : myEdgeParentShapes) {
84  i->removeChildEdge(myEdge);
85  }
86  for (const auto& i : myEdgeParentAdditionals) {
87  i->removeChildEdge(myEdge);
88  }
89  for (const auto& i : myEdgeParentDemandElements) {
90  i->removeChildEdge(myEdge);
91  }
92  // Remove edge from child elements
93  for (const auto& i : myChildEdgeShapes) {
94  i->removeParentEdge(myEdge);
95  }
96  for (const auto& i : myChildEdgeAdditionals) {
97  i->removeParentEdge(myEdge);
98  }
99  for (const auto& i : myChildEdgeDemandElements) {
100  i->removeParentEdge(myEdge);
101  }
102  // repeat operations for all lane's edge
103  for (int i = 0; i < (int)myEdge->getLanes().size(); i++) {
104  // Remove every lane's edge from parent elements
105  for (const auto& j : myLaneParentShapes.at(i)) {
106  j->removeChildLane(myEdge->getLanes().at(i));
107  }
108  for (const auto& j : myLaneParentAdditionals.at(i)) {
109  j->removeChildLane(myEdge->getLanes().at(i));
110  }
111  for (const auto& j : myLaneParentDemandElements.at(i)) {
112  j->removeChildLane(myEdge->getLanes().at(i));
113  }
114  // Remove every lane's edge from child elements
115  for (const auto& j : myChildLaneShapes.at(i)) {
116  j->removeParentLane(myEdge->getLanes().at(i));
117  }
118  for (const auto& j : myChildLaneAdditionals.at(i)) {
119  j->removeParentLane(myEdge->getLanes().at(i));
120  }
121  for (const auto& j : myChildLaneDemandElements.at(i)) {
122  j->removeParentLane(myEdge->getLanes().at(i));
123  }
124  }
125  // delete edge from net
126  myNet->deleteSingleEdge(myEdge, false);
127  } else {
128  // show extra information for tests
129  WRITE_DEBUG("Adding " + myEdge->getTagStr() + " '" + myEdge->getID() + "' from " + toString(SUMO_TAG_NET));
130  // insert edge into net
132  // add edge in parent elements
133  for (const auto& i : myEdgeParentShapes) {
134  i->addChildEdge(myEdge);
135  }
136  for (const auto& i : myEdgeParentAdditionals) {
137  i->addChildEdge(myEdge);
138  }
139  for (const auto& i : myEdgeParentDemandElements) {
140  i->addChildEdge(myEdge);
141  }
142  // add edge in child elements
143  for (const auto& i : myChildEdgeShapes) {
144  i->addParentEdge(myEdge);
145  }
146  for (const auto& i : myChildEdgeAdditionals) {
147  i->addParentEdge(myEdge);
148  }
149  for (const auto& i : myChildEdgeDemandElements) {
150  i->addParentEdge(myEdge);
151  }
152  // repeat operations for all lane's edge
153  for (int i = 0; i < (int)myEdge->getLanes().size(); i++) {
154  // add lane's edge in parent elements
155  for (const auto& j : myLaneParentShapes.at(i)) {
156  j->addChildLane(myEdge->getLanes().at(i));
157  }
158  for (const auto& j : myLaneParentAdditionals.at(i)) {
159  j->addChildLane(myEdge->getLanes().at(i));
160  }
161  for (const auto& j : myLaneParentDemandElements.at(i)) {
162  j->addChildLane(myEdge->getLanes().at(i));
163  }
164  // add lane's edge in child elements
165  for (const auto& j : myChildLaneShapes.at(i)) {
166  j->addParentLane(myEdge->getLanes().at(i));
167  }
168  for (const auto& j : myChildLaneAdditionals.at(i)) {
169  j->addParentLane(myEdge->getLanes().at(i));
170  }
171  for (const auto& j : myChildLaneDemandElements.at(i)) {
172  j->addParentLane(myEdge->getLanes().at(i));
173  }
174  }
175  }
176  // enable save netElements
177  myNet->requireSaveNet(true);
178 }
179 
180 
181 void
183  if (myForward) {
184  // show extra information for tests
185  WRITE_DEBUG("Adding " + myEdge->getTagStr() + " '" + myEdge->getID() + "' from " + toString(SUMO_TAG_NET));
186  // insert edge into net
188  // add edge in parent elements
189  for (const auto& i : myEdgeParentShapes) {
190  i->addChildEdge(myEdge);
191  }
192  for (const auto& i : myEdgeParentAdditionals) {
193  i->addChildEdge(myEdge);
194  }
195  for (const auto& i : myEdgeParentDemandElements) {
196  i->addChildEdge(myEdge);
197  }
198  // add edge in child elements
199  for (const auto& i : myChildEdgeShapes) {
200  i->addParentEdge(myEdge);
201  }
202  for (const auto& i : myChildEdgeAdditionals) {
203  i->addParentEdge(myEdge);
204  }
205  for (const auto& i : myChildEdgeDemandElements) {
206  i->addParentEdge(myEdge);
207  }
208  // repeat operations for all lane's edge
209  for (int i = 0; i < (int)myEdge->getLanes().size(); i++) {
210  // add lane's edge in parent elements
211  for (const auto& j : myLaneParentShapes.at(i)) {
212  j->addChildLane(myEdge->getLanes().at(i));
213  }
214  for (const auto& j : myLaneParentAdditionals.at(i)) {
215  j->addChildLane(myEdge->getLanes().at(i));
216  }
217  for (const auto& j : myLaneParentDemandElements.at(i)) {
218  j->addChildLane(myEdge->getLanes().at(i));
219  }
220  // add lane's edge in child elements
221  for (const auto& j : myChildLaneShapes.at(i)) {
222  j->addParentLane(myEdge->getLanes().at(i));
223  }
224  for (const auto& j : myChildLaneAdditionals.at(i)) {
225  j->addParentLane(myEdge->getLanes().at(i));
226  }
227  for (const auto& j : myChildLaneDemandElements.at(i)) {
228  j->addParentLane(myEdge->getLanes().at(i));
229  }
230  }
231  } else {
232  // show extra information for tests
233  WRITE_DEBUG("Removing " + myEdge->getTagStr() + " '" + myEdge->getID() + "' from " + toString(SUMO_TAG_NET));
234  // Remove edge from parent elements
235  for (const auto& i : myEdgeParentShapes) {
236  i->removeChildEdge(myEdge);
237  }
238  for (const auto& i : myEdgeParentAdditionals) {
239  i->removeChildEdge(myEdge);
240  }
241  for (const auto& i : myEdgeParentDemandElements) {
242  i->removeChildEdge(myEdge);
243  }
244  // Remove edge from child elements
245  for (const auto& i : myChildEdgeShapes) {
246  i->removeParentEdge(myEdge);
247  }
248  for (const auto& i : myChildEdgeAdditionals) {
249  i->removeParentEdge(myEdge);
250  }
251  for (const auto& i : myChildEdgeDemandElements) {
252  i->removeParentEdge(myEdge);
253  }
254  // repeat operations for all lane's edge
255  for (int i = 0; i < (int)myEdge->getLanes().size(); i++) {
256  // Remove every lane's edge from parent elements
257  for (const auto& j : myLaneParentShapes.at(i)) {
258  j->removeChildLane(myEdge->getLanes().at(i));
259  }
260  for (const auto& j : myLaneParentAdditionals.at(i)) {
261  j->removeChildLane(myEdge->getLanes().at(i));
262  }
263  for (const auto& j : myLaneParentDemandElements.at(i)) {
264  j->removeChildLane(myEdge->getLanes().at(i));
265  }
266  // Remove every lane's edge from child elements
267  for (const auto& j : myChildLaneShapes.at(i)) {
268  j->removeParentLane(myEdge->getLanes().at(i));
269  }
270  for (const auto& j : myChildLaneAdditionals.at(i)) {
271  j->removeParentLane(myEdge->getLanes().at(i));
272  }
273  for (const auto& j : myChildLaneDemandElements.at(i)) {
274  j->removeParentLane(myEdge->getLanes().at(i));
275  }
276  }
277  // delete edge from net
278  myNet->deleteSingleEdge(myEdge, false);
279  }
280  // enable save netElements
281  myNet->requireSaveNet(true);
282 }
283 
284 
285 FXString
287  if (myForward) {
288  return ("Undo create " + toString(SUMO_TAG_EDGE)).c_str();
289  } else {
290  return ("Undo delete " + toString(SUMO_TAG_EDGE)).c_str();
291  }
292 }
293 
294 
295 FXString
297  if (myForward) {
298  return ("Redo create " + toString(SUMO_TAG_EDGE)).c_str();
299  } else {
300  return ("Redo delete " + toString(SUMO_TAG_EDGE)).c_str();
301  }
302 }
GNENet::requireSaveNet
void requireSaveNet(bool value)
inform that net has to be saved
Definition: GNENet.cpp:982
GNEChange_Edge::undo
void undo()
undo action
Definition: GNEChange_Edge.cpp:78
GNEReferenceCounter::unreferenced
bool unreferenced()
check if object ins't referenced
Definition: GNEReferenceCounter.h:78
GNEAdditional.h
GNEChange_Edge::myChildEdgeDemandElements
const std::vector< GNEDemandElement * > & myChildEdgeDemandElements
vector of references to vector of child demand elements (used by lanes)
Definition: GNEChange_Edge.h:99
GNEAttributeCarrier::getID
const std::string getID() const
function to support debugging
Definition: GNEAttributeCarrier.cpp:1289
GNEChange_Edge::myEdgeParentShapes
const std::vector< GNEShape * > & myEdgeParentShapes
reference to vector of parent shapes
Definition: GNEChange_Edge.h:84
GNEChange::myForward
bool myForward
we group antagonistic commands (create junction/delete junction) and keep them apart by this flag
Definition: GNEChange.h:80
GNENet::insertEdge
void insertEdge(GNEEdge *edge)
inserts a single edge into the net and into the underlying netbuild-container
Definition: GNENet.cpp:2896
GNEChange_Edge::myLaneParentShapes
std::vector< std::vector< GNEShape * > > myLaneParentShapes
vector of references to vector of parent shapes (used by lanes)
Definition: GNEChange_Edge.h:102
GNENet::deleteSingleEdge
void deleteSingleEdge(GNEEdge *edge, bool updateViewAfterDeleting)
deletes a single edge
Definition: GNENet.cpp:2975
GNEChange_Edge
Definition: GNEChange_Edge.h:47
GNEChange_Edge::myChildLaneShapes
std::vector< std::vector< GNEShape * > > myChildLaneShapes
vector of references to vector of child shapes (used by lanes)
Definition: GNEChange_Edge.h:111
GNEChange_Edge.h
GNEChange_Edge::undoName
FXString undoName() const
return undoName
Definition: GNEChange_Edge.cpp:286
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:51
GNEDemandElement.h
GNEChange_Edge::myLaneParentAdditionals
std::vector< std::vector< GNEAdditional * > > myLaneParentAdditionals
vector of references to vector of parent additionals (used by lanes)
Definition: GNEChange_Edge.h:105
SUMO_TAG_EDGE
@ SUMO_TAG_EDGE
begin/end of the description of an edge
Definition: SUMOXMLDefinitions.h:47
GNEEdge.h
GNEChange_Edge::myLaneParentDemandElements
std::vector< std::vector< GNEDemandElement * > > myLaneParentDemandElements
vector of references to vector of parent demand elements (used by lanes)
Definition: GNEChange_Edge.h:108
GNEChange::myNet
GNENet * myNet
the net to which operations shall be applied or which shall be informed about gui updates (we are not...
Definition: GNEChange.h:75
GNEReferenceCounter::decRef
void decRef(const std::string &debugMsg="")
Decrease reference.
Definition: GNEReferenceCounter.h:52
GNEEdge::getLanes
const std::vector< GNELane * > & getLanes() const
returns a reference to the lane vector
Definition: GNEEdge.cpp:874
GNELane.h
GNEShape.h
GNEChange_Edge::myChildLaneAdditionals
std::vector< std::vector< GNEAdditional * > > myChildLaneAdditionals
vector of references to vector of child additional (used by lanes)
Definition: GNEChange_Edge.h:114
GNEChange_Edge::myEdgeParentAdditionals
const std::vector< GNEAdditional * > & myEdgeParentAdditionals
reference to vector of parent additionals
Definition: GNEChange_Edge.h:87
GNEChange_Edge::myChildLaneDemandElements
std::vector< std::vector< GNEDemandElement * > > myChildLaneDemandElements
vector of references to vector of child demand elements (used by lanes)
Definition: GNEChange_Edge.h:117
GNEChange_Edge::redoName
FXString redoName() const
get Redo name
Definition: GNEChange_Edge.cpp:296
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
GNEChange_Edge::redo
void redo()
redo action
Definition: GNEChange_Edge.cpp:182
SUMO_TAG_NET
@ SUMO_TAG_NET
root element of a network file
Definition: SUMOXMLDefinitions.h:45
GNEChange_Edge::myChildEdgeShapes
const std::vector< GNEShape * > & myChildEdgeShapes
reference to vector of child shapes
Definition: GNEChange_Edge.h:93
config.h
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition: GNEAttributeCarrier.cpp:1267
GNEChange_Edge::myChildEdgeAdditionals
const std::vector< GNEAdditional * > & myChildEdgeAdditionals
reference to vector of child additional
Definition: GNEChange_Edge.h:96
GNEChange
the function-object for an editing operation (abstract base)
Definition: GNEChange.h:42
GNEChange_Edge::myEdge
GNEEdge * myEdge
full information regarding the edge that is to be created/deleted
Definition: GNEChange_Edge.h:81
WRITE_DEBUG
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:284
GNENet.h
GNEChange_Edge::~GNEChange_Edge
~GNEChange_Edge()
Destructor.
Definition: GNEChange_Edge.cpp:66
GNEChange_Edge::myEdgeParentDemandElements
const std::vector< GNEDemandElement * > & myEdgeParentDemandElements
reference to vector of parent demand elements
Definition: GNEChange_Edge.h:90