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