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-2017 German Aerospace Center (DLR) and others.
4 /****************************************************************************/
5 //
6 // This program and the accompanying materials
7 // are made available under the terms of the Eclipse Public License v2.0
8 // which accompanies this distribution, and is available at
9 // http://www.eclipse.org/legal/epl-v20.html
10 //
11 /****************************************************************************/
24 // APIs for getting/setting vehicle values via TraCI
25 /****************************************************************************/
26 
27 
28 // ===========================================================================
29 // included modules
30 // ===========================================================================
31 #ifdef _MSC_VER
32 #include <windows_config.h>
33 #else
34 #include <config.h>
35 #endif
36 
37 #ifndef NO_TRACI
38 
39 #include <microsim/MSNet.h>
41 #include <microsim/MSVehicle.h>
43 #include <microsim/MSLane.h>
44 #include <microsim/MSEdge.h>
45 #include <microsim/MSGlobals.h>
53 #include <libsumo/Vehicle.h>
54 #include "TraCIConstants.h"
56 #include "TraCIServerAPI_Vehicle.h"
58 
59 
60 // ===========================================================================
61 // static member variables
62 // ===========================================================================
63 
64 
65 // ===========================================================================
66 // method definitions
67 // ===========================================================================
68 bool
70  tcpip::Storage& outputStorage) {
71  // variable & id
72  int variable = inputStorage.readUnsignedByte();
73  std::string id = inputStorage.readString();
74  // check variable
75  if (variable != ID_LIST && variable != VAR_SPEED && variable != VAR_SPEED_WITHOUT_TRACI
76  && variable != VAR_POSITION && variable != VAR_ANGLE && variable != VAR_POSITION3D
77  && variable != VAR_ROAD_ID && variable != VAR_LANE_ID && variable != VAR_LANE_INDEX
78  && variable != VAR_TYPE && variable != VAR_ROUTE_ID && variable != VAR_COLOR
79  && variable != VAR_LANEPOSITION
80  && variable != VAR_LANEPOSITION_LAT
81  && variable != VAR_CO2EMISSION && variable != VAR_COEMISSION
82  && variable != VAR_HCEMISSION && variable != VAR_PMXEMISSION
83  && variable != VAR_NOXEMISSION && variable != VAR_FUELCONSUMPTION && variable != VAR_NOISEEMISSION
84  && variable != VAR_ELECTRICITYCONSUMPTION && variable != VAR_PERSON_NUMBER && variable != VAR_LEADER
85  && variable != VAR_EDGE_TRAVELTIME && variable != VAR_EDGE_EFFORT
86  && variable != VAR_ROUTE_VALID && variable != VAR_EDGES
87  && variable != VAR_SIGNALS && variable != VAR_DISTANCE
88  && variable != VAR_LENGTH && variable != VAR_MAXSPEED && variable != VAR_VEHICLECLASS
89  && variable != VAR_SPEED_FACTOR && variable != VAR_SPEED_DEVIATION
90  && variable != VAR_ALLOWED_SPEED && variable != VAR_EMISSIONCLASS
91  && variable != VAR_WIDTH && variable != VAR_MINGAP && variable != VAR_SHAPECLASS
92  && variable != VAR_ACCEL && variable != VAR_DECEL && variable != VAR_IMPERFECTION
93  && variable != VAR_APPARENT_DECEL && variable != VAR_EMERGENCY_DECEL
94  && variable != VAR_ACTIONSTEPLENGTH
95  && variable != VAR_TAU && variable != VAR_BEST_LANES && variable != DISTANCE_REQUEST
96  && variable != VAR_LATALIGNMENT
97  && variable != VAR_MAXSPEED_LAT
98  && variable != VAR_MINGAP_LAT
99  && variable != ID_COUNT && variable != VAR_STOPSTATE
100  && variable != VAR_WAITING_TIME && variable != VAR_ACCUMULATED_WAITING_TIME
101  && variable != VAR_ROUTE_INDEX
102  && variable != VAR_PARAMETER
103  && variable != VAR_SPEEDSETMODE
104  && variable != VAR_LANECHANGE_MODE
105  && variable != VAR_ROUTING_MODE
106  && variable != VAR_NEXT_TLS
107  && variable != VAR_SLOPE
108  && variable != VAR_HEIGHT
109  && variable != VAR_LINE
110  && variable != VAR_VIA
111  && variable != CMD_CHANGELANE
112  ) {
113  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Get Vehicle Variable: unsupported variable " + toHex(variable, 2) + " specified", outputStorage);
114  }
115  // begin response building
116  tcpip::Storage tempMsg;
117  // response-code, variableID, objectID
119  tempMsg.writeUnsignedByte(variable);
120  tempMsg.writeString(id);
121  // process request
122  try {
123  switch (variable) {
124  case ID_LIST:
127  break;
128  case ID_COUNT:
131  break;
132  case VAR_SPEED:
135  break;
139  break;
140  case VAR_POSITION: {
143  tempMsg.writeDouble(pos.x);
144  tempMsg.writeDouble(pos.y);
145  break;
146  }
147  case VAR_POSITION3D: {
150  tempMsg.writeDouble(pos.x);
151  tempMsg.writeDouble(pos.y);
152  tempMsg.writeDouble(pos.z);
153  break;
154  }
155  case VAR_ANGLE:
158  break;
159  case VAR_SLOPE:
162  break;
163  case VAR_ROAD_ID:
166  break;
167  case VAR_LANE_ID:
170  break;
171  case VAR_LANE_INDEX:
174  break;
175  case VAR_TYPE:
178  break;
179  case VAR_ROUTE_ID:
182  break;
183  case VAR_ROUTE_INDEX:
186  break;
187  case VAR_COLOR: {
189  tempMsg.writeUnsignedByte(TYPE_COLOR);
190  tempMsg.writeUnsignedByte(color.r);
191  tempMsg.writeUnsignedByte(color.g);
192  tempMsg.writeUnsignedByte(color.b);
193  tempMsg.writeUnsignedByte(color.a);
194  break;
195  }
196  case VAR_LANEPOSITION:
199  break;
203  break;
204  case VAR_CO2EMISSION:
207  break;
208  case VAR_COEMISSION:
211  break;
212  case VAR_HCEMISSION:
215  break;
216  case VAR_PMXEMISSION:
219  break;
220  case VAR_NOXEMISSION:
223  break;
224  case VAR_FUELCONSUMPTION:
227  break;
228  case VAR_NOISEEMISSION:
231  break;
235  break;
236  case VAR_PERSON_NUMBER:
239  break;
240  case VAR_LEADER: {
241  double dist = 0;
242  if (!server.readTypeCheckingDouble(inputStorage, dist)) {
243  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Leader retrieval requires a double.", outputStorage);
244  }
245  std::pair<std::string, double> leaderInfo = libsumo::Vehicle::getLeader(id, dist);
247  tempMsg.writeInt(2);
249  tempMsg.writeString(leaderInfo.first);
251  tempMsg.writeDouble(leaderInfo.second);
252  }
253  break;
254  case VAR_WAITING_TIME:
257  break;
261  break;
262  case VAR_EDGE_TRAVELTIME: {
263  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
264  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires a compound object.", outputStorage);
265  }
266  if (inputStorage.readInt() != 2) {
267  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires time and edge as parameter.", outputStorage);
268  }
269  // time
270  int time = 0;
271  if (!server.readTypeCheckingInt(inputStorage, time)) {
272  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires the referenced time as first parameter.", outputStorage);
273  }
274  // edge
275  std::string edgeID;
276  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
277  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires the referenced edge as second parameter.", outputStorage);
278  }
279  // retrieve
281  tempMsg.writeDouble(libsumo::Vehicle::getAdaptedTraveltime(id, edgeID, time));
282  }
283  break;
284  case VAR_EDGE_EFFORT: {
285  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
286  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of effort requires a compound object.", outputStorage);
287  }
288  if (inputStorage.readInt() != 2) {
289  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of effort requires time and edge as parameter.", outputStorage);
290  }
291  // time
292  int time = 0;
293  if (!server.readTypeCheckingInt(inputStorage, time)) {
294  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of effort requires the referenced time as first parameter.", outputStorage);
295  }
296  // edge
297  std::string edgeID;
298  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
299  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of effort requires the referenced edge as second parameter.", outputStorage);
300  }
302  tempMsg.writeDouble(libsumo::Vehicle::getEffort(id, edgeID, time));
303  }
304  break;
305  case VAR_ROUTE_VALID: {
306  std::string msg;
307  tempMsg.writeUnsignedByte(TYPE_UBYTE);
309  }
310  break;
311  case VAR_EDGES:
314  break;
315  case VAR_SIGNALS:
318  break;
319  case VAR_BEST_LANES: {
321  tcpip::Storage tempContent;
322  int cnt = 0;
323  tempContent.writeUnsignedByte(TYPE_INTEGER);
324  std::vector<libsumo::TraCIBestLanesData> bestLanes = libsumo::Vehicle::getBestLanes(id);
325  tempContent.writeInt((int) bestLanes.size());
326  ++cnt;
327  for (std::vector<libsumo::TraCIBestLanesData>::const_iterator i = bestLanes.begin(); i != bestLanes.end(); ++i) {
328  const libsumo::TraCIBestLanesData& bld = *i;
329  tempContent.writeUnsignedByte(TYPE_STRING);
330  tempContent.writeString(bld.laneID);
331  ++cnt;
332  tempContent.writeUnsignedByte(TYPE_DOUBLE);
333  tempContent.writeDouble(bld.length);
334  ++cnt;
335  tempContent.writeUnsignedByte(TYPE_DOUBLE);
336  tempContent.writeDouble(bld.occupation);
337  ++cnt;
338  tempContent.writeUnsignedByte(TYPE_BYTE);
339  tempContent.writeByte(bld.bestLaneOffset);
340  ++cnt;
341  tempContent.writeUnsignedByte(TYPE_UBYTE);
342  bld.allowsContinuation ? tempContent.writeUnsignedByte(1) : tempContent.writeUnsignedByte(0);
343  ++cnt;
344  tempContent.writeUnsignedByte(TYPE_STRINGLIST);
345  tempContent.writeStringList(bld.continuationLanes);
346  ++cnt;
347  }
348  tempMsg.writeInt((int) cnt);
349  tempMsg.writeStorage(tempContent);
350  }
351  break;
352  case VAR_NEXT_TLS: {
353  std::vector<libsumo::TraCINextTLSData> nextTLS = libsumo::Vehicle::getNextTLS(id);
355  const int cnt = 1 + (int)nextTLS.size() * 4;
356  tempMsg.writeInt(cnt);
358  tempMsg.writeInt((int)nextTLS.size());
359  for (std::vector<libsumo::TraCINextTLSData>::iterator it = nextTLS.begin(); it != nextTLS.end(); ++it) {
361  tempMsg.writeString(it->id);
363  tempMsg.writeInt(it->tlIndex);
365  tempMsg.writeDouble(it->dist);
366  tempMsg.writeUnsignedByte(TYPE_BYTE);
367  tempMsg.writeByte(it->state);
368  }
369  }
370  break;
371  case VAR_STOPSTATE:
372  tempMsg.writeUnsignedByte(TYPE_UBYTE);
374  break;
375  case VAR_DISTANCE:
378  break;
379  case DISTANCE_REQUEST: {
380  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
381  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of distance requires a compound object.", outputStorage);
382  }
383  if (inputStorage.readInt() != 2) {
384  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of distance requires position and distance type as parameter.", outputStorage);
385  }
386 
387  double edgePos;
388  std::string roadID;
389  int laneIndex;
390  // read position
391  int posType = inputStorage.readUnsignedByte();
392  switch (posType) {
393  case POSITION_ROADMAP:
394  try {
395  std::string roadID = inputStorage.readString();
396  edgePos = inputStorage.readDouble();
397  laneIndex = inputStorage.readUnsignedByte();
399  tempMsg.writeDouble(libsumo::Vehicle::getDrivingDistance(id, roadID, edgePos, laneIndex));
400  break;
401  } catch (libsumo::TraCIException& e) {
402  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, e.what(), outputStorage);
403  }
404  case POSITION_2D:
405  case POSITION_3D: {
406  const double p1x = inputStorage.readDouble();
407  const double p1y = inputStorage.readDouble();
408  if (posType == POSITION_3D) {
409  inputStorage.readDouble(); // z value is ignored
410  }
413  }
414  break;
415  default:
416  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Unknown position format used for distance request", outputStorage);
417  }
418  // read distance type
419  int distType = inputStorage.readUnsignedByte();
420  if (distType != REQUEST_DRIVINGDIST) {
421  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Only driving distance is supported for vehicles.", outputStorage);
422  }
423  break;
424  }
425  case VAR_ALLOWED_SPEED:
428  break;
429  case VAR_SPEED_FACTOR:
432  break;
433  case VAR_SPEEDSETMODE:
436  break;
437  case VAR_LANECHANGE_MODE:
440  break;
441  case VAR_ROUTING_MODE:
444  break;
445  case VAR_LINE:
448  break;
449  case VAR_VIA:
452  break;
453  case CMD_CHANGELANE: {
454  int direction = 0;
455  if (!server.readTypeCheckingInt(inputStorage, direction)) {
456  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of lane change state requires a direction as int.", outputStorage);
457  }
458  const std::pair<int, int> state = libsumo::Vehicle::getLaneChangeState(id, direction);
460  tempMsg.writeInt(2);
462  tempMsg.writeInt(state.first);
464  tempMsg.writeInt(state.second);
465  }
466  break;
467  case VAR_PARAMETER: {
468  std::string paramName = "";
469  if (!server.readTypeCheckingString(inputStorage, paramName)) {
470  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of a parameter requires its name.", outputStorage);
471  }
473  tempMsg.writeString(libsumo::Vehicle::getParameter(id, paramName));
474  }
475  break;
476  case VAR_LASTACTIONTIME: {
479  }
480  break;
481  default:
483  break;
484  }
485  } catch (libsumo::TraCIException& e) {
486  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, e.what(), outputStorage);
487  }
488  server.writeStatusCmd(CMD_GET_VEHICLE_VARIABLE, RTYPE_OK, "", outputStorage);
489  server.writeResponseWithLength(outputStorage, tempMsg);
490  return true;
491 }
492 
493 
494 bool
496  tcpip::Storage& outputStorage) {
497  std::string warning = ""; // additional description for response
498  // variable
499  int variable = inputStorage.readUnsignedByte();
500  if (variable != CMD_STOP && variable != CMD_CHANGELANE
501  && variable != CMD_CHANGESUBLANE
502  && variable != CMD_SLOWDOWN && variable != CMD_CHANGETARGET && variable != CMD_RESUME
503  && variable != VAR_TYPE && variable != VAR_ROUTE_ID && variable != VAR_ROUTE
504  && variable != VAR_EDGE_TRAVELTIME && variable != VAR_EDGE_EFFORT
505  && variable != CMD_REROUTE_TRAVELTIME && variable != CMD_REROUTE_EFFORT
506  && variable != VAR_SIGNALS && variable != VAR_MOVE_TO
507  && variable != VAR_LENGTH && variable != VAR_MAXSPEED && variable != VAR_VEHICLECLASS
508  && variable != VAR_SPEED_FACTOR && variable != VAR_EMISSIONCLASS
509  && variable != VAR_WIDTH && variable != VAR_MINGAP && variable != VAR_SHAPECLASS
510  && variable != VAR_ACCEL && variable != VAR_DECEL && variable != VAR_IMPERFECTION
511  && variable != VAR_APPARENT_DECEL && variable != VAR_EMERGENCY_DECEL
512  && variable != VAR_ACTIONSTEPLENGTH
513  && variable != VAR_TAU && variable != VAR_LANECHANGE_MODE
514  && variable != VAR_SPEED && variable != VAR_SPEEDSETMODE && variable != VAR_COLOR
515  && variable != ADD && variable != ADD_FULL && variable != REMOVE
516  && variable != VAR_HEIGHT
517  && variable != VAR_ROUTING_MODE
518  && variable != VAR_LATALIGNMENT
519  && variable != VAR_MAXSPEED_LAT
520  && variable != VAR_MINGAP_LAT
521  && variable != VAR_LINE
522  && variable != VAR_VIA
523  && variable != MOVE_TO_XY && variable != VAR_PARAMETER/* && variable != VAR_SPEED_TIME_LINE && variable != VAR_LANE_TIME_LINE*/
524  ) {
525  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Change Vehicle State: unsupported variable " + toHex(variable, 2) + " specified", outputStorage);
526  }
527  // id
528  std::string id = inputStorage.readString();
529 #ifdef DEBUG_MOVEXY
530  std::cout << SIMTIME << " processSet veh=" << id << "\n";
531 #endif
532  const bool shouldExist = variable != ADD && variable != ADD_FULL;
534  if (sumoVehicle == 0) {
535  if (shouldExist) {
536  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Vehicle '" + id + "' is not known", outputStorage);
537  }
538  }
539  MSVehicle* v = dynamic_cast<MSVehicle*>(sumoVehicle);
540  if (v == 0 && shouldExist) {
541  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Vehicle '" + id + "' is not a micro-simulation vehicle", outputStorage);
542  }
543  try {
544  switch (variable) {
545  case CMD_STOP: {
546  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
547  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Stop needs a compound object description.", outputStorage);
548  }
549  int compoundSize = inputStorage.readInt();
550  if (compoundSize < 4 || compoundSize > 7) {
551  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Stop needs a compound object description of four to seven items.", outputStorage);
552  }
553  // read road map position
554  std::string edgeID;
555  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
556  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The first stop parameter must be the edge id given as a string.", outputStorage);
557  }
558  double pos = 0;
559  if (!server.readTypeCheckingDouble(inputStorage, pos)) {
560  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The second stop parameter must be the end position along the edge given as a double.", outputStorage);
561  }
562  int laneIndex = 0;
563  if (!server.readTypeCheckingByte(inputStorage, laneIndex)) {
564  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The third stop parameter must be the lane index given as a byte.", outputStorage);
565  }
566  // waitTime
567  int waitTime = -1;
568  if (!server.readTypeCheckingInt(inputStorage, waitTime)) {
569  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "The fourth stop parameter must be the waiting time given as an integer.", outputStorage);
570  }
571  int stopFlags = 0;
572  if (compoundSize >= 5) {
573  if (!server.readTypeCheckingByte(inputStorage, stopFlags)) {
574  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The fifth stop parameter must be a byte indicating its parking/triggered status.", outputStorage);
575  }
576  }
577  double startPos = pos - POSITION_EPS;
578  if (compoundSize >= 6) {
579  double tmp;
580  if (!server.readTypeCheckingDouble(inputStorage, tmp)) {
581  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The sixth stop parameter must be the start position along the edge given as a double.", outputStorage);
582  }
583  if (tmp != INVALID_DOUBLE_VALUE) {
584  startPos = tmp;
585  }
586  }
587  int until = -1;
588  if (compoundSize >= 7) {
589  if (!server.readTypeCheckingInt(inputStorage, until)) {
590  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The seventh stop parameter must be the minimum departure time given as integer.", outputStorage);
591  }
592  }
593  libsumo::Vehicle::setStop(id, edgeID, pos, laneIndex, waitTime, stopFlags, startPos, until);
594  }
595  break;
596  case CMD_RESUME: {
597  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
598  server.writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Resuming requires a compound object.", outputStorage);
599  return false;
600  }
601  if (inputStorage.readInt() != 0) {
602  server.writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Resuming should obtain an empty compound object.", outputStorage);
603  return false;
604  }
606  }
607  break;
608  case CMD_CHANGELANE: {
609  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
610  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Lane change needs a compound object description.", outputStorage);
611  }
612  if (inputStorage.readInt() != 2) {
613  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Lane change needs a compound object description of two items.", outputStorage);
614  }
615  // Lane ID
616  int laneIndex = 0;
617  if (!server.readTypeCheckingByte(inputStorage, laneIndex)) {
618  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The first lane change parameter must be the lane index given as a byte.", outputStorage);
619  }
620  // duration
621  int duration = 0;
622  if (!server.readTypeCheckingInt(inputStorage, duration)) {
623  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The second lane change parameter must be the duration given as an integer.", outputStorage);
624  }
625  if ((laneIndex < 0) || (laneIndex >= (int)(v->getEdge()->getLanes().size()))) {
626  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "No lane with index '" + toString(laneIndex) + "' on road '" + v->getEdge()->getID() + "'.", outputStorage);
627  }
628  libsumo::Vehicle::changeLane(id, laneIndex, duration);
629  }
630  break;
631  case CMD_CHANGESUBLANE: {
632  double latDist = 0;
633  if (!server.readTypeCheckingDouble(inputStorage, latDist)) {
634  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Sublane-changing requires a double.", outputStorage);
635  }
636  libsumo::Vehicle::changeSublane(id, latDist);
637  }
638  break;
639  case CMD_SLOWDOWN: {
640  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
641  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Slow down needs a compound object description.", outputStorage);
642  }
643  if (inputStorage.readInt() != 2) {
644  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Slow down needs a compound object description of two items.", outputStorage);
645  }
646  double newSpeed = 0;
647  if (!server.readTypeCheckingDouble(inputStorage, newSpeed)) {
648  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The first slow down parameter must be the speed given as a double.", outputStorage);
649  }
650  if (newSpeed < 0) {
651  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Speed must not be negative", outputStorage);
652  }
653  int duration = 0;
654  if (!server.readTypeCheckingInt(inputStorage, duration)) {
655  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The second slow down parameter must be the duration given as an integer.", outputStorage);
656  }
657  if (duration < 0 || MSNet::getInstance()->getCurrentTimeStep() + (SUMOTime)duration > SUMOTime_MAX - DELTA_T) {
658  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Invalid time interval", outputStorage);
659  }
660  libsumo::Vehicle::slowDown(id, newSpeed, (SUMOTime)duration);
661  }
662  break;
663  case CMD_CHANGETARGET: {
664  std::string edgeID;
665  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
666  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Change target requires a string containing the id of the new destination edge as parameter.", outputStorage);
667  }
668  libsumo::Vehicle::changeTarget(id, edgeID);
669  }
670  break;
671  case VAR_TYPE: {
672  std::string vTypeID;
673  if (!server.readTypeCheckingString(inputStorage, vTypeID)) {
674  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The vehicle type id must be given as a string.", outputStorage);
675  }
676  libsumo::Vehicle::setType(id, vTypeID);
677  }
678  break;
679  case VAR_ROUTE_ID: {
680  std::string rid;
681  if (!server.readTypeCheckingString(inputStorage, rid)) {
682  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The route id must be given as a string.", outputStorage);
683  }
685  }
686  break;
687  case VAR_ROUTE: {
688  std::vector<std::string> edgeIDs;
689  if (!server.readTypeCheckingStringList(inputStorage, edgeIDs)) {
690  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "A route must be defined as a list of edge ids.", outputStorage);
691  }
692  libsumo::Vehicle::setRoute(id, edgeIDs);
693  }
694  break;
695  case VAR_EDGE_TRAVELTIME: {
696  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
697  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time requires a compound object.", outputStorage);
698  }
699  int parameterCount = inputStorage.readInt();
700  std::string edgeID;
701  int begTime = 0;
702  int endTime = -1;
703  double value = INVALID_DOUBLE_VALUE;
704  if (parameterCount == 4) {
705  // begin time
706  if (!server.readTypeCheckingInt(inputStorage, begTime)) {
707  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 4 parameters requires the begin time as first parameter.", outputStorage);
708  }
709  // begin time
710  if (!server.readTypeCheckingInt(inputStorage, endTime)) {
711  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 4 parameters requires the end time as second parameter.", outputStorage);
712  }
713  // edge
714  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
715  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 4 parameters requires the referenced edge as third parameter.", outputStorage);
716  }
717  // value
718  if (!server.readTypeCheckingDouble(inputStorage, value)) {
719  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 4 parameters requires the travel time as double as fourth parameter.", outputStorage);
720  }
721  } else if (parameterCount == 2) {
722  // edge
723  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
724  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 2 parameters requires the referenced edge as first parameter.", outputStorage);
725  }
726  // value
727  if (!server.readTypeCheckingDouble(inputStorage, value)) {
728  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 2 parameters requires the travel time as second parameter.", outputStorage);
729  }
730  } else if (parameterCount == 1) {
731  // edge
732  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
733  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 1 parameter requires the referenced edge as first parameter.", outputStorage);
734  }
735  } else {
736  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time requires 1, 2, or 4 parameters.", outputStorage);
737  }
738  libsumo::Vehicle::setAdaptedTraveltime(id, edgeID, value, (double)begTime, endTime == -1 ? std::numeric_limits<double>::max() : (double)endTime);
739  }
740  break;
741  case VAR_EDGE_EFFORT: {
742  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
743  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort requires a compound object.", outputStorage);
744  }
745  int parameterCount = inputStorage.readInt();
746  std::string edgeID;
747  int begTime = 0;
748  int endTime = -1;
749  double value = INVALID_DOUBLE_VALUE;
750  if (parameterCount == 4) {
751  // begin time
752  if (!server.readTypeCheckingInt(inputStorage, begTime)) {
753  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 4 parameters requires the begin time as first parameter.", outputStorage);
754  }
755  // begin time
756  if (!server.readTypeCheckingInt(inputStorage, endTime)) {
757  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 4 parameters requires the end time as second parameter.", outputStorage);
758  }
759  // edge
760  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
761  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 4 parameters requires the referenced edge as third parameter.", outputStorage);
762  }
763  // value
764  if (!server.readTypeCheckingDouble(inputStorage, value)) {
765  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 4 parameters requires the travel time as fourth parameter.", outputStorage);
766  }
767  } else if (parameterCount == 2) {
768  // edge
769  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
770  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 2 parameters requires the referenced edge as first parameter.", outputStorage);
771  }
772  if (!server.readTypeCheckingDouble(inputStorage, value)) {
773  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 2 parameters requires the travel time as second parameter.", outputStorage);
774  }
775  } else if (parameterCount == 1) {
776  // edge
777  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
778  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 1 parameter requires the referenced edge as first parameter.", outputStorage);
779  }
780  } else {
781  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort requires 1, 2, or 4 parameters.", outputStorage);
782  }
783  // retrieve
784  libsumo::Vehicle::setEffort(id, edgeID, value, (double)begTime, endTime == -1 ? std::numeric_limits<double>::max() : (double)endTime);
785  }
786  break;
787  case CMD_REROUTE_TRAVELTIME: {
788  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
789  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Rerouting requires a compound object.", outputStorage);
790  }
791  if (inputStorage.readInt() != 0) {
792  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Rerouting should obtain an empty compound object.", outputStorage);
793  }
795  }
796  break;
797  case CMD_REROUTE_EFFORT: {
798  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
799  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Rerouting requires a compound object.", outputStorage);
800  }
801  if (inputStorage.readInt() != 0) {
802  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Rerouting should obtain an empty compound object.", outputStorage);
803  }
805  }
806  break;
807  case VAR_SIGNALS: {
808  int signals = 0;
809  if (!server.readTypeCheckingInt(inputStorage, signals)) {
810  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting signals requires an integer.", outputStorage);
811  }
812  libsumo::Vehicle::setSignals(id, signals);
813  }
814  break;
815  case VAR_MOVE_TO: {
816  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
817  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting position requires a compound object.", outputStorage);
818  }
819  if (inputStorage.readInt() != 2) {
820  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting position should obtain the lane id and the position.", outputStorage);
821  }
822  // lane ID
823  std::string laneID;
824  if (!server.readTypeCheckingString(inputStorage, laneID)) {
825  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The first parameter for setting a position must be the lane ID given as a string.", outputStorage);
826  }
827  // position on lane
828  double position = 0;
829  if (!server.readTypeCheckingDouble(inputStorage, position)) {
830  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The second parameter for setting a position must be the position given as a double.", outputStorage);
831  }
832  // process
833  libsumo::Vehicle::moveTo(id, laneID, position);
834  }
835  break;
836  case VAR_SPEED: {
837  double speed = 0;
838  if (!server.readTypeCheckingDouble(inputStorage, speed)) {
839  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting speed requires a double.", outputStorage);
840  }
841  std::vector<std::pair<SUMOTime, double> > speedTimeLine;
842  if (speed >= 0) {
843  speedTimeLine.push_back(std::make_pair(MSNet::getInstance()->getCurrentTimeStep(), speed));
844  speedTimeLine.push_back(std::make_pair(SUMOTime_MAX - DELTA_T, speed));
845  }
846  v->getInfluencer().setSpeedTimeLine(speedTimeLine);
847  }
848  break;
849  case VAR_SPEEDSETMODE: {
850  int speedMode = 0;
851  if (!server.readTypeCheckingInt(inputStorage, speedMode)) {
852  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting speed mode requires an integer.", outputStorage);
853  }
854  v->getInfluencer().setSpeedMode(speedMode);
855  }
856  break;
857  case VAR_LANECHANGE_MODE: {
858  int laneChangeMode = 0;
859  if (!server.readTypeCheckingInt(inputStorage, laneChangeMode)) {
860  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting lane change mode requires an integer.", outputStorage);
861  }
862  v->getInfluencer().setLaneChangeMode(laneChangeMode);
863  }
864  break;
865  case VAR_ROUTING_MODE: {
866  int routingMode = 0;
867  if (!server.readTypeCheckingInt(inputStorage, routingMode)) {
868  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting routing mode requires an integer.", outputStorage);
869  }
870  v->getInfluencer().setRoutingMode(routingMode);
871  }
872  break;
873  case VAR_COLOR: {
875  if (!server.readTypeCheckingColor(inputStorage, col)) {
876  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The color must be given using the according type.", outputStorage);
877  }
878  v->getParameter().color.set(col.r, col.g, col.b, col.a);
880  }
881  break;
882  case ADD: {
883  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
884  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Adding a vehicle requires a compound object.", outputStorage);
885  }
886  if (inputStorage.readInt() != 6) {
887  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Adding a vehicle needs six parameters.", outputStorage);
888  }
889  std::string vTypeID;
890  if (!server.readTypeCheckingString(inputStorage, vTypeID)) {
891  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "First parameter (type) requires a string.", outputStorage);
892  }
893  std::string routeID;
894  if (!server.readTypeCheckingString(inputStorage, routeID)) {
895  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Second parameter (route) requires a string.", outputStorage);
896  }
897  int depart;
898  if (!server.readTypeCheckingInt(inputStorage, depart)) {
899  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Third parameter (depart) requires an integer.", outputStorage);
900  }
901  double departPos;
902  if (!server.readTypeCheckingDouble(inputStorage, departPos)) {
903  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Fourth parameter (position) requires a double.", outputStorage);
904  }
905  double departSpeed;
906  if (!server.readTypeCheckingDouble(inputStorage, departSpeed)) {
907  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Fifth parameter (speed) requires a double.", outputStorage);
908  }
909  int departLane;
910  if (!server.readTypeCheckingByte(inputStorage, departLane)) {
911  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Sixth parameter (lane) requires a byte.", outputStorage);
912  }
913  libsumo::Vehicle::add(id, routeID, vTypeID, depart, departLane, departPos, departSpeed);
914  }
915  break;
916  case ADD_FULL: {
917  if (v != 0) {
918  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The vehicle " + id + " to add already exists.", outputStorage);
919  }
920  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
921  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Adding a vehicle requires a compound object.", outputStorage);
922  }
923  if (inputStorage.readInt() != 14) {
924  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Adding a fully specified vehicle needs fourteen parameters.", outputStorage);
925  }
926  SUMOVehicleParameter vehicleParams;
927  vehicleParams.id = id;
928 
929  std::string routeID;
930  if (!server.readTypeCheckingString(inputStorage, routeID)) {
931  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Second parameter (route) requires a string.", outputStorage);
932  }
933  const MSRoute* route = MSRoute::dictionary(routeID);
934  if (!route) {
935  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Invalid route '" + routeID + "' for vehicle: '" + id + "'", outputStorage);
936  }
937 
938  std::string vTypeID;
939  if (!server.readTypeCheckingString(inputStorage, vTypeID)) {
940  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "First parameter (type) requires a string.", outputStorage);
941  }
942  MSVehicleType* vehicleType = MSNet::getInstance()->getVehicleControl().getVType(vTypeID);
943  if (!vehicleType) {
944  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Invalid type '" + vTypeID + "' for vehicle '" + id + "'", outputStorage);
945  }
946 
947  std::string helper;
948  std::string error;
949  if (!server.readTypeCheckingString(inputStorage, helper)) {
950  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Third parameter (depart) requires an string.", outputStorage);
951  }
952  if (!SUMOVehicleParameter::parseDepart(helper, "vehicle", id, vehicleParams.depart, vehicleParams.departProcedure, error)) {
953  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
954  }
955  if (vehicleParams.departProcedure == DEPART_GIVEN && vehicleParams.depart < MSNet::getInstance()->getCurrentTimeStep()) {
956  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Departure time in the past.", outputStorage);
957  }
958 
959  if (!server.readTypeCheckingString(inputStorage, helper)) {
960  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Fourth parameter (depart lane) requires a string.", outputStorage);
961  }
962  if (!SUMOVehicleParameter::parseDepartLane(helper, "vehicle", id, vehicleParams.departLane, vehicleParams.departLaneProcedure, error)) {
963  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
964  }
965  if (!server.readTypeCheckingString(inputStorage, helper)) {
966  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Fifth parameter (depart position) requires a string.", outputStorage);
967  }
968  if (!SUMOVehicleParameter::parseDepartPos(helper, "vehicle", id, vehicleParams.departPos, vehicleParams.departPosProcedure, error)) {
969  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
970  }
971  if (!server.readTypeCheckingString(inputStorage, helper)) {
972  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Sixth parameter (depart speed) requires a string.", outputStorage);
973  }
974  if (!SUMOVehicleParameter::parseDepartSpeed(helper, "vehicle", id, vehicleParams.departSpeed, vehicleParams.departSpeedProcedure, error)) {
975  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
976  }
977 
978  if (!server.readTypeCheckingString(inputStorage, helper)) {
979  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Seventh parameter (arrival lane) requires a string.", outputStorage);
980  }
981  if (!SUMOVehicleParameter::parseArrivalLane(helper, "vehicle", id, vehicleParams.arrivalLane, vehicleParams.arrivalLaneProcedure, error)) {
982  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
983  }
984  if (!server.readTypeCheckingString(inputStorage, helper)) {
985  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Eighth parameter (arrival position) requires a string.", outputStorage);
986  }
987  if (!SUMOVehicleParameter::parseArrivalPos(helper, "vehicle", id, vehicleParams.arrivalPos, vehicleParams.arrivalPosProcedure, error)) {
988  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
989  }
990  if (!server.readTypeCheckingString(inputStorage, helper)) {
991  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Ninth parameter (arrival speed) requires a string.", outputStorage);
992  }
993  if (!SUMOVehicleParameter::parseArrivalSpeed(helper, "vehicle", id, vehicleParams.arrivalSpeed, vehicleParams.arrivalSpeedProcedure, error)) {
994  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
995  }
996 
997  if (!server.readTypeCheckingString(inputStorage, vehicleParams.fromTaz)) {
998  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Tenth parameter (from taz) requires a string.", outputStorage);
999  }
1000  if (!server.readTypeCheckingString(inputStorage, vehicleParams.toTaz)) {
1001  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Eleventh parameter (to taz) requires a string.", outputStorage);
1002  }
1003  if (!server.readTypeCheckingString(inputStorage, vehicleParams.line)) {
1004  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Twelth parameter (line) requires a string.", outputStorage);
1005  }
1006 
1007  int num;
1008  if (!server.readTypeCheckingInt(inputStorage, num)) {
1009  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "13th parameter (person capacity) requires an int.", outputStorage);
1010  }
1011  if (!server.readTypeCheckingInt(inputStorage, num)) {
1012  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "14th parameter (person number) requires an int.", outputStorage);
1013  }
1014  vehicleParams.personNumber = num;
1015 
1016  SUMOVehicleParameter* params = new SUMOVehicleParameter(vehicleParams);
1017  try {
1018  SUMOVehicle* vehicle = MSNet::getInstance()->getVehicleControl().buildVehicle(params, route, vehicleType, true, false);
1019  MSNet::getInstance()->getVehicleControl().addVehicle(vehicleParams.id, vehicle);
1021  } catch (ProcessError& e) {
1022  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, e.what(), outputStorage);
1023  }
1024  }
1025  break;
1026  case REMOVE: {
1027  int why = 0;
1028  if (!server.readTypeCheckingByte(inputStorage, why)) {
1029  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Removing a vehicle requires a byte.", outputStorage);
1030  }
1032  switch (why) {
1033  case REMOVE_TELEPORT:
1034  // XXX semantics unclear
1035  // n = MSMoveReminder::NOTIFICATION_TELEPORT;
1037  break;
1038  case REMOVE_PARKING:
1039  // XXX semantics unclear
1040  // n = MSMoveReminder::NOTIFICATION_PARKING;
1042  break;
1043  case REMOVE_ARRIVED:
1045  break;
1046  case REMOVE_VAPORIZED:
1048  break;
1051  break;
1052  default:
1053  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Unknown removal status.", outputStorage);
1054  }
1055  if (v->hasDeparted()) {
1056  v->onRemovalFromNet(n);
1057  if (v->getLane() != 0) {
1058  v->getLane()->removeVehicle(v, n);
1059  }
1061  } else {
1064  }
1065  }
1066  break;
1067  case MOVE_TO_XY: {
1068  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
1069  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "MoveToXY vehicle requires a compound object.", outputStorage);
1070  }
1071  const int numArgs = inputStorage.readInt();
1072  if (numArgs != 5 && numArgs != 6) {
1073  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "MoveToXY vehicle should obtain: edgeID, lane, x, y, angle and optionally keepRouteFlag.", outputStorage);
1074  }
1075  // edge ID
1076  std::string edgeID;
1077  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
1078  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The first parameter for moveToXY must be the edge ID given as a string.", outputStorage);
1079  }
1080  // lane index
1081  int laneNum = 0;
1082  if (!server.readTypeCheckingInt(inputStorage, laneNum)) {
1083  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The second parameter for moveToXY must be lane given as an int.", outputStorage);
1084  }
1085  // x
1086  double x = 0;
1087  if (!server.readTypeCheckingDouble(inputStorage, x)) {
1088  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The third parameter for moveToXY must be the x-position given as a double.", outputStorage);
1089  }
1090  // y
1091  double y = 0;
1092  if (!server.readTypeCheckingDouble(inputStorage, y)) {
1093  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The fourth parameter for moveToXY must be the y-position given as a double.", outputStorage);
1094  }
1095  // angle
1096  double angle = 0;
1097  if (!server.readTypeCheckingDouble(inputStorage, angle)) {
1098  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The fifth parameter for moveToXY must be the angle given as a double.", outputStorage);
1099  }
1100 
1101  int keepRouteFlag = 1;
1102  if (numArgs == 6) {
1103  if (!server.readTypeCheckingByte(inputStorage, keepRouteFlag)) {
1104  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The sixth parameter for moveToXY must be the keepRouteFlag given as a byte.", outputStorage);
1105  }
1106  }
1107  libsumo::Vehicle::moveToXY(id, edgeID, laneNum, x, y, angle, keepRouteFlag);
1108  }
1109  break;
1110  case VAR_SPEED_FACTOR: {
1111  double factor = 0;
1112  if (!server.readTypeCheckingDouble(inputStorage, factor)) {
1113  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting speed factor requires a double.", outputStorage);
1114  }
1115  v->setChosenSpeedFactor(factor);
1116  }
1117  break;
1118  case VAR_LINE: {
1119  std::string line;
1120  if (!server.readTypeCheckingString(inputStorage, line)) {
1121  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The line must be given as a string.", outputStorage);
1122  }
1123  v->getParameter().line = line;
1124  }
1125  break;
1126  case VAR_VIA: {
1127  std::vector<std::string> edgeIDs;
1128  if (!server.readTypeCheckingStringList(inputStorage, edgeIDs)) {
1129  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Vias must be defined as a list of edge ids.", outputStorage);
1130  }
1131  try {
1132  // ensure edges exist
1133  ConstMSEdgeVector edges;
1134  MSEdge::parseEdgesList(edgeIDs, edges, "<via-edges>");
1135  } catch (ProcessError& e) {
1136  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, e.what(), outputStorage);
1137  }
1138  v->getParameter().via = edgeIDs;
1139  }
1140  break;
1141  case VAR_PARAMETER: {
1142  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
1143  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "A compound object is needed for setting a parameter.", outputStorage);
1144  }
1145  //readt itemNo
1146  inputStorage.readInt();
1147  std::string name;
1148  if (!server.readTypeCheckingString(inputStorage, name)) {
1149  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The name of the parameter must be given as a string.", outputStorage);
1150  }
1151  std::string value;
1152  if (!server.readTypeCheckingString(inputStorage, value)) {
1153  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The value of the parameter must be given as a string.", outputStorage);
1154  }
1155  try {
1157  libsumo::Vehicle::setParameter(id, name, value);
1158  } catch (libsumo::TraCIException& e) {
1159  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, e.what(), outputStorage);
1160  }
1161  }
1162  break;
1163  case VAR_ACTIONSTEPLENGTH: {
1164  double value = 0;
1165  if (!server.readTypeCheckingDouble(inputStorage, value)) {
1166  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting action step length requires a double.", outputStorage);
1167  }
1168  if (fabs(value) == std::numeric_limits<double>::infinity()) {
1169  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Invalid action step length.", outputStorage);
1170  }
1171  bool resetActionOffset = value >= 0.0;
1172  libsumo::Vehicle::setActionStepLength(id, fabs(value), resetActionOffset);
1173  }
1174  break;
1175  default:
1176  try {
1177  const MSVehicleType& type = v->getSingularType();
1178  if (!TraCIServerAPI_VehicleType::setVariable(CMD_SET_VEHICLE_VARIABLE, variable, type.getID(), server, inputStorage, outputStorage)) {
1179  return false;
1180  }
1181  } catch (ProcessError& e) {
1182  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, e.what(), outputStorage);
1183  } catch (libsumo::TraCIException& e) {
1184  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, e.what(), outputStorage);
1185  }
1186  break;
1187  }
1188  } catch (libsumo::TraCIException& e) {
1189  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, e.what(), outputStorage);
1190  }
1191  server.writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_OK, warning, outputStorage);
1192  return true;
1193 }
1194 
1195 
1196 
1197 // ------ helper functions ------
1198 bool
1199 TraCIServerAPI_Vehicle::getPosition(const std::string& id, Position& p) {
1200  MSVehicle* v = dynamic_cast<MSVehicle*>(MSNet::getInstance()->getVehicleControl().getVehicle(id));
1201  if (v == 0) {
1202  return false;
1203  }
1204  p = v->getPosition();
1205  return true;
1206 }
1207 
1208 
1209 #endif
1210 
1211 
1212 /****************************************************************************/
1213 
#define VAR_ROAD_ID
static void slowDown(const std::string &vehicleID, double speed, SUMOTime duration)
Definition: Vehicle.cpp:946
unsigned char g
Definition: TraCIDefs.h:79
static std::string getLaneID(const std::string &vehicleID)
Definition: Vehicle.cpp:150
static std::vector< TraCIBestLanesData > getBestLanes(const std::string &vehicleID)
Definition: Vehicle.cpp:319
#define REMOVE_PARKING
static std::vector< std::string > getEdges(const std::string &vehicleID)
Definition: Vehicle.cpp:302
bool readTypeCheckingColor(tcpip::Storage &inputStorage, libsumo::TraCIColor &into)
Reads the value type and a color, verifying the type.
RGBColor color
The vehicle&#39;s color, TraCI may change this.
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:1031
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:83
#define VAR_EMISSIONCLASS
virtual void deleteVehicle(SUMOVehicle *v, bool discard=false)
Deletes the vehicle.
#define VAR_VIA
static TraCIPosition getPosition(const std::string &vehicleID)
Definition: Vehicle.cpp:114
#define VAR_CO2EMISSION
#define REQUEST_DRIVINGDIST
#define VAR_LENGTH
bool allowsContinuation
Whether this lane allows continuing the route.
Definition: TraCIDefs.h:201
The time is given.
#define VAR_LATALIGNMENT
#define RESPONSE_GET_VEHICLE_VARIABLE
static int getSignalStates(const std::string &vehicleID)
Definition: Vehicle.cpp:314
#define CMD_GET_VEHICLE_VARIABLE
#define TYPE_COMPOUND
static double getSpeedWithoutTraCI(const std::string &vehicleID)
Definition: Vehicle.cpp:107
static std::string getRoadID(const std::string &vehicleID)
Definition: Vehicle.cpp:143
#define VAR_ACCUMULATED_WAITING_TIME
static void setRoute(const std::string &vehicleID, const std::vector< std::string > &edgeIDs)
Definition: Vehicle.cpp:991
static double getDrivingDistance(const std::string &vehicleID, const std::string &edgeID, double position, int laneIndex)
Definition: Vehicle.cpp:421
bool hasDeparted() const
Returns whether this vehicle has already departed.
static int getPersonNumber(const std::string &vehicleID)
Definition: Vehicle.cpp:244
#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_POSITION
MSLane * getLane() const
Returns the lane the vehicle is on.
Definition: MSVehicle.h:564
ArrivalLaneDefinition arrivalLaneProcedure
Information how the vehicle shall choose the lane to arrive on.
#define VAR_ROUTE
#define CMD_CHANGELANE
#define VAR_SPEEDSETMODE
#define VAR_TAU
#define CMD_STOP
static std::pair< std::string, double > getLeader(const std::string &vehicleID, double dist)
Definition: Vehicle.cpp:250
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
static void setParameter(const std::string &vehicleID, const std::string &key, const std::string &value)
Definition: Vehicle.cpp:1182
#define VAR_ALLOWED_SPEED
#define TYPE_UBYTE
#define RTYPE_OK
static double getSlope(const std::string &vehicleID)
Definition: Vehicle.cpp:136
#define POSITION_ROADMAP
#define VAR_HEIGHT
#define DISTANCE_REQUEST
#define VAR_WAITING_TIME
const SUMOVehicleParameter & getParameter() const
Returns the vehicle&#39;s parameter (including departure definition)
virtual double readDouble()
#define VAR_SIGNALS
static std::string getTypeID(const std::string &vehicleID)
Definition: Vehicle.cpp:163
#define VAR_TYPE
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
int parametersSet
Information for the router which parameter were set, TraCI may modify this (whe changing color) ...
#define VAR_ROUTE_ID
Notification
Definition of a vehicle state.
virtual MSVehicle * removeVehicle(MSVehicle *remVehicle, MSMoveReminder::Notification notification, bool notify=true)
Definition: MSLane.cpp:1944
#define CMD_CHANGESUBLANE
#define VAR_VEHICLECLASS
#define VAR_SPEED_FACTOR
#define VAR_COLOR
static bool getPosition(const std::string &id, Position &p)
Returns the named vehicle&#39;s position.
double occupation
The traffic density along length.
Definition: TraCIDefs.h:197
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:167
static double getCOEmission(const std::string &vehicleID)
Definition: Vehicle.cpp:202
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:167
std::string laneID
The id of the lane.
Definition: TraCIDefs.h:193
SUMOTime DELTA_T
Definition: SUMOTime.cpp:39
bool readTypeCheckingString(tcpip::Storage &inputStorage, std::string &into)
Reads the value type and a string, verifying the type.
#define TYPE_COLOR
#define TYPE_STRINGLIST
bool readTypeCheckingDouble(tcpip::Storage &inputStorage, double &into)
Reads the value type and a double, verifying the type.
#define VAR_ROUTING_MODE
static std::vector< std::string > getVia(const std::string &vehicleID)
Definition: Vehicle.cpp:491
The vehicle got vaporized.
#define POSITION_3D
Position getPosition(const double offset=0) const
Return current position (x/y, cartesian)
Definition: MSVehicle.cpp:901
virtual bool addVehicle(const std::string &id, SUMOVehicle *v)
Tries to insert the vehicle into the internal vehicle container.
#define VAR_BEST_LANES
std::vector< const MSEdge * > ConstMSEdgeVector
Definition: MSEdge.h:78
ArrivalSpeedDefinition arrivalSpeedProcedure
Information how the vehicle&#39;s end speed shall be chosen.
static void setRouteID(const std::string &vehicleID, const std::string &routeID)
Definition: Vehicle.cpp:970
const std::string & getID() const
Returns the id.
Definition: Named.h:65
virtual void writeUnsignedByte(int)
#define VAR_NEXT_TLS
static double getAngle(const std::string &vehicleID)
Definition: Vehicle.cpp:129
bool writeErrorStatusCmd(int commandId, const std::string &description, tcpip::Storage &outputStorage)
Writes a status command to the given storage with status = RTYPE_ERR.
static std::string getLine(const std::string &vehicleID)
Definition: Vehicle.cpp:486
static double getSpeedFactor(const std::string &vehicleID)
Definition: Vehicle.cpp:465
static bool getVariable(const int variable, const std::string &v, tcpip::Storage &tempMsg)
Processes a value request for the given type.
#define VAR_SPEED_DEVIATION
#define VAR_NOISEEMISSION
#define VAR_FUELCONSUMPTION
static double getDistance(const std::string &vehicleID)
Definition: Vehicle.cpp:394
static double getNoiseEmission(const std::string &vehicleID)
Definition: Vehicle.cpp:232
virtual void writeInt(int)
#define VAR_POSITION3D
The car-following model and parameter.
Definition: MSVehicleType.h:72
#define TYPE_STRING
#define SIMTIME
Definition: SUMOTime.h:71
virtual int readUnsignedByte()
std::string toTaz
The vehicle&#39;s destination zone (district)
static std::pair< int, int > getLaneChangeState(const std::string &vehicleID, int direction)
Definition: Vehicle.cpp:497
static void add(const std::string &vehicleID, const std::string &routeID, const std::string &typeID="DEFAULT_VEHTYPE", int depart=DEPARTFLAG_NOW, int departLane=DEPARTFLAG_LANE_FIRST_ALLOWED, double departPos=DEPARTFLAG_POS_BASE, double departSpeed=0, int arrivalLane=ARRIVALFLAG_LANE_CURRENT, double arrivalPos=ARRIVALFLAG_POS_MAX, double arrivalSpeed=ARRIVALFLAG_SPEED_CURRENT, const std::string &fromTaz="", const std::string &toTaz="", const std::string &line="", int personCapacity=4, int personNumber=0)
Definition: Vehicle.cpp:753
static bool processGet(TraCIServer &server, tcpip::Storage &inputStorage, tcpip::Storage &outputStorage)
Processes a get value command (Command 0xa4: Get Vehicle Variable)
static double getNOxEmission(const std::string &vehicleID)
Definition: Vehicle.cpp:220
static void rerouteTraveltime(const std::string &vehicleID)
Definition: Vehicle.cpp:1057
#define VAR_NOXEMISSION
static double getWaitingTime(const std::string &vehicleID)
Definition: Vehicle.cpp:264
static double getLastActionTime(const std::string &vehicleID)
Definition: Vehicle.cpp:583
static double getCO2Emission(const std::string &vehicleID)
Definition: Vehicle.cpp:196
static const MSVehicleType & getVehicleType(const std::string &vehicleID)
Definition: Vehicle.cpp:540
#define VAR_ANGLE
int bestLaneOffset
The offset of this lane from the best lane.
Definition: TraCIDefs.h:199
unsigned char b
Definition: TraCIDefs.h:79
double departSpeed
(optional) The initial speed of the vehicle
static void resume(const std::string &vehicleID)
Definition: Vehicle.cpp:693
void setSpeedTimeLine(const std::vector< std::pair< SUMOTime, double > > &speedTimeLine)
Sets a new velocity timeline.
Definition: MSVehicle.cpp:266
void setSpeedMode(int speedMode)
Sets speed-constraining behaviors.
Definition: MSVehicle.cpp:438
#define VAR_PERSON_NUMBER
#define CMD_SLOWDOWN
#define VAR_SHAPECLASS
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle&#39;s initial speed shall be chosen.
#define REMOVE_ARRIVED
static std::vector< TraCINextTLSData > getNextTLS(const std::string &vehicleID)
Definition: Vehicle.cpp:345
static int getSpeedMode(const std::string &vehicleID)
Definition: Vehicle.cpp:471
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:55
#define MOVE_TO_XY
static int getRouteIndex(const std::string &vehicleID)
Definition: Vehicle.cpp:173
#define VAR_ACCEL
#define CMD_CHANGETARGET
Representation of a vehicle.
Definition: SUMOVehicle.h:66
virtual int readInt()
static double getLateralLanePosition(const std::string &vehicleID)
Definition: Vehicle.cpp:190
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
#define REMOVE_TELEPORT_ARRIVED
static double getHCEmission(const std::string &vehicleID)
Definition: Vehicle.cpp:208
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:45
void set(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
assigns new values
Definition: RGBColor.cpp:82
#define SUMOTime_MAX
Definition: TraCIDefs.h:52
#define VAR_LANEPOSITION
#define VAR_ACTIONSTEPLENGTH
const MSEdge * getEdge() const
Returns the edge the vehicle is currently at.
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:306
virtual void writeByte(int)
static double getFuelConsumption(const std::string &vehicleID)
Definition: Vehicle.cpp:226
#define REMOVE_TELEPORT
#define VAR_LASTACTIONTIME
static double getLanePosition(const std::string &vehicleID)
Definition: Vehicle.cpp:184
#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.
The vehicle arrived at its destination (is deleted)
int arrivalLane
(optional) The lane the vehicle shall arrive on (not used yet)
unsigned char a
Definition: TraCIDefs.h:79
virtual void writeStringList(const std::vector< std::string > &s)
SUMOTime depart
The vehicle&#39;s departure time.
#define VAR_PMXEMISSION
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:253
static void changeLane(const std::string &vehicleID, int laneIndex, SUMOTime duration)
Definition: Vehicle.cpp:738
#define CMD_SET_VEHICLE_VARIABLE
static void moveTo(const std::string &vehicleID, const std::string &laneID, double position)
Definition: Vehicle.cpp:1084
#define VAR_IMPERFECTION
#define POSITION_EPS
Definition: config.h:175
std::string fromTaz
The vehicle&#39;s origin zone (district)
virtual std::string readString()
#define VAR_EDGES
void onRemovalFromNet(const MSMoveReminder::Notification reason)
Called when the vehicle is removed from the network.
Definition: MSVehicle.cpp:709
unsigned char r
Definition: TraCIDefs.h:79
static bool parseArrivalLane(const std::string &val, const std::string &element, const std::string &id, int &lane, ArrivalLaneDefinition &ald, std::string &error)
Validates a given arrivalLane value.
static std::vector< std::string > getIDList()
Definition: Vehicle.cpp:83
#define VAR_EDGE_EFFORT
#define CMD_REROUTE_EFFORT
static double getAccumulatedWaitingTime(const std::string &vehicleID)
Definition: Vehicle.cpp:270
#define VAR_STOPSTATE
#define ADD
void setChosenSpeedFactor(const double factor)
Returns the precomputed factor by which the driver wants to be faster than the speed limit...
#define VAR_SLOPE
#define REMOVE
TraCI server used to control sumo by a remote TraCI client.
Definition: TraCIServer.h:69
const int VEHPARS_COLOR_SET
virtual void writeStorage(tcpip::Storage &store)
#define VAR_LEADER
int personNumber
The static number of persons in the vehicle when it departs (not including boarding persons) ...
static std::string getRouteID(const std::string &vehicleID)
Definition: Vehicle.cpp:168
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
std::string line
The vehicle&#39;s line (mainly for public transport)
#define INVALID_DOUBLE_VALUE
double arrivalPos
(optional) The position the vehicle shall arrive on
#define VAR_SPEED
void setRoutingMode(int value)
Sets routing behavior.
Definition: MSVehicle.h:1424
void writeResponseWithLength(tcpip::Storage &outputStorage, tcpip::Storage &tempMsg)
void alreadyDeparted(SUMOVehicle *veh)
stops trying to emit the given vehicle (because it already departed)
MSVehicleType * getVType(const std::string &id=DEFAULT_VTYPE_ID, std::mt19937 *rng=0)
Returns the named vehicle type or a sample from the named distribution.
std::vector< std::string > via
List of the via-edges the vehicle must visit.
static void setStop(const std::string &vehicleID, const std::string &edgeID, double endPos=1., int laneIndex=0, SUMOTime duration=4294967295u, int flags=STOP_DEFAULT, double startPos=INVALID_DOUBLE_VALUE, SUMOTime until=-1)
Definition: Vehicle.cpp:630
static std::string getParameter(const std::string &vehicleID, const std::string &key)
Definition: Vehicle.cpp:508
#define VAR_EDGE_TRAVELTIME
static int getLaneIndex(const std::string &vehicleID)
Definition: Vehicle.cpp:157
static int getIDCount()
Definition: Vehicle.cpp:95
static void moveToXY(const std::string &vehicleID, const std::string &edgeID, const int laneIndex, const double x, const double y, double angle, const int keepRouteFlag)
Definition: Vehicle.cpp:843
double departPos
(optional) The position the vehicle shall depart from
#define VAR_COEMISSION
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:712
Influencer & getInfluencer()
Returns the velocity/lane influencer.
Definition: MSVehicle.cpp:4812
void scheduleVehicleRemoval(SUMOVehicle *veh)
Removes a vehicle after it has ended.
Structure representing possible vehicle parameter.
#define VAR_LANEPOSITION_LAT
static double getAllowedSpeed(const std::string &vehicleID)
Definition: Vehicle.cpp:455
static double getPMxEmission(const std::string &vehicleID)
Definition: Vehicle.cpp:214
#define VAR_MOVE_TO
static void setSignals(const std::string &vehicleID, int signals)
Definition: Vehicle.cpp:1071
static bool isRouteValid(const std::string &vehicleID)
Definition: Vehicle.cpp:296
#define TYPE_DOUBLE
std::string toHex(const T i, std::streamsize numDigits=0)
Definition: ToString.h:65
static TraCIColor getColor(const std::string &vehicleID)
Definition: Vehicle.cpp:179
MSInsertionControl & getInsertionControl()
Returns the insertion control.
Definition: MSNet.h:359
static bool parseDepartPos(const std::string &val, const std::string &element, const std::string &id, double &pos, DepartPosDefinition &dpd, std::string &error)
Validates a given departPos value.
#define CMD_REROUTE_TRAVELTIME
static double getDrivingDistance2D(const std::string &vehicleID, double x, double y)
Definition: Vehicle.cpp:437
#define TYPE_BYTE
static bool parseArrivalSpeed(const std::string &val, const std::string &element, const std::string &id, double &speed, ArrivalSpeedDefinition &asd, std::string &error)
Validates a given arrivalSpeed value.
#define VAR_ELECTRICITYCONSUMPTION
#define VAR_ROUTE_INDEX
const std::string & getID() const
Returns the name of the vehicle type.
static int getRoutingMode(const std::string &vehicleID)
Definition: Vehicle.cpp:481
static bool parseArrivalPos(const std::string &val, const std::string &element, const std::string &id, double &pos, ArrivalPosDefinition &apd, std::string &error)
Validates a given arrivalPos value.
static bool parseDepartSpeed(const std::string &val, const std::string &element, const std::string &id, double &speed, DepartSpeedDefinition &dsd, std::string &error)
Validates a given departSpeed value.
void setLaneChangeMode(int value)
Sets lane changing behavior.
Definition: MSVehicle.cpp:448
virtual void writeDouble(double)
#define REMOVE_VAPORIZED
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:1005
static int getLanechangeMode(const std::string &vehicleID)
Definition: Vehicle.cpp:476
void writeStatusCmd(int commandId, int status, const std::string &description, tcpip::Storage &outputStorage)
Writes a status command to the given storage.
#define VAR_APPARENT_DECEL
#define VAR_SPEED_WITHOUT_TRACI
long long int SUMOTime
Definition: TraCIDefs.h:51
double length
The length than can be driven from that lane without lane change.
Definition: TraCIDefs.h:195
double arrivalSpeed
(optional) The final speed of the vehicle (not used yet)
#define VAR_LANECHANGE_MODE
#define VAR_MAXSPEED
#define VAR_MINGAP_LAT
The vehicle was teleported out of the net.
#define VAR_DECEL
#define VAR_ROUTE_VALID
static double getElectricityConsumption(const std::string &vehicleID)
Definition: Vehicle.cpp:238
#define VAR_PARAMETER
virtual SUMOVehicle * buildVehicle(SUMOVehicleParameter *defs, const MSRoute *route, MSVehicleType *type, const bool ignoreStopErrors, const bool fromRouteFile=true)
Builds a vehicle, increases the number of built vehicles.
#define ID_COUNT
#define VAR_LANE_INDEX
static double getEffort(const std::string &vehicleID, const std::string &edgeID, int time)
Definition: Vehicle.cpp:286
static void setType(const std::string &vehicleID, const std::string &typeID)
Definition: Vehicle.cpp:961
#define VAR_LANE_ID
#define VAR_LINE
MSVehicleType & getSingularType()
Replaces the current vehicle type with a new one used by this vehicle only.
A 3D-position.
Definition: TraCIDefs.h:71
#define RTYPE_ERR
#define TYPE_INTEGER
#define VAR_MINGAP
#define ID_LIST
#define ADD_FULL
void add(SUMOVehicle *veh)
Adds a single vehicle for departure.
static void changeSublane(const std::string &vehicleID, double latDist)
Definition: Vehicle.cpp:747
static double getSpeed(const std::string &vehicleID)
Definition: Vehicle.cpp:100
static int getStopState(const std::string &vehicleID)
Definition: Vehicle.cpp:377
static void parseEdgesList(const std::string &desc, ConstMSEdgeVector &into, const std::string &rid)
Parses the given string assuming it contains a list of edge ids divided by spaces.
Definition: MSEdge.cpp:801
#define VAR_MAXSPEED_LAT
static bool parseDepart(const std::string &val, const std::string &element, const std::string &id, SUMOTime &depart, DepartDefinition &dd, std::string &error)
Validates a given depart value.
#define VAR_DISTANCE
std::vector< std::string > continuationLanes
The sequence of lanes that best allows continuing the route without lane change.
Definition: TraCIDefs.h:203
bool readTypeCheckingByte(tcpip::Storage &inputStorage, int &into)
Reads the value type and a byte, verifying the type.
#define VAR_HCEMISSION
ArrivalPosDefinition arrivalPosProcedure
Information how the vehicle shall choose the arrival position.
std::string id
The vehicle&#39;s id.
static double getAdaptedTraveltime(const std::string &vehicleID, const std::string &edgeID, int time)
Definition: Vehicle.cpp:276
#define VAR_WIDTH
static void rerouteEffort(const std::string &vehicleID)
Definition: Vehicle.cpp:1064
static bool dictionary(const std::string &id, const MSRoute *route)
Adds a route to the dictionary.
Definition: MSRoute.cpp:117
static bool parseDepartLane(const std::string &val, const std::string &element, const std::string &id, int &lane, DepartLaneDefinition &dld, std::string &error)
Validates a given departLane value.
static void setActionStepLength(const std::string &vehicleID, double actionStepLength, bool resetActionOffset=true)
Definition: Vehicle.cpp:1123