Eclipse SUMO - Simulation of Urban MObility
TraCIServerAPI_Vehicle.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2009-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 /****************************************************************************/
23 // APIs for getting/setting vehicle values via TraCI
24 /****************************************************************************/
25 
26 
27 // ===========================================================================
28 // included modules
29 // ===========================================================================
30 #include <config.h>
31 
32 #include <microsim/MSNet.h>
34 #include <microsim/MSVehicle.h>
36 #include <microsim/MSLane.h>
37 #include <microsim/MSEdge.h>
38 #include <microsim/MSGlobals.h>
46 #include <libsumo/TraCIConstants.h>
47 #include <libsumo/Vehicle.h>
48 #include <libsumo/VehicleType.h>
50 #include "TraCIServerAPI_Vehicle.h"
52 
53 
54 // ===========================================================================
55 // method definitions
56 // ===========================================================================
57 bool
59  tcpip::Storage& outputStorage) {
60  const int variable = inputStorage.readUnsignedByte();
61  const std::string id = inputStorage.readString();
63  try {
64  if (!libsumo::Vehicle::handleVariable(id, variable, &server) &&
66  switch (variable) {
67  case libsumo::VAR_LEADER: {
68  double dist = 0;
69  if (!server.readTypeCheckingDouble(inputStorage, dist)) {
70  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Leader retrieval requires a double.", outputStorage);
71  }
72  std::pair<std::string, double> leaderInfo = libsumo::Vehicle::getLeader(id, dist);
74  server.getWrapperStorage().writeInt(2);
76  server.getWrapperStorage().writeString(leaderInfo.first);
78  server.getWrapperStorage().writeDouble(leaderInfo.second);
79  break;
80  }
82  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
83  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires a compound object.", outputStorage);
84  }
85  if (inputStorage.readInt() != 2) {
86  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires time and edge as parameter.", outputStorage);
87  }
88  double time = 0.;
89  if (!server.readTypeCheckingDouble(inputStorage, time)) {
90  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires the referenced time as first parameter.", outputStorage);
91  }
92  // edge
93  std::string edgeID;
94  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
95  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires the referenced edge as second parameter.", outputStorage);
96  }
97  // retrieve
100  break;
101  }
103  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
104  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Retrieval of effort requires a compound object.", outputStorage);
105  }
106  if (inputStorage.readInt() != 2) {
107  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Retrieval of effort requires time and edge as parameter.", outputStorage);
108  }
109  double time = 0.;
110  if (!server.readTypeCheckingDouble(inputStorage, time)) {
111  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Retrieval of effort requires the referenced time as first parameter.", outputStorage);
112  }
113  // edge
114  std::string edgeID;
115  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
116  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Retrieval of effort requires the referenced edge as second parameter.", outputStorage);
117  }
119  server.getWrapperStorage().writeDouble(libsumo::Vehicle::getEffort(id, time, edgeID));
120  break;
121  }
124  tcpip::Storage tempContent;
125  int cnt = 0;
127  std::vector<libsumo::TraCIBestLanesData> bestLanes = libsumo::Vehicle::getBestLanes(id);
128  tempContent.writeInt((int)bestLanes.size());
129  ++cnt;
130  for (std::vector<libsumo::TraCIBestLanesData>::const_iterator i = bestLanes.begin(); i != bestLanes.end(); ++i) {
131  const libsumo::TraCIBestLanesData& bld = *i;
133  tempContent.writeString(bld.laneID);
134  ++cnt;
136  tempContent.writeDouble(bld.length);
137  ++cnt;
139  tempContent.writeDouble(bld.occupation);
140  ++cnt;
142  tempContent.writeByte(bld.bestLaneOffset);
143  ++cnt;
145  bld.allowsContinuation ? tempContent.writeUnsignedByte(1) : tempContent.writeUnsignedByte(0);
146  ++cnt;
148  tempContent.writeStringList(bld.continuationLanes);
149  ++cnt;
150  }
151  server.getWrapperStorage().writeInt((int)cnt);
152  server.getWrapperStorage().writeStorage(tempContent);
153  break;
154  }
155  case libsumo::VAR_NEXT_TLS: {
156  std::vector<libsumo::TraCINextTLSData> nextTLS = libsumo::Vehicle::getNextTLS(id);
158  const int cnt = 1 + (int)nextTLS.size() * 4;
159  server.getWrapperStorage().writeInt(cnt);
161  server.getWrapperStorage().writeInt((int)nextTLS.size());
162  for (std::vector<libsumo::TraCINextTLSData>::iterator it = nextTLS.begin(); it != nextTLS.end(); ++it) {
164  server.getWrapperStorage().writeString(it->id);
166  server.getWrapperStorage().writeInt(it->tlIndex);
168  server.getWrapperStorage().writeDouble(it->dist);
170  server.getWrapperStorage().writeByte(it->state);
171  }
172  break;
173  }
175  std::vector<libsumo::TraCINextStopData> nextStops = libsumo::Vehicle::getNextStops(id);
177  const int cnt = 1 + (int)nextStops.size() * 4;
178  server.getWrapperStorage().writeInt(cnt);
180  server.getWrapperStorage().writeInt((int)nextStops.size());
181  for (std::vector<libsumo::TraCINextStopData>::iterator it = nextStops.begin(); it != nextStops.end(); ++it) {
183  server.getWrapperStorage().writeString(it->lane);
185  server.getWrapperStorage().writeDouble(it->endPos);
187  server.getWrapperStorage().writeString(it->stoppingPlaceID);
189  server.getWrapperStorage().writeInt(it->stopFlags);
191  server.getWrapperStorage().writeDouble(it->duration);
193  server.getWrapperStorage().writeDouble(it->until);
194  }
195  break;
196  }
198  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
199  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Retrieval of distance requires a compound object.", outputStorage);
200  }
201  if (inputStorage.readInt() != 2) {
202  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Retrieval of distance requires position and distance type as parameter.", outputStorage);
203  }
204 
205  // read position
206  int posType = inputStorage.readUnsignedByte();
207  switch (posType) {
209  try {
210  const std::string roadID = inputStorage.readString();
211  const double edgePos = inputStorage.readDouble();
212  const int laneIndex = inputStorage.readUnsignedByte();
214  server.getWrapperStorage().writeDouble(libsumo::Vehicle::getDrivingDistance(id, roadID, edgePos, laneIndex));
215  break;
216  } catch (libsumo::TraCIException& e) {
217  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, e.what(), outputStorage);
218  }
220  case libsumo::POSITION_3D: {
221  const double p1x = inputStorage.readDouble();
222  const double p1y = inputStorage.readDouble();
223  if (posType == libsumo::POSITION_3D) {
224  inputStorage.readDouble(); // z value is ignored
225  }
228  break;
229  }
230  default:
231  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Unknown position format used for distance request", outputStorage);
232  }
233  // read distance type
234  int distType = inputStorage.readUnsignedByte();
235  if (distType != libsumo::REQUEST_DRIVINGDIST) {
236  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Only driving distance is supported for vehicles.", outputStorage);
237  }
238  break;
239  }
241  int direction = 0;
242  if (!server.readTypeCheckingInt(inputStorage, direction)) {
243  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Retrieval of lane change state requires a direction as int.", outputStorage);
244  }
245  const std::pair<int, int> state = libsumo::Vehicle::getLaneChangeState(id, direction);
247  server.getWrapperStorage().writeInt(2);
249  server.getWrapperStorage().writeInt(state.first);
251  server.getWrapperStorage().writeInt(state.second);
252  break;
253  }
254  case libsumo::VAR_PARAMETER: {
255  std::string paramName = "";
256  if (!server.readTypeCheckingString(inputStorage, paramName)) {
257  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Retrieval of a parameter requires its name.", outputStorage);
258  }
261  break;
262  }
263  case libsumo::VAR_NEIGHBORS: {
264  int mode;
265  if (!server.readTypeCheckingUnsignedByte(inputStorage, mode)) {
266  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Retrieval of neighboring vehicles needs bitset to specify mode.", outputStorage);
267  }
268  const std::vector<std::pair<std::string, double> >& neighVehicles = libsumo::Vehicle::getNeighbors(id, mode);
270  server.getWrapperStorage().writeInt((int)neighVehicles.size());
271  for (auto& p : neighVehicles) {
272  server.getWrapperStorage().writeString(p.first);
273  server.getWrapperStorage().writeDouble(p.second);
274  }
275  break;
276  }
277  default:
278  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Get Vehicle Variable: unsupported variable " + toHex(variable, 2) + " specified", outputStorage);
279  }
280  }
281  } catch (libsumo::TraCIException& e) {
282  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, e.what(), outputStorage);
283  }
285  server.writeResponseWithLength(outputStorage, server.getWrapperStorage());
286  return true;
287 }
288 
289 
290 bool
292  tcpip::Storage& outputStorage) {
293  std::string warning = ""; // additional description for response
294  // variable
295  int variable = inputStorage.readUnsignedByte();
296  if (variable != libsumo::CMD_STOP && variable != libsumo::CMD_CHANGELANE
297  && variable != libsumo::CMD_REROUTE_TO_PARKING
298  && variable != libsumo::CMD_CHANGESUBLANE && variable != libsumo::CMD_OPENGAP
299  && variable != libsumo::CMD_SLOWDOWN && variable != libsumo::CMD_CHANGETARGET && variable != libsumo::CMD_RESUME
300  && variable != libsumo::VAR_TYPE && variable != libsumo::VAR_ROUTE_ID && variable != libsumo::VAR_ROUTE
301  && variable != libsumo::VAR_UPDATE_BESTLANES
302  && variable != libsumo::VAR_EDGE_TRAVELTIME && variable != libsumo::VAR_EDGE_EFFORT
304  && variable != libsumo::VAR_SIGNALS && variable != libsumo::VAR_MOVE_TO
305  && variable != libsumo::VAR_LENGTH && variable != libsumo::VAR_MAXSPEED && variable != libsumo::VAR_VEHICLECLASS
306  && variable != libsumo::VAR_SPEED_FACTOR && variable != libsumo::VAR_EMISSIONCLASS
307  && variable != libsumo::VAR_WIDTH && variable != libsumo::VAR_MINGAP && variable != libsumo::VAR_SHAPECLASS
308  && variable != libsumo::VAR_ACCEL && variable != libsumo::VAR_DECEL && variable != libsumo::VAR_IMPERFECTION
309  && variable != libsumo::VAR_APPARENT_DECEL && variable != libsumo::VAR_EMERGENCY_DECEL
310  && variable != libsumo::VAR_ACTIONSTEPLENGTH
311  && variable != libsumo::VAR_TAU && variable != libsumo::VAR_LANECHANGE_MODE
312  && variable != libsumo::VAR_SPEED && variable != libsumo::VAR_SPEEDSETMODE && variable != libsumo::VAR_COLOR
313  && variable != libsumo::ADD && variable != libsumo::ADD_FULL && variable != libsumo::REMOVE
314  && variable != libsumo::VAR_HEIGHT
315  && variable != libsumo::VAR_ROUTING_MODE
316  && variable != libsumo::VAR_LATALIGNMENT
317  && variable != libsumo::VAR_MAXSPEED_LAT
318  && variable != libsumo::VAR_MINGAP_LAT
319  && variable != libsumo::VAR_LINE
320  && variable != libsumo::VAR_VIA
321  && variable != libsumo::VAR_HIGHLIGHT
322  && variable != libsumo::MOVE_TO_XY && variable != libsumo::VAR_PARAMETER/* && variable != libsumo::VAR_SPEED_TIME_LINE && variable != libsumo::VAR_LANE_TIME_LINE*/
323  ) {
324  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Change Vehicle State: unsupported variable " + toHex(variable, 2) + " specified", outputStorage);
325  }
326  // id
327  std::string id = inputStorage.readString();
328 #ifdef DEBUG_MOVEXY
329  std::cout << SIMTIME << " processSet veh=" << id << "\n";
330 #endif
331  const bool shouldExist = variable != libsumo::ADD && variable != libsumo::ADD_FULL;
333  if (sumoVehicle == nullptr) {
334  if (shouldExist) {
335  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Vehicle '" + id + "' is not known", outputStorage);
336  }
337  }
338  MSVehicle* v = dynamic_cast<MSVehicle*>(sumoVehicle);
339  if (v == nullptr && shouldExist) {
340  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "Vehicle '" + id + "' is not a micro-simulation vehicle", outputStorage);
341  }
342  try {
343  switch (variable) {
344  case libsumo::CMD_STOP: {
345  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
346  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Stop needs a compound object description.", outputStorage);
347  }
348  int compoundSize = inputStorage.readInt();
349  if (compoundSize < 4 || compoundSize > 7) {
350  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Stop needs a compound object description of four to seven items.", outputStorage);
351  }
352  // read road map position
353  std::string edgeID;
354  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
355  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The first stop parameter must be the edge id given as a string.", outputStorage);
356  }
357  double pos = 0;
358  if (!server.readTypeCheckingDouble(inputStorage, pos)) {
359  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The second stop parameter must be the end position along the edge given as a double.", outputStorage);
360  }
361  int laneIndex = 0;
362  if (!server.readTypeCheckingByte(inputStorage, laneIndex)) {
363  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The third stop parameter must be the lane index given as a byte.", outputStorage);
364  }
365  // waitTime
366  double duration = libsumo::INVALID_DOUBLE_VALUE;
367  if (!server.readTypeCheckingDouble(inputStorage, duration)) {
368  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLE_VARIABLE, "The fourth stop parameter must be the stopping duration given as a double.", outputStorage);
369  }
370  int stopFlags = 0;
371  if (compoundSize >= 5) {
372  if (!server.readTypeCheckingByte(inputStorage, stopFlags)) {
373  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The fifth stop parameter must be a byte indicating its parking/triggered status.", outputStorage);
374  }
375  }
376  double startPos = libsumo::INVALID_DOUBLE_VALUE;
377  if (compoundSize >= 6) {
378  if (!server.readTypeCheckingDouble(inputStorage, startPos)) {
379  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The sixth stop parameter must be the start position along the edge given as a double.", outputStorage);
380  }
381  }
382  double until = libsumo::INVALID_DOUBLE_VALUE;
383  if (compoundSize >= 7) {
384  if (!server.readTypeCheckingDouble(inputStorage, until)) {
385  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The seventh stop parameter must be the minimum departure time given as a double.", outputStorage);
386  }
387  }
388  libsumo::Vehicle::setStop(id, edgeID, pos, laneIndex, duration, stopFlags, startPos, until);
389  }
390  break;
392  // read variables
393  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
394  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Reroute to stop needs a compound object description.", outputStorage);
395  }
396  int compoundSize = inputStorage.readInt();
397  if (compoundSize != 1) {
398  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Reroute to stop needs a compound object description of 1 item.", outputStorage);
399  }
400  std::string parkingAreaID;
401  if (!server.readTypeCheckingString(inputStorage, parkingAreaID)) {
402  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The first reroute to stop parameter must be the parking area id given as a string.", outputStorage);
403  }
404  libsumo::Vehicle::rerouteParkingArea(id, parkingAreaID);
405  }
406  break;
407  case libsumo::CMD_RESUME: {
408  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
409  server.writeStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, libsumo::RTYPE_ERR, "Resuming requires a compound object.", outputStorage);
410  return false;
411  }
412  if (inputStorage.readInt() != 0) {
413  server.writeStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, libsumo::RTYPE_ERR, "Resuming should obtain an empty compound object.", outputStorage);
414  return false;
415  }
417  }
418  break;
420  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
421  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Lane change needs a compound object description.", outputStorage);
422  }
423  int compounds = inputStorage.readInt();
424  if (compounds != 3 && compounds != 2) {
425  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Lane change needs a compound object description of two or three items.", outputStorage);
426  }
427  // Lane ID
428  int laneIndex = 0;
429  if (!server.readTypeCheckingByte(inputStorage, laneIndex)) {
430  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The first lane change parameter must be the lane index given as a byte.", outputStorage);
431  }
432  // duration
433  double duration = 0.;
434  if (!server.readTypeCheckingDouble(inputStorage, duration)) {
435  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The second lane change parameter must be the duration given as a double.", outputStorage);
436  }
437  // relativelanechange
438  int relative = 0;
439  if (compounds == 3) {
440  if (!server.readTypeCheckingByte(inputStorage, relative)) {
441  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The third lane change parameter must be a Byte for defining whether a relative lane change should be applied.", outputStorage);
442  }
443  }
444 
445  if ((laneIndex < 0 || laneIndex >= (int)v->getEdge()->getLanes().size()) && relative < 1) {
446  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "No lane with index '" + toString(laneIndex) + "' on road '" + v->getEdge()->getID() + "'.", outputStorage);
447  }
448 
449  if (relative < 1) {
450  libsumo::Vehicle::changeLane(id, laneIndex, duration);
451  } else {
452  libsumo::Vehicle::changeLaneRelative(id, laneIndex, duration);
453  }
454  }
455  break;
457  double latDist = 0;
458  if (!server.readTypeCheckingDouble(inputStorage, latDist)) {
459  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Sublane-changing requires a double.", outputStorage);
460  }
461  libsumo::Vehicle::changeSublane(id, latDist);
462  }
463  break;
464  case libsumo::CMD_SLOWDOWN: {
465  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
466  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Slow down needs a compound object description.", outputStorage);
467  }
468  if (inputStorage.readInt() != 2) {
469  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Slow down needs a compound object description of two items.", outputStorage);
470  }
471  double newSpeed = 0;
472  if (!server.readTypeCheckingDouble(inputStorage, newSpeed)) {
473  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The first slow down parameter must be the speed given as a double.", outputStorage);
474  }
475  if (newSpeed < 0) {
476  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Speed must not be negative", outputStorage);
477  }
478  double duration = 0.;
479  if (!server.readTypeCheckingDouble(inputStorage, duration)) {
480  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The second slow down parameter must be the duration given as a double.", outputStorage);
481  }
482  if (duration < 0 || SIMTIME + duration > STEPS2TIME(SUMOTime_MAX - DELTA_T)) {
483  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Invalid time interval", outputStorage);
484  }
485  libsumo::Vehicle::slowDown(id, newSpeed, duration);
486  }
487  break;
489  std::string edgeID;
490  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
491  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Change target requires a string containing the id of the new destination edge as parameter.", outputStorage);
492  }
493  libsumo::Vehicle::changeTarget(id, edgeID);
494  }
495  break;
496  case libsumo::CMD_OPENGAP: {
497  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
498  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Create gap needs a compound object description.", outputStorage);
499  }
500  const int nParameter = inputStorage.readInt();
501  if (nParameter != 5 && nParameter != 6) {
502  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Create gap needs a compound object description of five or six items.", outputStorage);
503  }
504  double newTimeHeadway = 0;
505  if (!server.readTypeCheckingDouble(inputStorage, newTimeHeadway)) {
506  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The first create gap parameter must be the new desired time headway (tau) given as a double.", outputStorage);
507  }
508  double newSpaceHeadway = 0;
509  if (!server.readTypeCheckingDouble(inputStorage, newSpaceHeadway)) {
510  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The second create gap parameter must be the new desired space headway given as a double.", outputStorage);
511  }
512  double duration = 0.;
513  if (!server.readTypeCheckingDouble(inputStorage, duration)) {
514  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The third create gap parameter must be the duration given as a double.", outputStorage);
515  }
516  double changeRate = 0;
517  if (!server.readTypeCheckingDouble(inputStorage, changeRate)) {
518  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The fourth create gap parameter must be the change rate given as a double.", outputStorage);
519  }
520  double maxDecel = 0;
521  if (!server.readTypeCheckingDouble(inputStorage, maxDecel)) {
522  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The fifth create gap parameter must be the maximal braking rate given as a double.", outputStorage);
523  }
524 
525  if (newTimeHeadway == -1 && newSpaceHeadway == -1 && duration == -1 && changeRate == -1 && maxDecel == -1) {
527  } else {
528  if (newTimeHeadway <= 0) {
529  if (newTimeHeadway != -1) {
530  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The value for the new desired time headway (tau) must be positive for create gap", outputStorage);
531  } // else if == -1: keep vehicles current headway, see libsumo::Vehicle::openGap
532  }
533  if (newSpaceHeadway < 0) {
534  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The value for the new desired space headway must be non-negative for create gap", outputStorage);
535  }
536  if ((duration < 0 && duration != -1) || SIMTIME + duration > STEPS2TIME(SUMOTime_MAX - DELTA_T)) {
537  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Invalid time interval for create gap", outputStorage);
538  }
539  if (changeRate <= 0) {
540  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The value for the change rate must be positive for the openGap command", outputStorage);
541  }
542  if (maxDecel <= 0) {
543  if (maxDecel != -1) {
544  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The value for the maximal braking rate must be positive for the openGap command", outputStorage);
545  } // else if == -1: don't limit cf model's suggested brake rate, see libsumo::Vehicle::openGap
546  }
547  std::string refVehID = "";
548  if (nParameter == 6) {
549  if (!server.readTypeCheckingString(inputStorage, refVehID)) {
550  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The sixth create gap parameter must be a reference vehicle's ID given as a string.", outputStorage);
551  }
552  }
553  libsumo::Vehicle::openGap(id, newTimeHeadway, newSpaceHeadway, duration, changeRate, maxDecel, refVehID);
554  }
555  }
556  break;
557  case libsumo::VAR_TYPE: {
558  std::string vTypeID;
559  if (!server.readTypeCheckingString(inputStorage, vTypeID)) {
560  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The vehicle type id must be given as a string.", outputStorage);
561  }
562  libsumo::Vehicle::setType(id, vTypeID);
563  }
564  break;
565  case libsumo::VAR_ROUTE_ID: {
566  std::string rid;
567  if (!server.readTypeCheckingString(inputStorage, rid)) {
568  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The route id must be given as a string.", outputStorage);
569  }
571  }
572  break;
573  case libsumo::VAR_ROUTE: {
574  std::vector<std::string> edgeIDs;
575  if (!server.readTypeCheckingStringList(inputStorage, edgeIDs)) {
576  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "A route must be defined as a list of edge ids.", outputStorage);
577  }
578  libsumo::Vehicle::setRoute(id, edgeIDs);
579  }
580  break;
582  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
583  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting travel time requires a compound object.", outputStorage);
584  }
585  int parameterCount = inputStorage.readInt();
586  std::string edgeID;
587  double begTime = 0.;
588  double endTime = std::numeric_limits<double>::max();
589  double value = libsumo::INVALID_DOUBLE_VALUE;
590  if (parameterCount == 4) {
591  // begin time
592  if (!server.readTypeCheckingDouble(inputStorage, begTime)) {
593  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 4 parameters requires the begin time as first parameter.", outputStorage);
594  }
595  // begin time
596  if (!server.readTypeCheckingDouble(inputStorage, endTime)) {
597  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 4 parameters requires the end time as second parameter.", outputStorage);
598  }
599  // edge
600  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
601  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 4 parameters requires the referenced edge as third parameter.", outputStorage);
602  }
603  // value
604  if (!server.readTypeCheckingDouble(inputStorage, value)) {
605  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 4 parameters requires the travel time as double as fourth parameter.", outputStorage);
606  }
607  } else if (parameterCount == 2) {
608  // edge
609  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
610  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 2 parameters requires the referenced edge as first parameter.", outputStorage);
611  }
612  // value
613  if (!server.readTypeCheckingDouble(inputStorage, value)) {
614  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 2 parameters requires the travel time as second parameter.", outputStorage);
615  }
616  } else if (parameterCount == 1) {
617  // edge
618  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
619  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 1 parameter requires the referenced edge as first parameter.", outputStorage);
620  }
621  } else {
622  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting travel time requires 1, 2, or 4 parameters.", outputStorage);
623  }
624  libsumo::Vehicle::setAdaptedTraveltime(id, edgeID, value, begTime, endTime);
625  }
626  break;
628  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
629  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting effort requires a compound object.", outputStorage);
630  }
631  int parameterCount = inputStorage.readInt();
632  std::string edgeID;
633  double begTime = 0.;
634  double endTime = std::numeric_limits<double>::max();
635  double value = libsumo::INVALID_DOUBLE_VALUE;
636  if (parameterCount == 4) {
637  // begin time
638  if (!server.readTypeCheckingDouble(inputStorage, begTime)) {
639  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting effort using 4 parameters requires the begin time as first parameter.", outputStorage);
640  }
641  // begin time
642  if (!server.readTypeCheckingDouble(inputStorage, endTime)) {
643  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting effort using 4 parameters requires the end time as second parameter.", outputStorage);
644  }
645  // edge
646  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
647  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting effort using 4 parameters requires the referenced edge as third parameter.", outputStorage);
648  }
649  // value
650  if (!server.readTypeCheckingDouble(inputStorage, value)) {
651  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting effort using 4 parameters requires the travel time as fourth parameter.", outputStorage);
652  }
653  } else if (parameterCount == 2) {
654  // edge
655  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
656  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting effort using 2 parameters requires the referenced edge as first parameter.", outputStorage);
657  }
658  if (!server.readTypeCheckingDouble(inputStorage, value)) {
659  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting effort using 2 parameters requires the travel time as second parameter.", outputStorage);
660  }
661  } else if (parameterCount == 1) {
662  // edge
663  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
664  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting effort using 1 parameter requires the referenced edge as first parameter.", outputStorage);
665  }
666  } else {
667  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting effort requires 1, 2, or 4 parameters.", outputStorage);
668  }
669  // retrieve
670  libsumo::Vehicle::setEffort(id, edgeID, value, begTime, endTime);
671  }
672  break;
674  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
675  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Rerouting requires a compound object.", outputStorage);
676  }
677  if (inputStorage.readInt() != 0) {
678  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Rerouting should obtain an empty compound object.", outputStorage);
679  }
681  }
682  break;
684  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
685  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Rerouting requires a compound object.", outputStorage);
686  }
687  if (inputStorage.readInt() != 0) {
688  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Rerouting should obtain an empty compound object.", outputStorage);
689  }
691  }
692  break;
693  case libsumo::VAR_SIGNALS: {
694  int signals = 0;
695  if (!server.readTypeCheckingInt(inputStorage, signals)) {
696  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting signals requires an integer.", outputStorage);
697  }
698  libsumo::Vehicle::setSignals(id, signals);
699  }
700  break;
701  case libsumo::VAR_MOVE_TO: {
702  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
703  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting position requires a compound object.", outputStorage);
704  }
705  if (inputStorage.readInt() != 2) {
706  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting position should obtain the lane id and the position.", outputStorage);
707  }
708  // lane ID
709  std::string laneID;
710  if (!server.readTypeCheckingString(inputStorage, laneID)) {
711  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The first parameter for setting a position must be the lane ID given as a string.", outputStorage);
712  }
713  // position on lane
714  double position = 0;
715  if (!server.readTypeCheckingDouble(inputStorage, position)) {
716  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The second parameter for setting a position must be the position given as a double.", outputStorage);
717  }
718  // process
719  libsumo::Vehicle::moveTo(id, laneID, position);
720  }
721  break;
722  case libsumo::VAR_SPEED: {
723  double speed = 0;
724  if (!server.readTypeCheckingDouble(inputStorage, speed)) {
725  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting speed requires a double.", outputStorage);
726  }
727  libsumo::Vehicle::setSpeed(id, speed);
728  }
729  break;
731  int speedMode = 0;
732  if (!server.readTypeCheckingInt(inputStorage, speedMode)) {
733  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting speed mode requires an integer.", outputStorage);
734  }
735  libsumo::Vehicle::setSpeedMode(id, speedMode);
736  }
737  break;
739  int laneChangeMode = 0;
740  if (!server.readTypeCheckingInt(inputStorage, laneChangeMode)) {
741  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting lane change mode requires an integer.", outputStorage);
742  }
743  libsumo::Vehicle::setLaneChangeMode(id, laneChangeMode);
744  }
745  break;
747  int routingMode = 0;
748  if (!server.readTypeCheckingInt(inputStorage, routingMode)) {
749  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting routing mode requires an integer.", outputStorage);
750  }
751  libsumo::Vehicle::setRoutingMode(id, routingMode);
752  }
753  break;
754  case libsumo::VAR_COLOR: {
756  if (!server.readTypeCheckingColor(inputStorage, col)) {
757  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The color must be given using the according type.", outputStorage);
758  }
759  libsumo::Vehicle::setColor(id, col);
760  break;
761  }
762  case libsumo::ADD: {
763  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
764  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Adding a vehicle requires a compound object.", outputStorage);
765  }
766  if (inputStorage.readInt() != 6) {
767  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Adding a vehicle needs six parameters.", outputStorage);
768  }
769  std::string vTypeID;
770  if (!server.readTypeCheckingString(inputStorage, vTypeID)) {
771  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "First parameter (type) requires a string.", outputStorage);
772  }
773  std::string routeID;
774  if (!server.readTypeCheckingString(inputStorage, routeID)) {
775  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Second parameter (route) requires a string.", outputStorage);
776  }
777  int departCode;
778  if (!server.readTypeCheckingInt(inputStorage, departCode)) {
779  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Third parameter (depart) requires an integer.", outputStorage);
780  }
781  std::string depart = toString(STEPS2TIME(departCode));
782  if (-departCode == DEPART_TRIGGERED) {
783  depart = "triggered";
784  } else if (-departCode == DEPART_CONTAINER_TRIGGERED) {
785  depart = "containerTriggered";
786  } else if (-departCode == DEPART_NOW) {
787  depart = "now";
788  }
789 
790  double departPosCode;
791  if (!server.readTypeCheckingDouble(inputStorage, departPosCode)) {
792  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Fourth parameter (position) requires a double.", outputStorage);
793  }
794  std::string departPos = toString(departPosCode);
795  if (-departPosCode == DEPART_POS_RANDOM) {
796  departPos = "random";
797  } else if (-departPosCode == DEPART_POS_RANDOM_FREE) {
798  departPos = "random_free";
799  } else if (-departPosCode == DEPART_POS_FREE) {
800  departPos = "free";
801  } else if (-departPosCode == DEPART_POS_BASE) {
802  departPos = "base";
803  } else if (-departPosCode == DEPART_POS_LAST) {
804  departPos = "last";
805  } else if (-departPosCode == DEPART_POS_GIVEN) {
806  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Invalid departure position.", outputStorage);
807  }
808 
809  double departSpeedCode;
810  if (!server.readTypeCheckingDouble(inputStorage, departSpeedCode)) {
811  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Fifth parameter (speed) requires a double.", outputStorage);
812  }
813  std::string departSpeed = toString(departSpeedCode);
814  if (-departSpeedCode == DEPART_SPEED_RANDOM) {
815  departSpeed = "random";
816  } else if (-departSpeedCode == DEPART_SPEED_MAX) {
817  departSpeed = "max";
818  } else if (-departSpeedCode == DEPART_SPEED_DESIRED) {
819  departSpeed = "desired";
820  } else if (-departSpeedCode == DEPART_SPEED_LIMIT) {
821  departSpeed = "speedLimit";
822  }
823 
824  int departLaneCode;
825  if (!server.readTypeCheckingByte(inputStorage, departLaneCode)) {
826  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Sixth parameter (lane) requires a byte.", outputStorage);
827  }
828  std::string departLane = toString(departLaneCode);
829  if (-departLaneCode == DEPART_LANE_RANDOM) {
830  departLane = "random";
831  } else if (-departLaneCode == DEPART_LANE_FREE) {
832  departLane = "free";
833  } else if (-departLaneCode == DEPART_LANE_ALLOWED_FREE) {
834  departLane = "allowed";
835  } else if (-departLaneCode == DEPART_LANE_BEST_FREE) {
836  departLane = "best";
837  } else if (-departLaneCode == DEPART_LANE_FIRST_ALLOWED) {
838  departLane = "first";
839  }
840  libsumo::Vehicle::add(id, routeID, vTypeID, depart, departLane, departPos, departSpeed);
841  }
842  break;
843  case libsumo::ADD_FULL: {
844  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
845  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Adding a vehicle requires a compound object.", outputStorage);
846  }
847  if (inputStorage.readInt() != 14) {
848  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Adding a fully specified vehicle needs fourteen parameters.", outputStorage);
849  }
850  std::string routeID;
851  if (!server.readTypeCheckingString(inputStorage, routeID)) {
852  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Second parameter (route) requires a string.", outputStorage);
853  }
854  std::string vTypeID;
855  if (!server.readTypeCheckingString(inputStorage, vTypeID)) {
856  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "First parameter (type) requires a string.", outputStorage);
857  }
858  std::string depart;
859  if (!server.readTypeCheckingString(inputStorage, depart)) {
860  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Third parameter (depart) requires an string.", outputStorage);
861  }
862  std::string departLane;
863  if (!server.readTypeCheckingString(inputStorage, departLane)) {
864  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Fourth parameter (depart lane) requires a string.", outputStorage);
865  }
866  std::string departPos;
867  if (!server.readTypeCheckingString(inputStorage, departPos)) {
868  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Fifth parameter (depart position) requires a string.", outputStorage);
869  }
870  std::string departSpeed;
871  if (!server.readTypeCheckingString(inputStorage, departSpeed)) {
872  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Sixth parameter (depart speed) requires a string.", outputStorage);
873  }
874  std::string arrivalLane;
875  if (!server.readTypeCheckingString(inputStorage, arrivalLane)) {
876  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Seventh parameter (arrival lane) requires a string.", outputStorage);
877  }
878  std::string arrivalPos;
879  if (!server.readTypeCheckingString(inputStorage, arrivalPos)) {
880  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Eighth parameter (arrival position) requires a string.", outputStorage);
881  }
882  std::string arrivalSpeed;
883  if (!server.readTypeCheckingString(inputStorage, arrivalSpeed)) {
884  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Ninth parameter (arrival speed) requires a string.", outputStorage);
885  }
886  std::string fromTaz;
887  if (!server.readTypeCheckingString(inputStorage, fromTaz)) {
888  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Tenth parameter (from taz) requires a string.", outputStorage);
889  }
890  std::string toTaz;
891  if (!server.readTypeCheckingString(inputStorage, toTaz)) {
892  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Eleventh parameter (to taz) requires a string.", outputStorage);
893  }
894  std::string line;
895  if (!server.readTypeCheckingString(inputStorage, line)) {
896  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Twelth parameter (line) requires a string.", outputStorage);
897  }
898  int personCapacity;
899  if (!server.readTypeCheckingInt(inputStorage, personCapacity)) {
900  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "13th parameter (person capacity) requires an int.", outputStorage);
901  }
902  int personNumber;
903  if (!server.readTypeCheckingInt(inputStorage, personNumber)) {
904  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "14th parameter (person number) requires an int.", outputStorage);
905  }
906  libsumo::Vehicle::add(id, routeID, vTypeID, depart, departLane, departPos, departSpeed, arrivalLane, arrivalPos, arrivalSpeed,
907  fromTaz, toTaz, line, personCapacity, personNumber);
908  }
909  break;
910  case libsumo::REMOVE: {
911  int why = 0;
912  if (!server.readTypeCheckingByte(inputStorage, why)) {
913  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Removing a vehicle requires a byte.", outputStorage);
914  }
915  libsumo::Vehicle::remove(id, (char)why);
916  }
917  break;
918  case libsumo::MOVE_TO_XY: {
919  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
920  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "MoveToXY vehicle requires a compound object.", outputStorage);
921  }
922  const int numArgs = inputStorage.readInt();
923  if (numArgs != 5 && numArgs != 6) {
924  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "MoveToXY vehicle should obtain: edgeID, lane, x, y, angle and optionally keepRouteFlag.", outputStorage);
925  }
926  // edge ID
927  std::string edgeID;
928  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
929  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The first parameter for moveToXY must be the edge ID given as a string.", outputStorage);
930  }
931  // lane index
932  int laneNum = 0;
933  if (!server.readTypeCheckingInt(inputStorage, laneNum)) {
934  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The second parameter for moveToXY must be lane given as an int.", outputStorage);
935  }
936  // x
937  double x = 0;
938  if (!server.readTypeCheckingDouble(inputStorage, x)) {
939  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The third parameter for moveToXY must be the x-position given as a double.", outputStorage);
940  }
941  // y
942  double y = 0;
943  if (!server.readTypeCheckingDouble(inputStorage, y)) {
944  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The fourth parameter for moveToXY must be the y-position given as a double.", outputStorage);
945  }
946  // angle
947  double angle = 0;
948  if (!server.readTypeCheckingDouble(inputStorage, angle)) {
949  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The fifth parameter for moveToXY must be the angle given as a double.", outputStorage);
950  }
951 
952  int keepRouteFlag = 1;
953  if (numArgs == 6) {
954  if (!server.readTypeCheckingByte(inputStorage, keepRouteFlag)) {
955  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The sixth parameter for moveToXY must be the keepRouteFlag given as a byte.", outputStorage);
956  }
957  }
958  libsumo::Vehicle::moveToXY(id, edgeID, laneNum, x, y, angle, keepRouteFlag);
959  }
960  break;
962  double factor = 0;
963  if (!server.readTypeCheckingDouble(inputStorage, factor)) {
964  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting speed factor requires a double.", outputStorage);
965  }
966  libsumo::Vehicle::setSpeedFactor(id, factor);
967  }
968  break;
969  case libsumo::VAR_LINE: {
970  std::string line;
971  if (!server.readTypeCheckingString(inputStorage, line)) {
972  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The line must be given as a string.", outputStorage);
973  }
974  libsumo::Vehicle::setLine(id, line);
975  }
976  break;
977  case libsumo::VAR_VIA: {
978  std::vector<std::string> edgeIDs;
979  if (!server.readTypeCheckingStringList(inputStorage, edgeIDs)) {
980  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Vias must be defined as a list of edge ids.", outputStorage);
981  }
982  libsumo::Vehicle::setVia(id, edgeIDs);
983  }
984  break;
985  case libsumo::VAR_PARAMETER: {
986  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
987  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "A compound object is needed for setting a parameter.", outputStorage);
988  }
989  //readt itemNo
990  inputStorage.readInt();
991  std::string name;
992  if (!server.readTypeCheckingString(inputStorage, name)) {
993  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The name of the parameter must be given as a string.", outputStorage);
994  }
995  std::string value;
996  if (!server.readTypeCheckingString(inputStorage, value)) {
997  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The value of the parameter must be given as a string.", outputStorage);
998  }
999  try {
1001  libsumo::Vehicle::setParameter(id, name, value);
1002  } catch (libsumo::TraCIException& e) {
1003  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, e.what(), outputStorage);
1004  }
1005  }
1006  break;
1007  case libsumo::VAR_HIGHLIGHT: {
1008  // Highlight the vehicle by adding a tracking polygon. (NOTE: duplicated code exists for POI domain)
1009  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
1010  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "A compound object is needed for highlighting an object.", outputStorage);
1011  }
1012  int itemNo = inputStorage.readUnsignedByte();
1013  if (itemNo > 5) {
1014  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Highlighting an object needs zero to five parameters.", outputStorage);
1015  }
1016  libsumo::TraCIColor col = libsumo::TraCIColor(255, 0, 0);
1017  if (itemNo > 0) {
1018  if (!server.readTypeCheckingColor(inputStorage, col)) {
1019  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The first parameter for highlighting must be the highlight color.", outputStorage);
1020  }
1021  }
1022  double size = -1;
1023  if (itemNo > 1) {
1024  if (!server.readTypeCheckingDouble(inputStorage, size)) {
1025  return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The second parameter for highlighting must be the highlight size.", outputStorage);
1026  }
1027  }
1028  int alphaMax = -1;
1029  if (itemNo > 2) {
1030  if (!server.readTypeCheckingUnsignedByte(inputStorage, alphaMax)) {
1031  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The third parameter for highlighting must be maximal alpha.", outputStorage);
1032  }
1033  }
1034  double duration = -1;
1035  if (itemNo > 3) {
1036  if (!server.readTypeCheckingDouble(inputStorage, duration)) {
1037  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The fourth parameter for highlighting must be the highlight duration.", outputStorage);
1038  }
1039  }
1040  int type = 0;
1041  if (itemNo > 4) {
1042  if (!server.readTypeCheckingUnsignedByte(inputStorage, type)) {
1043  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The fifth parameter for highlighting must be the highlight type id as ubyte.", outputStorage);
1044  }
1045  }
1046  libsumo::Vehicle::highlight(id, col, size, alphaMax, duration, type);
1047  }
1048  break;
1050  double value = 0;
1051  if (!server.readTypeCheckingDouble(inputStorage, value)) {
1052  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting action step length requires a double.", outputStorage);
1053  }
1054  if (fabs(value) == std::numeric_limits<double>::infinity()) {
1055  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Invalid action step length.", outputStorage);
1056  }
1057  bool resetActionOffset = value >= 0.0;
1058  libsumo::Vehicle::setActionStepLength(id, fabs(value), resetActionOffset);
1059  }
1060  break;
1063  }
1064  break;
1065  default: {
1066  try {
1067  if (!TraCIServerAPI_VehicleType::setVariable(libsumo::CMD_SET_VEHICLE_VARIABLE, variable, v->getSingularType().getID(), server, inputStorage, outputStorage)) {
1068  return false;
1069  }
1070  } catch (ProcessError& e) {
1071  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, e.what(), outputStorage);
1072  } catch (libsumo::TraCIException& e) {
1073  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, e.what(), outputStorage);
1074  }
1075  }
1076  break;
1077  }
1078  } catch (libsumo::TraCIException& e) {
1079  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, e.what(), outputStorage);
1080  }
1081  server.writeStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, libsumo::RTYPE_OK, warning, outputStorage);
1082  return true;
1083 }
1084 
1085 
1086 /****************************************************************************/
libsumo::Vehicle::highlight
static void highlight(const std::string &vehicleID, const TraCIColor &col, double size, const int alphaMax, const double duration, const int type)
Definition: Vehicle.cpp:1664
libsumo::RTYPE_OK
TRACI_CONST int RTYPE_OK
Definition: TraCIConstants.h:352
libsumo::Vehicle::setSpeed
static void setSpeed(const std::string &vehicleID, double speed)
Definition: Vehicle.cpp:1220
libsumo::VAR_SPEEDSETMODE
TRACI_CONST int VAR_SPEEDSETMODE
Definition: TraCIConstants.h:744
libsumo::VAR_HEIGHT
TRACI_CONST int VAR_HEIGHT
Definition: TraCIConstants.h:772
libsumo::Vehicle::setStop
static void setStop(const std::string &vehicleID, const std::string &edgeID, double pos=1., int laneIndex=0, double duration=INVALID_DOUBLE_VALUE, int flags=STOP_DEFAULT, double startPos=INVALID_DOUBLE_VALUE, double until=INVALID_DOUBLE_VALUE)
Definition: Vehicle.cpp:814
libsumo::Vehicle::setLaneChangeMode
static void setLaneChangeMode(const std::string &vehicleID, int laneChangeMode)
Definition: Vehicle.cpp:1236
tcpip::Storage::readDouble
virtual double readDouble()
MSVehicleType::getID
const std::string & getID() const
Returns the name of the vehicle type.
Definition: MSVehicleType.h:93
TraCIServerAPI_Vehicle.h
TraCIServerAPI_Vehicle::processSet
static bool processSet(TraCIServer &server, tcpip::Storage &inputStorage, tcpip::Storage &outputStorage)
Processes a set value command (Command 0xc4: Change Vehicle State)
Definition: TraCIServerAPI_Vehicle.cpp:291
libsumo::Vehicle::openGap
static void openGap(const std::string &vehicleID, double newTimeHeadway, double newSpaceHeadway, double duration, double changeRate, double maxDecel=INVALID_DOUBLE_VALUE, const std::string &referenceVehID="")
Definition: Vehicle.cpp:1189
MSNet.h
libsumo::Vehicle::getEffort
static double getEffort(const std::string &vehicleID, double time, const std::string &edgeID)
Definition: Vehicle.cpp:313
libsumo::VAR_EMISSIONCLASS
TRACI_CONST int VAR_EMISSIONCLASS
Definition: TraCIConstants.h:657
libsumo::INVALID_DOUBLE_VALUE
TRACI_CONST double INVALID_DOUBLE_VALUE
Definition: TraCIConstants.h:362
libsumo::Vehicle::getLaneChangeState
static std::pair< int, int > getLaneChangeState(const std::string &vehicleID, int direction)
Definition: Vehicle.cpp:582
libsumo::VAR_MINGAP
TRACI_CONST int VAR_MINGAP
Definition: TraCIConstants.h:663
libsumo::POSITION_3D
TRACI_CONST int POSITION_3D
Definition: TraCIConstants.h:318
TraCIServer::readTypeCheckingUnsignedByte
bool readTypeCheckingUnsignedByte(tcpip::Storage &inputStorage, int &into)
Reads the value type and an unsigned byte, verifying the type.
Definition: TraCIServer.cpp:1479
DELTA_T
SUMOTime DELTA_T
Definition: SUMOTime.cpp:36
libsumo::Vehicle::handleVariable
static bool handleVariable(const std::string &objID, const int variable, VariableWrapper *wrapper)
Definition: Vehicle.cpp:1742
libsumo::VAR_MAXSPEED
TRACI_CONST int VAR_MAXSPEED
Definition: TraCIConstants.h:615
tcpip::Storage::writeUnsignedByte
virtual void writeUnsignedByte(int)
libsumo::VAR_COLOR
TRACI_CONST int VAR_COLOR
Definition: TraCIConstants.h:630
TraCIServer::readTypeCheckingColor
bool readTypeCheckingColor(tcpip::Storage &inputStorage, libsumo::TraCIColor &into)
Reads the value type and a color, verifying the type.
Definition: TraCIServer.cpp:1444
libsumo::Vehicle::resume
static void resume(const std::string &vehicleID)
Definition: Vehicle.cpp:891
libsumo::VAR_VIA
TRACI_CONST int VAR_VIA
Definition: TraCIConstants.h:778
libsumo::VAR_SIGNALS
TRACI_CONST int VAR_SIGNALS
Definition: TraCIConstants.h:714
libsumo::CMD_SET_POI_VARIABLE
TRACI_CONST int CMD_SET_POI_VARIABLE
Definition: TraCIConstants.h:198
libsumo::TraCIBestLanesData::bestLaneOffset
int bestLaneOffset
The offset of this lane from the best lane.
Definition: TraCIDefs.h:336
libsumo::Vehicle::setRouteID
static void setRouteID(const std::string &vehicleID, const std::string &routeID)
Definition: Vehicle.cpp:1255
TraCIServerAPI_Simulation.h
TraCIServer::readTypeCheckingString
bool readTypeCheckingString(tcpip::Storage &inputStorage, std::string &into)
Reads the value type and a string, verifying the type.
Definition: TraCIServer.cpp:1414
libsumo::VAR_WIDTH
TRACI_CONST int VAR_WIDTH
Definition: TraCIConstants.h:666
TraCIServer::writeResponseWithLength
void writeResponseWithLength(tcpip::Storage &outputStorage, tcpip::Storage &tempMsg)
Definition: TraCIServer.cpp:1366
DEPART_LANE_BEST_FREE
@ DEPART_LANE_BEST_FREE
The least occupied lane from best lanes.
Definition: SUMOVehicleParameter.h:128
DEPART_POS_LAST
@ DEPART_POS_LAST
Insert behind the last vehicle as close as possible to still allow the specified departSpeed....
Definition: SUMOVehicleParameter.h:152
SUMOVehicle
Representation of a vehicle.
Definition: SUMOVehicle.h:60
libsumo::CMD_CHANGETARGET
TRACI_CONST int CMD_CHANGETARGET
Definition: TraCIConstants.h:79
libsumo::VAR_VEHICLECLASS
TRACI_CONST int VAR_VEHICLECLASS
Definition: TraCIConstants.h:654
libsumo::VAR_HIGHLIGHT
TRACI_CONST int VAR_HIGHLIGHT
Definition: TraCIConstants.h:723
libsumo::VAR_PARAMETER
TRACI_CONST int VAR_PARAMETER
Definition: TraCIConstants.h:939
libsumo::Vehicle::moveTo
static void moveTo(const std::string &vehicleID, const std::string &laneID, double position)
Definition: Vehicle.cpp:1381
libsumo::VAR_ACCEL
TRACI_CONST int VAR_ACCEL
Definition: TraCIConstants.h:633
libsumo::TYPE_BYTE
TRACI_CONST int TYPE_BYTE
Definition: TraCIConstants.h:331
libsumo::VehicleType::handleVariable
static bool handleVariable(const std::string &objID, const int variable, VariableWrapper *wrapper)
Definition: VehicleType.cpp:365
libsumo::VAR_EDGE_TRAVELTIME
TRACI_CONST int VAR_EDGE_TRAVELTIME
Definition: TraCIConstants.h:705
MSEdge.h
VehicleType.h
libsumo::VAR_MOVE_TO
TRACI_CONST int VAR_MOVE_TO
Definition: TraCIConstants.h:717
libsumo::TraCIColor
A color.
Definition: TraCIDefs.h:135
MSInsertionControl.h
libsumo::VAR_LEADER
TRACI_CONST int VAR_LEADER
Definition: TraCIConstants.h:819
libsumo::VAR_ROUTE_ID
TRACI_CONST int VAR_ROUTE_ID
Definition: TraCIConstants.h:684
libsumo::Vehicle::deactivateGapControl
static void deactivateGapControl(const std::string &vehicleID)
Definition: Vehicle.cpp:1207
Vehicle.h
libsumo::VAR_NEIGHBORS
TRACI_CONST int VAR_NEIGHBORS
Definition: TraCIConstants.h:781
TraCIServer::getWrapperStorage
tcpip::Storage & getWrapperStorage()
Definition: TraCIServer.cpp:174
TraCIServerAPI_VehicleType.h
libsumo::CMD_REROUTE_EFFORT
TRACI_CONST int CMD_REROUTE_EFFORT
Definition: TraCIConstants.h:973
libsumo::CMD_GET_VEHICLE_VARIABLE
TRACI_CONST int CMD_GET_VEHICLE_VARIABLE
Definition: TraCIConstants.h:149
libsumo::CMD_SET_VEHICLE_VARIABLE
TRACI_CONST int CMD_SET_VEHICLE_VARIABLE
Definition: TraCIConstants.h:153
libsumo::ADD
TRACI_CONST int ADD
Definition: TraCIConstants.h:943
libsumo::Vehicle::getBestLanes
static std::vector< TraCIBestLanesData > getBestLanes(const std::string &vehicleID)
Definition: Vehicle.cpp:347
TraCIServer::readTypeCheckingDouble
bool readTypeCheckingDouble(tcpip::Storage &inputStorage, double &into)
Reads the value type and a double, verifying the type.
Definition: TraCIServer.cpp:1404
libsumo::CMD_STOP
TRACI_CONST int CMD_STOP
Definition: TraCIConstants.h:58
DEPART_SPEED_LIMIT
@ DEPART_SPEED_LIMIT
The maximum lane speed is used (speedLimit)
Definition: SUMOVehicleParameter.h:204
MSVehicle.h
libsumo::TraCIBestLanesData::allowsContinuation
bool allowsContinuation
Whether this lane allows continuing the route.
Definition: TraCIDefs.h:338
SUMOVehicleParameter.h
HelpersHarmonoise.h
tcpip::Storage::writeByte
virtual void writeByte(int)
MSBaseVehicle::getEdge
const MSEdge * getEdge() const
Returns the edge the vehicle is currently at.
Definition: MSBaseVehicle.cpp:181
DEPART_LANE_ALLOWED_FREE
@ DEPART_LANE_ALLOWED_FREE
The least occupied lane from lanes which allow the continuation.
Definition: SUMOVehicleParameter.h:126
libsumo::Vehicle::getDrivingDistance
static double getDrivingDistance(const std::string &vehicleID, const std::string &edgeID, double position, int laneIndex=0)
Definition: Vehicle.cpp:502
libsumo::VAR_BEST_LANES
TRACI_CONST int VAR_BEST_LANES
Definition: TraCIConstants.h:741
libsumo::VAR_TAU
TRACI_CONST int VAR_TAU
Definition: TraCIConstants.h:651
TraCIServer::writeStatusCmd
void writeStatusCmd(int commandId, int status, const std::string &description, tcpip::Storage &outputStorage)
Writes a status command to the given storage.
Definition: TraCIServer.cpp:968
TraCIServerAPI_VehicleType::setVariable
static bool setVariable(const int cmd, const int variable, const std::string &id, TraCIServer &server, tcpip::Storage &inputStorage, tcpip::Storage &outputStorage)
Processes a set value for the given type.
Definition: TraCIServerAPI_VehicleType.cpp:120
libsumo::Vehicle::changeSublane
static void changeSublane(const std::string &vehicleID, double latDist)
Definition: Vehicle.cpp:954
TraCIServer::initWrapper
void initWrapper(const int domainID, const int variable, const std::string &objID)
Definition: TraCIServer.cpp:102
libsumo::Vehicle::setSignals
static void setSignals(const std::string &vehicleID, int signals)
Definition: Vehicle.cpp:1368
libsumo::VAR_MINGAP_LAT
TRACI_CONST int VAR_MINGAP_LAT
Definition: TraCIConstants.h:769
libsumo::TraCIBestLanesData
Definition: TraCIDefs.h:328
tcpip::Storage::readUnsignedByte
virtual int readUnsignedByte()
DEPART_LANE_RANDOM
@ DEPART_LANE_RANDOM
The lane is chosen randomly.
Definition: SUMOVehicleParameter.h:122
tcpip::Storage::writeInt
virtual void writeInt(int)
SIMTIME
#define SIMTIME
Definition: SUMOTime.h:63
MSVehicleControl::getVehicle
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
Definition: MSVehicleControl.cpp:240
libsumo::TraCIBestLanesData::occupation
double occupation
The traffic density along length.
Definition: TraCIDefs.h:334
libsumo::VAR_LATALIGNMENT
TRACI_CONST int VAR_LATALIGNMENT
Definition: TraCIConstants.h:763
libsumo::TYPE_DOUBLE
TRACI_CONST int TYPE_DOUBLE
Definition: TraCIConstants.h:335
libsumo::Vehicle::rerouteParkingArea
static void rerouteParkingArea(const std::string &vehicleID, const std::string &parkingAreaID)
Definition: Vehicle.cpp:881
TraCIServerAPI_Vehicle::processGet
static bool processGet(TraCIServer &server, tcpip::Storage &inputStorage, tcpip::Storage &outputStorage)
Processes a get value command (Command 0xa4: Get Vehicle Variable)
Definition: TraCIServerAPI_Vehicle.cpp:58
libsumo::Vehicle::setParameter
static void setParameter(const std::string &vehicleID, const std::string &key, const std::string &value)
Definition: Vehicle.cpp:1611
tcpip::Storage::readString
virtual std::string readString()
TraCIConstants.h
TraCIServer::readTypeCheckingByte
bool readTypeCheckingByte(tcpip::Storage &inputStorage, int &into)
Reads the value type and a byte, verifying the type.
Definition: TraCIServer.cpp:1469
tcpip::Storage::readInt
virtual int readInt()
DEPART_POS_FREE
@ DEPART_POS_FREE
A free position is chosen.
Definition: SUMOVehicleParameter.h:148
libsumo::TYPE_INTEGER
TRACI_CONST int TYPE_INTEGER
Definition: TraCIConstants.h:333
DEPART_SPEED_DESIRED
@ DEPART_SPEED_DESIRED
The maximum lane speed is used (speedLimit * speedFactor)
Definition: SUMOVehicleParameter.h:202
PollutantsInterface.h
libsumo::TraCIBestLanesData::length
double length
The length than can be driven from that lane without lane change.
Definition: TraCIDefs.h:332
libsumo::Vehicle::setRoute
static void setRoute(const std::string &vehicleID, const std::vector< std::string > &edgeIDs)
Definition: Vehicle.cpp:1275
tcpip::Storage::writeStorage
virtual void writeStorage(tcpip::Storage &store)
tcpip::Storage::writeStringList
virtual void writeStringList(const std::vector< std::string > &s)
STEPS2TIME
#define STEPS2TIME(x)
Definition: SUMOTime.h:56
libsumo::RTYPE_ERR
TRACI_CONST int RTYPE_ERR
Definition: TraCIConstants.h:356
libsumo::ADD_FULL
TRACI_CONST int ADD_FULL
Definition: TraCIConstants.h:961
libsumo::CMD_CHANGESUBLANE
TRACI_CONST int CMD_CHANGESUBLANE
Definition: TraCIConstants.h:73
libsumo::Vehicle::getParameter
static std::string getParameter(const std::string &vehicleID, const std::string &key)
Definition: Vehicle.cpp:593
libsumo::Vehicle::updateBestLanes
static void updateBestLanes(const std::string &vehicleID)
Definition: Vehicle.cpp:1292
ProcessError
Definition: UtilExceptions.h:39
toHex
std::string toHex(const T i, std::streamsize numDigits=0)
Definition: ToString.h:57
libsumo::REMOVE
TRACI_CONST int REMOVE
Definition: TraCIConstants.h:946
MSGlobals.h
libsumo::CMD_CHANGELANE
TRACI_CONST int CMD_CHANGELANE
Definition: TraCIConstants.h:67
libsumo::TraCIBestLanesData::laneID
std::string laneID
The id of the lane.
Definition: TraCIDefs.h:330
DEPART_TRIGGERED
@ DEPART_TRIGGERED
The departure is person triggered.
Definition: SUMOVehicleParameter.h:102
libsumo::POSITION_ROADMAP
TRACI_CONST int POSITION_ROADMAP
Definition: TraCIConstants.h:320
libsumo::RESPONSE_GET_VEHICLE_VARIABLE
TRACI_CONST int RESPONSE_GET_VEHICLE_VARIABLE
Definition: TraCIConstants.h:151
libsumo::Vehicle::remove
static void remove(const std::string &vehicleID, char reason=REMOVE_VAPORIZED)
Definition: Vehicle.cpp:1435
DEPART_SPEED_RANDOM
@ DEPART_SPEED_RANDOM
The speed is chosen randomly.
Definition: SUMOVehicleParameter.h:198
libsumo::DISTANCE_REQUEST
TRACI_CONST int DISTANCE_REQUEST
Definition: TraCIConstants.h:955
DEPART_POS_RANDOM
@ DEPART_POS_RANDOM
The position is chosen randomly.
Definition: SUMOVehicleParameter.h:146
libsumo::VAR_SPEED_FACTOR
TRACI_CONST int VAR_SPEED_FACTOR
Definition: TraCIConstants.h:729
libsumo::VAR_LINE
TRACI_CONST int VAR_LINE
Definition: TraCIConstants.h:775
libsumo::VAR_NEXT_STOPS
TRACI_CONST int VAR_NEXT_STOPS
Definition: TraCIConstants.h:834
libsumo::Vehicle::getTypeID
static std::string getTypeID(const std::string &vehicleID)
Definition: Vehicle.cpp:179
TraCIServer::readTypeCheckingStringList
bool readTypeCheckingStringList(tcpip::Storage &inputStorage, std::vector< std::string > &into)
Reads the value type and a string list, verifying the type.
Definition: TraCIServer.cpp:1424
libsumo::CMD_SLOWDOWN
TRACI_CONST int CMD_SLOWDOWN
Definition: TraCIConstants.h:70
libsumo::VAR_LENGTH
TRACI_CONST int VAR_LENGTH
Definition: TraCIConstants.h:627
libsumo::Vehicle::changeLane
static void changeLane(const std::string &vehicleID, int laneIndex, double duration)
Definition: Vehicle.cpp:936
libsumo::TraCIException
Definition: TraCIDefs.h:89
libsumo::VAR_EMERGENCY_DECEL
TRACI_CONST int VAR_EMERGENCY_DECEL
Definition: TraCIConstants.h:639
libsumo::Vehicle::slowDown
static void slowDown(const std::string &vehicleID, double speed, double duration)
Definition: Vehicle.cpp:1180
libsumo::Vehicle::changeTarget
static void changeTarget(const std::string &vehicleID, const std::string &edgeID)
Definition: Vehicle.cpp:910
libsumo::TYPE_STRINGLIST
TRACI_CONST int TYPE_STRINGLIST
Definition: TraCIConstants.h:339
libsumo::Vehicle::getNextStops
static std::vector< TraCINextStopData > getNextStops(const std::string &vehicleID)
Definition: Vehicle.cpp:432
tcpip::Storage::writeString
virtual void writeString(const std::string &s)
libsumo::Vehicle::setLine
static void setLine(const std::string &vehicleID, const std::string &line)
Definition: Vehicle.cpp:1489
libsumo::VAR_TYPE
TRACI_CONST int VAR_TYPE
Definition: TraCIConstants.h:672
libsumo::Vehicle::rerouteTraveltime
static void rerouteTraveltime(const std::string &vehicleID, const bool currentTravelTimes=true)
Definition: Vehicle.cpp:1351
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
libsumo::Vehicle::rerouteEffort
static void rerouteEffort(const std::string &vehicleID)
Definition: Vehicle.cpp:1360
libsumo::VAR_SHAPECLASS
TRACI_CONST int VAR_SHAPECLASS
Definition: TraCIConstants.h:660
libsumo::CMD_REROUTE_TO_PARKING
TRACI_CONST int CMD_REROUTE_TO_PARKING
Definition: TraCIConstants.h:61
libsumo::Vehicle::setSpeedMode
static void setSpeedMode(const std::string &vehicleID, int speedMode)
Definition: Vehicle.cpp:1231
TraCIServer::readTypeCheckingInt
bool readTypeCheckingInt(tcpip::Storage &inputStorage, int &into)
Reads the value type and an int, verifying the type.
Definition: TraCIServer.cpp:1394
MSNet::getInstance
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:167
libsumo::VAR_LANECHANGE_MODE
TRACI_CONST int VAR_LANECHANGE_MODE
Definition: TraCIConstants.h:754
libsumo::POSITION_2D
TRACI_CONST int POSITION_2D
Definition: TraCIConstants.h:314
libsumo::CMD_OPENGAP
TRACI_CONST int CMD_OPENGAP
Definition: TraCIConstants.h:76
libsumo::Vehicle::getDrivingDistance2D
static double getDrivingDistance2D(const std::string &vehicleID, double x, double y)
Definition: Vehicle.cpp:518
libsumo::TYPE_STRING
TRACI_CONST int TYPE_STRING
Definition: TraCIConstants.h:337
libsumo::VAR_EDGE_EFFORT
TRACI_CONST int VAR_EDGE_EFFORT
Definition: TraCIConstants.h:708
libsumo::VAR_NEXT_TLS
TRACI_CONST int VAR_NEXT_TLS
Definition: TraCIConstants.h:831
DEPART_POS_RANDOM_FREE
@ DEPART_POS_RANDOM_FREE
If a fixed number of random choices fails, a free position is chosen.
Definition: SUMOVehicleParameter.h:154
libsumo::Vehicle::setEffort
static void setEffort(const std::string &vehicleID, const std::string &edgeID, double effort=INVALID_DOUBLE_VALUE, double begSeconds=0, double endSeconds=std::numeric_limits< double >::max())
Definition: Vehicle.cpp:1325
libsumo::Vehicle::getAdaptedTraveltime
static double getAdaptedTraveltime(const std::string &vehicleID, double time, const std::string &edgeID)
Definition: Vehicle.cpp:304
MSBaseVehicle::getSingularType
MSVehicleType & getSingularType()
Replaces the current vehicle type with a new one used by this vehicle only.
Definition: MSBaseVehicle.cpp:736
libsumo::VAR_DECEL
TRACI_CONST int VAR_DECEL
Definition: TraCIConstants.h:636
libsumo::TYPE_UBYTE
TRACI_CONST int TYPE_UBYTE
Definition: TraCIConstants.h:329
libsumo::Vehicle::setType
static void setType(const std::string &vehicleID, const std::string &typeID)
Definition: Vehicle.cpp:1246
MSEdge::getLanes
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition: MSEdge.h:167
DEPART_SPEED_MAX
@ DEPART_SPEED_MAX
The maximum safe speed is used.
Definition: SUMOVehicleParameter.h:200
libsumo::MOVE_TO_XY
TRACI_CONST int MOVE_TO_XY
Definition: TraCIConstants.h:747
config.h
DEPART_POS_BASE
@ DEPART_POS_BASE
Back-at-zero position.
Definition: SUMOVehicleParameter.h:150
libsumo::VAR_IMPERFECTION
TRACI_CONST int VAR_IMPERFECTION
Definition: TraCIConstants.h:726
DijkstraRouter.h
libsumo::VAR_SPEED
TRACI_CONST int VAR_SPEED
Definition: TraCIConstants.h:609
libsumo::Vehicle::setAdaptedTraveltime
static void setAdaptedTraveltime(const std::string &vehicleID, const std::string &edgeID, double time=INVALID_DOUBLE_VALUE, double begSeconds=0, double endSeconds=std::numeric_limits< double >::max())
Definition: Vehicle.cpp:1299
tcpip::Storage::writeDouble
virtual void writeDouble(double)
libsumo::VAR_APPARENT_DECEL
TRACI_CONST int VAR_APPARENT_DECEL
Definition: TraCIConstants.h:642
libsumo::TraCIBestLanesData::continuationLanes
std::vector< std::string > continuationLanes
The sequence of lanes that best allows continuing the route without lane change.
Definition: TraCIDefs.h:340
DEPART_POS_GIVEN
@ DEPART_POS_GIVEN
The position is given.
Definition: SUMOVehicleParameter.h:144
libsumo::Vehicle::getNeighbors
static std::vector< std::pair< std::string, double > > getNeighbors(const std::string &vehicleID, const int mode)
Definition: Vehicle.cpp:632
TraCIServer
TraCI server used to control sumo by a remote TraCI client.
Definition: TraCIServer.h:61
SUMOTime_MAX
#define SUMOTime_MAX
Definition: SUMOTime.h:35
libsumo::VAR_MAXSPEED_LAT
TRACI_CONST int VAR_MAXSPEED_LAT
Definition: TraCIConstants.h:766
MSLane.h
libsumo::REQUEST_DRIVINGDIST
TRACI_CONST int REQUEST_DRIVINGDIST
Definition: TraCIConstants.h:375
DEPART_CONTAINER_TRIGGERED
@ DEPART_CONTAINER_TRIGGERED
The departure is container triggered.
Definition: SUMOVehicleParameter.h:104
libsumo::CMD_RESUME
TRACI_CONST int CMD_RESUME
Definition: TraCIConstants.h:64
libsumo::VAR_ACTIONSTEPLENGTH
TRACI_CONST int VAR_ACTIONSTEPLENGTH
Definition: TraCIConstants.h:645
libsumo::Vehicle::setRoutingMode
static void setRoutingMode(const std::string &vehicleID, int routingMode)
Definition: Vehicle.cpp:1241
MSVehicleControl.h
Named::getID
const std::string & getID() const
Returns the id.
Definition: Named.h:76
libsumo::Vehicle::getLeader
static std::pair< std::string, double > getLeader(const std::string &vehicleID, double dist=0.)
Definition: Vehicle.cpp:278
PositionVector.h
DEPART_LANE_FREE
@ DEPART_LANE_FREE
The least occupied lane is used.
Definition: SUMOVehicleParameter.h:124
libsumo::Vehicle::setVia
static void setVia(const std::string &vehicleID, const std::vector< std::string > &via)
Definition: Vehicle.cpp:1495
DEPART_LANE_FIRST_ALLOWED
@ DEPART_LANE_FIRST_ALLOWED
The rightmost lane the vehicle may use.
Definition: SUMOVehicleParameter.h:130
tcpip::Storage
Definition: storage.h:37
MSNet::getVehicleControl
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:336
libsumo::Vehicle::getNextTLS
static std::vector< TraCINextTLSData > getNextTLS(const std::string &vehicleID)
Definition: Vehicle.cpp:373
DEPART_NOW
@ DEPART_NOW
The vehicle is discarded if emission fails (not fully implemented yet)
Definition: SUMOVehicleParameter.h:106
libsumo::CMD_REROUTE_TRAVELTIME
TRACI_CONST int CMD_REROUTE_TRAVELTIME
Definition: TraCIConstants.h:970
libsumo::VAR_ROUTING_MODE
TRACI_CONST int VAR_ROUTING_MODE
Definition: TraCIConstants.h:735
libsumo::Vehicle::changeLaneRelative
static void changeLaneRelative(const std::string &vehicleID, int indexOffset, double duration)
Definition: Vehicle.cpp:944
libsumo::Vehicle::add
static void add(const std::string &vehicleID, const std::string &routeID, const std::string &typeID="DEFAULT_VEHTYPE", const std::string &depart="now", const std::string &departLane="first", const std::string &departPos="base", const std::string &departSpeed="0", const std::string &arrivalLane="current", const std::string &arrivalPos="max", const std::string &arrivalSpeed="current", const std::string &fromTaz="", const std::string &toTaz="", const std::string &line="", int personCapacity=4, int personNumber=0)
Definition: Vehicle.cpp:960
MSAbstractLaneChangeModel.h
libsumo::VAR_UPDATE_BESTLANES
TRACI_CONST int VAR_UPDATE_BESTLANES
Definition: TraCIConstants.h:690
libsumo::Vehicle::moveToXY
static void moveToXY(const std::string &vehicleID, const std::string &edgeID, const int laneIndex, const double x, const double y, double angle=INVALID_DOUBLE_VALUE, const int keepRoute=1)
Definition: Vehicle.cpp:1068
MSVehicle
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:79
libsumo::TYPE_COMPOUND
TRACI_CONST int TYPE_COMPOUND
Definition: TraCIConstants.h:341
libsumo::VAR_ROUTE
TRACI_CONST int VAR_ROUTE
Definition: TraCIConstants.h:702
TraCIServer::writeErrorStatusCmd
bool writeErrorStatusCmd(int commandId, const std::string &description, tcpip::Storage &outputStorage)
Writes a status command to the given storage with status = RTYPE_ERR.
Definition: TraCIServer.cpp:982