Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
4 : // This program and the accompanying materials are made available under the
5 : // terms of the Eclipse Public License 2.0 which is available at
6 : // https://www.eclipse.org/legal/epl-2.0/
7 : // This Source Code may also be made available under the following Secondary
8 : // Licenses when the conditions for such availability set forth in the Eclipse
9 : // Public License 2.0 are satisfied: GNU General Public License, version 2
10 : // or later which is available at
11 : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 : /****************************************************************************/
14 : /// @file TraCIServerAPI_VehicleType.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Jakob Erdmann
17 : /// @author Michael Behrisch
18 : /// @author Laura Bieker
19 : /// @author Robert Hilbrich
20 : /// @author Gregor Laemmel
21 : /// @date 07.05.2009
22 : ///
23 : // APIs for getting/setting vehicle type values via TraCI
24 : /****************************************************************************/
25 : #include <config.h>
26 :
27 : #include <limits>
28 : #include <utils/emissions/PollutantsInterface.h>
29 : #include <microsim/MSNet.h>
30 : #include <microsim/MSVehicleType.h>
31 : #include <libsumo/TraCIConstants.h>
32 : #include <libsumo/VehicleType.h>
33 : #include "TraCIServerAPI_VehicleType.h"
34 :
35 :
36 : // ===========================================================================
37 : // method definitions
38 : // ===========================================================================
39 : bool
40 2878 : TraCIServerAPI_VehicleType::processGet(TraCIServer& server, tcpip::Storage& inputStorage,
41 : tcpip::Storage& outputStorage) {
42 2878 : const int variable = inputStorage.readUnsignedByte();
43 2878 : const std::string id = inputStorage.readString();
44 2878 : server.initWrapper(libsumo::RESPONSE_GET_VEHICLETYPE_VARIABLE, variable, id);
45 : try {
46 2878 : if (!libsumo::VehicleType::handleVariable(id, variable, &server, &inputStorage)) {
47 2 : return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLETYPE_VARIABLE,
48 4 : "Get Vehicle Type Variable: unsupported variable " + toHex(variable, 2)
49 4 : + " specified", outputStorage);
50 : }
51 2 : } catch (libsumo::TraCIException& e) {
52 2 : return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLETYPE_VARIABLE, e.what(), outputStorage);
53 2 : }
54 2874 : server.writeStatusCmd(libsumo::CMD_GET_VEHICLETYPE_VARIABLE, libsumo::RTYPE_OK, "", outputStorage);
55 2874 : server.writeResponseWithLength(outputStorage, server.getWrapperStorage());
56 : return true;
57 : }
58 :
59 :
60 : bool
61 233 : TraCIServerAPI_VehicleType::processSet(TraCIServer& server, tcpip::Storage& inputStorage,
62 : tcpip::Storage& outputStorage) {
63 233 : std::string warning = ""; // additional description for response
64 : // variable
65 233 : int variable = inputStorage.readUnsignedByte();
66 233 : if (variable != libsumo::VAR_LENGTH && variable != libsumo::VAR_MAXSPEED && variable != libsumo::VAR_VEHICLECLASS
67 215 : && variable != libsumo::VAR_SPEED_FACTOR && variable != libsumo::VAR_SPEED_DEVIATION && variable != libsumo::VAR_EMISSIONCLASS
68 196 : && variable != libsumo::VAR_WIDTH && variable != libsumo::VAR_MINGAP && variable != libsumo::VAR_SHAPECLASS
69 181 : && variable != libsumo::VAR_ACCEL && variable != libsumo::VAR_IMPERFECTION
70 164 : && variable != libsumo::VAR_DECEL && variable != libsumo::VAR_EMERGENCY_DECEL && variable != libsumo::VAR_APPARENT_DECEL
71 126 : && variable != libsumo::VAR_TAU && variable != libsumo::VAR_COLOR && variable != libsumo::VAR_ACTIONSTEPLENGTH
72 114 : && variable != libsumo::VAR_SCALE
73 : && variable != libsumo::VAR_HEIGHT
74 100 : && variable != libsumo::VAR_MINGAP_LAT
75 : && variable != libsumo::VAR_MAXSPEED_LAT
76 90 : && variable != libsumo::VAR_LATALIGNMENT
77 80 : && variable != libsumo::VAR_BOARDING_DURATION
78 80 : && variable != libsumo::VAR_IMPATIENCE
79 72 : && variable != libsumo::VAR_PARAMETER
80 72 : && variable != libsumo::COPY
81 : ) {
82 0 : return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLETYPE_VARIABLE,
83 0 : "Change Vehicle Type State: unsupported variable " + toHex(variable, 2)
84 0 : + " specified", outputStorage);
85 : }
86 : // id
87 233 : std::string id = inputStorage.readString();
88 : // MSVehicleType* v = libsumo::VehicleType::getVType(id);
89 : // if (v == 0) {
90 : // return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, "Vehicle type '" + id + "' is not known",
91 : // outputStorage);
92 : // }
93 : // process
94 : try {
95 233 : if (setVariable(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, variable, id, server, inputStorage, outputStorage)) {
96 221 : server.writeStatusCmd(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, libsumo::RTYPE_OK, warning, outputStorage);
97 : return true;
98 : }
99 12 : } catch (ProcessError& e) {
100 0 : return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, e.what(), outputStorage);
101 12 : } catch (libsumo::TraCIException& e) {
102 12 : return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, e.what(), outputStorage);
103 12 : }
104 : return false;
105 : }
106 :
107 :
108 : bool
109 519 : TraCIServerAPI_VehicleType::setVariable(const int cmd, const int variable,
110 : const std::string& id, TraCIServer& server,
111 : tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) {
112 519 : switch (variable) {
113 97 : case libsumo::VAR_LENGTH: {
114 97 : double value = 0;
115 97 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
116 0 : return server.writeErrorStatusCmd(cmd, "Setting length requires a double.", outputStorage);
117 : }
118 97 : if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
119 0 : return server.writeErrorStatusCmd(cmd, "Invalid length.", outputStorage);
120 : }
121 97 : libsumo::VehicleType::setLength(id, value);
122 : }
123 97 : break;
124 16 : case libsumo::VAR_HEIGHT: {
125 16 : double value = 0;
126 16 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
127 0 : return server.writeErrorStatusCmd(cmd, "Setting height requires a double.", outputStorage);
128 : }
129 16 : if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
130 0 : return server.writeErrorStatusCmd(cmd, "Invalid height.", outputStorage);
131 : }
132 16 : libsumo::VehicleType::setHeight(id, value);
133 : }
134 16 : break;
135 43 : case libsumo::VAR_MAXSPEED: {
136 43 : double value = 0;
137 43 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
138 0 : return server.writeErrorStatusCmd(cmd, "Setting maximum speed requires a double.", outputStorage);
139 : }
140 43 : if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
141 2 : return server.writeErrorStatusCmd(cmd, "Invalid maximum speed.", outputStorage);
142 : }
143 42 : libsumo::VehicleType::setMaxSpeed(id, value);
144 : }
145 42 : break;
146 : case libsumo::VAR_VEHICLECLASS: {
147 : std::string vclass;
148 14 : if (!server.readTypeCheckingString(inputStorage, vclass)) {
149 0 : return server.writeErrorStatusCmd(cmd, "Setting vehicle class requires a string.", outputStorage);
150 : }
151 : try {
152 14 : libsumo::VehicleType::setVehicleClass(id, vclass);
153 0 : } catch (InvalidArgument&) {
154 0 : return server.writeErrorStatusCmd(cmd, "Unknown vehicle class '" + vclass + "'.", outputStorage);
155 0 : }
156 : }
157 : break;
158 7 : case libsumo::VAR_SPEED_FACTOR: {
159 7 : double value = 0;
160 7 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
161 0 : return server.writeErrorStatusCmd(cmd, "Setting speed factor requires a double.", outputStorage);
162 : }
163 7 : if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
164 0 : return server.writeErrorStatusCmd(cmd, "Invalid speed factor.", outputStorage);
165 : }
166 7 : libsumo::VehicleType::setSpeedFactor(id, value);
167 : }
168 7 : break;
169 4 : case libsumo::VAR_SPEED_DEVIATION: {
170 4 : double value = 0;
171 4 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
172 0 : return server.writeErrorStatusCmd(cmd, "Setting speed deviation requires a double.", outputStorage);
173 : }
174 4 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
175 0 : return server.writeErrorStatusCmd(cmd, "Invalid speed deviation.", outputStorage);
176 : }
177 4 : libsumo::VehicleType::setSpeedDeviation(id, value);
178 : }
179 4 : break;
180 : case libsumo::VAR_EMISSIONCLASS: {
181 : std::string eclass;
182 19 : if (!server.readTypeCheckingString(inputStorage, eclass)) {
183 0 : return server.writeErrorStatusCmd(cmd, "Setting emission class requires a string.", outputStorage);
184 : }
185 : try {
186 19 : libsumo::VehicleType::setEmissionClass(id, eclass);
187 0 : } catch (InvalidArgument& e) {
188 0 : return server.writeErrorStatusCmd(cmd, e.what(), outputStorage);
189 0 : }
190 : }
191 : break;
192 23 : case libsumo::VAR_WIDTH: {
193 23 : double value = 0;
194 23 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
195 0 : return server.writeErrorStatusCmd(cmd, "Setting width requires a double.", outputStorage);
196 : }
197 23 : if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
198 0 : return server.writeErrorStatusCmd(cmd, "Invalid width.", outputStorage);
199 : }
200 23 : libsumo::VehicleType::setWidth(id, value);
201 : }
202 23 : break;
203 12 : case libsumo::VAR_MINGAP: {
204 12 : double value = 0;
205 12 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
206 0 : return server.writeErrorStatusCmd(cmd, "Setting minimum gap requires a double.", outputStorage);
207 : }
208 12 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
209 0 : return server.writeErrorStatusCmd(cmd, "Invalid minimum gap.", outputStorage);
210 : }
211 12 : libsumo::VehicleType::setMinGap(id, value);
212 : }
213 12 : break;
214 5 : case libsumo::VAR_MINGAP_LAT: {
215 5 : double value = 0;
216 5 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
217 0 : return server.writeErrorStatusCmd(cmd, "Setting minimum lateral gap requires a double.", outputStorage);
218 : }
219 5 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
220 0 : return server.writeErrorStatusCmd(cmd, "Invalid minimum lateral gap.", outputStorage);
221 : }
222 5 : libsumo::VehicleType::setMinGapLat(id, value);
223 : }
224 5 : break;
225 11 : case libsumo::VAR_MAXSPEED_LAT: {
226 11 : double value = 0;
227 11 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
228 0 : return server.writeErrorStatusCmd(cmd, "Setting maximum lateral speed requires a double.", outputStorage);
229 : }
230 11 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
231 0 : return server.writeErrorStatusCmd(cmd, "Invalid maximum lateral speed.", outputStorage);
232 : }
233 11 : libsumo::VehicleType::setMaxSpeedLat(id, value);
234 : }
235 11 : break;
236 : case libsumo::VAR_LATALIGNMENT: {
237 : std::string latAlign;
238 11 : if (!server.readTypeCheckingString(inputStorage, latAlign)) {
239 0 : return server.writeErrorStatusCmd(cmd, "Setting preferred lateral alignment requires a string.",
240 : outputStorage);
241 : }
242 : try {
243 11 : libsumo::VehicleType::setLateralAlignment(id, latAlign);
244 0 : } catch (const libsumo::TraCIException& e) {
245 0 : return server.writeErrorStatusCmd(cmd, e.what(), outputStorage);
246 0 : }
247 : }
248 : break;
249 : case libsumo::VAR_SHAPECLASS: {
250 : std::string sclass;
251 12 : if (!server.readTypeCheckingString(inputStorage, sclass)) {
252 0 : return server.writeErrorStatusCmd(cmd, "Setting vehicle shape requires a string.", outputStorage);
253 : }
254 : try {
255 12 : libsumo::VehicleType::setShapeClass(id, sclass);
256 0 : } catch (InvalidArgument& e) {
257 0 : return server.writeErrorStatusCmd(cmd, e.what(), outputStorage);
258 0 : }
259 : }
260 : break;
261 32 : case libsumo::VAR_ACCEL: {
262 32 : double value = 0;
263 32 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
264 0 : return server.writeErrorStatusCmd(cmd, "Setting acceleration requires a double.", outputStorage);
265 : }
266 32 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
267 0 : return server.writeErrorStatusCmd(cmd, "Invalid acceleration.", outputStorage);
268 : }
269 32 : libsumo::VehicleType::setAccel(id, value);
270 : }
271 32 : break;
272 19 : case libsumo::VAR_DECEL: {
273 19 : double value = 0;
274 19 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
275 0 : return server.writeErrorStatusCmd(cmd, "Setting deceleration requires a double.", outputStorage);
276 : }
277 19 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
278 0 : return server.writeErrorStatusCmd(cmd, "Invalid deceleration.", outputStorage);
279 : }
280 19 : libsumo::VehicleType::setDecel(id, value);
281 : }
282 19 : break;
283 25 : case libsumo::VAR_EMERGENCY_DECEL: {
284 25 : double value = 0;
285 25 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
286 0 : return server.writeErrorStatusCmd(cmd, "Setting deceleration requires a double.", outputStorage);
287 : }
288 25 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
289 0 : return server.writeErrorStatusCmd(cmd, "Invalid deceleration.", outputStorage);
290 : }
291 25 : libsumo::VehicleType::setEmergencyDecel(id, value);
292 : }
293 25 : break;
294 19 : case libsumo::VAR_APPARENT_DECEL: {
295 19 : double value = 0;
296 19 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
297 0 : return server.writeErrorStatusCmd(cmd, "Setting deceleration requires a double.", outputStorage);
298 : }
299 19 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
300 0 : return server.writeErrorStatusCmd(cmd, "Invalid deceleration.", outputStorage);
301 : }
302 19 : libsumo::VehicleType::setApparentDecel(id, value);
303 : }
304 19 : break;
305 4 : case libsumo::VAR_SCALE: {
306 4 : double value = 0;
307 4 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
308 0 : return server.writeErrorStatusCmd(cmd, "Setting traffic scale requires a double.", outputStorage);
309 : }
310 4 : if (value < 0.0) {
311 0 : return server.writeErrorStatusCmd(cmd, "Traffic scale may not be negative.", outputStorage);
312 : }
313 4 : libsumo::VehicleType::setScale(id, value);
314 : }
315 4 : break;
316 10 : case libsumo::VAR_ACTIONSTEPLENGTH: {
317 10 : double value = 0;
318 10 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
319 0 : return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting action step length requires a double.", outputStorage);
320 : }
321 10 : if (fabs(value) == std::numeric_limits<double>::infinity()) {
322 0 : return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Invalid action step length.", outputStorage);
323 : }
324 10 : bool resetActionOffset = value >= 0.0;
325 10 : libsumo::VehicleType::setActionStepLength(id, fabs(value), resetActionOffset);
326 : }
327 10 : break;
328 27 : case libsumo::VAR_IMPERFECTION: {
329 27 : double value = 0;
330 27 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
331 0 : return server.writeErrorStatusCmd(cmd, "Setting driver imperfection requires a double.", outputStorage);
332 : }
333 27 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
334 0 : return server.writeErrorStatusCmd(cmd, "Invalid driver imperfection.", outputStorage);
335 : }
336 27 : libsumo::VehicleType::setImperfection(id, value);
337 : }
338 27 : break;
339 19 : case libsumo::VAR_TAU: {
340 19 : double value = 0;
341 19 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
342 0 : return server.writeErrorStatusCmd(cmd, "Setting headway time requires a double.", outputStorage);
343 : }
344 19 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
345 0 : return server.writeErrorStatusCmd(cmd, "Invalid headway time.", outputStorage);
346 : }
347 19 : libsumo::VehicleType::setTau(id, value);
348 : }
349 19 : break;
350 4 : case libsumo::VAR_IMPATIENCE: {
351 4 : double value = 0;
352 4 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
353 0 : return server.writeErrorStatusCmd(cmd, "Setting impatience requires a double.", outputStorage);
354 : }
355 4 : libsumo::VehicleType::setImpatience(id, value);
356 : }
357 4 : break;
358 10 : case libsumo::VAR_BOARDING_DURATION: {
359 10 : double value = 0;
360 10 : if (!server.readTypeCheckingDouble(inputStorage, value)) {
361 0 : return server.writeErrorStatusCmd(cmd, "Setting boardingDuration requires a double.", outputStorage);
362 : }
363 10 : libsumo::VehicleType::setBoardingDuration(id, value);
364 : }
365 10 : break;
366 : case libsumo::VAR_COLOR: {
367 : libsumo::TraCIColor col;
368 4 : if (!server.readTypeCheckingColor(inputStorage, col)) {
369 0 : return server.writeErrorStatusCmd(cmd, "The color must be given using the according type.", outputStorage);
370 : }
371 4 : libsumo::VehicleType::setColor(id, col);
372 : }
373 : break;
374 : case libsumo::COPY: {
375 : std::string newTypeID;
376 5 : if (!server.readTypeCheckingString(inputStorage, newTypeID)) {
377 0 : return server.writeErrorStatusCmd(cmd, "copying a vehicle type requires a string.",
378 : outputStorage);
379 : }
380 5 : libsumo::VehicleType::copy(id, newTypeID);
381 : }
382 : break;
383 67 : case libsumo::VAR_PARAMETER: {
384 67 : if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
385 0 : return server.writeErrorStatusCmd(cmd, "A compound object is needed for setting a parameter.",
386 : outputStorage);
387 : }
388 : //readt itemNo
389 67 : inputStorage.readInt();
390 : std::string name;
391 67 : if (!server.readTypeCheckingString(inputStorage, name)) {
392 12 : return server.writeErrorStatusCmd(cmd, "The name of the parameter must be given as a string.",
393 : outputStorage);
394 : }
395 : std::string value;
396 67 : if (!server.readTypeCheckingString(inputStorage, value)) {
397 12 : return server.writeErrorStatusCmd(cmd, "The value of the parameter must be given as a string.",
398 : outputStorage);
399 : }
400 67 : libsumo::VehicleType::setParameter(id, name, value);
401 : }
402 : break;
403 : default:
404 : break;
405 : }
406 : return true;
407 : }
408 :
409 :
410 : /****************************************************************************/
|
