Eclipse SUMO - Simulation of Urban MObility
GNEHierarchicalParentElements.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 abstract class for representation of additional elements
15 /****************************************************************************/
16 
17 // ===========================================================================
18 // included modules
19 // ===========================================================================
20 #include <config.h>
21 
22 #include <netedit/GNENet.h>
23 #include <netedit/GNEViewNet.h>
29 #include <utils/gui/div/GLHelper.h>
31 
33 
34 // ===========================================================================
35 // member method definitions
36 // ===========================================================================
37 
38 // ---------------------------------------------------------------------------
39 // GNEHierarchicalParentElements - methods
40 // ---------------------------------------------------------------------------
41 
43  const std::vector<GNEEdge*>& parentEdges,
44  const std::vector<GNELane*>& parentLanes,
45  const std::vector<GNEShape*>& parentShapes,
46  const std::vector<GNEAdditional*>& parentAdditionals,
47  const std::vector<GNEDemandElement*>& parentDemandElements) :
48  myParentConnections(this),
49  myParentEdges(parentEdges),
50  myParentLanes(parentLanes),
51  myParentShapes(parentShapes),
52  myParentAdditionals(parentAdditionals),
53  myParentDemandElements(parentDemandElements),
54  myAC(AC) {
55 }
56 
57 
59 
60 
61 void
63  // First check that additional wasn't already inserted
64  if (std::find(myParentAdditionals.begin(), myParentAdditionals.end(), additional) != myParentAdditionals.end()) {
65  throw ProcessError(additional->getTagStr() + " with ID='" + additional->getID() + "' was already inserted in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
66  } else {
67  myParentAdditionals.push_back(additional);
68  }
69 }
70 
71 
72 void
74  // First check that additional was already inserted
75  auto it = std::find(myParentAdditionals.begin(), myParentAdditionals.end(), additional);
76  if (it == myParentAdditionals.end()) {
77  throw ProcessError(additional->getTagStr() + " with ID='" + additional->getID() + "' doesn't exist in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
78  } else {
79  myParentAdditionals.erase(it);
80  }
81 }
82 
83 
84 const std::vector<GNEAdditional*>&
86  return myParentAdditionals;
87 }
88 
89 
90 void
92  // First check that demandElement wasn't already inserted
93  if (std::find(myParentDemandElements.begin(), myParentDemandElements.end(), demandElement) != myParentDemandElements.end()) {
94  throw ProcessError(demandElement->getTagStr() + " with ID='" + demandElement->getID() + "' was already inserted in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
95  } else {
96  myParentDemandElements.push_back(demandElement);
97  }
98 }
99 
100 
101 void
103  // First check that demandElement was already inserted
104  auto it = std::find(myParentDemandElements.begin(), myParentDemandElements.end(), demandElement);
105  if (it == myParentDemandElements.end()) {
106  throw ProcessError(demandElement->getTagStr() + " with ID='" + demandElement->getID() + "' doesn't exist in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
107  } else {
108  myParentDemandElements.erase(it);
109  }
110 }
111 
112 
113 const std::vector<GNEDemandElement*>&
115  return myParentDemandElements;
116 }
117 
118 
119 std::string
120 GNEHierarchicalParentElements::getNewListOfParents(const GNENetElement* currentElement, const GNENetElement* newNextElement) const {
121  std::vector<std::string> solution;
122  if ((currentElement->getTagProperty().getTag() == SUMO_TAG_EDGE) && (newNextElement->getTagProperty().getTag() == SUMO_TAG_EDGE)) {
123  // reserve solution
124  solution.reserve(myParentEdges.size());
125  // iterate over edges
126  for (const auto& edge : myParentEdges) {
127  // add edge ID
128  solution.push_back(edge->getID());
129  // if current edge is the current element, then insert newNextElement ID
130  if (edge == currentElement) {
131  solution.push_back(newNextElement->getID());
132  }
133  }
134  } else if ((currentElement->getTagProperty().getTag() == SUMO_TAG_LANE) && (newNextElement->getTagProperty().getTag() == SUMO_TAG_LANE)) {
135  // reserve solution
136  solution.reserve(myParentLanes.size());
137  // iterate over lanes
138  for (const auto& lane : myParentLanes) {
139  // add lane ID
140  solution.push_back(lane->getID());
141  // if current lane is the current element, then insert newNextElement ID
142  if (lane == currentElement) {
143  solution.push_back(newNextElement->getID());
144  }
145  }
146  }
147  return toString(solution);
148 }
149 
150 
151 void
153  // Check that edge is valid and doesn't exist previously
154  if (edge == nullptr) {
155  throw InvalidArgument("Trying to add an empty " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
156  } else if (std::find(myParentEdges.begin(), myParentEdges.end(), edge) != myParentEdges.end()) {
157  throw InvalidArgument("Trying to add a duplicate " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
158  } else {
159  myParentEdges.push_back(edge);
160  }
161 }
162 
163 
164 void
166  // Check that edge is valid and exist previously
167  if (edge == nullptr) {
168  throw InvalidArgument("Trying to remove an empty " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
169  } else {
170  auto it = std::find(myParentEdges.begin(), myParentEdges.end(), edge);
171  if (it == myParentEdges.end()) {
172  throw InvalidArgument("Trying to remove a non previously inserted " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
173  } else {
174  myParentEdges.erase(it);
175  }
176  }
177 }
178 
179 
180 const std::vector<GNEEdge*>&
182  return myParentEdges;
183 }
184 
185 
186 std::vector<GNEEdge*>
188  std::vector<GNEEdge*> middleEdges;
189  // there are only middle edges if there is more than two edges
190  if (middleEdges.size() > 2) {
191  // resize middleEdges
192  middleEdges.resize(myParentEdges.size() - 2);
193  // iterate over second and previous last parent edge
194  for (auto i = (myParentEdges.begin() + 1); i != (myParentEdges.end() - 1); i++) {
195  middleEdges.push_back(*i);
196  }
197  }
198  return middleEdges;
199 }
200 
201 
202 const std::vector<GNEEdge*>&
204  return myRouteEdges;
205 }
206 
207 
208 void
210  // Check that lane is valid and doesn't exist previously
211  if (lane == nullptr) {
212  throw InvalidArgument("Trying to add an empty " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
213  } else if (std::find(myParentLanes.begin(), myParentLanes.end(), lane) != myParentLanes.end()) {
214  throw InvalidArgument("Trying to add a duplicate " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
215  } else {
216  myParentLanes.push_back(lane);
217  }
218 }
219 
220 
221 void
223  // Check that lane is valid and exist previously
224  if (lane == nullptr) {
225  throw InvalidArgument("Trying to remove an empty " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
226  } else if (std::find(myParentLanes.begin(), myParentLanes.end(), lane) == myParentLanes.end()) {
227  throw InvalidArgument("Trying to remove a non previously inserted " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
228  } else {
229  myParentLanes.erase(std::find(myParentLanes.begin(), myParentLanes.end(), lane));
230  }
231 }
232 
233 
234 const std::vector<GNELane*>&
236  return myParentLanes;
237 }
238 
239 
240 void
242  // Check that shape is valid and doesn't exist previously
243  if (shape == nullptr) {
244  throw InvalidArgument("Trying to add an empty " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
245  } else if (std::find(myParentShapes.begin(), myParentShapes.end(), shape) != myParentShapes.end()) {
246  throw InvalidArgument("Trying to add a duplicate " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
247  } else {
248  myParentShapes.push_back(shape);
249  }
250 }
251 
252 
253 void
255  // Check that shape is valid and exist previously
256  if (shape == nullptr) {
257  throw InvalidArgument("Trying to remove an empty " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
258  } else if (std::find(myParentShapes.begin(), myParentShapes.end(), shape) == myParentShapes.end()) {
259  throw InvalidArgument("Trying to remove a non previously inserted " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
260  } else {
261  myParentShapes.erase(std::find(myParentShapes.begin(), myParentShapes.end(), shape));
262  }
263 }
264 
265 
266 const std::vector<GNEShape*>&
268  return myParentShapes;
269 }
270 
271 // ---------------------------------------------------------------------------
272 // GNEHierarchicalParentElements - protected methods
273 // ---------------------------------------------------------------------------
274 
275 void
276 GNEHierarchicalParentElements::replaceParentEdges(GNEShape* elementChild, const std::string& newEdgeIDs) {
277  // remove additional of parent edges
278  for (const auto& edge : myParentEdges) {
279  edge->removeChildShape(elementChild);
280  }
281  // obtain new parent edges
282  myParentEdges = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(elementChild->getNet(), newEdgeIDs);
283  // check that lane parets aren't empty
284  if (myParentEdges.empty()) {
285  throw InvalidArgument("New list of parent edges cannot be empty");
286  } else {
287  // add additional into parent edges
288  for (const auto& edge : myParentEdges) {
289  edge->addChildShape(elementChild);
290  }
291  }
292 }
293 
294 
295 void
296 GNEHierarchicalParentElements::replaceParentEdges(GNEAdditional* elementChild, const std::string& newEdgeIDs) {
297  // remove additional of parent edges
298  for (const auto& edge : myParentEdges) {
299  edge->removeChildAdditional(elementChild);
300  }
301  // obtain new parent edges
302  myParentEdges = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(elementChild->getViewNet()->getNet(), newEdgeIDs);
303  // check that lane parets aren't empty
304  if (myParentEdges.empty()) {
305  throw InvalidArgument("New list of parent edges cannot be empty");
306  } else {
307  // add additional into parent edges
308  for (const auto& edge : myParentEdges) {
309  edge->addChildAdditional(elementChild);
310  }
311  }
312 }
313 
314 
315 void
316 GNEHierarchicalParentElements::replaceParentEdges(GNEDemandElement* elementChild, const std::string& newEdgeIDs) {
317  // remove demandElement of parent edges
318  for (const auto& edge : myParentEdges) {
319  edge->removeChildDemandElement(elementChild);
320  }
321  // obtain new parent edges
322  myParentEdges = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(elementChild->getViewNet()->getNet(), newEdgeIDs);
323  // check that lane parets aren't empty
324  if (myParentEdges.empty()) {
325  throw InvalidArgument("New list of parent edges cannot be empty");
326  } else {
327  // add demandElement into parent edges
328  for (const auto& edge : myParentEdges) {
329  edge->addChildDemandElement(elementChild);
330  }
331  }
332 }
333 
334 
335 void
336 GNEHierarchicalParentElements::replaceParentEdges(GNEDemandElement* elementChild, const std::vector<GNEEdge*>& newEdges) {
337  // remove demandElement of parent edges
338  for (const auto& edge : myParentEdges) {
339  edge->removeChildDemandElement(elementChild);
340  }
341  // set new edges
342  myParentEdges = newEdges;
343  // check that lane parets aren't empty
344  if (myParentEdges.empty()) {
345  throw InvalidArgument("New list of parent edges cannot be empty");
346  } else {
347  // add demandElement into parent edges
348  for (const auto& edge : myParentEdges) {
349  edge->addChildDemandElement(elementChild);
350  }
351  }
352 }
353 
354 
355 void
357  // first check that at least there is two edges
358  if (myParentEdges.size() < 2) {
359  throw InvalidArgument("Invalid minimum number of edges");
360  } else {
361  // remove demandElement of parent edges
362  myParentEdges.front()->removeChildDemandElement(elementChild);
363  // replace first edge
364  myParentEdges[0] = newFirstEdge;
365  // add demandElement into parent edges
366  myParentEdges.front()->addChildDemandElement(elementChild);
367  }
368 }
369 
370 
371 void
372 GNEHierarchicalParentElements::replaceMiddleParentEdges(GNEDemandElement* elementChild, const std::vector<GNEEdge*>& newMiddleEdges, const bool updateChildReferences) {
373  // declare a vector for new parent edges
374  std::vector<GNEEdge*> newEdges;
375  // check if add first edge
376  if (myParentEdges.size() > 0) {
377  newEdges.push_back(myParentEdges.front());
378  }
379  // add newMiddleEdges
380  for (const auto& edge : newMiddleEdges) {
381  newEdges.push_back(edge);
382  }
383  // check if add last edge
384  if (myParentEdges.size() > 1) {
385  newEdges.push_back(myParentEdges.back());
386  }
387  // check if we have to update references in all childs, or simply update parent edges vector
388  if (updateChildReferences) {
389  replaceParentEdges(elementChild, newEdges);
390  } else {
391  myParentEdges = newEdges;
392  }
393 }
394 
395 
396 void
398  // first check that at least there is two edges
399  if (myParentEdges.size() < 2) {
400  throw InvalidArgument("Invalid minimum number of edges");
401  } else {
402  // remove demandElement of parent edges
403  myParentEdges.back()->removeChildDemandElement(elementChild);
404  // replace last edge
405  myParentEdges.pop_back();
406  myParentEdges.push_back(newLastEdge);
407  // add demandElement into parent edges
408  myParentEdges.back()->addChildDemandElement(elementChild);
409  }
410 }
411 
412 
413 void
414 GNEHierarchicalParentElements::replacePathEdges(GNEDemandElement* elementChild, const std::vector<GNEEdge*>& routeEdges) {
415  // remove demandElement of parent edges
416  for (const auto& edge : myRouteEdges) {
417  edge->removePathElement(elementChild);
418  }
419  // set new route edges
420  myRouteEdges = routeEdges;
421  // add demandElement into parent edges
422  for (const auto& edge : myRouteEdges) {
423  edge->addPathElement(elementChild);
424  }
425 }
426 
427 
428 void
429 GNEHierarchicalParentElements::replaceParentLanes(GNEAdditional* elementChild, const std::string& newLaneIDs) {
430  // remove additional of parent edges
431  for (const auto& lane : myParentLanes) {
432  lane->removeChildAdditional(elementChild);
433  }
434  // obtain new parent edges
435  myParentLanes = GNEAttributeCarrier::parse<std::vector<GNELane*> >(elementChild->getViewNet()->getNet(), newLaneIDs);
436  // check that lane parets aren't empty
437  if (myParentLanes.empty()) {
438  throw InvalidArgument("New list of parent lanes cannot be empty");
439  } else {
440  // add additional into parent edges
441  for (const auto& lane : myParentLanes) {
442  lane->addChildAdditional(elementChild);
443  }
444  }
445 }
446 
447 
448 void
449 GNEHierarchicalParentElements::replaceParentLanes(GNEDemandElement* elementChild, const std::string& newLaneIDs) {
450  // remove demandElement of parent edges
451  for (const auto& lane : myParentLanes) {
452  lane->removeChildDemandElement(elementChild);
453  }
454  // obtain new parent edges
455  myParentLanes = GNEAttributeCarrier::parse<std::vector<GNELane*> >(elementChild->getViewNet()->getNet(), newLaneIDs);
456  // check that lane parets aren't empty
457  if (myParentLanes.empty()) {
458  throw InvalidArgument("New list of parent lanes cannot be empty");
459  } else {
460  // add demandElement into parent edges
461  for (const auto& lane : myParentLanes) {
462  lane->addChildDemandElement(elementChild);
463  }
464  }
465 }
466 
467 
468 void
469 GNEHierarchicalParentElements::replaceParentLanes(GNEShape* elementChild, const std::string& newLaneIDs) {
470  // remove demandElement of parent edges
471  for (const auto& lane : myParentLanes) {
472  lane->removeChildShape(elementChild);
473  }
474  // obtain new parent edges
475  myParentLanes = GNEAttributeCarrier::parse<std::vector<GNELane*> >(elementChild->getNet(), newLaneIDs);
476  // check that lane parets aren't empty
477  if (myParentLanes.empty()) {
478  throw InvalidArgument("New list of parent lanes cannot be empty");
479  } else {
480  // add demandElement into parent edges
481  for (const auto& lane : myParentLanes) {
482  lane->addChildShape(elementChild);
483  }
484  }
485 }
486 
487 
488 void
489 GNEHierarchicalParentElements::replaceParentAdditional(GNEShape* shapeTobeChanged, const std::string& newParentAdditionalID, int additionalParentIndex) {
490  if ((int)myParentAdditionals.size() < additionalParentIndex) {
491  throw InvalidArgument(myAC->getTagStr() + " with ID '" + myAC->getID() + "' doesn't have " + toString(additionalParentIndex) + " parent additionals");
492  } else {
493  // remove additional of the children of parent additional
494  myParentAdditionals.at(additionalParentIndex)->removeChildShape(shapeTobeChanged);
495  // set new parent additional
496  myParentAdditionals.at(additionalParentIndex) = shapeTobeChanged->getNet()->retrieveAdditional(myParentAdditionals.at(additionalParentIndex)->getTagProperty().getTag(), newParentAdditionalID);
497  // add additional int the children of parent additional
498  myParentAdditionals.at(additionalParentIndex)->addChildShape(shapeTobeChanged);
499  // update geometry after inserting
500  shapeTobeChanged->updateGeometry();
501  }
502 }
503 
504 
505 void
506 GNEHierarchicalParentElements::replaceParentAdditional(GNEAdditional* additionalTobeChanged, const std::string& newParentAdditionalID, int additionalParentIndex) {
507  if ((int)myParentAdditionals.size() < additionalParentIndex) {
508  throw InvalidArgument(myAC->getTagStr() + " with ID '" + myAC->getID() + "' doesn't have " + toString(additionalParentIndex) + " parent additionals");
509  } else {
510  // remove additional of the children of parent additional
511  myParentAdditionals.at(additionalParentIndex)->removeChildAdditional(additionalTobeChanged);
512  // set new parent additional
513  myParentAdditionals.at(additionalParentIndex) = additionalTobeChanged->getViewNet()->getNet()->retrieveAdditional(myParentAdditionals.at(additionalParentIndex)->getTagProperty().getTag(), newParentAdditionalID);
514  // add additional int the children of parent additional
515  myParentAdditionals.at(additionalParentIndex)->addChildAdditional(additionalTobeChanged);
516  // update geometry after inserting
517  additionalTobeChanged->updateGeometry();
518  }
519 }
520 
521 
522 void
523 GNEHierarchicalParentElements::replaceParentAdditional(GNEDemandElement* demandElementTobeChanged, const std::string& newParentAdditionalID, int additionalParentIndex) {
524  if ((int)myParentAdditionals.size() < additionalParentIndex) {
525  throw InvalidArgument(myAC->getTagStr() + " with ID '" + myAC->getID() + "' doesn't have " + toString(additionalParentIndex) + " parent additionals");
526  } else {
527  // remove demand element of the children of parent additional
528  myParentAdditionals.at(additionalParentIndex)->removeChildDemandElement(demandElementTobeChanged);
529  // set new parent demand element
530  myParentAdditionals.at(additionalParentIndex) = demandElementTobeChanged->getViewNet()->getNet()->retrieveAdditional(myParentAdditionals.at(additionalParentIndex)->getTagProperty().getTag(), newParentAdditionalID);
531  // add demand element int the children of parent additional
532  myParentAdditionals.at(additionalParentIndex)->removeChildDemandElement(demandElementTobeChanged);
533  // update geometry after inserting
534  demandElementTobeChanged->updateGeometry();
535  }
536 }
537 
538 
539 void
540 GNEHierarchicalParentElements::replaceParentDemandElement(GNEShape* shapeTobeChanged, const std::string& newParentDemandElementID, int demandElementParentIndex) {
541  if ((int)myParentDemandElements.size() < demandElementParentIndex) {
542  throw InvalidArgument(myAC->getTagStr() + " with ID '" + myAC->getID() + "' doesn't have " + toString(demandElementParentIndex) + " parent demand elements");
543  } else {
544  // remove demand element of the children of parent additional
545  myParentDemandElements.at(demandElementParentIndex)->removeChildShape(shapeTobeChanged);
546  // set new parent demand element
547  myParentDemandElements.at(demandElementParentIndex) = shapeTobeChanged->getNet()->retrieveDemandElement(myParentDemandElements.at(demandElementParentIndex)->getTagProperty().getTag(), newParentDemandElementID);
548  // add demand element int the children of parent additional
549  myParentDemandElements.at(demandElementParentIndex)->addChildShape(shapeTobeChanged);
550  // update geometry after inserting
551  shapeTobeChanged->updateGeometry();
552  }
553 }
554 
555 
556 void
557 GNEHierarchicalParentElements::replaceParentDemandElement(GNEAdditional* additionalTobeChanged, const std::string& newParentDemandElementID, int demandElementParentIndex) {
558  if ((int)myParentDemandElements.size() < demandElementParentIndex) {
559  throw InvalidArgument(myAC->getTagStr() + " with ID '" + myAC->getID() + "' doesn't have " + toString(demandElementParentIndex) + " parent demand elements");
560  } else {
561  // remove demand element of the children of parent additional
562  myParentDemandElements.at(demandElementParentIndex)->removeChildAdditional(additionalTobeChanged);
563  // set new parent demand element
564  myParentDemandElements.at(demandElementParentIndex) = additionalTobeChanged->getViewNet()->getNet()->retrieveDemandElement(myParentDemandElements.at(demandElementParentIndex)->getTagProperty().getTag(), newParentDemandElementID);
565  // add demand element int the children of parent additional
566  myParentDemandElements.at(demandElementParentIndex)->addChildAdditional(additionalTobeChanged);
567  // update geometry after inserting
568  additionalTobeChanged->updateGeometry();
569  }
570 }
571 
572 
573 void
574 GNEHierarchicalParentElements::replaceParentDemandElement(GNEDemandElement* demandElementTobeChanged, const std::string& newParentDemandElementID, int demandElementParentIndex) {
575  if ((int)myParentDemandElements.size() < demandElementParentIndex) {
576  throw InvalidArgument(myAC->getTagStr() + " with ID '" + myAC->getID() + "' doesn't have " + toString(demandElementParentIndex) + " parent demand elements");
577  } else {
578  // remove additional of the children of parent additional
579  myParentDemandElements.at(demandElementParentIndex)->removeChildDemandElement(demandElementTobeChanged);
580  // set new parent additional
581  myParentDemandElements.at(demandElementParentIndex) = demandElementTobeChanged->getViewNet()->getNet()->retrieveDemandElement(myParentDemandElements.at(demandElementParentIndex)->getTagProperty().getTag(), newParentDemandElementID);
582  // add additional int the children of parent additional
583  myParentDemandElements.at(demandElementParentIndex)->addChildDemandElement(demandElementTobeChanged);
584  // update geometry after inserting
585  demandElementTobeChanged->updateGeometry();
586  }
587 }
588 
589 /****************************************************************************/
GNEHierarchicalParentElements::myRouteEdges
std::vector< GNEEdge * > myRouteEdges
list of edges used in Flow/Trips/PersonTrips
Definition: GNEHierarchicalParentElements.h:240
GNEHierarchicalParentElements::replaceMiddleParentEdges
void replaceMiddleParentEdges(GNEDemandElement *elementChild, const std::vector< GNEEdge * > &newMiddleEdges, const bool updateChildReferences)
replace middle (via) parent edges
Definition: GNEHierarchicalParentElements.cpp:372
GNENet::retrieveAdditional
GNEAdditional * retrieveAdditional(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named additional.
Definition: GNENet.cpp:2183
GNEDemandElement
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEDemandElement.h:55
GNEHierarchicalParentElements::myParentAdditionals
std::vector< GNEAdditional * > myParentAdditionals
list of parent additionals of this element
Definition: GNEHierarchicalParentElements.h:249
GNEAdditional
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEAdditional.h:48
GNEAdditional.h
GNEHierarchicalParentElements::replaceParentEdges
void replaceParentEdges(GNEShape *elementChild, const std::string &newEdgeIDs)
replace the parent edges of a shape
Definition: GNEHierarchicalParentElements.cpp:276
GNEHierarchicalParentElements::getPathEdges
const std::vector< GNEEdge * > & getPathEdges() const
get path edges
Definition: GNEHierarchicalParentElements.cpp:203
GNEAttributeCarrier::getID
const std::string getID() const
function to support debugging
Definition: GNEAttributeCarrier.cpp:1289
GNEHierarchicalParentElements::replaceLastParentEdge
void replaceLastParentEdge(GNEDemandElement *elementChild, GNEEdge *newLastEdge)
replace the last parent edge (used by demand elements)
Definition: GNEHierarchicalParentElements.cpp:397
GNEHierarchicalParentElements::replacePathEdges
void replacePathEdges(GNEDemandElement *elementChild, const std::vector< GNEEdge * > &routeEdges)
replace edge route Parents
Definition: GNEHierarchicalParentElements.cpp:414
GNEHierarchicalParentElements::replaceFirstParentEdge
void replaceFirstParentEdge(GNEDemandElement *elementChild, GNEEdge *newFirstEdge)
replace the first parent edge (used by demand elements)
Definition: GNEHierarchicalParentElements.cpp:356
GNEHierarchicalParentElements::~GNEHierarchicalParentElements
~GNEHierarchicalParentElements()
Destructor.
Definition: GNEHierarchicalParentElements.cpp:58
GNEHierarchicalParentElements::getParentEdges
const std::vector< GNEEdge * > & getParentEdges() const
get parent edges
Definition: GNEHierarchicalParentElements.cpp:181
GNEHierarchicalParentElements.h
GNEHierarchicalParentElements::myParentLanes
std::vector< GNELane * > myParentLanes
list of parent lanes of this element
Definition: GNEHierarchicalParentElements.h:243
SUMO_TAG_LANE
@ SUMO_TAG_LANE
begin/end of the description of a single lane
Definition: SUMOXMLDefinitions.h:49
GNEHierarchicalParentElements::myParentDemandElements
std::vector< GNEDemandElement * > myParentDemandElements
list of demand elements parents of this element
Definition: GNEHierarchicalParentElements.h:252
GNENet::retrieveDemandElement
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
Definition: GNENet.cpp:2316
GNEHierarchicalParentElements::getParentLanes
const std::vector< GNELane * > & getParentLanes() const
get parent lanes
Definition: GNEHierarchicalParentElements.cpp:235
GNEHierarchicalParentElements::removeParentEdge
void removeParentEdge(GNEEdge *edge)
remove parent edge
Definition: GNEHierarchicalParentElements.cpp:165
GNEDemandElement::getViewNet
GNEViewNet * getViewNet() const
Returns a pointer to GNEViewNet in which demand element element is located.
Definition: GNEDemandElement.cpp:253
GLHelper.h
GNEHierarchicalParentElements::myParentEdges
std::vector< GNEEdge * > myParentEdges
list of parent edges of this element
Definition: GNEHierarchicalParentElements.h:237
GNEAttributeCarrier::TagProperties::getTag
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
Definition: GNEAttributeCarrier.cpp:523
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:51
GNEViewNet::getNet
GNENet * getNet() const
get the net object
Definition: GNEViewNet.cpp:1014
GNEHierarchicalParentElements::getParentAdditionals
const std::vector< GNEAdditional * > & getParentAdditionals() const
get parent additionals
Definition: GNEHierarchicalParentElements.cpp:85
GNEDemandElement::updateGeometry
virtual void updateGeometry()=0
update pre-computed geometry information
GNEAttributeCarrier::getTagProperty
const TagProperties & getTagProperty() const
get Tag Property assigned to this object
Definition: GNEAttributeCarrier.cpp:1273
GNEHierarchicalParentElements::getParentDemandElements
const std::vector< GNEDemandElement * > & getParentDemandElements() const
get parent demand elements
Definition: GNEHierarchicalParentElements.cpp:114
GNEShape
Definition: GNEShape.h:34
GNEDemandElement.h
GNEHierarchicalParentElements::myParentShapes
std::vector< GNEShape * > myParentShapes
list of parent shapes of this element
Definition: GNEHierarchicalParentElements.h:246
GNEViewNet.h
GNEHierarchicalParentElements::replaceParentLanes
void replaceParentLanes(GNEShape *elementChild, const std::string &newLaneIDs)
replace the parent edges of a shape
Definition: GNEHierarchicalParentElements.cpp:469
SUMO_TAG_EDGE
@ SUMO_TAG_EDGE
begin/end of the description of an edge
Definition: SUMOXMLDefinitions.h:47
ProcessError
Definition: UtilExceptions.h:39
GNEHierarchicalParentElements::getMiddleParentEdges
std::vector< GNEEdge * > getMiddleParentEdges() const
get middle (via) parent edges
Definition: GNEHierarchicalParentElements.cpp:187
GNEEdge.h
GNEShape::getNet
GNENet * getNet() const
get Net in which this element is placed
Definition: GNEShape.cpp:61
GNEHierarchicalParentElements::addParentLane
void addParentLane(GNELane *lane)
Definition: GNEHierarchicalParentElements.cpp:209
GNENetElement
Definition: GNENetElement.h:43
GNEHierarchicalParentElements::addParentDemandElement
void addParentDemandElement(GNEDemandElement *demandElement)
Definition: GNEHierarchicalParentElements.cpp:91
GNELane.h
GNEHierarchicalParentElements::replaceParentAdditional
void replaceParentAdditional(GNEShape *shapeTobeChanged, const std::string &newParentAdditionalID, int additionalParentIndex)
replace the parent additional of a shape
Definition: GNEHierarchicalParentElements.cpp:489
GNEHierarchicalParentElements::GNEHierarchicalParentElements
GNEHierarchicalParentElements(GNEAttributeCarrier *AC, const std::vector< GNEEdge * > &parentEdges, const std::vector< GNELane * > &parentLanes, const std::vector< GNEShape * > &parentShapes, const std::vector< GNEAdditional * > &parentAdditionals, const std::vector< GNEDemandElement * > &parentDemandElements)
Constructor used by elements that have another additionals as parent.
Definition: GNEHierarchicalParentElements.cpp:42
GNEHierarchicalParentElements::myAC
GNEAttributeCarrier * myAC
pointer to AC (needed to avoid diamond problem)
Definition: GNEHierarchicalParentElements.h:255
GNEHierarchicalParentElements::getNewListOfParents
std::string getNewListOfParents(const GNENetElement *currentElement, const GNENetElement *newNextElement) const
if use edge/parent lanes as a list of consecutive elements, obtain a list of IDs of elements after in...
Definition: GNEHierarchicalParentElements.cpp:120
GNEShape.h
GLIncludes.h
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
GNEHierarchicalParentElements::addParentAdditional
void addParentAdditional(GNEAdditional *additional)
Definition: GNEHierarchicalParentElements.cpp:62
GNEHierarchicalParentElements::removeParentDemandElement
void removeParentDemandElement(GNEDemandElement *demandElement)
remove parent demand element
Definition: GNEHierarchicalParentElements.cpp:102
InvalidArgument
Definition: UtilExceptions.h:56
GNEShape::updateGeometry
virtual void updateGeometry()=0
update pre-computed geometry information
GNEAdditional::getViewNet
GNEViewNet * getViewNet() const
Returns a pointer to GNEViewNet in which additional element is located.
Definition: GNEAdditional.cpp:307
GNEHierarchicalParentElements::getParentShapes
const std::vector< GNEShape * > & getParentShapes() const
get parent shapes
Definition: GNEHierarchicalParentElements.cpp:267
GNEHierarchicalParentElements::addParentShape
void addParentShape(GNEShape *shape)
Definition: GNEHierarchicalParentElements.cpp:241
GNEHierarchicalParentElements::replaceParentDemandElement
void replaceParentDemandElement(GNEShape *shapeTobeChanged, const std::string &newParentDemandElementID, int demandElementParentIndex)
replace the parent demand element of a shape
Definition: GNEHierarchicalParentElements.cpp:540
config.h
GNEHierarchicalParentElements::removeParentLane
void removeParentLane(GNELane *lane)
remove parent lane
Definition: GNEHierarchicalParentElements.cpp:222
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition: GNEAttributeCarrier.cpp:1267
GNEAdditional::updateGeometry
virtual void updateGeometry()=0
update pre-computed geometry information
GNEHierarchicalParentElements::removeParentAdditional
void removeParentAdditional(GNEAdditional *additional)
remove parent additional
Definition: GNEHierarchicalParentElements.cpp:73
GNEHierarchicalParentElements::addParentEdge
void addParentEdge(GNEEdge *edge)
Definition: GNEHierarchicalParentElements.cpp:152
GNELane
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:45
GNEAttributeCarrier
Definition: GNEAttributeCarrier.h:54
GNENet.h
GNEHierarchicalParentElements::removeParentShape
void removeParentShape(GNEShape *shape)
remove parent shape
Definition: GNEHierarchicalParentElements.cpp:254