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