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 /****************************************************************************/
15 // A network change in which a single junction is created or deleted
16 /****************************************************************************/
17 
18 // ===========================================================================
19 // included modules
20 // ===========================================================================
21 #include <config.h>
22 
23 #include <netedit/GNENet.h>
29 
30 
31 #include "GNEChange_Edge.h"
32 
33 // ===========================================================================
34 // FOX-declarations
35 // ===========================================================================
36 FXIMPLEMENT_ABSTRACT(GNEChange_Edge, GNEChange, nullptr, 0)
37 
38 // ===========================================================================
39 // member method definitions
40 // ===========================================================================
41 
42 
43 GNEChange_Edge::GNEChange_Edge(GNEEdge* edge, bool forward):
45  GNEChange(edge->getNet(), forward),
46  myEdge(edge),
47  myEdgeShapeParents(edge->getShapeParents()),
48  myEdgeAdditionalParents(edge->getAdditionalParents()),
49  myEdgeDemandElementParents(edge->getDemandElementParents()),
50  myEdgeShapeChildren(edge->getShapeChildren()),
51  myEdgeAdditionalChildren(edge->getAdditionalChildren()),
52  myEdgeDemandElementChildren(edge->getDemandElementChildren()) {
53  // now save all hierarchical elements of edge's lane
54  for (const auto& i : edge->getLanes()) {
55  myLaneShapeParents.push_back(i->getShapeParents());
56  myLaneAdditionalParents.push_back(i->getAdditionalParents());
57  myLaneDemandElementParents.push_back(i->getDemandElementParents());
58  myLaneShapeChildren.push_back(i->getShapeChildren());
59  myLaneAdditionalChildren.push_back(i->getAdditionalChildren());
60  myLaneDemandElementChildren.push_back(i->getDemandElementChildren());
61  }
62 
63  edge->incRef("GNEChange_Edge");
64 }
65 
66 
68  assert(myEdge);
69  myEdge->decRef("GNEChange_Edge");
70  if (myEdge->unreferenced()) {
71  // show extra information for tests
72  WRITE_DEBUG("Deleting unreferenced " + myEdge->getTagStr() + " '" + myEdge->getID() + "' GNEChange_Edge");
73  delete myEdge;
74  }
75 }
76 
77 
78 void
80  if (myForward) {
81  // show extra information for tests
82  WRITE_DEBUG("Removing " + myEdge->getTagStr() + " '" + myEdge->getID() + "' from " + toString(SUMO_TAG_NET));
83  // Remove edge from parent elements
84  for (const auto& i : myEdgeShapeParents) {
85  i->removeEdgeChild(myEdge);
86  }
87  for (const auto& i : myEdgeAdditionalParents) {
88  i->removeEdgeChild(myEdge);
89  }
90  for (const auto& i : myEdgeDemandElementParents) {
91  i->removeEdgeChild(myEdge);
92  }
93  // Remove edge from child elements
94  for (const auto& i : myEdgeShapeChildren) {
95  i->removeEdgeParent(myEdge);
96  }
97  for (const auto& i : myEdgeAdditionalChildren) {
98  i->removeEdgeParent(myEdge);
99  }
100  for (const auto& i : myEdgeDemandElementChildren) {
101  i->removeEdgeParent(myEdge);
102  }
103  // repeat operations for all lane's edge
104  for (int i = 0; i < (int)myEdge->getLanes().size(); i++) {
105  // Remove every lane's edge from parent elements
106  for (const auto& j : myLaneShapeParents.at(i)) {
107  j->removeLaneChild(myEdge->getLanes().at(i));
108  }
109  for (const auto& j : myLaneAdditionalParents.at(i)) {
110  j->removeLaneChild(myEdge->getLanes().at(i));
111  }
112  for (const auto& j : myLaneDemandElementParents.at(i)) {
113  j->removeLaneChild(myEdge->getLanes().at(i));
114  }
115  // Remove every lane's edge from child elements
116  for (const auto& j : myLaneShapeChildren.at(i)) {
117  j->removeLaneParent(myEdge->getLanes().at(i));
118  }
119  for (const auto& j : myLaneAdditionalChildren.at(i)) {
120  j->removeLaneParent(myEdge->getLanes().at(i));
121  }
122  for (const auto& j : myLaneDemandElementChildren.at(i)) {
123  j->removeLaneParent(myEdge->getLanes().at(i));
124  }
125  }
126  // delete edge from net
127  myNet->deleteSingleEdge(myEdge, false);
128  } else {
129  // show extra information for tests
130  WRITE_DEBUG("Adding " + myEdge->getTagStr() + " '" + myEdge->getID() + "' from " + toString(SUMO_TAG_NET));
131  // insert edge into net
133  // add edge in parent elements
134  for (const auto& i : myEdgeShapeParents) {
135  i->addEdgeChild(myEdge);
136  }
137  for (const auto& i : myEdgeAdditionalParents) {
138  i->addEdgeChild(myEdge);
139  }
140  for (const auto& i : myEdgeDemandElementParents) {
141  i->addEdgeChild(myEdge);
142  }
143  // add edge in child elements
144  for (const auto& i : myEdgeShapeChildren) {
145  i->addEdgeParent(myEdge);
146  }
147  for (const auto& i : myEdgeAdditionalChildren) {
148  i->addEdgeParent(myEdge);
149  }
150  for (const auto& i : myEdgeDemandElementChildren) {
151  i->addEdgeParent(myEdge);
152  }
153  // repeat operations for all lane's edge
154  for (int i = 0; i < (int)myEdge->getLanes().size(); i++) {
155  // add lane's edge in parent elements
156  for (const auto& j : myLaneShapeParents.at(i)) {
157  j->addLaneChild(myEdge->getLanes().at(i));
158  }
159  for (const auto& j : myLaneAdditionalParents.at(i)) {
160  j->addLaneChild(myEdge->getLanes().at(i));
161  }
162  for (const auto& j : myLaneDemandElementParents.at(i)) {
163  j->addLaneChild(myEdge->getLanes().at(i));
164  }
165  // add lane's edge in child elements
166  for (const auto& j : myLaneShapeChildren.at(i)) {
167  j->addLaneParent(myEdge->getLanes().at(i));
168  }
169  for (const auto& j : myLaneAdditionalChildren.at(i)) {
170  j->addLaneParent(myEdge->getLanes().at(i));
171  }
172  for (const auto& j : myLaneDemandElementChildren.at(i)) {
173  j->addLaneParent(myEdge->getLanes().at(i));
174  }
175  }
176  }
177  // enable save netElements
178  myNet->requiereSaveNet(true);
179 }
180 
181 
182 void
184  if (myForward) {
185  // show extra information for tests
186  WRITE_DEBUG("Adding " + myEdge->getTagStr() + " '" + myEdge->getID() + "' from " + toString(SUMO_TAG_NET));
187  // insert edge into net
189  // add edge in parent elements
190  for (const auto& i : myEdgeShapeParents) {
191  i->addEdgeChild(myEdge);
192  }
193  for (const auto& i : myEdgeAdditionalParents) {
194  i->addEdgeChild(myEdge);
195  }
196  for (const auto& i : myEdgeDemandElementParents) {
197  i->addEdgeChild(myEdge);
198  }
199  // add edge in child elements
200  for (const auto& i : myEdgeShapeChildren) {
201  i->addEdgeParent(myEdge);
202  }
203  for (const auto& i : myEdgeAdditionalChildren) {
204  i->addEdgeParent(myEdge);
205  }
206  for (const auto& i : myEdgeDemandElementChildren) {
207  i->addEdgeParent(myEdge);
208  }
209  // repeat operations for all lane's edge
210  for (int i = 0; i < (int)myEdge->getLanes().size(); i++) {
211  // add lane's edge in parent elements
212  for (const auto& j : myLaneShapeParents.at(i)) {
213  j->addLaneChild(myEdge->getLanes().at(i));
214  }
215  for (const auto& j : myLaneAdditionalParents.at(i)) {
216  j->addLaneChild(myEdge->getLanes().at(i));
217  }
218  for (const auto& j : myLaneDemandElementParents.at(i)) {
219  j->addLaneChild(myEdge->getLanes().at(i));
220  }
221  // add lane's edge in child elements
222  for (const auto& j : myLaneShapeChildren.at(i)) {
223  j->addLaneParent(myEdge->getLanes().at(i));
224  }
225  for (const auto& j : myLaneAdditionalChildren.at(i)) {
226  j->addLaneParent(myEdge->getLanes().at(i));
227  }
228  for (const auto& j : myLaneDemandElementChildren.at(i)) {
229  j->addLaneParent(myEdge->getLanes().at(i));
230  }
231  }
232  } else {
233  // show extra information for tests
234  WRITE_DEBUG("Removing " + myEdge->getTagStr() + " '" + myEdge->getID() + "' from " + toString(SUMO_TAG_NET));
235  // Remove edge from parent elements
236  for (const auto& i : myEdgeShapeParents) {
237  i->removeEdgeChild(myEdge);
238  }
239  for (const auto& i : myEdgeAdditionalParents) {
240  i->removeEdgeChild(myEdge);
241  }
242  for (const auto& i : myEdgeDemandElementParents) {
243  i->removeEdgeChild(myEdge);
244  }
245  // Remove edge from child elements
246  for (const auto& i : myEdgeShapeChildren) {
247  i->removeEdgeParent(myEdge);
248  }
249  for (const auto& i : myEdgeAdditionalChildren) {
250  i->removeEdgeParent(myEdge);
251  }
252  for (const auto& i : myEdgeDemandElementChildren) {
253  i->removeEdgeParent(myEdge);
254  }
255  // repeat operations for all lane's edge
256  for (int i = 0; i < (int)myEdge->getLanes().size(); i++) {
257  // Remove every lane's edge from parent elements
258  for (const auto& j : myLaneShapeParents.at(i)) {
259  j->removeLaneChild(myEdge->getLanes().at(i));
260  }
261  for (const auto& j : myLaneAdditionalParents.at(i)) {
262  j->removeLaneChild(myEdge->getLanes().at(i));
263  }
264  for (const auto& j : myLaneDemandElementParents.at(i)) {
265  j->removeLaneChild(myEdge->getLanes().at(i));
266  }
267  // Remove every lane's edge from child elements
268  for (const auto& j : myLaneShapeChildren.at(i)) {
269  j->removeLaneParent(myEdge->getLanes().at(i));
270  }
271  for (const auto& j : myLaneAdditionalChildren.at(i)) {
272  j->removeLaneParent(myEdge->getLanes().at(i));
273  }
274  for (const auto& j : myLaneDemandElementChildren.at(i)) {
275  j->removeLaneParent(myEdge->getLanes().at(i));
276  }
277  }
278  // delete edge from net
279  myNet->deleteSingleEdge(myEdge, false);
280  }
281  // enable save netElements
282  myNet->requiereSaveNet(true);
283 }
284 
285 
286 FXString
288  if (myForward) {
289  return ("Undo create " + toString(SUMO_TAG_EDGE)).c_str();
290  } else {
291  return ("Undo delete " + toString(SUMO_TAG_EDGE)).c_str();
292  }
293 }
294 
295 
296 FXString
298  if (myForward) {
299  return ("Redo create " + toString(SUMO_TAG_EDGE)).c_str();
300  } else {
301  return ("Redo delete " + toString(SUMO_TAG_EDGE)).c_str();
302  }
303 }
GNEChange_Edge::myLaneDemandElementParents
std::vector< std::vector< GNEDemandElement * > > myLaneDemandElementParents
vector of references to vector of demand element parents (used by lanes)
Definition: GNEChange_Edge.h:109
GNEChange_Edge::undo
void undo()
undo action
Definition: GNEChange_Edge.cpp:79
GNEChange_Edge::myEdgeDemandElementChildren
const std::vector< GNEDemandElement * > & myEdgeDemandElementChildren
vector of references to vector of demand element children (used by lanes)
Definition: GNEChange_Edge.h:100
GNEReferenceCounter::unreferenced
bool unreferenced()
check if object ins't referenced
Definition: GNEReferenceCounter.h:79
GNEAdditional.h
GNEAttributeCarrier::getID
const std::string getID() const
function to support debugging
Definition: GNEAttributeCarrier.cpp:1187
GNEChange_Edge::myEdgeAdditionalChildren
const std::vector< GNEAdditional * > & myEdgeAdditionalChildren
reference to vector of additional children
Definition: GNEChange_Edge.h:97
GNENet::requiereSaveNet
void requiereSaveNet(bool value)
inform that net has to be saved
Definition: GNENet.cpp:933
GNEChange::myForward
bool myForward
we group antagonistic commands (create junction/delete junction) and keep them apart by this flag
Definition: GNEChange.h:81
GNENet::insertEdge
void insertEdge(GNEEdge *edge)
inserts a single edge into the net and into the underlying netbuild-container
Definition: GNENet.cpp:2839
GNENet::deleteSingleEdge
void deleteSingleEdge(GNEEdge *edge, bool updateViewAfterDeleting)
deletes a single edge
Definition: GNENet.cpp:2918
GNEChange_Edge
Definition: GNEChange_Edge.h:48
GNEChange_Edge.h
GNEChange_Edge::myEdgeShapeParents
const std::vector< GNEShape * > & myEdgeShapeParents
reference to vector of shape parents
Definition: GNEChange_Edge.h:85
GNEChange_Edge::undoName
FXString undoName() const
return undoName
Definition: GNEChange_Edge.cpp:287
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:50
GNEChange_Edge::myEdgeDemandElementParents
const std::vector< GNEDemandElement * > & myEdgeDemandElementParents
reference to vector of demand element parents
Definition: GNEChange_Edge.h:91
GNEDemandElement.h
SUMO_TAG_EDGE
begin/end of the description of an edge
Definition: SUMOXMLDefinitions.h:48
GNEChange_Edge::myLaneDemandElementChildren
std::vector< std::vector< GNEDemandElement * > > myLaneDemandElementChildren
vector of references to vector of demand element children (used by lanes)
Definition: GNEChange_Edge.h:118
GNEEdge.h
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:76
GNEReferenceCounter::decRef
void decRef(const std::string &debugMsg="")
Decrease reference.
Definition: GNEReferenceCounter.h:53
GNEChange_Edge::myEdgeAdditionalParents
const std::vector< GNEAdditional * > & myEdgeAdditionalParents
reference to vector of additional parents
Definition: GNEChange_Edge.h:88
GNEEdge::getLanes
const std::vector< GNELane * > & getLanes() const
returns a reference to the lane vector
Definition: GNEEdge.cpp:840
GNELane.h
GNEShape.h
GNEChange_Edge::redoName
FXString redoName() const
get Redo name
Definition: GNEChange_Edge.cpp:297
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:48
GNEChange_Edge::redo
void redo()
redo action
Definition: GNEChange_Edge.cpp:183
SUMO_TAG_NET
root element of a network file
Definition: SUMOXMLDefinitions.h:46
GNEChange_Edge::myLaneShapeChildren
std::vector< std::vector< GNEShape * > > myLaneShapeChildren
vector of references to vector of shape children (used by lanes)
Definition: GNEChange_Edge.h:112
config.h
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition: GNEAttributeCarrier.cpp:1165
GNEChange_Edge::myLaneAdditionalChildren
std::vector< std::vector< GNEAdditional * > > myLaneAdditionalChildren
vector of references to vector of additional children (used by lanes)
Definition: GNEChange_Edge.h:115
GNEChange
the function-object for an editing operation (abstract base)
Definition: GNEChange.h:43
GNEChange_Edge::myEdge
GNEEdge * myEdge
full information regarding the edge that is to be created/deleted
Definition: GNEChange_Edge.h:82
GNEChange_Edge::myLaneShapeParents
std::vector< std::vector< GNEShape * > > myLaneShapeParents
vector of references to vector of shape parents (used by lanes)
Definition: GNEChange_Edge.h:103
WRITE_DEBUG
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:246
GNENet.h
GNEChange_Edge::~GNEChange_Edge
~GNEChange_Edge()
Destructor.
Definition: GNEChange_Edge.cpp:67
GNEChange_Edge::myLaneAdditionalParents
std::vector< std::vector< GNEAdditional * > > myLaneAdditionalParents
vector of references to vector of additional parents (used by lanes)
Definition: GNEChange_Edge.h:106
GNEChange_Edge::myEdgeShapeChildren
const std::vector< GNEShape * > & myEdgeShapeChildren
reference to vector of shape children
Definition: GNEChange_Edge.h:94