Eclipse SUMO - Simulation of Urban MObility
GNEHierarchicalElementParents.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 abstract class for representation of additional elements
16 /****************************************************************************/
17 
18 // ===========================================================================
19 // included modules
20 // ===========================================================================
21 #include <config.h>
22 
23 #include <netedit/GNENet.h>
24 #include <netedit/GNEViewNet.h>
30 #include <utils/gui/div/GLHelper.h>
32 
34 
35 // ===========================================================================
36 // member method definitions
37 // ===========================================================================
38 
39 // ---------------------------------------------------------------------------
40 // GNEHierarchicalElementParents - methods
41 // ---------------------------------------------------------------------------
42 
44  const std::vector<GNEEdge*>& edgeParents,
45  const std::vector<GNELane*>& laneParents,
46  const std::vector<GNEShape*>& shapeParents,
47  const std::vector<GNEAdditional*>& additionalParents,
48  const std::vector<GNEDemandElement*>& demandElementParents) :
49  myParentConnections(this),
50  myEdgeParents(edgeParents),
51  myLaneParents(laneParents),
52  myShapeParents(shapeParents),
53  myAdditionalParents(additionalParents),
54  myDemandElementParents(demandElementParents),
55  myAC(AC) {
56 }
57 
58 
60 
61 
62 void
64  // First check that additional wasn't already inserted
65  if (std::find(myAdditionalParents.begin(), myAdditionalParents.end(), additional) != myAdditionalParents.end()) {
66  throw ProcessError(additional->getTagStr() + " with ID='" + additional->getID() + "' was already inserted in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
67  } else {
68  myAdditionalParents.push_back(additional);
69  }
70 }
71 
72 
73 void
75  // First check that additional was already inserted
76  auto it = std::find(myAdditionalParents.begin(), myAdditionalParents.end(), additional);
77  if (it == myAdditionalParents.end()) {
78  throw ProcessError(additional->getTagStr() + " with ID='" + additional->getID() + "' doesn't exist in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
79  } else {
80  myAdditionalParents.erase(it);
81  }
82 }
83 
84 
85 const std::vector<GNEAdditional*>&
87  return myAdditionalParents;
88 }
89 
90 
91 void
93  // First check that demandElement wasn't already inserted
94  if (std::find(myDemandElementParents.begin(), myDemandElementParents.end(), demandElement) != myDemandElementParents.end()) {
95  throw ProcessError(demandElement->getTagStr() + " with ID='" + demandElement->getID() + "' was already inserted in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
96  } else {
97  myDemandElementParents.push_back(demandElement);
98  }
99 }
100 
101 
102 void
104  // First check that demandElement was already inserted
105  auto it = std::find(myDemandElementParents.begin(), myDemandElementParents.end(), demandElement);
106  if (it == myDemandElementParents.end()) {
107  throw ProcessError(demandElement->getTagStr() + " with ID='" + demandElement->getID() + "' doesn't exist in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
108  } else {
109  myDemandElementParents.erase(it);
110  }
111 }
112 
113 
114 const std::vector<GNEDemandElement*>&
116  return myDemandElementParents;
117 }
118 
119 
120 void
122  // Check that edge is valid and doesn't exist previously
123  if (edge == nullptr) {
124  throw InvalidArgument("Trying to add an empty " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
125  } else if (std::find(myEdgeParents.begin(), myEdgeParents.end(), edge) != myEdgeParents.end()) {
126  throw InvalidArgument("Trying to add a duplicate " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
127  } else {
128  myEdgeParents.push_back(edge);
129  }
130 }
131 
132 
133 void
135  // Check that edge is valid and exist previously
136  if (edge == nullptr) {
137  throw InvalidArgument("Trying to remove an empty " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
138  } else {
139  auto it = std::find(myEdgeParents.begin(), myEdgeParents.end(), edge);
140  if (it == myEdgeParents.end()) {
141  throw InvalidArgument("Trying to remove a non previously inserted " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
142  } else {
143  myEdgeParents.erase(it);
144  }
145  }
146 }
147 
148 
149 const std::vector<GNEEdge*>&
151  return myEdgeParents;
152 }
153 
154 
155 void
157  // Check that lane is valid and doesn't exist previously
158  if (lane == nullptr) {
159  throw InvalidArgument("Trying to add an empty " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
160  } else if (std::find(myLaneParents.begin(), myLaneParents.end(), lane) != myLaneParents.end()) {
161  throw InvalidArgument("Trying to add a duplicate " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
162  } else {
163  myLaneParents.push_back(lane);
164  }
165 }
166 
167 
168 void
170  // Check that lane is valid and exist previously
171  if (lane == nullptr) {
172  throw InvalidArgument("Trying to remove an empty " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
173  } else if (std::find(myLaneParents.begin(), myLaneParents.end(), lane) == myLaneParents.end()) {
174  throw InvalidArgument("Trying to remove a non previously inserted " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
175  } else {
176  myLaneParents.erase(std::find(myLaneParents.begin(), myLaneParents.end(), lane));
177  }
178 }
179 
180 
181 const std::vector<GNELane*>&
183  return myLaneParents;
184 }
185 
186 
187 void
189  // Check that shape is valid and doesn't exist previously
190  if (shape == nullptr) {
191  throw InvalidArgument("Trying to add an empty " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
192  } else if (std::find(myShapeParents.begin(), myShapeParents.end(), shape) != myShapeParents.end()) {
193  throw InvalidArgument("Trying to add a duplicate " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
194  } else {
195  myShapeParents.push_back(shape);
196  }
197 }
198 
199 
200 void
202  // Check that shape is valid and exist previously
203  if (shape == nullptr) {
204  throw InvalidArgument("Trying to remove an empty " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
205  } else if (std::find(myShapeParents.begin(), myShapeParents.end(), shape) == myShapeParents.end()) {
206  throw InvalidArgument("Trying to remove a non previously inserted " + toString(SUMO_TAG_EDGE) + " parent in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'");
207  } else {
208  myShapeParents.erase(std::find(myShapeParents.begin(), myShapeParents.end(), shape));
209  }
210 }
211 
212 
213 const std::vector<GNEShape*>&
215  return myShapeParents;
216 }
217 
218 // ---------------------------------------------------------------------------
219 // GNEHierarchicalElementParents::ParentConnections - methods
220 // ---------------------------------------------------------------------------
221 
223  myHierarchicalElement(hierarchicalElement) {}
224 
225 
226 void
228  // first clear connection positions
229  connectionPositions.clear();
230  symbolsPositionAndRotation.clear();
231 
232  // calculate position and rotation of every simbol for every edge
233  for (auto i : myHierarchicalElement->myEdgeParents) {
234  for (auto j : i->getLanes()) {
235  std::pair<Position, double> posRot;
236  // set position and lenght depending of shape's lengt
237  if (j->getGeometry().shape.length() - 6 > 0) {
238  posRot.first = j->getGeometry().shape.positionAtOffset(j->getGeometry().shape.length() - 6);
239  posRot.second = j->getGeometry().shape.rotationDegreeAtOffset(j->getGeometry().shape.length() - 6);
240  } else {
241  posRot.first = j->getGeometry().shape.positionAtOffset(j->getGeometry().shape.length());
242  posRot.second = j->getGeometry().shape.rotationDegreeAtOffset(j->getGeometry().shape.length());
243  }
244  symbolsPositionAndRotation.push_back(posRot);
245  }
246  }
247 
248  // calculate position and rotation of every symbol for every lane
249  for (auto i : myHierarchicalElement->myLaneParents) {
250  std::pair<Position, double> posRot;
251  // set position and lenght depending of shape's lengt
252  if (i->getGeometry().shape.length() - 6 > 0) {
253  posRot.first = i->getGeometry().shape.positionAtOffset(i->getGeometry().shape.length() - 6);
254  posRot.second = i->getGeometry().shape.rotationDegreeAtOffset(i->getGeometry().shape.length() - 6);
255  } else {
256  posRot.first = i->getGeometry().shape.positionAtOffset(i->getGeometry().shape.length());
257  posRot.second = i->getGeometry().shape.rotationDegreeAtOffset(i->getGeometry().shape.length());
258  }
259  symbolsPositionAndRotation.push_back(posRot);
260  }
261 
262  // calculate position for every additional parent
263  for (auto i : myHierarchicalElement->myAdditionalParents) {
264  // check that position is different of position
265  if (i->getPositionInView() != myHierarchicalElement->getPositionInView()) {
266  std::vector<Position> posConnection;
267  double A = std::abs(i->getPositionInView().x() - myHierarchicalElement->getPositionInView().x());
268  double B = std::abs(i->getPositionInView().y() - myHierarchicalElement->getPositionInView().y());
269  // Set positions of connection's vertex. Connection is build from Entry to E3
270  posConnection.push_back(i->getPositionInView());
271  if (myHierarchicalElement->getPositionInView().x() > i->getPositionInView().x()) {
272  if (myHierarchicalElement->getPositionInView().y() > i->getPositionInView().y()) {
273  posConnection.push_back(Position(i->getPositionInView().x() + A, i->getPositionInView().y()));
274  } else {
275  posConnection.push_back(Position(i->getPositionInView().x(), i->getPositionInView().y() - B));
276  }
277  } else {
278  if (myHierarchicalElement->getPositionInView().y() > i->getPositionInView().y()) {
279  posConnection.push_back(Position(i->getPositionInView().x(), i->getPositionInView().y() + B));
280  } else {
281  posConnection.push_back(Position(i->getPositionInView().x() - A, i->getPositionInView().y()));
282  }
283  }
284  posConnection.push_back(myHierarchicalElement->getPositionInView());
285  connectionPositions.push_back(posConnection);
286  }
287  }
288 
289  // calculate geometry for connections between parent and parents
290  for (auto i : symbolsPositionAndRotation) {
291  std::vector<Position> posConnection;
292  double A = std::abs(i.first.x() - myHierarchicalElement->getPositionInView().x());
293  double B = std::abs(i.first.y() - myHierarchicalElement->getPositionInView().y());
294  // Set positions of connection's vertex. Connection is build from Entry to E3
295  posConnection.push_back(i.first);
296  if (myHierarchicalElement->getPositionInView().x() > i.first.x()) {
297  if (myHierarchicalElement->getPositionInView().y() > i.first.y()) {
298  posConnection.push_back(Position(i.first.x() + A, i.first.y()));
299  } else {
300  posConnection.push_back(Position(i.first.x(), i.first.y() - B));
301  }
302  } else {
303  if (myHierarchicalElement->getPositionInView().y() > i.first.y()) {
304  posConnection.push_back(Position(i.first.x(), i.first.y() + B));
305  } else {
306  posConnection.push_back(Position(i.first.x() - A, i.first.y()));
307  }
308  }
309  posConnection.push_back(myHierarchicalElement->getPositionInView());
310  connectionPositions.push_back(posConnection);
311  }
312 }
313 
314 
315 void
317  // Iterate over myConnectionPositions
318  for (const PositionVector& i : connectionPositions) {
319  // Add a draw matrix
320  glPushMatrix();
321  // translate in the Z axis
322  glTranslated(0, 0, parentType - 0.01);
323  // Set color of the base
325  // iterate over connections
326  for (PositionVector::const_iterator j = i.begin(); (j + 1) != i.end(); ++j) {
327  // Draw Lines
328  GLHelper::drawLine((*j), (*(j + 1)));
329  }
330  // Pop draw matrix
331  glPopMatrix();
332  }
333 }
334 
335 
336 // ---------------------------------------------------------------------------
337 // GNEHierarchicalElementParents - protected methods
338 // ---------------------------------------------------------------------------
339 void
340 GNEHierarchicalElementParents::changeEdgeParents(GNEShape* elementChild, const std::string& newEdgeIDs) {
341  // remove additional of edge parents
342  for (const auto& i : myEdgeParents) {
343  i->removeShapeChild(elementChild);
344  }
345  // obtain new parent edges
346  myEdgeParents = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(elementChild->getNet(), newEdgeIDs);
347  // check that lane parets aren't empty
348  if (myEdgeParents.empty()) {
349  throw InvalidArgument("New list of edge parents cannot be empty");
350  } else {
351  // add additional into edge parents
352  for (const auto& i : myEdgeParents) {
353  i->addShapeChild(elementChild);
354  }
355  }
356 }
357 
358 
359 void
360 GNEHierarchicalElementParents::changeEdgeParents(GNEAdditional* elementChild, const std::string& newEdgeIDs) {
361  // remove additional of edge parents
362  for (const auto& i : myEdgeParents) {
363  i->removeAdditionalChild(elementChild);
364  }
365  // obtain new parent edges
366  myEdgeParents = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(elementChild->getViewNet()->getNet(), newEdgeIDs);
367  // check that lane parets aren't empty
368  if (myEdgeParents.empty()) {
369  throw InvalidArgument("New list of edge parents cannot be empty");
370  } else {
371  // add additional into edge parents
372  for (const auto& i : myEdgeParents) {
373  i->addAdditionalChild(elementChild);
374  }
375  }
376 }
377 
378 
379 void
380 GNEHierarchicalElementParents::changeEdgeParents(GNEDemandElement* elementChild, const std::string& newEdgeIDs) {
381  // remove demandElement of edge parents
382  for (const auto& i : myEdgeParents) {
383  i->removeDemandElementChild(elementChild);
384  }
385  // obtain new parent edges
386  myEdgeParents = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(elementChild->getViewNet()->getNet(), newEdgeIDs);
387  // check that lane parets aren't empty
388  if (myEdgeParents.empty()) {
389  throw InvalidArgument("New list of edge parents cannot be empty");
390  } else {
391  // add demandElement into edge parents
392  for (const auto& i : myEdgeParents) {
393  i->addDemandElementChild(elementChild);
394  }
395  }
396 }
397 
398 
399 void
400 GNEHierarchicalElementParents::changeEdgeParents(GNEDemandElement* elementChild, const std::vector<GNEEdge*>& newEdges) {
401  // remove demandElement of edge parents
402  for (const auto& i : myEdgeParents) {
403  i->removeDemandElementChild(elementChild);
404  }
405  // set new edges
406  myEdgeParents = newEdges;
407  // check that lane parets aren't empty
408  if (myEdgeParents.empty()) {
409  throw InvalidArgument("New list of edge parents cannot be empty");
410  } else {
411  // add demandElement into edge parents
412  for (const auto& i : myEdgeParents) {
413  i->addDemandElementChild(elementChild);
414  }
415  }
416 }
417 
418 
419 void
420 GNEHierarchicalElementParents::changeLaneParents(GNEAdditional* elementChild, const std::string& newLaneIDs) {
421  // remove additional of edge parents
422  for (const auto& i : myLaneParents) {
423  i->removeAdditionalChild(elementChild);
424  }
425  // obtain new parent edges
426  myLaneParents = GNEAttributeCarrier::parse<std::vector<GNELane*> >(elementChild->getViewNet()->getNet(), newLaneIDs);
427  // check that lane parets aren't empty
428  if (myLaneParents.empty()) {
429  throw InvalidArgument("New list of lane parents cannot be empty");
430  } else {
431  // add additional into edge parents
432  for (const auto& i : myLaneParents) {
433  i->addAdditionalChild(elementChild);
434  }
435  }
436 }
437 
438 
439 void
440 GNEHierarchicalElementParents::changeLaneParents(GNEDemandElement* elementChild, const std::string& newLaneIDs) {
441  // remove demandElement of edge parents
442  for (const auto& i : myLaneParents) {
443  i->removeDemandElementChild(elementChild);
444  }
445  // obtain new parent edges
446  myLaneParents = GNEAttributeCarrier::parse<std::vector<GNELane*> >(elementChild->getViewNet()->getNet(), newLaneIDs);
447  // check that lane parets aren't empty
448  if (myLaneParents.empty()) {
449  throw InvalidArgument("New list of lane parents cannot be empty");
450  } else {
451  // add demandElement into edge parents
452  for (const auto& i : myLaneParents) {
453  i->addDemandElementChild(elementChild);
454  }
455  }
456 }
457 
458 
459 void
460 GNEHierarchicalElementParents::changeLaneParents(GNEShape* elementChild, const std::string& newLaneIDs) {
461  // remove demandElement of edge parents
462  for (const auto& i : myLaneParents) {
463  i->removeShapeChild(elementChild);
464  }
465  // obtain new parent edges
466  myLaneParents = GNEAttributeCarrier::parse<std::vector<GNELane*> >(elementChild->getNet(), newLaneIDs);
467  // check that lane parets aren't empty
468  if (myLaneParents.empty()) {
469  throw InvalidArgument("New list of lane parents cannot be empty");
470  } else {
471  // add demandElement into edge parents
472  for (const auto& i : myLaneParents) {
473  i->addShapeChild(elementChild);
474  }
475  }
476 }
477 
478 
479 void
480 GNEHierarchicalElementParents::changeAdditionalParent(GNEShape* shapeTobeChanged, const std::string& newAdditionalParentID, int additionalParentIndex) {
481  if ((int)myAdditionalParents.size() < additionalParentIndex) {
482  throw InvalidArgument(myAC->getTagStr() + " with ID '" + myAC->getID() + "' doesn't have " + toString(additionalParentIndex) + " additional parents");
483  } else {
484  // remove additional of the children of parent additional
485  myAdditionalParents.at(additionalParentIndex)->removeShapeChild(shapeTobeChanged);
486  // set new additional parent
487  myAdditionalParents.at(additionalParentIndex) = shapeTobeChanged->getNet()->retrieveAdditional(myAdditionalParents.at(additionalParentIndex)->getTagProperty().getTag(), newAdditionalParentID);
488  // add additional int the children of parent additional
489  myAdditionalParents.at(additionalParentIndex)->addShapeChild(shapeTobeChanged);
490  // update geometry after inserting
491  shapeTobeChanged->updateGeometry();
492  }
493 }
494 
495 
496 void
497 GNEHierarchicalElementParents::changeAdditionalParent(GNEAdditional* additionalTobeChanged, const std::string& newAdditionalParentID, int additionalParentIndex) {
498  if ((int)myAdditionalParents.size() < additionalParentIndex) {
499  throw InvalidArgument(myAC->getTagStr() + " with ID '" + myAC->getID() + "' doesn't have " + toString(additionalParentIndex) + " additional parents");
500  } else {
501  // remove additional of the children of parent additional
502  myAdditionalParents.at(additionalParentIndex)->removeAdditionalChild(additionalTobeChanged);
503  // set new additional parent
504  myAdditionalParents.at(additionalParentIndex) = additionalTobeChanged->getViewNet()->getNet()->retrieveAdditional(myAdditionalParents.at(additionalParentIndex)->getTagProperty().getTag(), newAdditionalParentID);
505  // add additional int the children of parent additional
506  myAdditionalParents.at(additionalParentIndex)->addAdditionalChild(additionalTobeChanged);
507  // update geometry after inserting
508  additionalTobeChanged->updateGeometry();
509  }
510 }
511 
512 
513 void
514 GNEHierarchicalElementParents::changeAdditionalParent(GNEDemandElement* demandElementTobeChanged, const std::string& newAdditionalParentID, int additionalParentIndex) {
515  if ((int)myAdditionalParents.size() < additionalParentIndex) {
516  throw InvalidArgument(myAC->getTagStr() + " with ID '" + myAC->getID() + "' doesn't have " + toString(additionalParentIndex) + " additional parents");
517  } else {
518  // remove demand element of the children of parent additional
519  myAdditionalParents.at(additionalParentIndex)->removeDemandElementChild(demandElementTobeChanged);
520  // set new demand element parent
521  myAdditionalParents.at(additionalParentIndex) = demandElementTobeChanged->getViewNet()->getNet()->retrieveAdditional(myAdditionalParents.at(additionalParentIndex)->getTagProperty().getTag(), newAdditionalParentID);
522  // add demand element int the children of parent additional
523  myAdditionalParents.at(additionalParentIndex)->removeDemandElementChild(demandElementTobeChanged);
524  // update geometry after inserting
525  demandElementTobeChanged->updateGeometry();
526  }
527 }
528 
529 
530 void
531 GNEHierarchicalElementParents::changeDemandElementParent(GNEShape* shapeTobeChanged, const std::string& newDemandElementParentID, int demandElementParentIndex) {
532  if ((int)myDemandElementParents.size() < demandElementParentIndex) {
533  throw InvalidArgument(myAC->getTagStr() + " with ID '" + myAC->getID() + "' doesn't have " + toString(demandElementParentIndex) + " demand element parents");
534  } else {
535  // remove demand element of the children of parent additional
536  myDemandElementParents.at(demandElementParentIndex)->removeShapeChild(shapeTobeChanged);
537  // set new demand element parent
538  myDemandElementParents.at(demandElementParentIndex) = shapeTobeChanged->getNet()->retrieveDemandElement(myDemandElementParents.at(demandElementParentIndex)->getTagProperty().getTag(), newDemandElementParentID);
539  // add demand element int the children of parent additional
540  myDemandElementParents.at(demandElementParentIndex)->addShapeChild(shapeTobeChanged);
541  // update geometry after inserting
542  shapeTobeChanged->updateGeometry();
543  }
544 }
545 
546 
547 void
548 GNEHierarchicalElementParents::changeDemandElementParent(GNEAdditional* additionalTobeChanged, const std::string& newDemandElementParentID, int demandElementParentIndex) {
549  if ((int)myDemandElementParents.size() < demandElementParentIndex) {
550  throw InvalidArgument(myAC->getTagStr() + " with ID '" + myAC->getID() + "' doesn't have " + toString(demandElementParentIndex) + " demand element parents");
551  } else {
552  // remove demand element of the children of parent additional
553  myDemandElementParents.at(demandElementParentIndex)->removeAdditionalChild(additionalTobeChanged);
554  // set new demand element parent
555  myDemandElementParents.at(demandElementParentIndex) = additionalTobeChanged->getViewNet()->getNet()->retrieveDemandElement(myDemandElementParents.at(demandElementParentIndex)->getTagProperty().getTag(), newDemandElementParentID);
556  // add demand element int the children of parent additional
557  myDemandElementParents.at(demandElementParentIndex)->addAdditionalChild(additionalTobeChanged);
558  // update geometry after inserting
559  additionalTobeChanged->updateGeometry();
560  }
561 }
562 
563 
564 void
565 GNEHierarchicalElementParents::changeDemandElementParent(GNEDemandElement* demandElementTobeChanged, const std::string& newDemandElementParentID, int demandElementParentIndex) {
566  if ((int)myDemandElementParents.size() < demandElementParentIndex) {
567  throw InvalidArgument(myAC->getTagStr() + " with ID '" + myAC->getID() + "' doesn't have " + toString(demandElementParentIndex) + " demand element parents");
568  } else {
569  // remove additional of the children of parent additional
570  myDemandElementParents.at(demandElementParentIndex)->removeDemandElementChild(demandElementTobeChanged);
571  // set new additional parent
572  myDemandElementParents.at(demandElementParentIndex) = demandElementTobeChanged->getViewNet()->getNet()->retrieveDemandElement(myDemandElementParents.at(demandElementParentIndex)->getTagProperty().getTag(), newDemandElementParentID);
573  // add additional int the children of parent additional
574  myDemandElementParents.at(demandElementParentIndex)->addDemandElementChild(demandElementTobeChanged);
575  // update geometry after inserting
576  demandElementTobeChanged->updateGeometry();
577  }
578 }
579 
580 /****************************************************************************/
GNEHierarchicalElementParents::myDemandElementParents
std::vector< GNEDemandElement * > myDemandElementParents
list of demand elements parents of this element
Definition: GNEHierarchicalElementParents.h:249
GNENet::retrieveAdditional
GNEAdditional * retrieveAdditional(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named additional.
Definition: GNENet.cpp:2133
GNEDemandElement
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEDemandElement.h:54
GNEAdditional
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEAdditional.h:47
GNEAdditional.h
GNEAttributeCarrier::getID
const std::string getID() const
function to support debugging
Definition: GNEAttributeCarrier.cpp:1187
GNEHierarchicalElementParents::myAC
GNEAttributeCarrier * myAC
pointer to AC (needed to avoid diamond problem)
Definition: GNEHierarchicalElementParents.h:252
GNEHierarchicalElementParents::changeAdditionalParent
void changeAdditionalParent(GNEShape *shapeTobeChanged, const std::string &newAdditionalParentID, int additionalParentIndex)
change additional parent of a shape
Definition: GNEHierarchicalElementParents.cpp:480
GNEHierarchicalElementParents::GNEHierarchicalElementParents
GNEHierarchicalElementParents(GNEAttributeCarrier *AC, const std::vector< GNEEdge * > &edgeParents, const std::vector< GNELane * > &laneParents, const std::vector< GNEShape * > &shapeParents, const std::vector< GNEAdditional * > &additionalParents, const std::vector< GNEDemandElement * > &demandElementParents)
Constructor used by elements that have another additionals as parent.
Definition: GNEHierarchicalElementParents.cpp:43
GNEHierarchicalElementParents::getShapeParents
const std::vector< GNEShape * > & getShapeParents() const
get shapes of VSS
Definition: GNEHierarchicalElementParents.cpp:214
GNENet::retrieveDemandElement
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
Definition: GNENet.cpp:2266
GNEHierarchicalElementParents::getEdgeParents
const std::vector< GNEEdge * > & getEdgeParents() const
get edge parents
Definition: GNEHierarchicalElementParents.cpp:150
GNEHierarchicalElementParents::myAdditionalParents
std::vector< GNEAdditional * > myAdditionalParents
list of additional parents of this element
Definition: GNEHierarchicalElementParents.h:246
GNEDemandElement::getViewNet
GNEViewNet * getViewNet() const
Returns a pointer to GNEViewNet in which demand element element is located.
Definition: GNEDemandElement.cpp:408
GUIVisualizationColorSettings::childConnections
static const RGBColor childConnections
color for child connections between parents and child elements
Definition: GUIVisualizationSettings.h:163
GLHelper.h
GNEHierarchicalElementParents::ParentConnections::draw
void draw(const GUIVisualizationSettings &s, const GUIGlObjectType parentType) const
draw connections between Parent and childrens
Definition: GNEHierarchicalElementParents.cpp:316
GNEHierarchicalElementParents
An special type of Attribute carrier that owns hierarchical elements.
Definition: GNEHierarchicalElementParents.h:48
PositionVector
A list of positions.
Definition: PositionVector.h:46
GNEHierarchicalElementParents::addLaneParent
void addLaneParent(GNELane *lane)
Definition: GNEHierarchicalElementParents.cpp:156
GLHelper::setColor
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:616
GNEHierarchicalElementParents::addDemandElementParent
void addDemandElementParent(GNEDemandElement *demandElement)
Definition: GNEHierarchicalElementParents.cpp:92
GUIGlObjectType
GUIGlObjectType
Definition: GUIGlObjectTypes.h:40
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:50
GNEHierarchicalElementParents::removeShapeParent
void removeShapeParent(GNEShape *shape)
remove shape parent
Definition: GNEHierarchicalElementParents.cpp:201
GNEHierarchicalElementParents::getLaneParents
const std::vector< GNELane * > & getLaneParents() const
get lanes of VSS
Definition: GNEHierarchicalElementParents.cpp:182
GNEViewNet::getNet
GNENet * getNet() const
get the net object
Definition: GNEViewNet.cpp:927
GNEHierarchicalElementParents::myLaneParents
std::vector< GNELane * > myLaneParents
list of lane parents of this element
Definition: GNEHierarchicalElementParents.h:240
GNEDemandElement::updateGeometry
virtual void updateGeometry()=0
update pre-computed geometry information
GNEShape
Definition: GNEShape.h:35
GNEDemandElement.h
GNEViewNet.h
SUMO_TAG_EDGE
begin/end of the description of an edge
Definition: SUMOXMLDefinitions.h:48
GNEHierarchicalElementParents::removeLaneParent
void removeLaneParent(GNELane *lane)
remove lane parent
Definition: GNEHierarchicalElementParents.cpp:169
ProcessError
Definition: UtilExceptions.h:40
GNEHierarchicalElementParents::changeDemandElementParent
void changeDemandElementParent(GNEShape *shapeTobeChanged, const std::string &newDemandElementParentID, int demandElementParentIndex)
change first demand element parent of a shape
Definition: GNEHierarchicalElementParents.cpp:531
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:39
GNEEdge.h
GLHelper::drawLine
static void drawLine(const Position &beg, double rot, double visLength)
Draws a thin line.
Definition: GLHelper.cpp:274
GNEShape::getNet
GNENet * getNet() const
get Net in which this element is placed
Definition: GNEShape.cpp:62
GNELane.h
GNEShape.h
GNEHierarchicalElementParents::addAdditionalParent
void addAdditionalParent(GNEAdditional *additional)
Definition: GNEHierarchicalElementParents.cpp:63
GNEHierarchicalElementParents::addEdgeParent
void addEdgeParent(GNEEdge *edge)
Definition: GNEHierarchicalElementParents.cpp:121
GLIncludes.h
GNEHierarchicalElementParents::myShapeParents
std::vector< GNEShape * > myShapeParents
list of shape parents of this element
Definition: GNEHierarchicalElementParents.h:243
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:48
GNEHierarchicalElementParents::removeDemandElementParent
void removeDemandElementParent(GNEDemandElement *demandElement)
remove demand element parent from this demand element
Definition: GNEHierarchicalElementParents.cpp:103
GNEHierarchicalElementParents::getDemandElementParents
const std::vector< GNEDemandElement * > & getDemandElementParents() const
return vector of demand elements that have as Parent this edge (For example, Calibrators)
Definition: GNEHierarchicalElementParents.cpp:115
GNEHierarchicalElementParents::getAdditionalParents
const std::vector< GNEAdditional * > & getAdditionalParents() const
return vector of additionals that have as Parent this edge (For example, Calibrators)
Definition: GNEHierarchicalElementParents.cpp:86
GNEHierarchicalElementParents::ParentConnections::ParentConnections
ParentConnections(GNEHierarchicalElementParents *hierarchicalElement)
constructor
Definition: GNEHierarchicalElementParents.cpp:222
InvalidArgument
Definition: UtilExceptions.h:57
GNEHierarchicalElementParents::addShapeParent
void addShapeParent(GNEShape *shape)
Definition: GNEHierarchicalElementParents.cpp:188
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:387
GNEHierarchicalElementParents.h
GNEHierarchicalElementParents::changeLaneParents
void changeLaneParents(GNEShape *elementChild, const std::string &newLaneIDs)
change edge parents of a shape
Definition: GNEHierarchicalElementParents.cpp:460
config.h
GNEHierarchicalElementParents::ParentConnections::update
void update()
update Connection's geometry
Definition: GNEHierarchicalElementParents.cpp:227
GNEHierarchicalElementParents::removeAdditionalParent
void removeAdditionalParent(GNEAdditional *additional)
remove additional parent from this additional
Definition: GNEHierarchicalElementParents.cpp:74
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition: GNEAttributeCarrier.cpp:1165
GNEHierarchicalElementParents::myEdgeParents
std::vector< GNEEdge * > myEdgeParents
list of edge parents of this element
Definition: GNEHierarchicalElementParents.h:237
GUIVisualizationSettings
Stores the information about how to visualize structures.
Definition: GUIVisualizationSettings.h:346
GNEHierarchicalElementParents::changeEdgeParents
void changeEdgeParents(GNEShape *elementChild, const std::string &newEdgeIDs)
change edge parents of a shape
Definition: GNEHierarchicalElementParents.cpp:340
GNEHierarchicalElementParents::~GNEHierarchicalElementParents
~GNEHierarchicalElementParents()
Destructor.
Definition: GNEHierarchicalElementParents.cpp:59
GNEAdditional::updateGeometry
virtual void updateGeometry()=0
update pre-computed geometry information
GNELane
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:46
GNEAttributeCarrier
Definition: GNEAttributeCarrier.h:54
GNEHierarchicalElementParents::removeEdgeParent
void removeEdgeParent(GNEEdge *edge)
remove edge parent
Definition: GNEHierarchicalElementParents.cpp:134
GNENet.h