TraCIServerAPI_Vehicle.cpp

Go to the documentation of this file.
00001 /****************************************************************************/
00007 // APIs for getting/setting vehicle values via TraCI
00008 /****************************************************************************/
00009 // SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
00010 // Copyright 2001-2010 DLR (http://www.dlr.de/) and contributors
00011 /****************************************************************************/
00012 //
00013 //   This program is free software; you can redistribute it and/or modify
00014 //   it under the terms of the GNU General Public License as published by
00015 //   the Free Software Foundation; either version 2 of the License, or
00016 //   (at your option) any later version.
00017 //
00018 /****************************************************************************/
00019 
00020 
00021 // ===========================================================================
00022 // included modules
00023 // ===========================================================================
00024 #ifdef _MSC_VER
00025 #include <windows_config.h>
00026 #else
00027 #include <config.h>
00028 #endif
00029 
00030 #include <microsim/MSNet.h>
00031 #include <microsim/MSVehicle.h>
00032 #include <microsim/MSLane.h>
00033 #include <microsim/MSEdge.h>
00034 #include <utils/geom/Position2DVector.h>
00035 #include <utils/common/DijkstraRouterTT.h>
00036 #include <utils/common/DijkstraRouterEffort.h>
00037 #include "TraCIConstants.h"
00038 #include "TraCIServerAPIHelper.h"
00039 #include "TraCIServerAPI_Vehicle.h"
00040 #include <utils/common/HelpersHBEFA.h>
00041 #include <utils/common/HelpersHarmonoise.h>
00042 #include <microsim/MSEdgeWeightsStorage.h>
00043 
00044 #ifdef CHECK_MEMORY_LEAKS
00045 #include <foreign/nvwa/debug_new.h>
00046 #endif // CHECK_MEMORY_LEAKS
00047 
00048 
00049 // ===========================================================================
00050 // used namespaces
00051 // ===========================================================================
00052 using namespace std;
00053 using namespace traci;
00054 using namespace tcpip;
00055 
00056 
00057 // ===========================================================================
00058 // method definitions
00059 // ===========================================================================
00060 bool
00061 TraCIServerAPI_Vehicle::processGet(tcpip::Storage &inputStorage,
00062                                    tcpip::Storage &outputStorage,
00063                                    bool withStatus) throw(TraCIException) {
00064     std::string warning = ""; // additional description for response
00065     // variable & id
00066     int variable = inputStorage.readUnsignedByte();
00067     std::string id = inputStorage.readString();
00068     // check variable
00069     if (variable!=ID_LIST&&variable!=VAR_SPEED&&variable!=VAR_SPEED_WITHOUT_TRACI&&variable!=VAR_POSITION&&variable!=VAR_ANGLE
00070             &&variable!=VAR_ROAD_ID&&variable!=VAR_LANE_ID&&variable!=VAR_LANE_INDEX
00071             &&variable!=VAR_TYPE&&variable!=VAR_ROUTE_ID&&variable!=VAR_COLOR
00072             &&variable!=VAR_LANEPOSITION
00073             &&variable!=VAR_CO2EMISSION&&variable!=VAR_COEMISSION&&variable!=VAR_HCEMISSION&&variable!=VAR_PMXEMISSION
00074             &&variable!=VAR_NOXEMISSION&&variable!=VAR_FUELCONSUMPTION&&variable!=VAR_NOISEEMISSION
00075             &&variable!=VAR_EDGE_TRAVELTIME&&variable!=VAR_EDGE_EFFORT
00076             &&variable!=VAR_ROUTE_VALID&&variable!=VAR_EDGES
00077        ) {
00078         TraCIServerAPIHelper::writeStatusCmd(CMD_GET_VEHICLE_VARIABLE, RTYPE_ERR, "Get Vehicle Variable: unsupported variable specified", outputStorage);
00079         return false;
00080     }
00081     // begin response building
00082     Storage tempMsg;
00083     //  response-code, variableID, objectID
00084     tempMsg.writeUnsignedByte(RESPONSE_GET_VEHICLE_VARIABLE);
00085     tempMsg.writeUnsignedByte(variable);
00086     tempMsg.writeString(id);
00087     // process request
00088     if (variable==ID_LIST) {
00089         std::vector<std::string> ids;
00090         MSVehicleControl &c = MSNet::getInstance()->getVehicleControl();
00091         for (MSVehicleControl::constVehIt i=c.loadedVehBegin(); i!=c.loadedVehEnd(); ++i) {
00092             if ((*i).second->isOnRoad()) {
00093                 ids.push_back((*i).first);
00094             }
00095         }
00096         tempMsg.writeUnsignedByte(TYPE_STRINGLIST);
00097         tempMsg.writeStringList(ids);
00098     } else {
00099         MSVehicle *v = MSNet::getInstance()->getVehicleControl().getVehicle(id);
00100         if (v==0) {
00101             TraCIServerAPIHelper::writeStatusCmd(CMD_GET_VEHICLE_VARIABLE, RTYPE_ERR, "Vehicle '" + id + "' is not known", outputStorage);
00102             return false;
00103         }
00104         switch (variable) {
00105         case VAR_SPEED:
00106             tempMsg.writeUnsignedByte(TYPE_FLOAT);
00107             tempMsg.writeFloat(v->getSpeed());
00108             break;
00109         case VAR_SPEED_WITHOUT_TRACI:
00110             tempMsg.writeUnsignedByte(TYPE_FLOAT);
00111             tempMsg.writeFloat(v->getSpeedWithoutTraciInfluence());
00112             break;
00113         case VAR_POSITION:
00114             tempMsg.writeUnsignedByte(TYPE_POSITION2D);
00115             tempMsg.writeFloat(v->getPosition().x());
00116             tempMsg.writeFloat(v->getPosition().y());
00117             break;
00118         case VAR_ANGLE:
00119             tempMsg.writeUnsignedByte(TYPE_FLOAT);
00120             tempMsg.writeFloat(v->getLane().getShape().rotationDegreeAtLengthPosition(v->getPositionOnLane()));
00121             break;
00122         case VAR_ROAD_ID:
00123             tempMsg.writeUnsignedByte(TYPE_STRING);
00124             tempMsg.writeString(v->getLane().getEdge().getID());
00125             break;
00126         case VAR_LANE_ID:
00127             tempMsg.writeUnsignedByte(TYPE_STRING);
00128             tempMsg.writeString(v->getLane().getID());
00129             break;
00130         case VAR_LANE_INDEX: {
00131             const std::vector<MSLane*> &lanes = v->getLane().getEdge().getLanes();
00132             tempMsg.writeUnsignedByte(TYPE_INTEGER);
00133             tempMsg.writeInt((int)(std::distance(lanes.begin(), std::find(lanes.begin(), lanes.end(), &v->getLane()))));
00134         }
00135         break;
00136         case VAR_TYPE:
00137             tempMsg.writeUnsignedByte(TYPE_STRING);
00138             tempMsg.writeString(v->getVehicleType().getID());
00139             break;
00140         case VAR_ROUTE_ID:
00141             tempMsg.writeUnsignedByte(TYPE_STRING);
00142             tempMsg.writeString(v->getRoute().getID());
00143             break;
00144         case VAR_COLOR:
00145             tempMsg.writeUnsignedByte(TYPE_COLOR);
00146             tempMsg.writeUnsignedByte((int)(v->getParameter().color.red()*255.));
00147             tempMsg.writeUnsignedByte((int)(v->getParameter().color.green()*255.));
00148             tempMsg.writeUnsignedByte((int)(v->getParameter().color.blue()*255.));
00149             tempMsg.writeUnsignedByte(255);
00150             break;
00151         case VAR_LANEPOSITION:
00152             tempMsg.writeUnsignedByte(TYPE_FLOAT);
00153             tempMsg.writeFloat(v->getPositionOnLane());
00154             break;
00155         case VAR_CO2EMISSION:
00156             tempMsg.writeUnsignedByte(TYPE_FLOAT);
00157             tempMsg.writeFloat(HelpersHBEFA::computeCO2(v->getVehicleType().getEmissionClass(), v->getSpeed(), v->getPreDawdleAcceleration()));
00158             break;
00159         case VAR_COEMISSION:
00160             tempMsg.writeUnsignedByte(TYPE_FLOAT);
00161             tempMsg.writeFloat(HelpersHBEFA::computeCO(v->getVehicleType().getEmissionClass(), v->getSpeed(), v->getPreDawdleAcceleration()));
00162             break;
00163         case VAR_HCEMISSION:
00164             tempMsg.writeUnsignedByte(TYPE_FLOAT);
00165             tempMsg.writeFloat(HelpersHBEFA::computeHC(v->getVehicleType().getEmissionClass(), v->getSpeed(), v->getPreDawdleAcceleration()));
00166             break;
00167         case VAR_PMXEMISSION:
00168             tempMsg.writeUnsignedByte(TYPE_FLOAT);
00169             tempMsg.writeFloat(HelpersHBEFA::computePMx(v->getVehicleType().getEmissionClass(), v->getSpeed(), v->getPreDawdleAcceleration()));
00170             break;
00171         case VAR_NOXEMISSION:
00172             tempMsg.writeUnsignedByte(TYPE_FLOAT);
00173             tempMsg.writeFloat(HelpersHBEFA::computeNOx(v->getVehicleType().getEmissionClass(), v->getSpeed(), v->getPreDawdleAcceleration()));
00174             break;
00175         case VAR_FUELCONSUMPTION:
00176             tempMsg.writeUnsignedByte(TYPE_FLOAT);
00177             tempMsg.writeFloat(HelpersHBEFA::computeFuel(v->getVehicleType().getEmissionClass(), v->getSpeed(), v->getPreDawdleAcceleration()));
00178             break;
00179         case VAR_NOISEEMISSION:
00180             tempMsg.writeUnsignedByte(TYPE_FLOAT);
00181             tempMsg.writeFloat(HelpersHarmonoise::computeNoise(v->getVehicleType().getEmissionClass(), v->getSpeed(), v->getPreDawdleAcceleration()));
00182             break;
00183         case VAR_EDGE_TRAVELTIME: {
00184             if (inputStorage.readUnsignedByte()!=TYPE_COMPOUND) {
00185                 TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Retrieval of travel time requires a compund object.", outputStorage);
00186                 return false;
00187             }
00188             if (inputStorage.readInt()!=2) {
00189                 TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Retrieval of travel time requires time, and edge as parameter.", outputStorage);
00190                 return false;
00191             }
00192             // time
00193             if (inputStorage.readUnsignedByte()!=TYPE_INTEGER) {
00194                 TraCIServerAPIHelper::writeStatusCmd(CMD_GET_VEHICLE_VARIABLE, RTYPE_ERR, "Retrieval of travel time requires the referenced time as first parameter.", outputStorage);
00195                 return false;
00196             }
00197             SUMOTime time = inputStorage.readInt();
00198             // edge
00199             if (inputStorage.readUnsignedByte()!=TYPE_STRING) {
00200                 TraCIServerAPIHelper::writeStatusCmd(CMD_GET_VEHICLE_VARIABLE, RTYPE_ERR, "Retrieval of travel time requires the referenced edge as second parameter.", outputStorage);
00201                 return false;
00202             }
00203             std::string edgeID = inputStorage.readString();
00204             MSEdge *edge = MSEdge::dictionary(edgeID);
00205             if (edge==0) {
00206                 TraCIServerAPIHelper::writeStatusCmd(CMD_GET_VEHICLE_VARIABLE, RTYPE_ERR, "Referenced edge '" + edgeID + "' is not known.", outputStorage);
00207                 return false;
00208             }
00209             // retrieve
00210             tempMsg.writeUnsignedByte(TYPE_FLOAT);
00211             SUMOReal value;
00212             if (!v->getWeightsStorage().retrieveExistingTravelTime(edge, 0, time, value)) {
00213                 tempMsg.writeFloat(-1);
00214             } else {
00215                 tempMsg.writeFloat(value);
00216             }
00217 
00218         }
00219         break;
00220         case VAR_EDGE_EFFORT: {
00221             if (inputStorage.readUnsignedByte()!=TYPE_COMPOUND) {
00222                 TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Retrieval of travel time requires a compund object.", outputStorage);
00223                 return false;
00224             }
00225             if (inputStorage.readInt()!=2) {
00226                 TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Retrieval of travel time requires time, and edge as parameter.", outputStorage);
00227                 return false;
00228             }
00229             // time
00230             if (inputStorage.readUnsignedByte()!=TYPE_INTEGER) {
00231                 TraCIServerAPIHelper::writeStatusCmd(CMD_GET_VEHICLE_VARIABLE, RTYPE_ERR, "Retrieval of effort requires the referenced time as first parameter.", outputStorage);
00232                 return false;
00233             }
00234             SUMOTime time = inputStorage.readInt();
00235             // edge
00236             if (inputStorage.readUnsignedByte()!=TYPE_STRING) {
00237                 TraCIServerAPIHelper::writeStatusCmd(CMD_GET_VEHICLE_VARIABLE, RTYPE_ERR, "Retrieval of effort requires the referenced edge as second parameter.", outputStorage);
00238                 return false;
00239             }
00240             std::string edgeID = inputStorage.readString();
00241             MSEdge *edge = MSEdge::dictionary(edgeID);
00242             if (edge==0) {
00243                 TraCIServerAPIHelper::writeStatusCmd(CMD_GET_VEHICLE_VARIABLE, RTYPE_ERR, "Referenced edge '" + edgeID + "' is not known.", outputStorage);
00244                 return false;
00245             }
00246             // retrieve
00247             tempMsg.writeUnsignedByte(TYPE_FLOAT);
00248             SUMOReal value;
00249             if (!v->getWeightsStorage().retrieveExistingEffort(edge, 0, time, value)) {
00250                 tempMsg.writeFloat(-1);
00251             } else {
00252                 tempMsg.writeFloat(value);
00253             }
00254 
00255         }
00256         break;
00257         case VAR_ROUTE_VALID: {
00258             std::string msg;
00259             if (!v->hasValidRoute(msg)) {
00260                 TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, msg, outputStorage);
00261                 return false;
00262             }
00263             tempMsg.writeUnsignedByte(TYPE_UBYTE);
00264             tempMsg.writeUnsignedByte(1);
00265         }
00266         break;
00267         case VAR_EDGES: {
00268             const MSRoute &r = v->getRoute();
00269             tempMsg.writeUnsignedByte(TYPE_STRINGLIST);
00270             tempMsg.writeInt(r.size());
00271             for (MSRouteIterator i=r.begin(); i!=r.end(); ++i) {
00272                 tempMsg.writeString((*i)->getID());
00273             }
00274         }
00275         break;
00276         default:
00277             break;
00278         }
00279     }
00280     if (withStatus) {
00281         TraCIServerAPIHelper::writeStatusCmd(CMD_GET_VEHICLE_VARIABLE, RTYPE_OK, warning, outputStorage);
00282     }
00283     // send response
00284     outputStorage.writeUnsignedByte(0); // command length -> extended
00285     outputStorage.writeInt(1 + 4 + tempMsg.size());
00286     outputStorage.writeStorage(tempMsg);
00287     return true;
00288 }
00289 
00290 
00291 bool
00292 TraCIServerAPI_Vehicle::processSet(tcpip::Storage &inputStorage,
00293                                    tcpip::Storage &outputStorage) throw(TraCIException) {
00294     std::string warning = ""; // additional description for response
00295     // variable
00296     int variable = inputStorage.readUnsignedByte();
00297     if (variable!=CMD_SETMAXSPEED&&variable!=CMD_STOP&&variable!=CMD_CHANGELANE
00298             &&variable!=CMD_SLOWDOWN&&/*variable!=CMD_CHANGEROUTE&&*/variable!=CMD_CHANGETARGET
00299             &&variable!=VAR_ROUTE_ID&&variable!=VAR_ROUTE
00300             &&variable!=VAR_EDGE_TRAVELTIME&&variable!=VAR_EDGE_EFFORT
00301             &&variable!=CMD_REROUTE_TRAVELTIME&&variable!=CMD_REROUTE_EFFORT
00302        ) {
00303         TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Change Vehicle State: unsupported variable specified", outputStorage);
00304         return false;
00305     }
00306     // id
00307     std::string id = inputStorage.readString();
00308     MSVehicle *v = MSNet::getInstance()->getVehicleControl().getVehicle(id);
00309     if (v==0) {
00310         TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Vehicle '" + id + "' is not known", outputStorage);
00311         return false;
00312     }
00313     // process
00314     int valueDataType = inputStorage.readUnsignedByte();
00315     switch (variable) {
00316     case CMD_SETMAXSPEED: {
00317         if (valueDataType!=TYPE_FLOAT) {
00318             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "The speed must be given as a float.", outputStorage);
00319             return false;
00320         }
00321         SUMOReal maxspeed = inputStorage.readFloat();
00322         if (maxspeed>=0.0) {
00323             v->setIndividualMaxSpeed(maxspeed);
00324         } else {
00325             v->unsetIndividualMaxSpeed();
00326         }
00327     }
00328     break;
00329     case CMD_STOP: {
00330         if (valueDataType!=TYPE_COMPOUND) {
00331             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Stop needs a compound object description.", outputStorage);
00332             return false;
00333         }
00334         if (inputStorage.readInt()!=4) {
00335             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Stop needs a compound object description of four items.", outputStorage);
00336             return false;
00337         }
00338         // read road map position
00339         valueDataType = inputStorage.readUnsignedByte();
00340         if (valueDataType!=TYPE_STRING) {
00341             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "The first stop parameter must be the edge id given as a string.", outputStorage);
00342             return false;
00343         }
00344         std::string roadId = inputStorage.readString();
00345         valueDataType = inputStorage.readUnsignedByte();
00346         if (valueDataType!=TYPE_FLOAT) {
00347             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "The second stop parameter must be the position along the edge given as a float.", outputStorage);
00348             return false;
00349         }
00350         SUMOReal pos = inputStorage.readFloat();
00351         valueDataType = inputStorage.readUnsignedByte();
00352         if (valueDataType!=TYPE_BYTE) {
00353             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "The third stop parameter must be the lane index given as a byte.", outputStorage);
00354             return false;
00355         }
00356         char laneIndex = inputStorage.readByte();
00357         // waitTime
00358         valueDataType = inputStorage.readUnsignedByte();
00359         if (valueDataType!=TYPE_INTEGER) {
00360             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "The fourth stop parameter must be the waiting time given as an integer.", outputStorage);
00361             return false;
00362         }
00363         SUMOTime waitTime = inputStorage.readInt();
00364         // check
00365         if (pos < 0) {
00366             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Position on lane must not be negative", outputStorage);
00367             return false;
00368         }
00369         // get the actual lane that is referenced by laneIndex
00370         MSEdge* road = MSEdge::dictionary(roadId);
00371         if (road == 0) {
00372             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Unable to retrieve road with given id", outputStorage);
00373             return false;
00374         }
00375         const std::vector<MSLane*> &allLanes = road->getLanes();
00376         if (laneIndex >= allLanes.size()) {
00377             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "No lane existing with such id on the given road", outputStorage);
00378             return false;
00379         }
00380         // Forward command to vehicle
00381         if (!v->addTraciStop(allLanes[laneIndex], pos, 0, waitTime)) {
00382             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Vehicle is too close or behind the stop on " + allLanes[laneIndex]->getID(), outputStorage);
00383             return false;
00384         }
00385     }
00386     break;
00387     case CMD_CHANGELANE: {
00388         if (valueDataType!=TYPE_COMPOUND) {
00389             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Lane change needs a compound object description.", outputStorage);
00390             return false;
00391         }
00392         if (inputStorage.readInt()!=2) {
00393             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Lane change needs a compound object description of two items.", outputStorage);
00394             return false;
00395         }
00396         // Lane ID
00397         valueDataType = inputStorage.readUnsignedByte();
00398         if (valueDataType!=TYPE_BYTE) {
00399             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "The first lane change parameter must be the lane index given as a byte.", outputStorage);
00400             return false;
00401         }
00402         char laneIndex = inputStorage.readByte();
00403         // stickyTime
00404         valueDataType = inputStorage.readUnsignedByte();
00405         if (valueDataType!=TYPE_INTEGER) {
00406             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "The second lane change parameter must be the duration given as an integer.", outputStorage);
00407             return false;
00408         }
00409         SUMOTime stickyTime = inputStorage.readInt();
00410         if ((laneIndex < 0) || (laneIndex >= v->getEdge()->getLanes().size())) {
00411             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "No lane existing with given id on the current road", outputStorage);
00412             return false;
00413         }
00414         // Forward command to vehicle
00415         v->startLaneChange(static_cast<unsigned>(laneIndex), static_cast<SUMOTime>(stickyTime));
00416     }
00417     break;
00418     case CMD_SLOWDOWN: {
00419         if (valueDataType!=TYPE_COMPOUND) {
00420             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Slow down needs a compound object description.", outputStorage);
00421             return false;
00422         }
00423         if (inputStorage.readInt()!=2) {
00424             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Slow down needs a compound object description of two items.", outputStorage);
00425             return false;
00426         }
00427         valueDataType = inputStorage.readUnsignedByte();
00428         if (valueDataType!=TYPE_FLOAT) {
00429             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "The first slow down parameter must be the speed given as a float.", outputStorage);
00430             return false;
00431         }
00432         SUMOReal newSpeed = MAX2(inputStorage.readFloat(), 0.0f);
00433         valueDataType = inputStorage.readUnsignedByte();
00434         if (valueDataType!=TYPE_INTEGER) {
00435             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "The second slow down parameter must be the duration given as an integer.", outputStorage);
00436             return false;
00437         }
00438         SUMOTime duration = inputStorage.readInt();
00439         if (duration <= 0) {
00440             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Invalid time interval", outputStorage);
00441             return false;
00442         }
00443         if (!v->startSpeedAdaption(newSpeed, static_cast<SUMOTime>(duration), MSNet::getInstance()->getCurrentTimeStep())) {
00444             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Could not slow down", outputStorage);
00445             return false;
00446         }
00447     }
00448     break;
00449     case CMD_CHANGEROUTE:
00450         break;
00451     case CMD_CHANGETARGET: {
00452         if (valueDataType!=TYPE_STRING) {
00453             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Change target requires a std::string containing the id of the new destination edge as parameter.", outputStorage);
00454             return false;
00455         }
00456         std::string edgeID = inputStorage.readString();
00457         const MSEdge* destEdge = MSEdge::dictionary(edgeID);
00458         if (destEdge == 0) {
00459             TraCIServerAPIHelper::writeStatusCmd(CMD_CHANGETARGET, RTYPE_ERR, "Can not retrieve road with ID " + edgeID, outputStorage);
00460             return false;
00461         }
00462         // build a new route between the vehicle's current edge and destination edge
00463         MSEdgeVector newRoute;
00464         const MSEdge* currentEdge = v->getEdge();
00465         MSEdgeWeightsStorage empty;
00466         MSNet::EdgeWeightsProxi proxi(empty, MSNet::getInstance()->getWeightsStorage());
00467         DijkstraRouterTT_ByProxi<MSEdge, SUMOVehicle, prohibited_withRestrictions<MSEdge, SUMOVehicle>, MSNet::EdgeWeightsProxi> router(MSEdge::dictSize(), true, &proxi, &MSNet::EdgeWeightsProxi::getTravelTime);
00468         router.compute(currentEdge, destEdge, (const MSVehicle* const) v, MSNet::getInstance()->getCurrentTimeStep(), newRoute);
00469         // replace the vehicle's route by the new one
00470         if (!v->replaceRoute(newRoute, MSNet::getInstance()->getCurrentTimeStep())) {
00471             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Route replacement failed for " + v->getID(), outputStorage);
00472             return false;
00473         }
00474     }
00475     break;
00476     case VAR_ROUTE_ID: {
00477         if (valueDataType!=TYPE_STRING) {
00478             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "The route id must be given as a string.", outputStorage);
00479             return false;
00480         }
00481         std::string rid = inputStorage.readString();
00482         const MSRoute *r = MSRoute::dictionary(rid);
00483         if (r==0) {
00484             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "The route '" + rid + "' is not known.", outputStorage);
00485             return false;
00486         }
00487         if (!v->replaceRoute(r->getEdges(), MSNet::getInstance()->getCurrentTimeStep())) {
00488             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Route replacement failed for " + v->getID(), outputStorage);
00489             return false;
00490         }
00491     }
00492     break;
00493     case VAR_ROUTE: {
00494         if (valueDataType!=TYPE_STRINGLIST) {
00495             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "A route must be defined as a list of edge ids.", outputStorage);
00496             return false;
00497         }
00498         std::vector<std::string> edgeIDs = inputStorage.readStringList();
00499         std::vector<const MSEdge*> edges;
00500         MSEdge::parseEdgesList(edgeIDs, edges, "<unknown>");
00501         if (!v->replaceRoute(edges, MSNet::getInstance()->getCurrentTimeStep())) {
00502             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Route replacement failed for " + v->getID(), outputStorage);
00503             return false;
00504         }
00505     }
00506     break;
00507     case VAR_EDGE_TRAVELTIME: {
00508         if (valueDataType!=TYPE_COMPOUND) {
00509             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Setting travel time requires a compund object.", outputStorage);
00510             return false;
00511         }
00512         if (inputStorage.readInt()!=4) {
00513             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Setting travel time requires begin time, end time, edge, and value as parameter.", outputStorage);
00514             return false;
00515         }
00516         // begin time
00517         if (inputStorage.readUnsignedByte()!=TYPE_INTEGER) {
00518             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Setting travel time requires the begin time as first parameter.", outputStorage);
00519             return false;
00520         }
00521         SUMOTime begTime = inputStorage.readInt();
00522         // begin time
00523         if (inputStorage.readUnsignedByte()!=TYPE_INTEGER) {
00524             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Setting travel time requires the end time as second parameter.", outputStorage);
00525             return false;
00526         }
00527         SUMOTime endTime = inputStorage.readInt();
00528         // edge
00529         if (inputStorage.readUnsignedByte()!=TYPE_STRING) {
00530             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Setting travel time requires the referenced edge as third parameter.", outputStorage);
00531             return false;
00532         }
00533         std::string edgeID = inputStorage.readString();
00534         MSEdge *edge = MSEdge::dictionary(edgeID);
00535         if (edge==0) {
00536             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Referenced edge '" + edgeID + "' is not known.", outputStorage);
00537             return false;
00538         }
00539         // value
00540         if (inputStorage.readUnsignedByte()!=TYPE_FLOAT) {
00541             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Setting travel time requires the travel time as fourth parameter.", outputStorage);
00542             return false;
00543         }
00544         SUMOReal value = inputStorage.readFloat();
00545         // retrieve
00546         v->getWeightsStorage().addTravelTime(edge, begTime, endTime, value);
00547     }
00548     break;
00549     case VAR_EDGE_EFFORT: {
00550         if (valueDataType!=TYPE_COMPOUND) {
00551             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Setting effort requires a compund object.", outputStorage);
00552             return false;
00553         }
00554         if (inputStorage.readInt()!=4) {
00555             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Setting effort requires begin time, end time, edge, and value as parameter.", outputStorage);
00556             return false;
00557         }
00558         // begin time
00559         if (inputStorage.readUnsignedByte()!=TYPE_INTEGER) {
00560             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Setting effort requires the begin time as first parameter.", outputStorage);
00561             return false;
00562         }
00563         SUMOTime begTime = inputStorage.readInt();
00564         // begin time
00565         if (inputStorage.readUnsignedByte()!=TYPE_INTEGER) {
00566             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Setting effort requires the end time as second parameter.", outputStorage);
00567             return false;
00568         }
00569         SUMOTime endTime = inputStorage.readInt();
00570         // edge
00571         if (inputStorage.readUnsignedByte()!=TYPE_STRING) {
00572             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Setting effort requires the referenced edge as third parameter.", outputStorage);
00573             return false;
00574         }
00575         std::string edgeID = inputStorage.readString();
00576         MSEdge *edge = MSEdge::dictionary(edgeID);
00577         if (edge==0) {
00578             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Referenced edge '" + edgeID + "' is not known.", outputStorage);
00579             return false;
00580         }
00581         // value
00582         if (inputStorage.readUnsignedByte()!=TYPE_FLOAT) {
00583             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Setting effort requires the travel time as fourth parameter.", outputStorage);
00584             return false;
00585         }
00586         SUMOReal value = inputStorage.readFloat();
00587         // retrieve
00588         v->getWeightsStorage().addEffort(edge, begTime, endTime, value);
00589     }
00590     break;
00591     case CMD_REROUTE_TRAVELTIME: {
00592         if (valueDataType!=TYPE_COMPOUND) {
00593             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Rerouting requires a compund object.", outputStorage);
00594             return false;
00595         }
00596         if (inputStorage.readInt()!=0) {
00597             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Rerouting should obtain an empty compund object.", outputStorage);
00598             return false;
00599         }
00600         MSNet::EdgeWeightsProxi proxi(v->getWeightsStorage(), MSNet::getInstance()->getWeightsStorage());
00601         DijkstraRouterTT_ByProxi<MSEdge, SUMOVehicle, prohibited_withRestrictions<MSEdge, SUMOVehicle>, MSNet::EdgeWeightsProxi> router(MSEdge::dictSize(), true, &proxi, &MSNet::EdgeWeightsProxi::getTravelTime);
00602         v->reroute(MSNet::getInstance()->getCurrentTimeStep(), router);
00603     }
00604     break;
00605     case CMD_REROUTE_EFFORT: {
00606         if (valueDataType!=TYPE_COMPOUND) {
00607             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Rerouting requires a compund object.", outputStorage);
00608             return false;
00609         }
00610         if (inputStorage.readInt()!=0) {
00611             TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Rerouting should obtain an empty compund object.", outputStorage);
00612             return false;
00613         }
00614         MSNet::EdgeWeightsProxi proxi(v->getWeightsStorage(), MSNet::getInstance()->getWeightsStorage());
00615         DijkstraRouterEffort_ByProxi<MSEdge, SUMOVehicle, prohibited_withRestrictions<MSEdge, SUMOVehicle>, MSNet::EdgeWeightsProxi> router(MSEdge::dictSize(), true, &proxi, &MSNet::EdgeWeightsProxi::getEffort, &MSNet::EdgeWeightsProxi::getTravelTime);
00616         v->reroute(MSNet::getInstance()->getCurrentTimeStep(), router);
00617     }
00618     break;
00619     default:
00620         break;
00621     }
00622     TraCIServerAPIHelper::writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_OK, warning, outputStorage);
00623     return true;
00624 }
00625 
00626 
00627 
00628 /****************************************************************************/
00629