Eclipse SUMO - Simulation of Urban MObility
GNERouteHandler.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 // Builds demand objects for netedit
15 /****************************************************************************/
16 
17 // ===========================================================================
18 // included modules
19 // ===========================================================================
20 #include <config.h>
21 #include <netedit/GNENet.h>
22 #include <netedit/GNEUndoList.h>
23 #include <netedit/GNEViewNet.h>
32 
33 #include "GNEPerson.h"
34 #include "GNEPersonTrip.h"
35 #include "GNERide.h"
36 #include "GNERoute.h"
37 #include "GNERouteHandler.h"
38 #include "GNEStop.h"
39 #include "GNEVehicle.h"
40 #include "GNEVehicleType.h"
41 #include "GNEWalk.h"
42 
43 
44 // ===========================================================================
45 // member method definitions
46 // ===========================================================================
47 
48 // ---------------------------------------------------------------------------
49 // GNERouteHandler::RouteParameter - methods
50 // ---------------------------------------------------------------------------
51 
53  loadedID(false),
54  vClass(SVC_PASSENGER),
55  color(RGBColor::BLACK) {
56 }
57 
58 
60  routeID(originalDemandElement->getTagProperty().isRoute() ?
61  originalDemandElement->getID() :
62  originalDemandElement->getViewNet()->getNet()->generateDemandElementID(originalDemandElement->getID(), SUMO_TAG_ROUTE)),
63  edges(originalDemandElement->getParentEdges()),
64  vClass(originalDemandElement->getVClass()),
65  color(originalDemandElement->getColor()) {
66 }
67 
68 
69 void
70 GNERouteHandler::RouteParameter::setEdges(GNEViewNet* viewNet, const std::string& edgeIDs) {
71  // clear edges
72  edges.clear();
73  // obtain edges (And show warnings if isn't valid)
74  if (GNEAttributeCarrier::canParse<std::vector<GNEEdge*> >(viewNet->getNet(), edgeIDs, true)) {
75  edges = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(viewNet->getNet(), edgeIDs);
76  }
77 }
78 
79 
80 void
81 GNERouteHandler::RouteParameter::setEdges(GNEViewNet* viewNet, const std::string& vehicleID, const std::string& fromID, const std::string& toID, const std::string& viaIDs) {
82  // clear edges
83  edges.clear();
84  // only continue if at least one of the edges is defined
85  if (fromID.size() + toID.size() > 0) {
86  // obtain from and to edges
87  GNEEdge* from = viewNet->getNet()->retrieveEdge(fromID, false);
88  GNEEdge* to = viewNet->getNet()->retrieveEdge(toID, false);
89  // check if edges are valid
90  if (from == nullptr) {
91  WRITE_ERROR("Invalid from-edge '" + fromID + "' used in trip '" + vehicleID + "'.");
92  } else if (to == nullptr) {
93  WRITE_ERROR("Invalid to-edge '" + toID + "' used in trip '" + vehicleID + "'.");
94  } else if (!GNEAttributeCarrier::canParse<std::vector<GNEEdge*> >(viewNet->getNet(), viaIDs, false)) {
95  WRITE_ERROR("Invalid 'via' edges used in trip '" + vehicleID + "'.");
96  } else {
97  // obtain via
98  std::vector<GNEEdge*> viaEdges = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(viewNet->getNet(), viaIDs);
99  // build edges (from - via - to)
100  edges.push_back(from);
101  for (const auto& i : viaEdges) {
102  edges.push_back(i);
103  }
104  // check that from and to edge are different
105  if (from != to) {
106  edges.push_back(to);
107  }
108  }
109  }
110 }
111 
112 // ---------------------------------------------------------------------------
113 // GNERouteHandler - methods
114 // ---------------------------------------------------------------------------
115 
116 GNERouteHandler::GNERouteHandler(const std::string& file, GNEViewNet* viewNet, bool undoDemandElements) :
117  SUMORouteHandler(file, "", false),
118  myViewNet(viewNet),
119  myUndoDemandElements(undoDemandElements),
121 }
122 
123 
125 
126 
127 bool
128 GNERouteHandler::isVehicleIdDuplicated(GNEViewNet* viewNet, const std::string& id) {
129  for (SumoXMLTag vehicleTag : std::vector<SumoXMLTag>({SUMO_TAG_VEHICLE, SUMO_TAG_TRIP, SUMO_TAG_ROUTEFLOW, SUMO_TAG_FLOW})) {
130  if (viewNet->getNet()->retrieveDemandElement(vehicleTag, id, false) != nullptr) {
131  WRITE_ERROR("There is another " + toString(vehicleTag) + " with the same ID='" + id + "'.");
132  return true;
133  }
134  }
135  return false;
136 }
137 
138 
139 bool
140 GNERouteHandler::isPersonIdDuplicated(GNEViewNet* viewNet, const std::string& id) {
141  for (SumoXMLTag personTag : std::vector<SumoXMLTag>({SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW})) {
142  if (viewNet->getNet()->retrieveDemandElement(personTag, id, false) != nullptr) {
143  WRITE_ERROR("There is another " + toString(personTag) + " with the same ID='" + id + "'.");
144  return true;
145  }
146  }
147  return false;
148 }
149 
150 
151 void
152 GNERouteHandler::buildVehicleOverRoute(GNEViewNet* viewNet, bool undoDemandElements, const SUMOVehicleParameter& vehicleParameters) {
153  // Check tag
154  assert(vehicleParameters.tag == SUMO_TAG_VEHICLE);
155  // first check if ID is duplicated
156  if (!isVehicleIdDuplicated(viewNet, vehicleParameters.id)) {
157  // obtain routes and vtypes
158  GNEDemandElement* vType = viewNet->getNet()->retrieveDemandElement(SUMO_TAG_VTYPE, vehicleParameters.vtypeid, false);
159  GNEDemandElement* route = viewNet->getNet()->retrieveDemandElement(SUMO_TAG_ROUTE, vehicleParameters.routeid, false);
160  if (vType == nullptr) {
161  WRITE_ERROR("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
162  } else if (route == nullptr) {
163  WRITE_ERROR("Invalid route '" + vehicleParameters.routeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
164  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DEPART_LANE_GIVEN) && ((int)route->getParentEdges().front()->getLanes().size() < vehicleParameters.departLane)) {
165  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
166  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DEPART_SPEED_GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
167  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
168  } else {
169  // create vehicle using vehicleParameters
170  GNEVehicle* vehicle = new GNEVehicle(viewNet, vType, route, vehicleParameters);
171  if (undoDemandElements) {
172  viewNet->getUndoList()->p_begin("add " + vehicle->getTagStr());
173  viewNet->getUndoList()->add(new GNEChange_DemandElement(vehicle, true), true);
174  // iterate over stops of vehicleParameters and create stops associated with it
175  for (const auto& i : vehicleParameters.stops) {
176  buildStop(viewNet, true, i, vehicle);
177  }
178  viewNet->getUndoList()->p_end();
179  } else {
180  viewNet->getNet()->insertDemandElement(vehicle);
181  // set vehicle as child of vType and Route
182  vType->addChildDemandElement(vehicle);
183  route->addChildDemandElement(vehicle);
184  vehicle->incRef("buildVehicleOverRoute");
185  // iterate over stops of vehicleParameters and create stops associated with it
186  for (const auto& i : vehicleParameters.stops) {
187  buildStop(viewNet, false, i, vehicle);
188  }
189  }
190  }
191  }
192 }
193 
194 
195 void
196 GNERouteHandler::buildFlowOverRoute(GNEViewNet* viewNet, bool undoDemandElements, const SUMOVehicleParameter& vehicleParameters) {
197  // Check tag
198  assert(vehicleParameters.tag == SUMO_TAG_ROUTEFLOW);
199  // first check if ID is duplicated
200  if (!isVehicleIdDuplicated(viewNet, vehicleParameters.id)) {
201  // obtain routes and vtypes
202  GNEDemandElement* vType = viewNet->getNet()->retrieveDemandElement(SUMO_TAG_VTYPE, vehicleParameters.vtypeid, false);
203  GNEDemandElement* route = viewNet->getNet()->retrieveDemandElement(SUMO_TAG_ROUTE, vehicleParameters.routeid, false);
204  if (vType == nullptr) {
205  WRITE_ERROR("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
206  } else if (route == nullptr) {
207  WRITE_ERROR("Invalid route '" + vehicleParameters.routeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
208  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DEPART_LANE_GIVEN) && ((int)route->getParentEdges().front()->getLanes().size() < vehicleParameters.departLane)) {
209  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
210  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DEPART_SPEED_GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
211  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
212  } else {
213  // create flow or trips using vehicleParameters
214  GNEVehicle* flow = new GNEVehicle(viewNet, vType, route, vehicleParameters);
215  if (undoDemandElements) {
216  viewNet->getUndoList()->p_begin("add " + flow->getTagStr());
217  viewNet->getUndoList()->add(new GNEChange_DemandElement(flow, true), true);
218  // iterate over stops of vehicleParameters and create stops associated with it
219  for (const auto& i : vehicleParameters.stops) {
220  buildStop(viewNet, true, i, flow);
221  }
222  viewNet->getUndoList()->p_end();
223  } else {
224  viewNet->getNet()->insertDemandElement(flow);
225  // set flow as child of vType and Route
226  vType->addChildDemandElement(flow);
227  route->addChildDemandElement(flow);
228  flow->incRef("buildFlowOverRoute");
229  // iterate over stops of vehicleParameters and create stops associated with it
230  for (const auto& i : vehicleParameters.stops) {
231  buildStop(viewNet, false, i, flow);
232  }
233  }
234  }
235  }
236 }
237 
238 
239 void
240 GNERouteHandler::buildVehicleWithEmbeddedRoute(GNEViewNet* viewNet, bool undoDemandElements, SUMOVehicleParameter vehicleParameters, GNEDemandElement* embeddedRouteCopy) {
241  // Check tags
242  assert(vehicleParameters.tag == SUMO_TAG_VEHICLE);
243  // first check if ID is duplicated
244  if (!isVehicleIdDuplicated(viewNet, vehicleParameters.id)) {
245  // obtain vType
246  GNEDemandElement* vType = viewNet->getNet()->retrieveDemandElement(SUMO_TAG_VTYPE, vehicleParameters.vtypeid, false);
247  if (vType == nullptr) {
248  WRITE_ERROR("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
249  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DEPART_LANE_GIVEN) && ((int)embeddedRouteCopy->getParentEdges().front()->getLanes().size() < vehicleParameters.departLane)) {
250  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
251  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DEPART_SPEED_GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
252  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
253  } else {
254  // generate a new route ID and add it to vehicleParameters
255  vehicleParameters.routeid = viewNet->getNet()->generateDemandElementID(vehicleParameters.id, SUMO_TAG_ROUTE);
256  // due vehicle was loaded without a route, change tag
257  vehicleParameters.tag = SUMO_TAG_VEHICLE;
258  // create vehicle or trips using myTemporalVehicleParameter without a route
259  GNEVehicle* vehicle = new GNEVehicle(viewNet, vType, vehicleParameters);
260  // creaste embedded route
261  GNERoute* embeddedRoute = new GNERoute(viewNet, vehicle, RouteParameter(embeddedRouteCopy));
262  // add both to net depending of myUndoDemandElements
263  if (undoDemandElements) {
264  viewNet->getUndoList()->p_begin("add vehicle and " + embeddedRoute->getTagStr());
265  // add both in net using undoList
266  viewNet->getUndoList()->add(new GNEChange_DemandElement(vehicle, true), true);
267  viewNet->getUndoList()->add(new GNEChange_DemandElement(embeddedRoute, true), true);
268  viewNet->getUndoList()->p_end();
269  } else {
270  // add vehicleOrRouteFlow in net and in their vehicle type parent
271  viewNet->getNet()->insertDemandElement(vehicle);
272  // set vehicle as child of vType
273  vType->addChildDemandElement(vehicle);
274  vehicle->incRef("buildVehicleWithEmbeddedRoute");
275  // add route manually in net, and in all of their edges and in vehicleOrRouteFlow
276  viewNet->getNet()->insertDemandElement(embeddedRoute);
277  for (const auto& i : embeddedRouteCopy->getParentEdges()) {
278  i->addChildDemandElement(vehicle);
279  }
280  // set route as child of vehicle
281  vehicle->addChildDemandElement(embeddedRoute);
282  embeddedRoute->incRef("buildVehicleWithEmbeddedRoute");
283  }
284  }
285  }
286 }
287 
288 
289 void
290 GNERouteHandler::buildFlowWithEmbeddedRoute(GNEViewNet* viewNet, bool undoDemandElements, SUMOVehicleParameter vehicleParameters, GNEDemandElement* embeddedRouteCopy) {
291  // Check tags
292  assert(vehicleParameters.tag == SUMO_TAG_ROUTEFLOW);
293  // first check if ID is duplicated
294  if (!isVehicleIdDuplicated(viewNet, vehicleParameters.id)) {
295  // obtain vType
296  GNEDemandElement* vType = viewNet->getNet()->retrieveDemandElement(SUMO_TAG_VTYPE, vehicleParameters.vtypeid, false);
297  if (vType == nullptr) {
298  WRITE_ERROR("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
299  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DEPART_LANE_GIVEN) && ((int)embeddedRouteCopy->getParentEdges().front()->getLanes().size() < vehicleParameters.departLane)) {
300  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
301  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DEPART_SPEED_GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
302  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
303  } else {
304  // generate a new route ID and add it to vehicleParameters
305  vehicleParameters.routeid = viewNet->getNet()->generateDemandElementID(vehicleParameters.id, SUMO_TAG_ROUTE);
306  // due vehicle was loaded without a route, change tag
307  vehicleParameters.tag = SUMO_TAG_ROUTEFLOW;
308  // create vehicle or trips using myTemporalVehicleParameter without a route
309  GNEVehicle* flow = new GNEVehicle(viewNet, vType, vehicleParameters);
310  // creaste embedded route
311  GNERoute* embeddedRoute = new GNERoute(viewNet, flow, RouteParameter(embeddedRouteCopy));
312  // add both to net depending of myUndoDemandElements
313  if (undoDemandElements) {
314  viewNet->getUndoList()->p_begin("add vehicle and " + embeddedRoute->getTagStr());
315  // add both in net using undoList
316  viewNet->getUndoList()->add(new GNEChange_DemandElement(flow, true), true);
317  viewNet->getUndoList()->add(new GNEChange_DemandElement(embeddedRoute, true), true);
318  viewNet->getUndoList()->p_end();
319  } else {
320  // add vehicleOrRouteFlow in net and in their vehicle type parent
321  viewNet->getNet()->insertDemandElement(flow);
322  // set vehicle as child of vType
323  vType->addChildDemandElement(flow);
324  flow->incRef("buildFlowWithEmbeddedRoute");
325  // add route manually in net, and in all of their edges and in vehicleOrRouteFlow
326  viewNet->getNet()->insertDemandElement(embeddedRoute);
327  for (const auto& i : embeddedRouteCopy->getParentEdges()) {
328  i->addChildDemandElement(flow);
329  }
330  // set route as child of flow
331  flow->addChildDemandElement(embeddedRoute);
332  embeddedRoute->incRef("buildFlowWithEmbeddedRoute");
333  }
334  }
335  }
336 }
337 
338 
339 void
340 GNERouteHandler::buildTrip(GNEViewNet* viewNet, bool undoDemandElements, const SUMOVehicleParameter& vehicleParameters, GNEEdge* fromEdge, GNEEdge* toEdge, const std::vector<GNEEdge*>& via) {
341  // Check tag
342  assert(vehicleParameters.tag == SUMO_TAG_TRIP);
343  // check if exist another vehicle with the same ID (note: Vehicles, Flows and Trips share namespace)
344  if (!isVehicleIdDuplicated(viewNet, vehicleParameters.id)) {
345  // obtain vtypes
346  GNEDemandElement* vType = viewNet->getNet()->retrieveDemandElement(SUMO_TAG_VTYPE, vehicleParameters.vtypeid, false);
347  if (vType == nullptr) {
348  WRITE_ERROR("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
349  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && ((vehicleParameters.departLaneProcedure == DEPART_LANE_GIVEN)) && ((int)fromEdge->getLanes().size() < vehicleParameters.departLane)) {
350  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
351  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DEPART_SPEED_GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
352  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
353  } else {
354  // add "via" edges in vehicleParameters
355  for (const auto& viaEdge : via) {
356  vehicleParameters.via.push_back(viaEdge->getID());
357  }
358  // create trip or flow using tripParameters
359  GNEVehicle* trip = new GNEVehicle(viewNet, vType, fromEdge, toEdge, via, vehicleParameters);
360  if (undoDemandElements) {
361  viewNet->getUndoList()->p_begin("add " + trip->getTagStr());
362  viewNet->getUndoList()->add(new GNEChange_DemandElement(trip, true), true);
363  // iterate over stops of vehicleParameters and create stops associated with it
364  for (const auto& i : vehicleParameters.stops) {
365  buildStop(viewNet, true, i, trip);
366  }
367  viewNet->getUndoList()->p_end();
368  } else {
369  viewNet->getNet()->insertDemandElement(trip);
370  // set vehicle as child of vType
371  vType->addChildDemandElement(trip);
372  trip->incRef("buildTrip");
373  // add reference in all edges
374  fromEdge->addChildDemandElement(trip);
375  toEdge->addChildDemandElement(trip);
376  for (const auto& viaEdge : via) {
377  viaEdge->addChildDemandElement(trip);
378  }
379  // iterate over stops of vehicleParameters and create stops associated with it
380  for (const auto& i : vehicleParameters.stops) {
381  buildStop(viewNet, false, i, trip);
382  }
383  }
384  }
385  }
386 }
387 
388 
389 void
390 GNERouteHandler::buildFlow(GNEViewNet* viewNet, bool undoDemandElements, const SUMOVehicleParameter& vehicleParameters, GNEEdge* fromEdge, GNEEdge* toEdge, const std::vector<GNEEdge*>& via) {
391  // Check tag
392  assert(vehicleParameters.tag == SUMO_TAG_FLOW);
393  // check if exist another vehicle with the same ID (note: Vehicles, Flows and Trips share namespace)
394  if (!isVehicleIdDuplicated(viewNet, vehicleParameters.id)) {
395  // obtain vtypes
396  GNEDemandElement* vType = viewNet->getNet()->retrieveDemandElement(SUMO_TAG_VTYPE, vehicleParameters.vtypeid, false);
397  if (vType == nullptr) {
398  WRITE_ERROR("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
399  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DEPART_LANE_GIVEN) && ((int)fromEdge->getLanes().size() < vehicleParameters.departLane)) {
400  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
401  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DEPART_SPEED_GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
402  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
403  } else {
404  // add "via" edges in vehicleParameters
405  for (const auto& viaEdge : via) {
406  vehicleParameters.via.push_back(viaEdge->getID());
407  }
408  // create trip or flow using tripParameters
409  GNEVehicle* flow = new GNEVehicle(viewNet, vType, fromEdge, toEdge, via, vehicleParameters);
410  if (undoDemandElements) {
411  viewNet->getUndoList()->p_begin("add " + flow->getTagStr());
412  viewNet->getUndoList()->add(new GNEChange_DemandElement(flow, true), true);
413  // iterate over stops of vehicleParameters and create stops associated with it
414  for (const auto& i : vehicleParameters.stops) {
415  buildStop(viewNet, true, i, flow);
416  }
417  viewNet->getUndoList()->p_end();
418  } else {
419  viewNet->getNet()->insertDemandElement(flow);
420  // set vehicle as child of vType
421  vType->addChildDemandElement(flow);
422  flow->incRef("buildFlow");
423  // add reference in all edges
424  fromEdge->addChildDemandElement(flow);
425  toEdge->addChildDemandElement(flow);
426  for (const auto& viaEdge : via) {
427  viaEdge->addChildDemandElement(flow);
428  }
429  // iterate over stops of vehicleParameters and create stops associated with it
430  for (const auto& i : vehicleParameters.stops) {
431  buildStop(viewNet, false, i, flow);
432  }
433  }
434  }
435  }
436 }
437 
438 
439 void
440 GNERouteHandler::buildStop(GNEViewNet* viewNet, bool undoDemandElements, const SUMOVehicleParameter::Stop& stopParameters, GNEDemandElement* stopParent) {
441  // declare pointers to stopping place and lane and obtain it
442  GNEAdditional* stoppingPlace = nullptr;
443  GNELane* lane = nullptr;
444  SumoXMLTag stopTagType = SUMO_TAG_NOTHING;
445  bool validParentDemandElement = true;
446  if (stopParameters.busstop.size() > 0) {
447  stoppingPlace = viewNet->getNet()->retrieveAdditional(SUMO_TAG_BUS_STOP, stopParameters.busstop, false);
448  // distinguish between stop for vehicles and stops for persons
449  if (stopParent->getTagProperty().isPerson()) {
450  stopTagType = SUMO_TAG_PERSONSTOP_BUSSTOP;
451  } else {
452  stopTagType = SUMO_TAG_STOP_BUSSTOP;
453  }
454  } else if (stopParameters.containerstop.size() > 0) {
455  stoppingPlace = viewNet->getNet()->retrieveAdditional(SUMO_TAG_CONTAINER_STOP, stopParameters.containerstop, false);
456  // distinguish between stop for vehicles and stops for persons
457  if (stopParent->getTagProperty().isPerson()) {
458  WRITE_ERROR("Persons doesn't support stops over container stops");
459  validParentDemandElement = false;
460  } else {
461  stopTagType = SUMO_TAG_STOP_CONTAINERSTOP;
462  }
463  } else if (stopParameters.chargingStation.size() > 0) {
464  stoppingPlace = viewNet->getNet()->retrieveAdditional(SUMO_TAG_CHARGING_STATION, stopParameters.chargingStation, false);
465  // distinguish between stop for vehicles and stops for persons
466  if (stopParent->getTagProperty().isPerson()) {
467  WRITE_ERROR("Persons doesn't support stops over charging stations");
468  validParentDemandElement = false;
469  } else {
470  stopTagType = SUMO_TAG_STOP_CHARGINGSTATION;
471  }
472  } else if (stopParameters.parkingarea.size() > 0) {
473  stoppingPlace = viewNet->getNet()->retrieveAdditional(SUMO_TAG_PARKING_AREA, stopParameters.parkingarea, false);
474  // distinguish between stop for vehicles and stops for persons
475  if (stopParent->getTagProperty().isPerson()) {
476  WRITE_ERROR("Persons doesn't support stops over parking areas");
477  validParentDemandElement = false;
478  } else {
479  stopTagType = SUMO_TAG_STOP_PARKINGAREA;
480  }
481  } else if (stopParameters.lane.size() > 0) {
482  lane = viewNet->getNet()->retrieveLane(stopParameters.lane, false);
483  // distinguish between stop for vehicles and stops for persons
484  if (stopParent->getTagProperty().isPerson()) {
485  stopTagType = SUMO_TAG_PERSONSTOP_LANE;
486  } else {
487  stopTagType = SUMO_TAG_STOP_LANE;
488  }
489  }
490  // first check that parent is valid
491  if (validParentDemandElement) {
492  // check if values are correct
493  if (stoppingPlace && lane) {
494  WRITE_ERROR("A stop must be defined either over a stoppingPlace or over a lane");
495  } else if (!stoppingPlace && !lane) {
496  WRITE_ERROR("A stop requires a stoppingPlace or a lane");
497  } else if (stoppingPlace) {
498  // create stop using stopParameters and stoppingPlace
499  GNEStop* stop = new GNEStop(stopTagType, viewNet, stopParameters, stoppingPlace, stopParent);
500  // add it depending of undoDemandElements
501  if (undoDemandElements) {
502  viewNet->getUndoList()->p_begin("add " + stop->getTagStr());
503  viewNet->getUndoList()->add(new GNEChange_DemandElement(stop, true), true);
504  viewNet->getUndoList()->p_end();
505  } else {
506  viewNet->getNet()->insertDemandElement(stop);
507  stoppingPlace->addChildDemandElement(stop);
508  stopParent->addChildDemandElement(stop);
509  stop->incRef("buildStoppingPlaceStop");
510  }
511  } else {
512  // create stop using stopParameters and lane
513  GNEStop* stop = new GNEStop(viewNet, stopParameters, lane, stopParent);
514  // add it depending of undoDemandElements
515  if (undoDemandElements) {
516  viewNet->getUndoList()->p_begin("add " + stop->getTagStr());
517  viewNet->getUndoList()->add(new GNEChange_DemandElement(stop, true), true);
518  viewNet->getUndoList()->p_end();
519  } else {
520  viewNet->getNet()->insertDemandElement(stop);
521  lane->addChildDemandElement(stop);
522  stopParent->addChildDemandElement(stop);
523  stop->incRef("buildLaneStop");
524  }
525  }
526  }
527 }
528 
529 
530 void
531 GNERouteHandler::buildPerson(GNEViewNet* viewNet, bool undoDemandElements, const SUMOVehicleParameter& personParameters) {
532  // first check if ID is duplicated
533  if (!isPersonIdDuplicated(viewNet, personParameters.id)) {
534  // obtain routes and vtypes
535  GNEDemandElement* pType = viewNet->getNet()->retrieveDemandElement(SUMO_TAG_PTYPE, personParameters.vtypeid, false);
536  if (pType == nullptr) {
537  WRITE_ERROR("Invalid person type '" + personParameters.vtypeid + "' used in " + toString(personParameters.tag) + " '" + personParameters.id + "'.");
538  } else {
539  // create person using personParameters
540  GNEPerson* person = new GNEPerson(SUMO_TAG_PERSON, viewNet, pType, personParameters);
541  if (undoDemandElements) {
542  viewNet->getUndoList()->p_begin("add " + person->getTagStr());
543  viewNet->getUndoList()->add(new GNEChange_DemandElement(person, true), true);
544  viewNet->getUndoList()->p_end();
545  } else {
546  viewNet->getNet()->insertDemandElement(person);
547  // set person as child of pType and Route
548  pType->addChildDemandElement(person);
549  person->incRef("buildPerson");
550  }
551  }
552  }
553 }
554 
555 
556 void
557 GNERouteHandler::buildPersonFlow(GNEViewNet* viewNet, bool undoDemandElements, const SUMOVehicleParameter& personFlowParameters) {
558  // first check if ID is duplicated
559  if (!isPersonIdDuplicated(viewNet, personFlowParameters.id)) {
560  // obtain routes and vtypes
561  GNEDemandElement* pType = viewNet->getNet()->retrieveDemandElement(SUMO_TAG_PTYPE, personFlowParameters.vtypeid, false);
562  if (pType == nullptr) {
563  WRITE_ERROR("Invalid personFlow type '" + personFlowParameters.vtypeid + "' used in " + toString(personFlowParameters.tag) + " '" + personFlowParameters.id + "'.");
564  } else {
565  // create personFlow using personFlowParameters
566  GNEPerson* personFlow = new GNEPerson(SUMO_TAG_PERSONFLOW, viewNet, pType, personFlowParameters);
567  if (undoDemandElements) {
568  viewNet->getUndoList()->p_begin("add " + personFlow->getTagStr());
569  viewNet->getUndoList()->add(new GNEChange_DemandElement(personFlow, true), true);
570  viewNet->getUndoList()->p_end();
571  } else {
572  viewNet->getNet()->insertDemandElement(personFlow);
573  // set personFlow as child of pType and Route
574  pType->addChildDemandElement(personFlow);
575  personFlow->incRef("buildPersonFlow");
576  }
577  }
578  }
579 }
580 
581 
582 void
583 GNERouteHandler::buildPersonTripFromTo(GNEViewNet* viewNet, bool undoDemandElements, GNEDemandElement* personParent, GNEEdge* fromEdge, GNEEdge* toEdge, double arrivalPos,
584  const std::vector<std::string>& types, const std::vector<std::string>& modes) {
585  // create personTripFromTo
586  GNEPersonTrip* personTripFromTo = new GNEPersonTrip(viewNet, personParent, fromEdge, toEdge, {}, arrivalPos, types, modes);
587  // add element using undo list or directly, depending of undoDemandElements flag
588  if (undoDemandElements) {
589  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_PERSONTRIP_FROMTO) + " within person '" + personParent->getID() + "'");
590  viewNet->getUndoList()->add(new GNEChange_DemandElement(personTripFromTo, true), true);
591  viewNet->getUndoList()->p_end();
592  } else {
593  // add vehicleOrPersonTripFlow in net and in their vehicle type parent
594  viewNet->getNet()->insertDemandElement(personTripFromTo);
595  personParent->addChildDemandElement(personTripFromTo);
596  personTripFromTo->incRef("buildPersonTripFromTo");
597  }
598  // update geometry
599  personParent->updateGeometry();
600 }
601 
602 
603 void
604 GNERouteHandler::buildPersonTripBusStop(GNEViewNet* viewNet, bool undoDemandElements, GNEDemandElement* personParent, GNEEdge* fromEdge, GNEAdditional* busStop,
605  const std::vector<std::string>& types, const std::vector<std::string>& modes) {
606  // create personTripBusStop
607  GNEPersonTrip* personTripBusStop = new GNEPersonTrip(viewNet, personParent, fromEdge, busStop, {}, types, modes);
608  // add element using undo list or directly, depending of undoDemandElements flag
609  if (undoDemandElements) {
610  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_PERSONTRIP_BUSSTOP) + " within person '" + personParent->getID() + "'");
611  viewNet->getUndoList()->add(new GNEChange_DemandElement(personTripBusStop, true), true);
612  viewNet->getUndoList()->p_end();
613  } else {
614  // add vehicleOrPersonTripFlow in net and in their vehicle type parent
615  viewNet->getNet()->insertDemandElement(personTripBusStop);
616  personParent->addChildDemandElement(personTripBusStop);
617  busStop->addChildDemandElement(personTripBusStop);
618  fromEdge->addChildDemandElement(personTripBusStop);
619  personTripBusStop->incRef("buildPersonTripBusStop");
620  }
621  // update geometry
622  personParent->updateGeometry();
623 }
624 
625 
626 void
627 GNERouteHandler::buildWalkEdges(GNEViewNet* viewNet, bool undoDemandElements, GNEDemandElement* personParent, const std::vector<GNEEdge*>& edges, double arrivalPos) {
628  // check that at least there is an edge
629  if (edges.size() == 0) {
630  WRITE_ERROR("A walk needs at least one edge. " + toString(SUMO_TAG_WALK_EDGES) + " within person with ID='" + personParent->getID() + "' cannot be created");
631  } else {
632  // obtain path between edges
633  std::vector<GNEEdge*> pathEdges = GNEDemandElement::getRouteCalculatorInstance()->calculateDijkstraRoute(personParent->getVClass(), edges);
634  // check if obtained path is valid
635  if (pathEdges.size() == 0) {
636  pathEdges = edges;
637  }
638  // create walkEdges
639  GNEWalk* walkEdges = new GNEWalk(viewNet, personParent, pathEdges, arrivalPos);
640  // add element using undo list or directly, depending of undoDemandElements flag
641  if (undoDemandElements) {
642  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_WALK_EDGES) + " within person '" + personParent->getID() + "'");
643  viewNet->getUndoList()->add(new GNEChange_DemandElement(walkEdges, true), true);
644  viewNet->getUndoList()->p_end();
645  } else {
646  // add vehicleOrWalkEdgesFlow in net and in their vehicle type parent
647  viewNet->getNet()->insertDemandElement(walkEdges);
648  personParent->addChildDemandElement(walkEdges);
649  // add reference in all edges
650  for (const auto& i : edges) {
651  i->addChildDemandElement(walkEdges);
652  }
653  walkEdges->incRef("buildWalkEdges");
654  }
655  // update geometry
656  personParent->updateGeometry();
657  }
658 }
659 
660 
661 void
662 GNERouteHandler::buildWalkFromTo(GNEViewNet* viewNet, bool undoDemandElements, GNEDemandElement* personParent, GNEEdge* fromEdge, GNEEdge* toEdge, double arrivalPos) {
663  // create walkFromTo
664  GNEWalk* walkFromTo = new GNEWalk(viewNet, personParent, fromEdge, toEdge, {}, arrivalPos);
665  // add element using undo list or directly, depending of undoDemandElements flag
666  if (undoDemandElements) {
667  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_WALK_FROMTO) + " within person '" + personParent->getID() + "'");
668  viewNet->getUndoList()->add(new GNEChange_DemandElement(walkFromTo, true), true);
669  viewNet->getUndoList()->p_end();
670  } else {
671  // add vehicleOrWalkFromToFlow in net and in their vehicle type parent
672  viewNet->getNet()->insertDemandElement(walkFromTo);
673  personParent->addChildDemandElement(walkFromTo);
674  // add reference in all edges
675  fromEdge->addChildDemandElement(walkFromTo);
676  toEdge->addChildDemandElement(walkFromTo);
677  walkFromTo->incRef("buildWalkFromTo");
678  }
679  // update geometry
680  personParent->updateGeometry();
681 }
682 
683 
684 void
685 GNERouteHandler::buildWalkBusStop(GNEViewNet* viewNet, bool undoDemandElements, GNEDemandElement* personParent, GNEEdge* fromEdge, GNEAdditional* busStop) {
686  // create walkBusStop
687  GNEWalk* walkBusStop = new GNEWalk(viewNet, personParent, fromEdge, busStop, {});
688  // add element using undo list or directly, depending of undoDemandElements flag
689  if (undoDemandElements) {
690  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_WALK_BUSSTOP) + " within person '" + personParent->getID() + "'");
691  viewNet->getUndoList()->add(new GNEChange_DemandElement(walkBusStop, true), true);
692  viewNet->getUndoList()->p_end();
693  } else {
694  // add vehicleOrWalkBusStopFlow in net and in their vehicle type parent
695  viewNet->getNet()->insertDemandElement(walkBusStop);
696  personParent->addChildDemandElement(walkBusStop);
697  busStop->addChildDemandElement(walkBusStop);
698  fromEdge->addChildDemandElement(walkBusStop);
699  walkBusStop->incRef("buildWalkBusStop");
700  }
701  // update geometry
702  personParent->updateGeometry();
703 }
704 
705 
706 void
707 GNERouteHandler::buildWalkRoute(GNEViewNet* viewNet, bool undoDemandElements, GNEDemandElement* personParent, GNEDemandElement* route, double arrivalPos) {
708  // create walkRoute
709  GNEWalk* walkRoute = new GNEWalk(viewNet, personParent, route, arrivalPos);
710  // add element using undo list or directly, depending of undoDemandElements flag
711  if (undoDemandElements) {
712  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_WALK_ROUTE) + " within person '" + personParent->getID() + "'");
713  viewNet->getUndoList()->add(new GNEChange_DemandElement(walkRoute, true), true);
714  viewNet->getUndoList()->p_end();
715  } else {
716  // add vehicleOrWalkBusStopFlow in net and in their vehicle type parent
717  viewNet->getNet()->insertDemandElement(walkRoute);
718  personParent->addChildDemandElement(walkRoute);
719  route->addChildDemandElement(walkRoute);
720  walkRoute->incRef("buildWalkRoute");
721  }
722  // update geometry
723  personParent->updateGeometry();
724 }
725 
726 
727 void
728 GNERouteHandler::buildRideFromTo(GNEViewNet* viewNet, bool undoDemandElements, GNEDemandElement* personParent, GNEEdge* fromEdge, GNEEdge* toEdge, const std::vector<std::string>& lines, double arrivalPos) {
729  // create rideFromTo
730  GNERide* rideFromTo = new GNERide(viewNet, personParent, fromEdge, toEdge, {}, arrivalPos, lines);
731  // add element using undo list or directly, depending of undoDemandElements flag
732  if (undoDemandElements) {
733  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_RIDE_FROMTO) + " within person '" + personParent->getID() + "'");
734  viewNet->getUndoList()->add(new GNEChange_DemandElement(rideFromTo, true), true);
735  viewNet->getUndoList()->p_end();
736  } else {
737  // add vehicleOrRideFromToFlow in net and in their vehicle type parent
738  viewNet->getNet()->insertDemandElement(rideFromTo);
739  personParent->addChildDemandElement(rideFromTo);
740  // add reference in all edges
741  fromEdge->addChildDemandElement(rideFromTo);
742  toEdge->addChildDemandElement(rideFromTo);
743  rideFromTo->incRef("buildRideFromTo");
744  }
745  // update geometry
746  personParent->updateGeometry();
747 }
748 
749 
750 void
751 GNERouteHandler::buildRideBusStop(GNEViewNet* viewNet, bool undoDemandElements, GNEDemandElement* personParent, GNEEdge* fromEdge, GNEAdditional* busStop, const std::vector<std::string>& lines) {
752  // create rideBusStop
753  GNERide* rideBusStop = new GNERide(viewNet, personParent, fromEdge, busStop, {}, lines);
754  // add element using undo list or directly, depending of undoDemandElements flag
755  if (undoDemandElements) {
756  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_RIDE_BUSSTOP) + " within person '" + personParent->getID() + "'");
757  viewNet->getUndoList()->add(new GNEChange_DemandElement(rideBusStop, true), true);
758  viewNet->getUndoList()->p_end();
759  } else {
760  // add vehicleOrRideBusStopFlow in net and in their vehicle type parent
761  viewNet->getNet()->insertDemandElement(rideBusStop);
762  personParent->addChildDemandElement(rideBusStop);
763  busStop->addChildDemandElement(rideBusStop);
764  // add reference in first edge
765  fromEdge->addChildDemandElement(rideBusStop);
766  rideBusStop->incRef("buildRideBusStop");
767  }
768  // update geometry
769  personParent->updateGeometry();
770 }
771 
772 
773 void
774 GNERouteHandler::transformToVehicle(GNEVehicle* originalVehicle, bool createEmbeddedRoute) {
775  // first check that given vehicle isn't already a vehicle
776  if (originalVehicle->getTagProperty().getTag() != SUMO_TAG_VEHICLE) {
777  // get pointer to undo list (due originalVehicle will be deleted)
778  GNEUndoList* undoList = originalVehicle->getViewNet()->getUndoList();
779  // begin undo-redo operation
780  undoList->p_begin("transform " + originalVehicle->getTagStr() + " to " + toString(SUMO_TAG_VEHICLE));
781  // declare flag to save if vehicle is selected
782  bool selected = originalVehicle->isAttributeCarrierSelected();
783  // first check if originalVehicle has an embedded route, and if true, separate it
784  if (((originalVehicle->getTagProperty().getTag() == SUMO_TAG_VEHICLE) || (originalVehicle->getTagProperty().getTag() == SUMO_TAG_ROUTEFLOW)) &&
785  (originalVehicle->getParentDemandElements().size() == 1)) {
786  originalVehicle = separateEmbeddedRoute(originalVehicle, undoList);
787  }
788  // obtain VType of original vehicle
789  GNEDemandElement* vType = originalVehicle->getParentDemandElements().at(0);
790  // extract vehicleParameters of originalVehicle
791  SUMOVehicleParameter newVehicleParameters = *originalVehicle;
792  // change tag in newVehicleParameters (needed for GNEVehicle constructor)
793  newVehicleParameters.tag = SUMO_TAG_VEHICLE;
794  // make transformation depending of vehicle tag
795  if ((originalVehicle->getTagProperty().getTag() == SUMO_TAG_VEHICLE) || (originalVehicle->getTagProperty().getTag() == SUMO_TAG_ROUTEFLOW)) {
796  // obtain vehicle's route (it always exist due call to function separateEmbeddedRoute(...)
797  GNEDemandElement* route = originalVehicle->getParentDemandElements().at(1);
798  // create Vehicle using values of original vehicle
799  GNEVehicle* vehicle = new GNEVehicle(originalVehicle->getViewNet(), vType, route, newVehicleParameters);
800  // remove original vehicle (to avoid problem with ID)
801  undoList->add(new GNEChange_DemandElement(originalVehicle, false), true);
802  // add new vehicle
803  undoList->add(new GNEChange_DemandElement(vehicle, true), true);
804  // as last step change vehicle's route to embedded route if createEmbeddedRoute is enabled
805  if (createEmbeddedRoute) {
806  embebbeRoute(vehicle, undoList);
807  }
808  // check if vehicle has to be selected
809  if (selected) {
810  undoList->p_add(new GNEChange_Attribute(vehicle, vehicle->getViewNet()->getNet(), GNE_ATTR_SELECTED, "true"));
811  }
812  } else if ((originalVehicle->getTagProperty().getTag() == SUMO_TAG_FLOW) || (originalVehicle->getTagProperty().getTag() == SUMO_TAG_TRIP)) {
813  // create route using values of originalVehicle flow/trip
814  GNERoute* route = new GNERoute(originalVehicle->getViewNet(), RouteParameter(originalVehicle));
815  // create Vehicle using values of original vehicle (including ID)
816  GNEVehicle* vehicle = new GNEVehicle(originalVehicle->getViewNet(), vType, route, newVehicleParameters);
817  // remove flow/trip (to avoid problem with ID)
818  undoList->add(new GNEChange_DemandElement(originalVehicle, false), true);
819  // add both new vehicle and route
820  undoList->add(new GNEChange_DemandElement(route, true), true);
821  undoList->add(new GNEChange_DemandElement(vehicle, true), true);
822  // check if vehicle has to be selected
823  if (selected) {
824  undoList->p_add(new GNEChange_Attribute(vehicle, vehicle->getViewNet()->getNet(), GNE_ATTR_SELECTED, "true"));
825  }
826  }
827  // end undo-redo operation
828  undoList->p_end();
829  }
830 }
831 
832 
833 void
834 GNERouteHandler::transformToRouteFlow(GNEVehicle* originalVehicle, bool createEmbeddedRoute) {
835  // first check that given vehicle isn't already a routeflow
836  if (originalVehicle->getTagProperty().getTag() != SUMO_TAG_ROUTEFLOW) {
837  // get pointer to undo list (due originalVehicle will be deleted)
838  GNEUndoList* undoList = originalVehicle->getViewNet()->getUndoList();
839  // begin undo-redo operation
840  undoList->p_begin("transform " + originalVehicle->getTagStr() + " to " + toString(SUMO_TAG_ROUTEFLOW));
841  // declare flag to save if vehicle is selected
842  bool selected = originalVehicle->isAttributeCarrierSelected();
843  // first check if originalVehicle has an embedded route, and if true, separate it
844  if (((originalVehicle->getTagProperty().getTag() == SUMO_TAG_VEHICLE) || (originalVehicle->getTagProperty().getTag() == SUMO_TAG_ROUTEFLOW)) &&
845  (originalVehicle->getParentDemandElements().size() == 1)) {
846  originalVehicle = separateEmbeddedRoute(originalVehicle, undoList);
847  }
848  // obtain VType of original vehicle
849  GNEDemandElement* vType = originalVehicle->getParentDemandElements().at(0);
850  // extract vehicleParameters of originalVehicle
851  SUMOVehicleParameter newVehicleParameters = *originalVehicle;
852  // change tag in newVehicleParameters (needed for GNEVehicle constructor)
853  newVehicleParameters.tag = SUMO_TAG_ROUTEFLOW;
854  // make transformation depending of vehicle tag
855  if ((originalVehicle->getTagProperty().getTag() == SUMO_TAG_VEHICLE) || (originalVehicle->getTagProperty().getTag() == SUMO_TAG_ROUTEFLOW)) {
856  // obtain vehicle's route (it always exist due call to function separateEmbeddedRoute(...)
857  GNEDemandElement* route = originalVehicle->getParentDemandElements().at(1);
858  // create flow using newVehicleParameters
859  GNEVehicle* flow = new GNEVehicle(originalVehicle->getViewNet(), vType, route, newVehicleParameters);
860  // remove original vehicle (to avoid problem with ID)
861  undoList->add(new GNEChange_DemandElement(originalVehicle, false), true);
862  // add new vehicle
863  undoList->add(new GNEChange_DemandElement(flow, true), true);
864  // as last step change vehicle's route to embedded route if createEmbeddedRoute is enabled
865  if (createEmbeddedRoute) {
866  embebbeRoute(flow, undoList);
867  }
868  // check if flow has to be selected
869  if (selected) {
870  undoList->p_add(new GNEChange_Attribute(flow, flow->getViewNet()->getNet(), GNE_ATTR_SELECTED, "true"));
871  }
872  } else if ((originalVehicle->getTagProperty().getTag() == SUMO_TAG_FLOW) || (originalVehicle->getTagProperty().getTag() == SUMO_TAG_TRIP)) {
873  // create route using values of originalVehicle flow/trip
874  GNERoute* route = new GNERoute(originalVehicle->getViewNet(), RouteParameter(originalVehicle));
875  // create flow using values of original vehicle (including ID)
876  GNEVehicle* flow = new GNEVehicle(originalVehicle->getViewNet(), vType, route, newVehicleParameters);
877  // remove flow/trip (to avoid problem with ID)
878  undoList->add(new GNEChange_DemandElement(originalVehicle, false), true);
879  // add both new vehicle and route
880  undoList->add(new GNEChange_DemandElement(route, true), true);
881  undoList->add(new GNEChange_DemandElement(flow, true), true);
882  // check if flow has to be selected
883  if (selected) {
884  undoList->p_add(new GNEChange_Attribute(flow, flow->getViewNet()->getNet(), GNE_ATTR_SELECTED, "true"));
885  }
886  }
887  // end undo-redo operation
888  undoList->p_end();
889  }
890 }
891 
892 
893 void
895  // first check that given vehicle isn't already a trip
896  if (originalVehicle->getTagProperty().getTag() != SUMO_TAG_TRIP) {
897  // get pointer to undo list (due originalVehicle will be deleted)
898  GNEUndoList* undoList = originalVehicle->getViewNet()->getUndoList();
899  // begin undo-redo operation
900  undoList->p_begin("transform " + originalVehicle->getTagStr() + " to " + toString(SUMO_TAG_FLOW));
901  // declare pointer to get embedded route if is created
902  GNEDemandElement* separatedEmbeddedRoute = nullptr;
903  // declare flag to save if vehicle is selected
904  bool selected = originalVehicle->isAttributeCarrierSelected();
905  // first check if originalVehicle has an embedded route, and if true, separate it
906  if (((originalVehicle->getTagProperty().getTag() == SUMO_TAG_VEHICLE) || (originalVehicle->getTagProperty().getTag() == SUMO_TAG_ROUTEFLOW)) &&
907  (originalVehicle->getParentDemandElements().size() == 1)) {
908  originalVehicle = separateEmbeddedRoute(originalVehicle, undoList);
909  }
910  // obtain VType of original vehicle
911  GNEDemandElement* vType = originalVehicle->getParentDemandElements().at(0);
912  // extract vehicleParameters of originalVehicle
913  SUMOVehicleParameter newVehicleParameters = *originalVehicle;
914  // change tag in newVehicleParameters (needed for GNEVehicle constructor)
915  newVehicleParameters.tag = SUMO_TAG_TRIP;
916  // make transformation depending of vehicle tag
917  if ((originalVehicle->getTagProperty().getTag() == SUMO_TAG_VEHICLE) || (originalVehicle->getTagProperty().getTag() == SUMO_TAG_ROUTEFLOW)) {
918  // create trip using values of original vehicle (including ID) and route's edges
919  GNEVehicle* trip = new GNEVehicle(originalVehicle->getViewNet(), vType,
920  originalVehicle->getParentDemandElements().at(1)->getParentEdges().front(),
921  originalVehicle->getParentDemandElements().at(1)->getParentEdges().back(),
922  originalVehicle->getParentDemandElements().at(1)->getMiddleParentEdges(),
923  newVehicleParameters);
924  // first remove vehicle (to avoid problem with ID)
925  undoList->add(new GNEChange_DemandElement(originalVehicle, false), true);
926  // add new vehicle
927  undoList->add(new GNEChange_DemandElement(trip, true), true);
928  // check if trip has to be selected
929  if (selected) {
930  undoList->p_add(new GNEChange_Attribute(trip, trip->getViewNet()->getNet(), GNE_ATTR_SELECTED, "true"));
931  }
932  } else if ((originalVehicle->getTagProperty().getTag() == SUMO_TAG_FLOW) || (originalVehicle->getTagProperty().getTag() == SUMO_TAG_TRIP)) {
933  // create trip using values of original vehicle (including ID)
934  GNEVehicle* trip = new GNEVehicle(originalVehicle->getViewNet(), vType,
935  originalVehicle->getParentEdges().front(),
936  originalVehicle->getParentEdges().back(),
937  originalVehicle->getMiddleParentEdges(),
938  newVehicleParameters);
939  // remove originalVehicle
940  undoList->add(new GNEChange_DemandElement(originalVehicle, false), true);
941  // add new trip
942  undoList->add(new GNEChange_DemandElement(trip, true), true);
943  // check if trip has to be selected
944  if (selected) {
945  undoList->p_add(new GNEChange_Attribute(trip, trip->getViewNet()->getNet(), GNE_ATTR_SELECTED, "true"));
946  }
947  }
948  // check if separatedEmbeddedRoute has to be removed
949  if (separatedEmbeddedRoute) {
950  undoList->add(new GNEChange_DemandElement(separatedEmbeddedRoute, false), true);
951  }
952  // end undo-redo operation
953  undoList->p_end();
954  }
955 }
956 
957 
958 void
960  // first check that given vehicle isn't already a flow
961  if (originalVehicle->getTagProperty().getTag() != SUMO_TAG_FLOW) {
962  // get pointer to undo list (due originalVehicle will be deleted)
963  GNEUndoList* undoList = originalVehicle->getViewNet()->getUndoList();
964  // begin undo-redo operation
965  undoList->p_begin("transform " + originalVehicle->getTagStr() + " to " + toString(SUMO_TAG_FLOW));
966  // declare pointer to get embedded route if is created
967  GNEDemandElement* separatedEmbeddedRoute = nullptr;
968  // declare flag to save if vehicle is selected
969  bool selected = originalVehicle->isAttributeCarrierSelected();
970  // first check if originalVehicle has an embedded route, and if true, separate it
971  if (((originalVehicle->getTagProperty().getTag() == SUMO_TAG_VEHICLE) || (originalVehicle->getTagProperty().getTag() == SUMO_TAG_ROUTEFLOW)) &&
972  (originalVehicle->getParentDemandElements().size() == 1)) {
973  originalVehicle = separateEmbeddedRoute(originalVehicle, undoList);
974  separatedEmbeddedRoute = originalVehicle->getParentDemandElements().at(1);
975  }
976  // obtain VType of original vehicle
977  GNEDemandElement* vType = originalVehicle->getParentDemandElements().at(0);
978  // extract vehicleParameters of originalVehicle
979  SUMOVehicleParameter newVehicleParameters = *originalVehicle;
980  // change tag in newVehicleParameters (needed for GNEVehicle constructor)
981  newVehicleParameters.tag = SUMO_TAG_FLOW;
982  // make transformation depending of vehicle tag
983  if ((originalVehicle->getTagProperty().getTag() == SUMO_TAG_VEHICLE) || (originalVehicle->getTagProperty().getTag() == SUMO_TAG_ROUTEFLOW)) {
984  // create Vehicle using values of original vehicle (including ID) and route's edges
985  GNEVehicle* flow = new GNEVehicle(originalVehicle->getViewNet(), vType,
986  originalVehicle->getParentDemandElements().at(1)->getParentEdges().front(),
987  originalVehicle->getParentDemandElements().at(1)->getParentEdges().back(),
988  originalVehicle->getParentDemandElements().at(1)->getMiddleParentEdges(),
989  newVehicleParameters);
990  // first remove vehicle (to avoid problem with ID)
991  undoList->add(new GNEChange_DemandElement(originalVehicle, false), true);
992  // add new flow
993  undoList->add(new GNEChange_DemandElement(flow, true), true);
994  } else if ((originalVehicle->getTagProperty().getTag() == SUMO_TAG_FLOW) || (originalVehicle->getTagProperty().getTag() == SUMO_TAG_TRIP)) {
995  // create flow using values of original vehicle (including ID)
996  GNEVehicle* flow = new GNEVehicle(originalVehicle->getViewNet(), vType,
997  originalVehicle->getParentEdges().front(),
998  originalVehicle->getParentEdges().back(),
999  originalVehicle->getMiddleParentEdges(),
1000  newVehicleParameters);
1001  // remove originalVehicle
1002  undoList->add(new GNEChange_DemandElement(originalVehicle, false), true);
1003  // add new flow
1004  undoList->add(new GNEChange_DemandElement(flow, true), true);
1005  // check if flow has to be selected
1006  if (selected) {
1007  undoList->p_add(new GNEChange_Attribute(flow, flow->getViewNet()->getNet(), GNE_ATTR_SELECTED, "true"));
1008  }
1009  }
1010  // check if separatedEmbeddedRoute has to be removed
1011  if (separatedEmbeddedRoute) {
1012  undoList->add(new GNEChange_DemandElement(separatedEmbeddedRoute, false), true);
1013  }
1014  // end undo-redo operation
1015  undoList->p_end();
1016  }
1017 }
1018 
1019 
1020 void
1022  //
1023 }
1024 
1025 
1026 void
1028  //
1029 }
1030 
1031 
1032 void
1033 GNERouteHandler::setFlowParameters(const SumoXMLAttr attribute, int& parameters) {
1034  // modify parametersSetCopy depending of given Flow attribute
1035  switch (attribute) {
1036  case SUMO_ATTR_END: {
1037  // give more priority to end
1038  parameters = VEHPARS_END_SET | VEHPARS_NUMBER_SET;
1039  break;
1040  }
1041  case SUMO_ATTR_NUMBER:
1042  parameters ^= VEHPARS_END_SET;
1043  parameters |= VEHPARS_NUMBER_SET;
1044  break;
1045  case SUMO_ATTR_VEHSPERHOUR: {
1046  // give more priority to end
1047  if ((parameters & VEHPARS_END_SET) && (parameters & VEHPARS_NUMBER_SET)) {
1048  parameters = VEHPARS_END_SET;
1049  } else if (parameters & VEHPARS_END_SET) {
1050  parameters = VEHPARS_END_SET;
1051  } else if (parameters & VEHPARS_NUMBER_SET) {
1052  parameters = VEHPARS_NUMBER_SET;
1053  }
1054  // set VehsPerHour
1055  parameters |= VEHPARS_VPH_SET;
1056  break;
1057  }
1058  case SUMO_ATTR_PERIOD: {
1059  // give more priority to end
1060  if ((parameters & VEHPARS_END_SET) && (parameters & VEHPARS_NUMBER_SET)) {
1061  parameters = VEHPARS_END_SET;
1062  } else if (parameters & VEHPARS_END_SET) {
1063  parameters = VEHPARS_END_SET;
1064  } else if (parameters & VEHPARS_NUMBER_SET) {
1065  parameters = VEHPARS_NUMBER_SET;
1066  }
1067  // set period
1068  parameters |= VEHPARS_PERIOD_SET;
1069  break;
1070  }
1071  case SUMO_ATTR_PROB: {
1072  // give more priority to end
1073  if ((parameters & VEHPARS_END_SET) && (parameters & VEHPARS_NUMBER_SET)) {
1074  parameters = VEHPARS_END_SET;
1075  } else if (parameters & VEHPARS_END_SET) {
1076  parameters = VEHPARS_END_SET;
1077  } else if (parameters & VEHPARS_NUMBER_SET) {
1078  parameters = VEHPARS_NUMBER_SET;
1079  }
1080  // set probability
1081  parameters |= VEHPARS_PROB_SET;
1082  break;
1083  }
1084  default:
1085  break;
1086  }
1087 }
1088 
1089 // ===========================================================================
1090 // protected
1091 // ===========================================================================
1092 
1093 void
1095  // create a copy of vehicle with the same attributes but without embedded route
1096  GNEVehicle* vehicleWithEmbebbeRoute = new GNEVehicle(vehicle->getViewNet(), vehicle->getParentDemandElements().at(0), *vehicle);
1097  // create a embeddedRoute based on parameters of vehicle's route
1098  GNERoute* embeddedRoute = new GNERoute(vehicleWithEmbebbeRoute->getViewNet(), vehicleWithEmbebbeRoute, RouteParameter(vehicle->getParentDemandElements().at(1)));
1099  // remove vehicle, but NOT route
1100  undoList->add(new GNEChange_DemandElement(vehicle, false), true);
1101  // now add bot vehicleWithEmbebbeRoute and embeddedRoute
1102  undoList->add(new GNEChange_DemandElement(vehicleWithEmbebbeRoute, true), true);
1103  undoList->add(new GNEChange_DemandElement(embeddedRoute, true), true);
1104 }
1105 
1106 
1107 GNEVehicle*
1109  // first create a Route based on the parameters of vehicle's embedded route
1110  GNERoute* nonEmbeddedRoute = new GNERoute(vehicle->getChildDemandElements().at(0));
1111  // create a copy of vehicle with the same attributes but with the nonEmbeddedRoute
1112  GNEVehicle* vehicleWithoutEmbebbeRoute = new GNEVehicle(vehicle->getViewNet(), vehicle->getParentDemandElements().at(0), nonEmbeddedRoute, *vehicle);
1113  // remove embedded route andvehicle (because a embebbbed route without vehicle cannot exist)
1114  undoList->add(new GNEChange_DemandElement(vehicle->getChildDemandElements().at(0), false), true);
1115  undoList->add(new GNEChange_DemandElement(vehicle, false), true);
1116  // now add bot nonEmbeddedRoute and vehicleWithoutEmbebbeRoute
1117  undoList->add(new GNEChange_DemandElement(nonEmbeddedRoute, true), true);
1118  undoList->add(new GNEChange_DemandElement(vehicleWithoutEmbebbeRoute, true), true);
1119  // return vehicleWithoutEmbebbeRoute
1120  return vehicleWithoutEmbebbeRoute;
1121 }
1122 
1123 
1124 void
1126  // currently unused
1127 }
1128 
1129 
1130 void
1132  // currently unused
1133 }
1134 
1135 
1136 void
1138  // change abort flag
1139  myAbort = false;
1140  // check if route has ID (due embebbed routes)
1141  if (attrs.hasAttribute(SUMO_ATTR_ID)) {
1142  myRouteParameter.routeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_ROUTE, SUMO_ATTR_ID, myAbort);
1143  myRouteParameter.loadedID = true;
1144  } else {
1145  myRouteParameter.routeID.clear();
1146  myRouteParameter.loadedID = false;
1147  }
1148  // parse other attributes
1149  myRouteParameter.setEdges(myViewNet, GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myRouteParameter.routeID, SUMO_TAG_ROUTE, SUMO_ATTR_EDGES, myAbort));
1150  myRouteParameter.color = GNEAttributeCarrier::parseAttributeFromXML<RGBColor>(attrs, myRouteParameter.routeID, SUMO_TAG_ROUTE, SUMO_ATTR_COLOR, myAbort);
1151 }
1152 
1153 
1154 void
1156  // change abort flag
1157  myAbort = false;
1158  // parse flow attributes
1160  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myVehicleParameter->id, SUMO_TAG_TRIP, SUMO_ATTR_FROM, myAbort),
1161  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myVehicleParameter->id, SUMO_TAG_TRIP, SUMO_ATTR_TO, myAbort),
1162  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myVehicleParameter->id, SUMO_TAG_TRIP, SUMO_ATTR_VIA, myAbort));
1163 }
1164 
1165 
1166 void
1168  // change abort flag
1169  myAbort = false;
1170  // parse trips attributes
1172  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myVehicleParameter->id, SUMO_TAG_TRIP, SUMO_ATTR_FROM, myAbort),
1173  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myVehicleParameter->id, SUMO_TAG_TRIP, SUMO_ATTR_TO, myAbort),
1174  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myVehicleParameter->id, SUMO_TAG_TRIP, SUMO_ATTR_VIA, myAbort));
1175 }
1176 
1177 
1178 void
1179 GNERouteHandler::closeRoute(const bool /* mayBeDisconnected */) {
1180  // first copy parameters from SUMORouteHanlder to myRouteParameter
1182  // clear loaded parameters after set
1184  // we have two possibilities: Either create a route with their own ID, or create a route within a vehicle
1185  if (myVehicleParameter) {
1186  // extra warning for embebbed routes
1187  if (myRouteParameter.loadedID) {
1188  WRITE_WARNING("Attribute ID ignored in embedded routes");
1189  }
1190  // check edges
1191  if (myRouteParameter.edges.size() == 0) {
1192  WRITE_ERROR("A route needs at least one edge. Vehicle with ID='" + myVehicleParameter->id + "' cannot be created");
1193  } else {
1194  // obtain vType
1196  if (vType == nullptr) {
1197  WRITE_ERROR("Invalid vehicle type '" + myVehicleParameter->vtypeid + "' used in " + toString(myVehicleParameter->tag) + " '" + myVehicleParameter->id + "'.");
1198  } else {
1199  // generate a new route ID and add it to myVehicleParameter
1201  // due vehicle was loaded without a route, change tag
1203  // create vehicle or trips using myTemporalVehicleParameter without a route
1205  // creaste embedded route
1207  // add both to net depending of myUndoDemandElements
1208  if (myUndoDemandElements) {
1209  myViewNet->getUndoList()->p_begin("add vehicle and " + embeddedRoute->getTagStr());
1210  // add both in net using undoList
1212  myViewNet->getUndoList()->add(new GNEChange_DemandElement(embeddedRoute, true), true);
1213  // iterate over stops of myActiveRouteStops and create stops associated with it
1214  for (const auto& i : myActiveRouteStops) {
1216  }
1217  } else {
1218  // add vehicleOrRouteFlow in net and in their vehicle type parent
1221  myLoadedVehicleWithEmbebbedRoute->incRef("buildVehicleAndRoute");
1222  // add route manually in net, and in all of their edges and in vehicleOrRouteFlow
1223  myViewNet->getNet()->insertDemandElement(embeddedRoute);
1224  for (const auto& i : myRouteParameter.edges) {
1225  i->addChildDemandElement(myLoadedVehicleWithEmbebbedRoute);
1226  }
1228  embeddedRoute->incRef("buildVehicleAndRoute");
1229  // iterate over stops of myActiveRouteStops and create stops associated with it
1230  for (const auto& i : myActiveRouteStops) {
1232  }
1233  }
1234  }
1235  }
1236  } else if (myRouteParameter.loadedID == false) {
1237  WRITE_ERROR(toString(SUMO_TAG_ROUTE) + " needs a valid ID.");
1239  WRITE_ERROR(toString(SUMO_TAG_ROUTE) + " ID='" + myRouteParameter.routeID + "' contains invalid characters.");
1240  } else if (myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_ROUTE, myRouteParameter.routeID, false) != nullptr) {
1241  WRITE_ERROR("There is another " + toString(SUMO_TAG_ROUTE) + " with the same ID='" + myRouteParameter.routeID + "'.");
1242  } else if (myRouteParameter.edges.size() == 0) {
1243  WRITE_ERROR("A route needs at least one edge.");
1244  } else {
1245  // creaste GNERoute
1247  if (myUndoDemandElements) {
1248  myViewNet->getUndoList()->p_begin("add " + route->getTagStr());
1249  myViewNet->getUndoList()->add(new GNEChange_DemandElement(route, true), true);
1250  // iterate over stops of myActiveRouteStops and create stops associated with it
1251  for (const auto& i : myActiveRouteStops) {
1252  buildStop(myViewNet, true, i, route);
1253  }
1254  myViewNet->getUndoList()->p_end();
1255  } else {
1257  for (const auto& i : myRouteParameter.edges) {
1258  i->addChildDemandElement(route);
1259  }
1260  route->incRef("buildRoute");
1261  // iterate over stops of myActiveRouteStops and create stops associated with it
1262  for (const auto& i : myActiveRouteStops) {
1263  buildStop(myViewNet, false, i, route);
1264  }
1265  }
1266  }
1267 }
1268 
1269 
1270 void
1272  // currently unused
1273 }
1274 
1275 
1276 void
1278  // currently unused
1279 }
1280 
1281 
1282 void
1284  // first check if we're closing a vehicle with embebbed routes and stops
1287  // check if current command group size has to be ended
1289  myViewNet->getUndoList()->p_end();
1290  }
1291  } else {
1292  // now check if myVehicleParameter was sucesfully created
1293  if (myVehicleParameter) {
1294  // build vehicle over route
1296  }
1297  }
1298 }
1299 
1300 
1301 void
1303  // first check that VType was sucesfully created
1304  if (myCurrentVType) {
1305  // first check if we're creating a vType or a pType
1307  // check if loaded vType/pType is a default vtype
1309  // overwrite default vehicle type
1311  } else if (myViewNet->getNet()->retrieveDemandElement(vTypeTag, myCurrentVType->id, false) != nullptr) {
1312  WRITE_ERROR("There is another " + toString(vTypeTag) + " with the same ID='" + myCurrentVType->id + "'.");
1313  } else {
1314  // create vType/pType using myCurrentVType
1315  GNEVehicleType* vType = new GNEVehicleType(myViewNet, *myCurrentVType, vTypeTag);
1316  if (myUndoDemandElements) {
1317  myViewNet->getUndoList()->p_begin("add " + vType->getTagStr());
1318  myViewNet->getUndoList()->add(new GNEChange_DemandElement(vType, true), true);
1319  myViewNet->getUndoList()->p_end();
1320  } else {
1322  vType->incRef("buildVType");
1323  }
1324  }
1325  }
1326 }
1327 
1328 
1329 void
1331  // first check if myVehicleParameter was sucesfully created
1332  if (myVehicleParameter) {
1333  // first check if ID is duplicated
1335  // obtain ptype
1337  if (pType == nullptr) {
1338  WRITE_ERROR("Invalid person type '" + myVehicleParameter->vtypeid + "' used in " + toString(myVehicleParameter->tag) + " '" + myVehicleParameter->vtypeid + "'.");
1339  } else {
1340  // declare flag to abort person plans creation
1341  bool abortPersonPlans = false;
1342  // create person using personParameters
1344  // begin undo-list creation
1345  myViewNet->getUndoList()->p_begin("add " + person->getTagStr());
1346  // add person
1347  myViewNet->getUndoList()->add(new GNEChange_DemandElement(person, true), true);
1348  // iterate over all personplan childs and add it
1349  for (auto i = myPersonPlanValues.begin(); (i != myPersonPlanValues.end()) && !abortPersonPlans; i++) {
1350  switch (i->tag) {
1352  // check if "from" attribute was loaded, or it must be taked fron previous personPlan values
1353  if (i->from && i->to) {
1354  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNEPersonTrip(myViewNet, person, i->from, i->to, {}, i->arrivalPos, i->vTypes, i->modes), true), true);
1355  } else if ((i != myPersonPlanValues.begin()) && i->to) {
1356  // update 'from' edge using 'to' edge of last personPlan element
1357  i->from = (i - 1)->getLastEdge();
1358  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNEPersonTrip(myViewNet, person, i->from, i->to, {}, i->arrivalPos, i->vTypes, i->modes), true), true);
1359  } else {
1360  WRITE_ERROR("The first person plan of type '" + toString(i->tag) + "' needs a from edge. Person cannot be created.");
1361  // abort last command group (to remove created person)
1363  // abort person plan creation
1364  abortPersonPlans = true;
1365  }
1366  break;
1368  // check if "from" attribute was loaded, or it must be taked fron previous personPlan values
1369  if (i->from) {
1370  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNEPersonTrip(myViewNet, person, i->from, i->busStop, {}, i->vTypes, i->modes), true), true);
1371  } else if (i != myPersonPlanValues.begin()) {
1372  // update 'from' edge using 'to' edge of last personPlan element
1373  i->from = (i - 1)->getLastEdge();
1374  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNEPersonTrip(myViewNet, person, i->from, i->busStop, {}, i->vTypes, i->modes), true), true);
1375  } else {
1376  WRITE_ERROR("The first person plan of type '" + toString(i->tag) + "' needs a from edge. Person cannot be created.");
1377  // abort last command group (to remove created person)
1379  // abort person plan creation
1380  abortPersonPlans = true;
1381  }
1382  break;
1383  case SUMO_TAG_RIDE_FROMTO:
1384  // check if "from" attribute was loaded, or it must be taked fron previous personPlan values
1385  if (i->from && i->to) {
1386  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNERide(myViewNet, person, i->from, i->to, {}, i->arrivalPos, i->lines), true), true);
1387  } else if ((i != myPersonPlanValues.begin()) && i->to) {
1388  // update 'from' edge using 'to' edge of last personPlan element
1389  i->from = (i - 1)->getLastEdge();
1390  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNERide(myViewNet, person, i->from, i->to, {}, i->arrivalPos, i->lines), true), true);
1391  } else {
1392  WRITE_ERROR("The first person plan of type '" + toString(i->tag) + "' needs a from edge. Person cannot be created.");
1393  // abort last command group (to remove created person)
1395  // abort person plan creation
1396  abortPersonPlans = true;
1397  }
1398  break;
1399  case SUMO_TAG_RIDE_BUSSTOP:
1400  // check if "from" attribute was loaded, or it must be taked fron previous personPlan values
1401  if (i->from) {
1402  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNERide(myViewNet, person, i->from, i->busStop, {}, i->lines), true), true);
1403  } else if (i != myPersonPlanValues.begin()) {
1404  // update 'from' edge using 'to' edge of last personPlan element
1405  i->from = (i - 1)->getLastEdge();
1406  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNERide(myViewNet, person, i->from, i->busStop, {}, i->lines), true), true);
1407  } else {
1408  WRITE_ERROR("The first person plan of type '" + toString(i->tag) + "' needs a from edge. Person cannot be created.");
1409  // abort last command group (to remove created person)
1411  // abort person plan creation
1412  abortPersonPlans = true;
1413  }
1414  break;
1415  case SUMO_TAG_WALK_EDGES:
1416  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNEWalk(myViewNet, person, i->edges, i->arrivalPos), true), true);
1417  break;
1418  case SUMO_TAG_WALK_FROMTO:
1419  // check if "from" attribute was loaded, or it must be taked fron previous personPlan values
1420  if (i->from && i->to) {
1421  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNEWalk(myViewNet, person, i->from, i->to, {}, i->arrivalPos), true), true);
1422  } else if ((i != myPersonPlanValues.begin()) && i->to) {
1423  // update 'from' edge using 'to' edge of last personPlan element
1424  i->from = (i - 1)->getLastEdge();
1425  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNEWalk(myViewNet, person, i->from, i->to, {}, i->arrivalPos), true), true);
1426  } else {
1427  WRITE_ERROR("The first person plan of type '" + toString(i->tag) + "' needs a from edge. Person cannot be created.");
1428  // abort last command group (to remove created person)
1430  // abort person plan creation
1431  abortPersonPlans = true;
1432  }
1433  break;
1434  case SUMO_TAG_WALK_BUSSTOP:
1435  // check if "from" attribute was loaded, or it must be taked fron previous personPlan values
1436  if (i->from) {
1437  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNEWalk(myViewNet, person, i->from, i->busStop, {}), true), true);
1438  } else if (i != myPersonPlanValues.begin()) {
1439  // update 'from' edge using 'to' edge of last personPlan element
1440  i->from = (i - 1)->getLastEdge();
1441  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNEWalk(myViewNet, person, i->from, i->busStop, {}), true), true);
1442  } else {
1443  WRITE_ERROR("The first person plan of type '" + toString(i->tag) + "' needs a from edge. Person cannot be created.");
1444  // abort last command group (to remove created person)
1446  // abort person plan creation
1447  abortPersonPlans = true;
1448  }
1449  break;
1450  case SUMO_TAG_WALK_ROUTE:
1451  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNEWalk(myViewNet, person, i->route, i->arrivalPos), true), true);
1452  break;
1454  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNEStop(myViewNet, i->stopParameters, i->laneStop, person), true), true);
1455  break;
1457  myViewNet->getUndoList()->add(new GNEChange_DemandElement(new GNEStop(i->tag, myViewNet, i->stopParameters, i->busStop, person), true), true);
1458  break;
1459  default:
1460  break;
1461  }
1462  }
1463  // end undo-list depending of abortPersonPlans
1464  if (!abortPersonPlans) {
1465  myViewNet->getUndoList()->p_end();
1466  }
1467  }
1468  }
1469 
1470  }
1471  // clear person plan values clear
1472  myPersonPlanValues.clear();
1473 }
1474 
1475 void
1477  // first check if myVehicleParameter was sucesfully created
1478  if (myVehicleParameter) {
1479  // build person flow
1481  }
1482 }
1483 
1484 void
1486  // currently unused
1487 }
1488 
1489 
1490 void
1492  // first check if myVehicleParameter was sucesfully created
1493  if (myVehicleParameter) {
1494  // check if we're creating a flow or a routeFlow over route
1495  if (myRouteParameter.edges.size() > 1) {
1496  // extract via edges
1497  std::vector<GNEEdge*> viaEdges;
1498  for (int i = 1; i < ((int)myRouteParameter.edges.size() - 1); i++) {
1499  viaEdges.push_back(myRouteParameter.edges.at(i));
1500  }
1501  // build flow
1503  } else if (myRouteParameter.edges.size() == 0) {
1504  // build flow over route
1506  }
1507  }
1508 }
1509 
1510 
1511 void
1513  // first check if myVehicleParameter was sucesfully created
1514  if (myVehicleParameter && (myRouteParameter.edges.size() > 1)) {
1515  // force reroute
1517  // extract via edges
1518  std::vector<GNEEdge*> viaEdges;
1519  for (int i = 1; i < ((int)myRouteParameter.edges.size() - 1); i++) {
1520  viaEdges.push_back(myRouteParameter.edges.at(i));
1521  }
1522  // build trip
1524  }
1525 }
1526 
1527 
1528 void
1530  // declare a personStop
1531  PersonPlansValues stop;
1532  std::string errorSuffix;
1533  if (myVehicleParameter != nullptr) {
1534  errorSuffix = " in " + toString(myVehicleParameter->tag) + " '" + myVehicleParameter->id + "'.";
1535  } else {
1536  errorSuffix = " in route '" + myActiveRouteID + "'.";
1537  }
1538  // try to parse stop
1539  myAbort = parseStop(stop.stopParameters, attrs, errorSuffix, MsgHandler::getErrorInstance());
1540  if (!myAbort) {
1541  return;
1542  }
1543  // try to parse the assigned bus stop
1544  if (stop.stopParameters.busstop != "") {
1545  // ok, we have a busStop
1546  GNEBusStop* bs = dynamic_cast<GNEBusStop*>(myViewNet->getNet()->retrieveAdditional(SUMO_TAG_BUS_STOP, stop.stopParameters.busstop, false));
1547  if (bs == nullptr) {
1548  WRITE_ERROR(toString(SUMO_TAG_BUS_STOP) + " '" + stop.stopParameters.busstop + "' is not known" + errorSuffix);
1549  return;
1550  }
1551  // save lane
1553  // save stoping place in stop
1554  stop.busStop = bs;
1555  // set tag
1556  stop.tag = SUMO_TAG_STOP_BUSSTOP;
1557  // special case for persons
1560  }
1561  } else if (stop.stopParameters.containerstop != "") {
1562  // special case for persons
1564  WRITE_ERROR("Persons don't support " + toString(SUMO_TAG_CONTAINER_STOP) + "s");
1565  return;
1566  }
1567  // ok, we have a containerStop
1568  GNEContainerStop* cs = dynamic_cast<GNEContainerStop*>(myViewNet->getNet()->retrieveAdditional(SUMO_TAG_CONTAINER_STOP, stop.stopParameters.containerstop, false));
1569  if (cs == nullptr) {
1570  WRITE_ERROR(toString(SUMO_TAG_CONTAINER_STOP) + " '" + stop.stopParameters.containerstop + "' is not known" + errorSuffix);
1571  return;
1572  }
1573  // save lane
1575  // save stoping place in stop
1576  stop.containerStop = cs;
1577  // set tag
1579 
1580  } else if (stop.stopParameters.chargingStation != "") {
1581  // special case for persons
1583  WRITE_ERROR("Persons don't support " + toString(SUMO_TAG_CHARGING_STATION) + "s");
1584  return;
1585  }
1586  // ok, we have a chargingStation
1587  GNEChargingStation* cs = dynamic_cast<GNEChargingStation*>(myViewNet->getNet()->retrieveAdditional(SUMO_TAG_CHARGING_STATION, stop.stopParameters.chargingStation, false));
1588  if (cs == nullptr) {
1589  WRITE_ERROR(toString(SUMO_TAG_CHARGING_STATION) + " '" + stop.stopParameters.chargingStation + "' is not known" + errorSuffix);
1590  return;
1591  }
1592  // save lane
1594  // save stoping place in stop
1595  stop.chargingStation = cs;
1596  // set tag
1598  } else if (stop.stopParameters.parkingarea != "") {
1599  // special case for persons
1601  WRITE_ERROR("Persons don't support " + toString(SUMO_TAG_PARKING_AREA) + "s");
1602  return;
1603  }
1604  // ok, we have a parkingArea
1605  GNEParkingArea* pa = dynamic_cast<GNEParkingArea*>(myViewNet->getNet()->retrieveAdditional(SUMO_TAG_PARKING_AREA, stop.stopParameters.parkingarea, false));
1606  if (pa == nullptr) {
1607  WRITE_ERROR(toString(SUMO_TAG_PARKING_AREA) + " '" + stop.stopParameters.parkingarea + "' is not known" + errorSuffix);
1608  return;
1609  }
1610  // save lane
1612  // save stoping place in stop
1613  stop.parkingArea = pa;
1614  // set tag
1616  } else {
1617  // no, the lane and the position should be given
1618  // get the lane
1619  stop.stopParameters.lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, nullptr, myAbort, "");
1620  stop.laneStop = myViewNet->getNet()->retrieveLane(stop.stopParameters.lane, false);
1621  // check if lane is valid
1622  if (myAbort && stop.stopParameters.lane != "") {
1623  if (stop.laneStop == nullptr) {
1624  WRITE_ERROR("The lane '" + stop.stopParameters.lane + "' for a stop is not known" + errorSuffix);
1625  return;
1626  }
1627  } else {
1628  WRITE_ERROR("A stop must be placed over a " + toString(SUMO_TAG_BUS_STOP) + ", a " + toString(SUMO_TAG_CONTAINER_STOP) +
1629  ", a " + toString(SUMO_TAG_CHARGING_STATION) + ", a " + toString(SUMO_TAG_PARKING_AREA) + " or a " + toString(SUMO_TAG_LANE) + errorSuffix);
1630  return;
1631  }
1632  // calculate start and end position
1633  stop.stopParameters.endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, nullptr, myAbort, stop.laneStop->getLaneParametricLength());
1634  if (attrs.hasAttribute(SUMO_ATTR_POSITION)) {
1635  WRITE_ERROR("Deprecated attribute 'pos' in description of stop" + errorSuffix);
1636  stop.stopParameters.endPos = attrs.getOpt<double>(SUMO_ATTR_POSITION, nullptr, myAbort, stop.stopParameters.endPos);
1637  }
1638  stop.stopParameters.startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, nullptr, myAbort, MAX2(0., stop.stopParameters.endPos - 2 * POSITION_EPS));
1639  stop.stopParameters.friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, nullptr, myAbort, false);
1641  WRITE_ERROR("Invalid start or end position for stop on lane '" + stop.stopParameters.lane + "'" + errorSuffix);
1642  return;
1643  }
1644  // set tag
1645  stop.tag = SUMO_TAG_STOP_LANE;
1646  // special case for persons
1649  }
1650  }
1651  // now create or store stop
1654  } else if (myVehicleParameter != nullptr) {
1656  myPersonPlanValues.push_back(stop);
1657  } else {
1658  myVehicleParameter->stops.push_back(stop.stopParameters);
1659  }
1660  } else {
1661  myActiveRouteStops.push_back(stop.stopParameters);
1662  }
1663 }
1664 
1665 
1666 void
1668  // SUMORouteHandler handle certain walks configurations as PersonTrips, then it needs a manually call to addWalk(...)
1669  if (attrs.getObjectType() == "walk") {
1670  addWalk(attrs);
1671  } else {
1672  // change abort flag
1673  myAbort = false;
1674  // declare value for saving loaded values
1675  PersonPlansValues personTripValuesLoaded;
1676  // first set tag
1677  if (attrs.hasAttribute(SUMO_ATTR_TO)) {
1678  // set tag
1679  personTripValuesLoaded.tag = SUMO_TAG_PERSONTRIP_FROMTO;
1680  // declare a flag to check if values are valid
1681  bool validValues = true;
1682  // extract rest of parameters
1683  if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
1684  personTripValuesLoaded.from = myViewNet->getNet()->retrieveEdge(GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", personTripValuesLoaded.tag, SUMO_ATTR_FROM, myAbort), false);
1685  if (personTripValuesLoaded.from == nullptr) {
1686  WRITE_ERROR("Invalid edge from in " + toString(personTripValuesLoaded.tag));
1687  validValues = false;
1688  }
1689  }
1690  personTripValuesLoaded.to = myViewNet->getNet()->retrieveEdge(GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", personTripValuesLoaded.tag, SUMO_ATTR_TO, myAbort), false);
1691  personTripValuesLoaded.vTypes = GNEAttributeCarrier::parseAttributeFromXML<std::vector<std::string> >(attrs, "", personTripValuesLoaded.tag, SUMO_ATTR_VTYPES, myAbort);
1692  personTripValuesLoaded.modes = GNEAttributeCarrier::parseAttributeFromXML<std::vector<std::string> >(attrs, "", personTripValuesLoaded.tag, SUMO_ATTR_MODES, myAbort);
1693  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS)) {
1694  personTripValuesLoaded.arrivalPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", personTripValuesLoaded.tag, SUMO_ATTR_ARRIVALPOS, myAbort);
1695  }
1696  // check that all parameters are correct
1697  if (personTripValuesLoaded.to == nullptr) {
1698  WRITE_ERROR("Invalid edge to in " + toString(personTripValuesLoaded.tag));
1699  validValues = false;
1700  }
1701  // check modes
1702  for (const auto& i : personTripValuesLoaded.modes) {
1703  if ((i != "public") && (i != "car") && (i != "bicycle")) {
1704  validValues = false;
1705  }
1706  }
1707  if (validValues) {
1708  // remove duplicated modes
1709  std::sort(personTripValuesLoaded.modes.begin(), personTripValuesLoaded.modes.end());
1710  personTripValuesLoaded.modes.erase(unique(personTripValuesLoaded.modes.begin(), personTripValuesLoaded.modes.end()), personTripValuesLoaded.modes.end());
1711  } else {
1712  WRITE_ERROR("A person trip mode can be only a combination of 'public', 'car' or 'bicycle'");
1713  }
1714  for (const auto& i : personTripValuesLoaded.vTypes) {
1716  WRITE_ERROR("Invalid vehicle type '" + i + "' used in " + toString(personTripValuesLoaded.tag));
1717  validValues = false;
1718  }
1719  }
1720  // save loaded values in container only if all parameters are valid
1721  if (validValues) {
1722  myPersonPlanValues.push_back(personTripValuesLoaded);
1723  }
1724  } else if (attrs.hasAttribute(SUMO_ATTR_BUS_STOP)) {
1725  // set tag
1726  personTripValuesLoaded.tag = SUMO_TAG_PERSONTRIP_BUSSTOP;
1727  // declare a flag to check if values are valid
1728  bool validValues = true;
1729  // extract rest of parameters
1730  if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
1731  personTripValuesLoaded.from = myViewNet->getNet()->retrieveEdge(GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", personTripValuesLoaded.tag, SUMO_ATTR_FROM, myAbort), false);
1732  if (personTripValuesLoaded.from == nullptr) {
1733  WRITE_ERROR("Invalid edge from in " + toString(personTripValuesLoaded.tag));
1734  validValues = false;
1735  }
1736  }
1737  personTripValuesLoaded.busStop = myViewNet->getNet()->retrieveAdditional(SUMO_TAG_BUS_STOP, GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", personTripValuesLoaded.tag, SUMO_ATTR_BUS_STOP, myAbort), false);
1738  personTripValuesLoaded.vTypes = GNEAttributeCarrier::parseAttributeFromXML<std::vector<std::string> >(attrs, "", personTripValuesLoaded.tag, SUMO_ATTR_VTYPES, myAbort);
1739  personTripValuesLoaded.modes = GNEAttributeCarrier::parseAttributeFromXML<std::vector<std::string> >(attrs, "", personTripValuesLoaded.tag, SUMO_ATTR_MODES, myAbort);
1740  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS)) {
1741  personTripValuesLoaded.arrivalPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", personTripValuesLoaded.tag, SUMO_ATTR_ARRIVALPOS, myAbort);
1742  }
1743  // check that all parameters are correct
1744  if (personTripValuesLoaded.busStop == nullptr) {
1745  WRITE_ERROR("Invalid busStop to in " + toString(personTripValuesLoaded.tag));
1746  validValues = false;
1747  }
1748  // check modes
1749  for (const auto& i : personTripValuesLoaded.modes) {
1750  if ((i != "public") && (i != "car") && (i != "bicycle")) {
1751  validValues = false;
1752  }
1753  }
1754  if (validValues) {
1755  // remove duplicated modes
1756  std::sort(personTripValuesLoaded.modes.begin(), personTripValuesLoaded.modes.end());
1757  personTripValuesLoaded.modes.erase(unique(personTripValuesLoaded.modes.begin(), personTripValuesLoaded.modes.end()), personTripValuesLoaded.modes.end());
1758  } else {
1759  WRITE_ERROR("A person trip mode can be only a combination of 'public', 'car' or 'bicycle'");
1760  }
1761  for (const auto& i : personTripValuesLoaded.vTypes) {
1763  WRITE_ERROR("Invalid vehicle type '" + i + "' used in " + toString(personTripValuesLoaded.tag));
1764  validValues = false;
1765  }
1766  }
1767  // save loaded values in container only if all parameters are valid
1768  if (validValues) {
1769  myPersonPlanValues.push_back(personTripValuesLoaded);
1770  }
1771  } else {
1772  WRITE_ERROR("A personTrip requires either a from-to edges or a from edge and a busStop");
1773  }
1774  }
1775 }
1776 
1777 
1778 void
1780  // change abort flag
1781  myAbort = false;
1782  // declare value for saving loaded values
1783  PersonPlansValues walkValuesLoaded;
1784  // first set tag
1785  if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
1786  // set tag
1787  walkValuesLoaded.tag = SUMO_TAG_WALK_EDGES;
1788  // parse edges
1789  std::string edgeIDs = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", walkValuesLoaded.tag, SUMO_ATTR_EDGES, myAbort);
1790  if (GNEAttributeCarrier::canParse<std::vector<GNEEdge*> >(myViewNet->getNet(), edgeIDs, true)) {
1791  walkValuesLoaded.edges = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(myViewNet->getNet(), edgeIDs);
1792  }
1793  // extract rest of parameters
1794  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS)) {
1795  walkValuesLoaded.arrivalPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", walkValuesLoaded.tag, SUMO_ATTR_ARRIVALPOS, myAbort);
1796  }
1797  // check that all parameters are correct
1798  if (walkValuesLoaded.edges.empty()) {
1799  WRITE_ERROR("Invalid edges of " + toString(walkValuesLoaded.tag));
1800  } else {
1801  // save loaded values in container
1802  myPersonPlanValues.push_back(walkValuesLoaded);
1803  }
1804  } else if (attrs.hasAttribute(SUMO_ATTR_TO)) {
1805  // set tag
1806  walkValuesLoaded.tag = SUMO_TAG_WALK_FROMTO;
1807  // extract rest of parameters
1808  if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
1809  walkValuesLoaded.from = myViewNet->getNet()->retrieveEdge(GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", walkValuesLoaded.tag, SUMO_ATTR_FROM, myAbort), false);
1810  if (walkValuesLoaded.from == nullptr) {
1811  WRITE_ERROR("Invalid edge from in " + toString(walkValuesLoaded.tag));
1812  }
1813  }
1814  walkValuesLoaded.to = myViewNet->getNet()->retrieveEdge(GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", walkValuesLoaded.tag, SUMO_ATTR_TO, myAbort), false);
1815  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS)) {
1816  walkValuesLoaded.arrivalPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", walkValuesLoaded.tag, SUMO_ATTR_ARRIVALPOS, myAbort);
1817  }
1818  // check that all parameters are correct
1819  if (walkValuesLoaded.to == nullptr) {
1820  WRITE_ERROR("Invalid edge to in " + toString(walkValuesLoaded.tag));
1821  } else {
1822  // save loaded values in container
1823  myPersonPlanValues.push_back(walkValuesLoaded);
1824  }
1825  } else if (attrs.hasAttribute(SUMO_ATTR_BUS_STOP)) {
1826  // set tag
1827  walkValuesLoaded.tag = SUMO_TAG_WALK_BUSSTOP;
1828  // extract rest of parameters
1829  if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
1830  walkValuesLoaded.from = myViewNet->getNet()->retrieveEdge(GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", walkValuesLoaded.tag, SUMO_ATTR_FROM, myAbort), false);
1831  if (walkValuesLoaded.from == nullptr) {
1832  WRITE_ERROR("Invalid edge from in " + toString(walkValuesLoaded.tag));
1833  }
1834  }
1835  walkValuesLoaded.busStop = myViewNet->getNet()->retrieveAdditional(SUMO_TAG_BUS_STOP, GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", walkValuesLoaded.tag, SUMO_ATTR_BUS_STOP, myAbort), false);
1836  // use edge of busstop's lane as to edge
1837  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS)) {
1838  walkValuesLoaded.arrivalPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", walkValuesLoaded.tag, SUMO_ATTR_ARRIVALPOS, myAbort);
1839  }
1840  // check that all parameters are correct
1841  if (walkValuesLoaded.busStop == nullptr) {
1842  WRITE_ERROR("Invalid busStop to in " + toString(walkValuesLoaded.tag));
1843  } else {
1844  // save loaded values in container
1845  myPersonPlanValues.push_back(walkValuesLoaded);
1846  }
1847  } else if (attrs.hasAttribute(SUMO_ATTR_ROUTE)) {
1848  // set tag
1849  walkValuesLoaded.tag = SUMO_TAG_WALK_ROUTE;
1850  // extract rest of parameters
1851  walkValuesLoaded.route = myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_ROUTE, GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", walkValuesLoaded.tag, SUMO_ATTR_ROUTE, myAbort), false);
1852  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS)) {
1853  walkValuesLoaded.arrivalPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", walkValuesLoaded.tag, SUMO_ATTR_ARRIVALPOS, myAbort);
1854  }
1855  // check that all parameters are correct
1856  if (walkValuesLoaded.route == nullptr) {
1857  WRITE_ERROR("Invalid route from in " + toString(walkValuesLoaded.tag));
1858  } else {
1859  // save loaded values in container
1860  myPersonPlanValues.push_back(walkValuesLoaded);
1861  }
1862  } else {
1863  WRITE_ERROR("A walk requires either a from-to edges, a from edge and a busStop or a route");
1864  }
1865 }
1866 
1867 
1868 void
1870  // currently unused
1871 }
1872 
1873 
1874 void
1876  // currently unused
1877 }
1878 
1879 
1880 void
1882  // change abort flag
1883  myAbort = false;
1884  // declare value for saving loaded values
1885  PersonPlansValues rideValuesLoaded;
1886  // first set tag
1887  if (attrs.hasAttribute(SUMO_ATTR_TO)) {
1888  // set tag
1889  rideValuesLoaded.tag = SUMO_TAG_RIDE_FROMTO;
1890  // extract rest of parameters
1891  if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
1892  rideValuesLoaded.from = myViewNet->getNet()->retrieveEdge(GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", rideValuesLoaded.tag, SUMO_ATTR_FROM, myAbort), false);
1893  if (rideValuesLoaded.from == nullptr) {
1894  WRITE_ERROR("Invalid edge from in " + toString(rideValuesLoaded.tag));
1895  }
1896  }
1897  rideValuesLoaded.to = myViewNet->getNet()->retrieveEdge(GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", rideValuesLoaded.tag, SUMO_ATTR_TO, myAbort), false);
1898  rideValuesLoaded.lines = GNEAttributeCarrier::parseAttributeFromXML<std::vector<std::string> >(attrs, "", rideValuesLoaded.tag, SUMO_ATTR_LINES, myAbort);
1899  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS)) {
1900  rideValuesLoaded.arrivalPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", rideValuesLoaded.tag, SUMO_ATTR_ARRIVALPOS, myAbort);
1901  }
1902  // check lines
1903  if (rideValuesLoaded.lines.empty()) {
1904  rideValuesLoaded.lines.push_back("ANY");
1905  }
1906  // check that all parameters are correct
1907  if (rideValuesLoaded.to == nullptr) {
1908  WRITE_ERROR("Invalid edge to in " + toString(rideValuesLoaded.tag));
1909  } else {
1910  // save loaded values in container
1911  myPersonPlanValues.push_back(rideValuesLoaded);
1912  }
1913  } else if (attrs.hasAttribute(SUMO_ATTR_BUS_STOP)) {
1914  // set tag
1915  rideValuesLoaded.tag = SUMO_TAG_RIDE_BUSSTOP;
1916  // extract rest of parameters
1917  if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
1918  rideValuesLoaded.from = myViewNet->getNet()->retrieveEdge(GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", rideValuesLoaded.tag, SUMO_ATTR_FROM, myAbort), false);
1919  if (rideValuesLoaded.from == nullptr) {
1920  WRITE_ERROR("Invalid edge from in " + toString(rideValuesLoaded.tag));
1921  }
1922  }
1923  rideValuesLoaded.busStop = myViewNet->getNet()->retrieveAdditional(SUMO_TAG_BUS_STOP, GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", rideValuesLoaded.tag, SUMO_ATTR_BUS_STOP, myAbort), false);
1924  rideValuesLoaded.lines = GNEAttributeCarrier::parseAttributeFromXML<std::vector<std::string> >(attrs, "", rideValuesLoaded.tag, SUMO_ATTR_LINES, myAbort);
1925  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS)) {
1926  rideValuesLoaded.arrivalPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", rideValuesLoaded.tag, SUMO_ATTR_ARRIVALPOS, myAbort);
1927  }
1928  // check lines
1929  if (rideValuesLoaded.lines.empty()) {
1930  rideValuesLoaded.lines.push_back("ANY");
1931  }
1932  // check that all parameters are correct
1933  if (rideValuesLoaded.busStop == nullptr) {
1934  WRITE_ERROR("Invalid busStop to in " + toString(rideValuesLoaded.tag));
1935  } else {
1936  // save loaded values in container
1937  myPersonPlanValues.push_back(rideValuesLoaded);
1938  }
1939  } else {
1940  WRITE_ERROR("A ride requires either a from-to edges or a from edge and a busStop");
1941  }
1942 }
1943 
1944 
1945 void
1947  // currently unused
1948 }
1949 
1950 
1951 void
1953  // currently unused
1954 }
1955 
1956 // ===========================================================================
1957 // private members
1958 // ===========================================================================
1959 
1961  tag(SUMO_TAG_NOTHING),
1962  from(nullptr),
1963  to(nullptr),
1964  busStop(nullptr),
1965  containerStop(nullptr),
1966  chargingStation(nullptr),
1967  parkingArea(nullptr),
1968  route(nullptr),
1969  arrivalPos(-1),
1970  laneStop(nullptr) {
1971 }
1972 
1973 
1974 GNEEdge*
1976  if (edges.size() > 0) {
1977  return edges.back();
1978  } else if (route) {
1979  return route->getParentEdges().back();
1980  } else if (busStop) {
1981  return busStop->getParentLanes().front()->getParentEdge();
1982  } else if (laneStop) {
1983  return laneStop->getParentEdge();
1984  } else if (to) {
1985  return to;
1986  } else {
1987  return nullptr;
1988  }
1989 }
1990 
1991 /****************************************************************************/
GNERouteHandler::PersonPlansValues::busStop
GNEAdditional * busStop
busStop
Definition: GNERouteHandler.h:292
SUMO_ATTR_MAXSPEED
Definition: SUMOXMLDefinitions.h:441
GNEAttributeCarrier::TagProperties::isPerson
bool isPerson() const
return true if tag correspond to a person element
Definition: GNEAttributeCarrier.cpp:756
SUMO_TAG_WALK_FROMTO
Definition: SUMOXMLDefinitions.h:307
SVC_PEDESTRIAN
pedestrian
Definition: SUMOVehicleClass.h:156
GNERouteHandler::GNERouteHandler
GNERouteHandler(const std::string &file, GNEViewNet *viewNet, bool undoDemandElements=true)
Constructor.
Definition: GNERouteHandler.cpp:116
GNERouteHandler::myRouteParameter
RouteParameter myRouteParameter
NETEDIT Route Parameters.
Definition: GNERouteHandler.h:332
GNENet::retrieveAdditional
GNEAdditional * retrieveAdditional(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named additional.
Definition: GNENet.cpp:2183
GNERouteHandler::transformToVehicle
static void transformToVehicle(GNEVehicle *originalVehicle, bool createEmbeddedRoute)
transform vehicle functions
Definition: GNERouteHandler.cpp:774
GNERouteHandler::closeVehicle
void closeVehicle()
Ends the processing of a vehicle.
Definition: GNERouteHandler.cpp:1283
GNERouteHandler::RouteParameter::setEdges
void setEdges(GNEViewNet *viewNet, const std::string &edgeIDs)
set edges (list of consecutive edges)
Definition: GNERouteHandler.cpp:70
SUMOVehicleParameter::wasSet
bool wasSet(int what) const
Returns whether the given parameter was set.
Definition: SUMOVehicleParameter.h:312
GNEDemandElement
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEDemandElement.h:55
SUMOSAXAttributes::hasAttribute
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
GNEAdditional
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEAdditional.h:48
SUMO_TAG_STOP_PARKINGAREA
stop placed over a parking area (used in netedit)
Definition: SUMOXMLDefinitions.h:188
GNERouteHandler::buildPersonTripFromTo
static void buildPersonTripFromTo(GNEViewNet *viewNet, bool undoDemandElements, GNEDemandElement *personParent, GNEEdge *fromEdge, GNEEdge *toEdge, double arrivalPos, const std::vector< std::string > &types, const std::vector< std::string > &modes)
build trip using a from-to edges
Definition: GNERouteHandler.cpp:583
GNEChange_DemandElement
Definition: GNEChange_DemandElement.h:45
SUMOVehicleParameter::parametersSet
int parametersSet
Information for the router which parameter were set, TraCI may modify this (whe changing color)
Definition: SUMOVehicleParameter.h:671
GNEDemandElement::getVClass
virtual SUMOVehicleClass getVClass() const =0
obtain VClass related with this demand element
GNERouteHandler::addContainer
void addContainer(const SUMOSAXAttributes &attrs)
Processing of a container.
Definition: GNERouteHandler.cpp:1875
GNEAttributeCarrier::getID
const std::string getID() const
function to support debugging
Definition: GNEAttributeCarrier.cpp:1289
WRITE_WARNING
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:275
GNERouteHandler::closeTrip
void closeTrip()
Ends the processing of a trip.
Definition: GNERouteHandler.cpp:1512
GNEDemandElement::getRouteCalculatorInstance
static RouteCalculator * getRouteCalculatorInstance()
obtain instance of RouteCalculator
Definition: GNEDemandElement.cpp:280
SUMOVehicleParameter::Stop::friendlyPos
bool friendlyPos
enable or disable friendly position (used by NETEDIT)
Definition: SUMOVehicleParameter.h:631
GNERouteHandler::buildVehicleOverRoute
static void buildVehicleOverRoute(GNEViewNet *viewNet, bool undoDemandElements, const SUMOVehicleParameter &vehicleParameters)
build functions
Definition: GNERouteHandler.cpp:152
DEFAULT_PEDTYPE_ID
const std::string DEFAULT_PEDTYPE_ID
SUMOVehicleParameter::Stop::lane
std::string lane
The lane to stop at.
Definition: SUMOVehicleParameter.h:586
GNEChange_DemandElement.h
GNERouteHandler::buildStop
static void buildStop(GNEViewNet *viewNet, bool undoDemandElements, const SUMOVehicleParameter::Stop &stopParameters, GNEDemandElement *stopParent)
build stop
Definition: GNERouteHandler.cpp:440
GNEHierarchicalChildElements::getChildDemandElements
const std::vector< GNEDemandElement * > & getChildDemandElements() const
return child demand elements
Definition: GNEHierarchicalChildElements.cpp:296
GNERouteHandler::RouteParameter::edges
std::vector< GNEEdge * > edges
edges
Definition: GNERouteHandler.h:74
SUMO_TAG_STOP_LANE
stop placed over a lane (used in netedit)
Definition: SUMOXMLDefinitions.h:180
GNERouteHandler::PersonPlansValues::parkingArea
GNEAdditional * parkingArea
parkingArea
Definition: GNERouteHandler.h:301
GNERouteHandler::isPersonIdDuplicated
static bool isPersonIdDuplicated(GNEViewNet *viewNet, const std::string &id)
check if there is already a person (Person or PersonFlow) with the given ID
Definition: GNERouteHandler.cpp:140
SUMORouteHandler::parseStop
bool parseStop(SUMOVehicleParameter::Stop &stop, const SUMOSAXAttributes &attrs, std::string errorSuffix, MsgHandler *const errorOutput)
parses attributes common to all stops
Definition: SUMORouteHandler.cpp:362
GNEHierarchicalParentElements::getParentEdges
const std::vector< GNEEdge * > & getParentEdges() const
get parent edges
Definition: GNEHierarchicalParentElements.cpp:181
GNEUndoList::p_end
void p_end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise,...
Definition: GNEUndoList.cpp:79
GNERouteHandler::buildRideFromTo
static void buildRideFromTo(GNEViewNet *viewNet, bool undoDemandElements, GNEDemandElement *personParent, GNEEdge *fromEdge, GNEEdge *toEdge, const std::vector< std::string > &lines, double arrivalPos)
build ride using a from-to edges
Definition: GNERouteHandler.cpp:728
SUMOVehicleParameter::departSpeed
double departSpeed
(optional) The initial speed of the vehicle
Definition: SUMOVehicleParameter.h:506
GNERouteHandler::closeFlow
void closeFlow()
Ends the processing of a routeFlow.
Definition: GNERouteHandler.cpp:1491
GNEPersonTrip.h
GNERouteHandler::isVehicleIdDuplicated
static bool isVehicleIdDuplicated(GNEViewNet *viewNet, const std::string &id)
check if there is already a vehicle (Vehicle, Trip, Flow or Flow) with the given ID
Definition: GNERouteHandler.cpp:128
GNERouteHandler::RouteParameter::loadedID
bool loadedID
flag to check if route was loaded
Definition: GNERouteHandler.h:71
SUMOVehicleParameter::vtypeid
std::string vtypeid
The vehicle's type id.
Definition: SUMOVehicleParameter.h:474
VEHPARS_NUMBER_SET
const int VEHPARS_NUMBER_SET
Definition: SUMOVehicleParameter.h:51
SUMO_TAG_WALK_ROUTE
Definition: SUMOXMLDefinitions.h:309
GNEHierarchicalChildElements::addChildDemandElement
void addChildDemandElement(GNEDemandElement *demandElement)
Definition: GNEHierarchicalChildElements.cpp:256
VEHPARS_FORCE_REROUTE
const int VEHPARS_FORCE_REROUTE
Definition: SUMOVehicleParameter.h:62
GNERouteHandler::transformToTrip
static void transformToTrip(GNEVehicle *originalVehicle)
transform to trip
Definition: GNERouteHandler.cpp:894
SUMO_TAG_CONTAINER_STOP
A container stop.
Definition: SUMOXMLDefinitions.h:105
GNERouteHandler::myLoadedVehicleWithEmbebbedRoute
GNEDemandElement * myLoadedVehicleWithEmbebbedRoute
Pointer to loaded vehicle with embebbed route (needed for GNEStops)
Definition: GNERouteHandler.h:341
SUMOVehicleParameter::Stop::busstop
std::string busstop
(Optional) bus stop if one is assigned to the stop
Definition: SUMOVehicleParameter.h:589
GNERouteHandler::~GNERouteHandler
~GNERouteHandler()
Destructor.
Definition: GNERouteHandler.cpp:124
SUMO_ATTR_PERIOD
Definition: SUMOXMLDefinitions.h:645
GNERouteHandler::embebbeRoute
static void embebbeRoute(GNEVehicle *vehicle, GNEUndoList *undoList)
embebbe route within a vehicle
Definition: GNERouteHandler.cpp:1094
SUMO_TAG_PERSON
Definition: SUMOXMLDefinitions.h:295
SUMO_TAG_LANE
begin/end of the description of a single lane
Definition: SUMOXMLDefinitions.h:49
GNERouteHandler::openTrip
void openTrip(const SUMOSAXAttributes &attrs)
opens a trip for reading
Definition: GNERouteHandler.cpp:1167
GNERouteHandler::openVehicleTypeDistribution
void openVehicleTypeDistribution(const SUMOSAXAttributes &attrs)
opens a type distribution for reading
Definition: GNERouteHandler.cpp:1125
GNEWalk
Definition: GNEWalk.h:38
GNERoute
Definition: GNERoute.h:41
SUMO_ATTR_LINES
Definition: SUMOXMLDefinitions.h:776
GNERouteHandler::closeContainer
void closeContainer()
Ends the processing of a container.
Definition: GNERouteHandler.cpp:1485
GNEPerson.h
SUMOSAXAttributes::getObjectType
const std::string & getObjectType() const
return the objecttype to which these attributes belong
Definition: SUMOSAXAttributes.h:396
GNERouteHandler::buildRideBusStop
static void buildRideBusStop(GNEViewNet *viewNet, bool undoDemandElements, GNEDemandElement *personParent, GNEEdge *fromEdge, GNEAdditional *busStop, const std::vector< std::string > &lines)
build ride using a from edge and a busStop
Definition: GNERouteHandler.cpp:751
GNENet::retrieveDemandElement
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
Definition: GNENet.cpp:2316
SUMO_TAG_PTYPE
description of a person type (used in NETEDIT)
Definition: SUMOXMLDefinitions.h:123
SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:704
GNERide.h
GNEViewNet
Definition: GNEViewNet.h:42
GNERouteHandler::transformToPerson
static void transformToPerson(GNEPerson *originalPerson)
transform person functions
Definition: GNERouteHandler.cpp:1021
SUMO_ATTR_ARRIVALPOS
Definition: SUMOXMLDefinitions.h:437
SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:378
GNEDemandElement::getViewNet
GNEViewNet * getViewNet() const
Returns a pointer to GNEViewNet in which demand element element is located.
Definition: GNEDemandElement.cpp:253
SUMOVehicleParameter::Stop::parkingarea
std::string parkingarea
(Optional) parking area if one is assigned to the stop
Definition: SUMOVehicleParameter.h:595
SUMOVehicleParameter
Structure representing possible vehicle parameter.
Definition: SUMOVehicleParameter.h:297
SUMO_TAG_NOTHING
invalid tag
Definition: SUMOXMLDefinitions.h:43
GNERouteHandler::transformToFlow
static void transformToFlow(GNEVehicle *originalVehicle)
transform to flow
Definition: GNERouteHandler.cpp:959
SUMO_ATTR_LANE
Definition: SUMOXMLDefinitions.h:637
GNERouteHandler::buildTrip
static void buildTrip(GNEViewNet *viewNet, bool undoDemandElements, const SUMOVehicleParameter &vehicleParameters, GNEEdge *fromEdge, GNEEdge *toEdge, const std::vector< GNEEdge * > &via)
build trip
Definition: GNERouteHandler.cpp:340
SUMO_TAG_VTYPE
description of a vehicle type
Definition: SUMOXMLDefinitions.h:121
SUMO_ATTR_ENDPOS
Definition: SUMOXMLDefinitions.h:798
GNERouteHandler::PersonPlansValues::from
GNEEdge * from
from edge
Definition: GNERouteHandler.h:280
GNERouteHandler::PersonPlansValues::modes
std::vector< std::string > modes
modes
Definition: GNERouteHandler.h:310
GNERide
Definition: GNERide.h:38
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:41
GNERouteHandler::PersonPlansValues::route
GNEDemandElement * route
arrival route
Definition: GNERouteHandler.h:304
VEHPARS_PROB_SET
const int VEHPARS_PROB_SET
Definition: SUMOVehicleParameter.h:54
VEHPARS_DEPARTSPEED_SET
const int VEHPARS_DEPARTSPEED_SET
Definition: SUMOVehicleParameter.h:49
GNEAttributeCarrier::TagProperties::getTag
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
Definition: GNEAttributeCarrier.cpp:523
SUMORouteHandler::checkStopPos
static StopPos checkStopPos(double &startPos, double &endPos, const double laneLength, const double minLength, const bool friendlyPos)
check start and end position of a stop
Definition: SUMORouteHandler.cpp:283
GNERouteHandler::RouteParameter::color
RGBColor color
string for saving parsed route colors
Definition: GNERouteHandler.h:80
SUMORouteHandler::myActiveRouteStops
std::vector< SUMOVehicleParameter::Stop > myActiveRouteStops
List of the stops on the parsed route.
Definition: SUMORouteHandler.h:227
SUMOVehicleParameter::tag
SumoXMLTag tag
The vehicle tag.
Definition: SUMOVehicleParameter.h:465
SUMO_ATTR_TO
Definition: SUMOXMLDefinitions.h:640
SUMORouteHandler::STOPPOS_VALID
Definition: SUMORouteHandler.h:54
MAX2
T MAX2(T a, T b)
Definition: StdDefs.h:79
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:51
SUMORouteHandler::myLoadedParameterised
Parameterised myLoadedParameterised
Parameterised used for saving loaded generic parameters that aren't saved in Vehicles or Vehicle Type...
Definition: SUMORouteHandler.h:233
GNERouteHandler::buildWalkRoute
static void buildWalkRoute(GNEViewNet *viewNet, bool undoDemandElements, GNEDemandElement *personParent, GNEDemandElement *route, double arrivalPos)
build walk using a list of consecutive edges
Definition: GNERouteHandler.cpp:707
GNEUndoList::p_add
void p_add(GNEChange_Attribute *cmd)
special method, avoid empty changes, always execute
Definition: GNEUndoList.cpp:131
GNEViewNet::getNet
GNENet * getNet() const
get the net object
Definition: GNEViewNet.cpp:1014
GNEChargingStation
Definition: GNEChargingStation.h:31
GNERoute.h
GNERouteHandler::closePersonFlow
void closePersonFlow()
Ends the processing of a personFlow.
Definition: GNERouteHandler.cpp:1476
GNERouteHandler::setFlowParameters
static void setFlowParameters(const SumoXMLAttr attribute, int &parameters)
configure flow parameters
Definition: GNERouteHandler.cpp:1033
GNERouteHandler::PersonPlansValues::arrivalPos
double arrivalPos
arrival pos
Definition: GNERouteHandler.h:316
SUMO_TAG_WALK_EDGES
Definition: SUMOXMLDefinitions.h:306
GNERouteHandler::RouteParameter
struct for saving route parameters
Definition: GNERouteHandler.h:53
GNEParkingArea
A lane area vehicles can park at (netedit-version)
Definition: GNEParkingArea.h:34
GNELane::getLaneParametricLength
double getLaneParametricLength() const
returns the parameteric length of the lane
Definition: GNELane.cpp:792
RGBColor
Definition: RGBColor.h:39
SUMO_TAG_ROUTEFLOW
a flow definition nusing a route instead of a from-to edges route (used in NETEDIT)
Definition: SUMOXMLDefinitions.h:151
GNEDemandElement::updateGeometry
virtual void updateGeometry()=0
update pre-computed geometry information
SUMO_TAG_FLOW
a flow definitio nusing a from-to edges instead of a route (used by router)
Definition: SUMOXMLDefinitions.h:149
SUMO_ATTR_PROB
Definition: SUMOXMLDefinitions.h:629
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
SUMO_ATTR_STARTPOS
Definition: SUMOXMLDefinitions.h:797
SUMO_TAG_CHARGING_STATION
A Charging Station.
Definition: SUMOXMLDefinitions.h:111
SUMO_TAG_STOP_CHARGINGSTATION
stop placed over a charging station (used in netedit)
Definition: SUMOXMLDefinitions.h:186
GNERouteHandler::openFlow
void openFlow(const SUMOSAXAttributes &attrs)
opens a routeFlow for reading
Definition: GNERouteHandler.cpp:1155
SUMO_TAG_PERSONSTOP_LANE
Definition: SUMOXMLDefinitions.h:313
GNEVehicleType
Definition: GNEVehicleType.h:36
GNERouteHandler::PersonPlansValues::tag
SumoXMLTag tag
walk tag
Definition: GNERouteHandler.h:277
GNEDemandElement::getAttributeDouble
virtual double getAttributeDouble(SumoXMLAttr key) const =0
GNEStop
Definition: GNEStop.h:34
GNERouteHandler::addRide
void addRide(const SUMOSAXAttributes &attrs)
Processing of a ride.
Definition: GNERouteHandler.cpp:1881
DEPART_SPEED_GIVEN
The speed is given.
Definition: SUMOVehicleParameter.h:196
DEFAULT_VTYPE_ID
const std::string DEFAULT_VTYPE_ID
DEPART_LANE_GIVEN
The lane is given.
Definition: SUMOVehicleParameter.h:120
GNEViewNet.h
SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
Definition: SUMOVehicleClass.h:159
GNERouteHandler::PersonPlansValues::vTypes
std::vector< std::string > vTypes
vehicle types
Definition: GNERouteHandler.h:307
SUMO_ATTR_DEPARTSPEED
Definition: SUMOXMLDefinitions.h:435
SUMOVehicleParameter::id
std::string id
The vehicle's id.
Definition: SUMOVehicleParameter.h:468
SUMO_ATTR_ROUTE
Definition: SUMOXMLDefinitions.h:440
SUMO_ATTR_EDGES
the edges of a route
Definition: SUMOXMLDefinitions.h:427
GNERouteHandler::PersonPlansValues::stopParameters
SUMOVehicleParameter::Stop stopParameters
stop parameters
Definition: GNERouteHandler.h:322
SUMO_ATTR_DEPARTLANE
Definition: SUMOXMLDefinitions.h:432
SUMO_TAG_PARKING_AREA
A parking area.
Definition: SUMOXMLDefinitions.h:107
SUMOVehicleParameter::arrivalPos
double arrivalPos
(optional) The position the vehicle shall arrive on
Definition: SUMOVehicleParameter.h:522
GNERouteHandler::buildWalkBusStop
static void buildWalkBusStop(GNEViewNet *viewNet, bool undoDemandElements, GNEDemandElement *personParent, GNEEdge *fromEdge, GNEAdditional *busStop)
build walk using a from edge an a busStop
Definition: GNERouteHandler.cpp:685
GNERouteHandler::RouteParameter::RouteParameter
RouteParameter()
constructor
Definition: GNERouteHandler.cpp:52
GNEHierarchicalParentElements::getMiddleParentEdges
std::vector< GNEEdge * > getMiddleParentEdges() const
get middle (via) parent edges
Definition: GNEHierarchicalParentElements.cpp:187
GNEContainerStop::getAttribute
std::string getAttribute(SumoXMLAttr key) const
Definition: GNEContainerStop.cpp:195
GNEEdge.h
GNERouteHandler::RouteParameter::routeID
std::string routeID
string for saving parsed Route ID
Definition: GNERouteHandler.h:68
GNEViewNet::getUndoList
GNEUndoList * getUndoList() const
get the undoList object
Definition: GNEViewNet.cpp:1020
GNEDemandElement::isAttributeCarrierSelected
bool isAttributeCarrierSelected() const
check if attribute carrier is selected
Definition: GNEDemandElement.cpp:552
GNERouteHandler::PersonPlansValues::getLastEdge
GNEEdge * getLastEdge() const
return last valid edge (used to create consecutive person plans)
Definition: GNERouteHandler.cpp:1975
SUMOVehicleParameter::Stop::endPos
double endPos
The stopping position end.
Definition: SUMOVehicleParameter.h:604
GNERouteHandler::buildPerson
static void buildPerson(GNEViewNet *viewNet, bool undoDemandElements, const SUMOVehicleParameter &personParameters)
build person
Definition: GNERouteHandler.cpp:531
SUMO_TAG_PERSONTRIP_BUSSTOP
Definition: SUMOXMLDefinitions.h:305
SUMOSAXAttributes::getOpt
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:518
GNERouteHandler::openRoute
void openRoute(const SUMOSAXAttributes &attrs)
opens a route for reading
Definition: GNERouteHandler.cpp:1137
GNERouteHandler::PersonPlansValues::containerStop
GNEAdditional * containerStop
containerStop
Definition: GNERouteHandler.h:295
SUMOVehicleParameter::routeid
std::string routeid
The vehicle's route id.
Definition: SUMOVehicleParameter.h:471
GNEUndoList::p_abortLastCommandGroup
void p_abortLastCommandGroup()
reverts last command group
Definition: GNEUndoList.cpp:103
GNEPerson
Definition: GNEPerson.h:36
SUMORouteHandler::myVehicleParameter
SUMOVehicleParameter * myVehicleParameter
Parameter of the current vehicle, trip, person, container or flow.
Definition: SUMORouteHandler.h:206
GNERouteHandler::transformToRouteFlow
static void transformToRouteFlow(GNEVehicle *originalVehicle, bool createEmbeddedRoute)
transform routeFlow over an existent route
Definition: GNERouteHandler.cpp:834
GNEEdge::getLanes
const std::vector< GNELane * > & getLanes() const
returns a reference to the lane vector
Definition: GNEEdge.cpp:874
SUMO_TAG_VEHICLE
description of a vehicle
Definition: SUMOXMLDefinitions.h:119
SUMO_ATTR_FRIENDLY_POS
Definition: SUMOXMLDefinitions.h:765
VEHPARS_VPH_SET
const int VEHPARS_VPH_SET
Definition: SUMOVehicleParameter.h:53
GNELane.h
GNERouteHandler::addPerson
void addPerson(const SUMOSAXAttributes &attrs)
Processing of a person.
Definition: GNERouteHandler.cpp:1869
GNEBusStop
A lane area vehicles can halt at (netedit-version)
Definition: GNEBusStop.h:34
GNERouteHandler::addTranship
void addTranship(const SUMOSAXAttributes &attrs)
Processing of a tranship.
Definition: GNERouteHandler.cpp:1952
GNEAttributeCarrier::canParse
static bool canParse(const std::string &string)
true if a value of type T can be parsed from string
Definition: GNEAttributeCarrier.h:636
SUMO_ATTR_POSITION
Definition: SUMOXMLDefinitions.h:660
VEHPARS_DEPARTLANE_SET
const int VEHPARS_DEPARTLANE_SET
Definition: SUMOVehicleParameter.h:47
GNEContainerStop.h
GNEWalk.h
SUMO_ATTR_FROM
Definition: SUMOXMLDefinitions.h:639
SUMOVehicleParameter::Stop::startPos
double startPos
The stopping position start.
Definition: SUMOVehicleParameter.h:601
GNERouteHandler::PersonPlansValues::lines
std::vector< std::string > lines
lines
Definition: GNERouteHandler.h:313
GNEUndoList::currentCommandGroupSize
int currentCommandGroupSize() const
get size of current CommandGroup
Definition: GNEUndoList.cpp:141
SUMOVehicleParameter::departLane
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
Definition: SUMOVehicleParameter.h:488
GNERouteHandler::closePerson
void closePerson()
Ends the processing of a person.
Definition: GNERouteHandler.cpp:1330
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
GNERouteHandler::PersonPlansValues
struct used for load person plans (Rides, Walks, etc.)
Definition: GNERouteHandler.h:269
SUMO_TAG_BUS_STOP
A bus stop.
Definition: SUMOXMLDefinitions.h:97
SUMOVehicleParameter::departLaneProcedure
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
Definition: SUMOVehicleParameter.h:491
SUMO_TAG_STOP_CONTAINERSTOP
stop placed over a containerStop (used in netedit)
Definition: SUMOXMLDefinitions.h:184
GNERouteHandler::PersonPlansValues::edges
std::vector< GNEEdge * > edges
list of edges
Definition: GNERouteHandler.h:289
GNERouteHandler::RouteParameter::parameters
Parameterised parameters
parameters
Definition: GNERouteHandler.h:83
GNERouteHandler::myViewNet
GNEViewNet * myViewNet
pointer to View's Net
Definition: GNERouteHandler.h:326
SUMO_ATTR_VIA
Definition: SUMOXMLDefinitions.h:723
GNERouteHandler::openRouteDistribution
void openRouteDistribution(const SUMOSAXAttributes &attrs)
opens a route distribution for reading
Definition: GNERouteHandler.cpp:1271
GNERouteHandler::myUndoDemandElements
bool myUndoDemandElements
flag to check if created demand elements must be undo and redo
Definition: GNERouteHandler.h:338
SUMOVehicleParameter::via
std::vector< std::string > via
List of the via-edges the vehicle must visit.
Definition: SUMOVehicleParameter.h:659
SUMOXMLDefinitions::isValidTypeID
static bool isValidTypeID(const std::string &value)
whether the given string is a valid id for an edge or vehicle type
Definition: SUMOXMLDefinitions.cpp:979
SUMOVTypeParameter::id
std::string id
The vehicle type's id.
Definition: SUMOVTypeParameter.h:212
GNERouteHandler::closeRoute
void closeRoute(const bool mayBeDisconnected=false)
Definition: GNERouteHandler.cpp:1179
SUMO_ATTR_VTYPES
Definition: SUMOXMLDefinitions.h:632
GNERouteHandler::buildVehicleWithEmbeddedRoute
static void buildVehicleWithEmbeddedRoute(GNEViewNet *viewNet, bool undoDemandElements, SUMOVehicleParameter vehicleParameters, GNEDemandElement *embeddedRouteCopy)
build vehicle with a embedded route
Definition: GNERouteHandler.cpp:240
GNERouteHandler::buildPersonFlow
static void buildPersonFlow(GNEViewNet *viewNet, bool undoDemandElements, const SUMOVehicleParameter &personFlowParameters)
build person flow
Definition: GNERouteHandler.cpp:557
GNEParkingArea.h
SUMOXMLDefinitions::isValidVehicleID
static bool isValidVehicleID(const std::string &value)
whether the given string is a valid id for a vehicle or flow
Definition: SUMOXMLDefinitions.cpp:973
GNERouteHandler::myPersonPlanValues
std::vector< PersonPlansValues > myPersonPlanValues
container for person trips loaded values
Definition: GNERouteHandler.h:329
GNEReferenceCounter::incRef
void incRef(const std::string &debugMsg="")
Increarse reference.
Definition: GNEReferenceCounter.h:67
SUMO_TAG_PERSONTRIP_FROMTO
Definition: SUMOXMLDefinitions.h:304
GNERouteHandler::buildPersonTripBusStop
static void buildPersonTripBusStop(GNEViewNet *viewNet, bool undoDemandElements, GNEDemandElement *personParent, GNEEdge *fromEdge, GNEAdditional *busStop, const std::vector< std::string > &types, const std::vector< std::string > &modes)
build trip using a from edge and a busStop
Definition: GNERouteHandler.cpp:604
GNEBusStop.h
SUMO_TAG_RIDE_BUSSTOP
Definition: SUMOXMLDefinitions.h:311
GNERouteHandler::addStop
void addStop(const SUMOSAXAttributes &attrs)
Processing of a stop.
Definition: GNERouteHandler.cpp:1529
GNEVehicleType::overwriteVType
static void overwriteVType(GNEDemandElement *vType, SUMOVTypeParameter *newVTypeParameter, GNEUndoList *undoList)
overwrite all values of GNEVehicleType with a SUMOVTypeParameter
Definition: GNEVehicleType.cpp:874
GNEChargingStation::getAttribute
std::string getAttribute(SumoXMLAttr key) const
Definition: GNEChargingStation.cpp:196
GNEVehicle
Definition: GNEVehicle.h:35
GNERouteHandler::closeVType
void closeVType()
Ends the processing of a vehicle Type.
Definition: GNERouteHandler.cpp:1302
SUMO_ATTR_MODES
Definition: SUMOXMLDefinitions.h:653
GNERouteHandler::addPersonTrip
void addPersonTrip(const SUMOSAXAttributes &attrs)
add a routing request for a walking or intermodal person
Definition: GNERouteHandler.cpp:1667
GNERouteHandler::transformToPersonFlow
static void transformToPersonFlow(GNEPerson *originalPerson)
transform routeFlow over an existent route
Definition: GNERouteHandler.cpp:1027
SUMO_TAG_WALK_BUSSTOP
Definition: SUMOXMLDefinitions.h:308
GNENet::retrieveEdge
GNEEdge * retrieveEdge(const std::string &id, bool failHard=true)
get edge by id
Definition: GNENet.cpp:1069
GNERouteHandler::addTransport
void addTransport(const SUMOSAXAttributes &attrs)
Processing of a transport.
Definition: GNERouteHandler.cpp:1946
SUMO_TAG_ROUTE
begin/end of the description of a route
Definition: SUMOXMLDefinitions.h:125
GNENet::retrieveLane
GNELane * retrieveLane(const std::string &id, bool failHard=true, bool checkVolatileChange=false)
get lane by id
Definition: GNENet.cpp:1228
Parameterised::clearParameter
void clearParameter()
Clears the parameter map.
Definition: Parameterised.cpp:100
SUMORouteHandler
Parser for routes during their loading.
Definition: SUMORouteHandler.h:50
config.h
SUMO_TAG_PERSONFLOW
Definition: SUMOXMLDefinitions.h:299
GNEVehicle.h
GNEParkingArea::getAttribute
std::string getAttribute(SumoXMLAttr key) const
Definition: GNEParkingArea.cpp:213
GNEVehicleType.h
GNEDemandElement::RouteCalculator::calculateDijkstraRoute
std::vector< GNEEdge * > calculateDijkstraRoute(SUMOVehicleClass vClass, const std::vector< GNEEdge * > &partialEdges) const
calculate Dijkstra route between a list of partial edges
Definition: GNEDemandElement.cpp:76
GNE_ATTR_SELECTED
element is selected
Definition: SUMOXMLDefinitions.h:971
SUMORouteHandler::myCurrentVType
SUMOVTypeParameter * myCurrentVType
The currently parsed vehicle type.
Definition: SUMORouteHandler.h:230
GNEStop.h
SUMO_ATTR_END
weights: time range end
Definition: SUMOXMLDefinitions.h:680
GNEBusStop::getAttribute
std::string getAttribute(SumoXMLAttr key) const
Definition: GNEBusStop.cpp:228
SUMO_TAG_STOP_BUSSTOP
stop placed over a busStop (used in netedit)
Definition: SUMOXMLDefinitions.h:182
GNEChange_Attribute
the function-object for an editing operation (abstract base)
Definition: GNEChange_Attribute.h:47
VEHPARS_PERIOD_SET
const int VEHPARS_PERIOD_SET
Definition: SUMOVehicleParameter.h:52
GNEContainerStop
A lane area vehicles can halt at (netedit-version)
Definition: GNEContainerStop.h:34
GNERouteHandler::PersonPlansValues::to
GNEEdge * to
to edge
Definition: GNERouteHandler.h:283
GNERouteHandler::separateEmbeddedRoute
static GNEVehicle * separateEmbeddedRoute(GNEVehicle *vehicle, GNEUndoList *undoList)
separate vehicle and embedded route
Definition: GNERouteHandler.cpp:1108
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition: GNEAttributeCarrier.cpp:1267
GNENet::generateDemandElementID
std::string generateDemandElementID(const std::string &prefix, SumoXMLTag type) const
generate demand element id
Definition: GNENet.cpp:2461
GNEUndoList
Definition: GNEUndoList.h:48
SUMO_TAG_PERSONSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:312
SUMO_ATTR_VEHSPERHOUR
Definition: SUMOXMLDefinitions.h:786
GNERouteHandler::PersonPlansValues::laneStop
GNELane * laneStop
laneStop
Definition: GNERouteHandler.h:319
MsgHandler::getErrorInstance
static MsgHandler * getErrorInstance()
Returns the instance to add errors to.
Definition: MsgHandler.cpp:81
GNERouteHandler::closeRouteDistribution
void closeRouteDistribution()
closes (ends) the building of a distribution
Definition: GNERouteHandler.cpp:1277
GNERouteHandler::buildFlowOverRoute
static void buildFlowOverRoute(GNEViewNet *viewNet, bool undoDemandElements, const SUMOVehicleParameter &vehicleParameters)
build a flow over an existent route
Definition: GNERouteHandler.cpp:196
VEHPARS_END_SET
const int VEHPARS_END_SET
Definition: SUMOVehicleParameter.h:50
SUMO_ATTR_BUS_STOP
Definition: SUMOXMLDefinitions.h:769
GNEUndoList::p_begin
void p_begin(const std::string &description)
Begin undo command sub-group. This begins a new group of commands that are treated as a single comman...
Definition: GNEUndoList.cpp:72
GNENet::insertDemandElement
void insertDemandElement(GNEDemandElement *demandElement)
Insert a demand element element int GNENet container.
Definition: GNENet.cpp:2777
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition: SUMOXMLDefinitions.h:372
SUMOVehicleParameter::stops
std::vector< Stop > stops
List of the stops the vehicle will make, TraCI may add entries here.
Definition: SUMOVehicleParameter.h:656
DEFAULT_BIKETYPE_ID
const std::string DEFAULT_BIKETYPE_ID
GNERouteHandler::buildFlow
static void buildFlow(GNEViewNet *viewNet, bool undoDemandElements, const SUMOVehicleParameter &vehicleParameters, GNEEdge *fromEdge, GNEEdge *toEdge, const std::vector< GNEEdge * > &via)
build flow
Definition: GNERouteHandler.cpp:390
GNERouteHandler::closeVehicleTypeDistribution
void closeVehicleTypeDistribution()
closes (ends) the building of a distribution
Definition: GNERouteHandler.cpp:1131
GNERouteHandler::PersonPlansValues::chargingStation
GNEAdditional * chargingStation
chargingStation
Definition: GNERouteHandler.h:298
GNERouteHandler::myAbort
bool myAbort
flag used for parsing values
Definition: GNERouteHandler.h:335
SUMO_ATTR_NUMBER
Definition: SUMOXMLDefinitions.h:666
SUMOSAXAttributes
Encapsulated SAX-Attributes.
Definition: SUMOSAXAttributes.h:56
GNEChargingStation.h
SUMOVehicleParameter::Stop::chargingStation
std::string chargingStation
(Optional) charging station if one is assigned to the stop
Definition: SUMOVehicleParameter.h:598
SUMOVTypeParameter::vehicleClass
SUMOVehicleClass vehicleClass
The vehicle's class.
Definition: SUMOVTypeParameter.h:240
POSITION_EPS
#define POSITION_EPS
Definition: config.h:172
SUMOVehicleParameter::Stop::containerstop
std::string containerstop
(Optional) container stop if one is assigned to the stop
Definition: SUMOVehicleParameter.h:592
WRITE_ERROR
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:283
GNELane
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:45
GNERouteHandler::addWalk
void addWalk(const SUMOSAXAttributes &attrs)
add a fully specified walk
Definition: GNERouteHandler.cpp:1779
SUMORouteHandler::myActiveRouteID
std::string myActiveRouteID
The id of the current route.
Definition: SUMORouteHandler.h:212
SUMO_TAG_RIDE_FROMTO
Definition: SUMOXMLDefinitions.h:310
GNERouteHandler::buildWalkFromTo
static void buildWalkFromTo(GNEViewNet *viewNet, bool undoDemandElements, GNEDemandElement *personParent, GNEEdge *fromEdge, GNEEdge *toEdge, double arrivalPos)
build walk using a from-to edges
Definition: GNERouteHandler.cpp:662
GNERouteHandler::buildFlowWithEmbeddedRoute
static void buildFlowWithEmbeddedRoute(GNEViewNet *viewNet, bool undoDemandElements, SUMOVehicleParameter vehicleParameters, GNEDemandElement *embeddedRouteCopy)
build flow with a embedded route
Definition: GNERouteHandler.cpp:290
GNEChange_Attribute.h
GNENet.h
SUMOVehicleParameter::departSpeedProcedure
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
Definition: SUMOVehicleParameter.h:509
SUMO_TAG_TRIP
a single trip definition (used by router)
Definition: SUMOXMLDefinitions.h:145
GNERouteHandler.h
SUMOVehicleParameter::Stop
Definition of vehicle stop (position and duration)
Definition: SUMOVehicleParameter.h:572
GNERouteHandler::PersonPlansValues::PersonPlansValues
PersonPlansValues()
default constructor
Definition: GNERouteHandler.cpp:1960
GNEUndoList.h
GNERouteHandler::buildWalkEdges
static void buildWalkEdges(GNEViewNet *viewNet, bool undoDemandElements, GNEDemandElement *personParent, const std::vector< GNEEdge * > &edges, double arrivalPos)
build walk using a list of consecutive edges
Definition: GNERouteHandler.cpp:627
GNEPersonTrip
Definition: GNEPersonTrip.h:38