TraCIServerAPI_Vehicle Class Reference

#include <TraCIServerAPI_Vehicle.h>

Detailed Description

APIs for getting/setting vehicle values via TraCI.

Definition at line 44 of file TraCIServerAPI_Vehicle.h.


Static Public Member Functions
static bool	processGet (tcpip::Storage &inputStorage, tcpip::Storage &outputStorage, bool withStatus=true) throw (traci::TraCIException)
	Processes a get value command (Command 0xa4: Get Vehicle Variable).
static bool	processSet (tcpip::Storage &inputStorage, tcpip::Storage &outputStorage) throw (traci::TraCIException)
	Processes a set value command (Command 0xc4: Change Vehicle State).
Private Member Functions
TraCIServerAPI_Vehicle &	operator= (const TraCIServerAPI_Vehicle &s)
	invalidated assignment operator
	TraCIServerAPI_Vehicle (const TraCIServerAPI_Vehicle &s)
	invalidated copy constructor

Constructor & Destructor Documentation

TraCIServerAPI_Vehicle::TraCIServerAPI_Vehicle ( const TraCIServerAPI_Vehicle & s ) [private]

invalidated copy constructor

Member Function Documentation

TraCIServerAPI_Vehicle& TraCIServerAPI_Vehicle::operator= ( const TraCIServerAPI_Vehicle & s ) [private]

invalidated assignment operator

bool TraCIServerAPI_Vehicle::processGet	(	tcpip::Storage &	inputStorage,
		tcpip::Storage &	outputStorage,
		bool	withStatus = `true`
	)			throw (traci::TraCIException) `[static]`

Processes a get value command (Command 0xa4: Get Vehicle Variable).

Parameters:

`[in]`	inputStorage	The storage to read the command from
`[out]`	outputStorage	The storage to write the result to
`[in]`	withStatus	Whether the status message shall be written (not in subscription)

Definition at line 61 of file TraCIServerAPI_Vehicle.cpp.

References MSRoute::begin(), RGBColor::blue(), CMD_GET_VEHICLE_VARIABLE, CMD_SET_VEHICLE_VARIABLE, SUMOVehicleParameter::color, HelpersHBEFA::computeCO(), HelpersHBEFA::computeCO2(), HelpersHBEFA::computeFuel(), HelpersHBEFA::computeHC(), HelpersHarmonoise::computeNoise(), HelpersHBEFA::computeNOx(), HelpersHBEFA::computePMx(), MSEdge::dictionary(), MSRoute::end(), MSLane::getEdge(), MSVehicleType::getEmissionClass(), Named::getID(), MSVehicleType::getID(), MSLane::getID(), MSEdge::getID(), MSNet::getInstance(), MSVehicle::getLane(), MSEdge::getLanes(), MSVehicle::getParameter(), MSVehicle::getPosition(), MSVehicle::getPositionOnLane(), MSVehicle::getPreDawdleAcceleration(), MSVehicle::getRoute(), MSLane::getShape(), MSVehicle::getSpeed(), MSVehicle::getSpeedWithoutTraciInfluence(), MSVehicleControl::getVehicle(), MSNet::getVehicleControl(), MSVehicle::getVehicleType(), MSVehicle::getWeightsStorage(), RGBColor::green(), MSVehicle::hasValidRoute(), ID_LIST, MSVehicleControl::loadedVehBegin(), MSVehicleControl::loadedVehEnd(), RGBColor::red(), RESPONSE_GET_VEHICLE_VARIABLE, MSEdgeWeightsStorage::retrieveExistingEffort(), MSEdgeWeightsStorage::retrieveExistingTravelTime(), Position2DVector::rotationDegreeAtLengthPosition(), RTYPE_ERR, RTYPE_OK, tcpip::Storage::size(), MSRoute::size(), SUMOReal, TYPE_COLOR, TYPE_COMPOUND, TYPE_FLOAT, TYPE_INTEGER, TYPE_POSITION2D, TYPE_STRING, TYPE_STRINGLIST, TYPE_UBYTE, VAR_ANGLE, VAR_CO2EMISSION, VAR_COEMISSION, VAR_COLOR, VAR_EDGE_EFFORT, VAR_EDGE_TRAVELTIME, VAR_EDGES, VAR_FUELCONSUMPTION, VAR_HCEMISSION, VAR_LANE_ID, VAR_LANE_INDEX, VAR_LANEPOSITION, VAR_NOISEEMISSION, VAR_NOXEMISSION, VAR_PMXEMISSION, VAR_POSITION, VAR_ROAD_ID, VAR_ROUTE_ID, VAR_ROUTE_VALID, VAR_SPEED, VAR_SPEED_WITHOUT_TRACI, VAR_TYPE, tcpip::Storage::writeFloat(), tcpip::Storage::writeInt(), TraCIServerAPIHelper::writeStatusCmd(), tcpip::Storage::writeString(), tcpip::Storage::writeStringList(), tcpip::Storage::writeUnsignedByte(), Position2D::x(), and Position2D::y().

Referenced by traci::TraCIServer::dispatchCommand(), and traci::TraCIServer::processSingleSubscription().

00063                                                                           {
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 }

bool TraCIServerAPI_Vehicle::processSet	(	tcpip::Storage &	inputStorage,
		tcpip::Storage &	outputStorage
	)			throw (traci::TraCIException) `[static]`

Processes a set value command (Command 0xc4: Change Vehicle State).

Parameters:

`[in]`	inputStorage	The storage to read the command from
`[out]`	outputStorage	The storage to write the result to

Definition at line 292 of file TraCIServerAPI_Vehicle.cpp.

References MSEdgeWeightsStorage::addEffort(), MSVehicle::addTraciStop(), MSEdgeWeightsStorage::addTravelTime(), CMD_CHANGELANE, CMD_CHANGEROUTE, CMD_CHANGETARGET, CMD_REROUTE_EFFORT, CMD_REROUTE_TRAVELTIME, CMD_SET_VEHICLE_VARIABLE, CMD_SETMAXSPEED, CMD_SLOWDOWN, CMD_STOP, DijkstraRouterTTBase< E, V, PF >::compute(), MSRoute::dictionary(), MSEdge::dictionary(), MSEdge::dictSize(), MSNet::getCurrentTimeStep(), MSVehicle::getEdge(), MSRoute::getEdges(), MSNet::EdgeWeightsProxi::getEffort(), MSVehicle::getID(), MSNet::getInstance(), MSEdge::getLanes(), MSNet::EdgeWeightsProxi::getTravelTime(), MSVehicleControl::getVehicle(), MSNet::getVehicleControl(), MSNet::getWeightsStorage(), MSVehicle::getWeightsStorage(), MAX2(), MSEdge::parseEdgesList(), MSVehicle::replaceRoute(), MSVehicle::reroute(), RTYPE_ERR, RTYPE_OK, MSVehicle::setIndividualMaxSpeed(), MSVehicle::startLaneChange(), MSVehicle::startSpeedAdaption(), SUMOReal, TYPE_BYTE, TYPE_COMPOUND, TYPE_FLOAT, TYPE_INTEGER, TYPE_STRING, TYPE_STRINGLIST, MSVehicle::unsetIndividualMaxSpeed(), VAR_EDGE_EFFORT, VAR_EDGE_TRAVELTIME, VAR_ROUTE, VAR_ROUTE_ID, and TraCIServerAPIHelper::writeStatusCmd().

Referenced by traci::TraCIServer::dispatchCommand().

00293                                                                                       {
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 }

The documentation for this class was generated from the following files:

TraCIServerAPI_Vehicle Class Reference

Detailed Description

Static Public Member Functions

Private Member Functions

Constructor & Destructor Documentation

Member Function Documentation