Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2002-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_Edge.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Jakob Erdmann
17 : /// @author Jerome Haerri
18 : /// @author Michael Behrisch
19 : /// @author Laura Bieker
20 : /// @author Mario Krumnow
21 : /// @author Gregor Laemmel
22 : /// @date Sept 2002
23 : ///
24 : // APIs for getting/setting edge values via TraCI
25 : /****************************************************************************/
26 : #include <config.h>
27 :
28 : #include <utils/common/StdDefs.h>
29 : #include <microsim/MSNet.h>
30 : #include <microsim/MSEdgeControl.h>
31 : #include <microsim/MSEdge.h>
32 : #include <microsim/MSLane.h>
33 : #include <microsim/MSVehicle.h>
34 : #include <microsim/transportables/MSPerson.h>
35 : #include <libsumo/TraCIConstants.h>
36 : #include "TraCIServerAPI_Edge.h"
37 : #include <microsim/MSEdgeWeightsStorage.h>
38 : #include <utils/emissions/HelpersHarmonoise.h>
39 : #include <libsumo/StorageHelper.h>
40 : #include <libsumo/Edge.h>
41 :
42 :
43 : // ===========================================================================
44 : // method definitions
45 : // ===========================================================================
46 : bool
47 14687 : TraCIServerAPI_Edge::processGet(TraCIServer& server, tcpip::Storage& inputStorage,
48 : tcpip::Storage& outputStorage) {
49 14687 : const int variable = inputStorage.readUnsignedByte();
50 14687 : const std::string id = inputStorage.readString();
51 14687 : server.initWrapper(libsumo::RESPONSE_GET_EDGE_VARIABLE, variable, id);
52 : try {
53 14687 : if (!libsumo::Edge::handleVariable(id, variable, &server, &inputStorage)) {
54 98 : switch (variable) {
55 : case libsumo::VAR_EDGE_TRAVELTIME: {
56 66 : const double time = StoHelp::readTypedDouble(inputStorage, "The message must contain the time definition.");
57 66 : StoHelp::writeTypedDouble(server.getWrapperStorage(), libsumo::Edge::getAdaptedTraveltime(id, time));
58 : break;
59 : }
60 : case libsumo::VAR_EDGE_EFFORT: {
61 30 : const double time = StoHelp::readTypedDouble(inputStorage, "The message must contain the time definition.");
62 30 : StoHelp::writeTypedDouble(server.getWrapperStorage(), libsumo::Edge::getEffort(id, time));
63 : break;
64 : }
65 2 : default:
66 2 : return server.writeErrorStatusCmd(libsumo::CMD_GET_EDGE_VARIABLE,
67 2 : "Get Edge Variable: unsupported variable " + toHex(variable, 2)
68 2 : + " specified", outputStorage);
69 : }
70 : }
71 2 : } catch (libsumo::TraCIException& e) {
72 2 : return server.writeErrorStatusCmd(libsumo::CMD_GET_EDGE_VARIABLE, e.what(), outputStorage);
73 2 : }
74 14683 : server.writeStatusCmd(libsumo::CMD_GET_EDGE_VARIABLE, libsumo::RTYPE_OK, "", outputStorage);
75 14683 : server.writeResponseWithLength(outputStorage, server.getWrapperStorage());
76 : return true;
77 : }
78 :
79 :
80 : bool
81 137 : TraCIServerAPI_Edge::processSet(TraCIServer& server, tcpip::Storage& inputStorage,
82 : tcpip::Storage& outputStorage) {
83 : std::string warning; // additional description for response
84 : // variable
85 137 : int variable = inputStorage.readUnsignedByte();
86 137 : if (variable != libsumo::VAR_EDGE_TRAVELTIME
87 137 : && variable != libsumo::VAR_EDGE_EFFORT
88 137 : && variable != libsumo::VAR_MAXSPEED
89 : && variable != libsumo::LANE_ALLOWED
90 41 : && variable != libsumo::LANE_DISALLOWED
91 35 : && variable != libsumo::VAR_FRICTION
92 35 : && variable != libsumo::VAR_PARAMETER) {
93 0 : return server.writeErrorStatusCmd(libsumo::CMD_SET_EDGE_VARIABLE,
94 0 : "Change Edge State: unsupported variable " + toHex(variable, 2)
95 0 : + " specified", outputStorage);
96 : }
97 : // id
98 137 : std::string id = inputStorage.readString();
99 : try {
100 : // process
101 137 : switch (variable) {
102 : case libsumo::LANE_ALLOWED: {
103 : // read and set allowed vehicle classes
104 6 : const std::vector<std::string> classes = StoHelp::readTypedStringList(inputStorage, "Allowed vehicle classes must be given as a list of strings.");
105 6 : libsumo::Edge::setAllowed(id, classes);
106 : break;
107 6 : }
108 : case libsumo::LANE_DISALLOWED: {
109 : // read and set disallowed vehicle classes
110 0 : const std::vector<std::string> classes = StoHelp::readTypedStringList(inputStorage, "Not allowed vehicle classes must be given as a list of strings.");
111 0 : libsumo::Edge::setDisallowed(id, classes);
112 : break;
113 0 : }
114 : case libsumo::VAR_EDGE_TRAVELTIME: {
115 : // read and set travel time
116 71 : const int parameterCount = StoHelp::readCompound(inputStorage, -1, "Setting travel time requires a compound object.");
117 71 : if (parameterCount == 3) {
118 : // bound by time
119 15 : const double begTime = StoHelp::readTypedDouble(inputStorage, "The first variable must be the begin time given as double.");
120 15 : const double endTime = StoHelp::readTypedDouble(inputStorage, "The second variable must be the end time given as double.");
121 15 : const double value = StoHelp::readTypedDouble(inputStorage, "The third variable must be the value given as double.");
122 15 : libsumo::Edge::adaptTraveltime(id, value, begTime, endTime);
123 56 : } else if (parameterCount == 1) {
124 : // unbound
125 56 : const double value = StoHelp::readTypedDouble(inputStorage, "The variable must be the value given as double.");
126 56 : libsumo::Edge::adaptTraveltime(id, value, 0., std::numeric_limits<double>::max());
127 : } else {
128 0 : return server.writeErrorStatusCmd(libsumo::CMD_SET_EDGE_VARIABLE,
129 : "Setting travel time requires either begin time, end time, and value, or only value as parameter.",
130 : outputStorage);
131 : }
132 : break;
133 : }
134 : case libsumo::VAR_EDGE_EFFORT: {
135 : // read and set effort
136 12 : const int parameterCount = StoHelp::readCompound(inputStorage, -1, "Setting effort requires a compound object.");
137 12 : if (parameterCount == 3) {
138 : // bound by time
139 9 : const double begTime = StoHelp::readTypedDouble(inputStorage, "The first variable must be the begin time given as double.");
140 9 : const double endTime = StoHelp::readTypedDouble(inputStorage, "The second variable must be the end time given as double.");
141 9 : const double value = StoHelp::readTypedDouble(inputStorage, "The third variable must be the value given as double.");
142 9 : libsumo::Edge::setEffort(id, value, begTime, endTime);
143 3 : } else if (parameterCount == 1) {
144 : // unbound
145 3 : const double value = StoHelp::readTypedDouble(inputStorage, "The variable must be the value given as double.");
146 3 : libsumo::Edge::setEffort(id, value, 0., std::numeric_limits<double>::max());
147 : } else {
148 0 : return server.writeErrorStatusCmd(libsumo::CMD_SET_EDGE_VARIABLE,
149 : "Setting effort requires either begin time, end time, and value, or only value as parameter.",
150 : outputStorage);
151 : }
152 : break;
153 : }
154 : case libsumo::VAR_MAXSPEED: {
155 : // read and set max. speed
156 13 : const double value = StoHelp::readTypedDouble(inputStorage, "The speed must be given as a double.");
157 13 : libsumo::Edge::setMaxSpeed(id, value);
158 : break;
159 : }
160 : case libsumo::VAR_FRICTION: {
161 : // read and set friction for entire edge
162 0 : const double value = StoHelp::readTypedDouble(inputStorage, "The friction must be given as a double.");
163 0 : libsumo::Edge::setFriction(id, value);
164 : break;
165 : }
166 : case libsumo::VAR_PARAMETER: {
167 : // read and check item number
168 35 : StoHelp::readCompound(inputStorage, 2, "A compound object of size 2 is needed for setting a parameter.");
169 35 : const std::string name = StoHelp::readTypedString(inputStorage, "The name of the parameter must be given as a string.");
170 35 : const std::string value = StoHelp::readTypedString(inputStorage, "The value of the parameter must be given as a string.");
171 35 : libsumo::Edge::setParameter(id, name, value);
172 : break;
173 : }
174 : default:
175 : break;
176 : }
177 2 : } catch (libsumo::TraCIException& e) {
178 2 : return server.writeErrorStatusCmd(libsumo::CMD_SET_EDGE_VARIABLE, e.what(), outputStorage);
179 2 : }
180 135 : server.writeStatusCmd(libsumo::CMD_SET_EDGE_VARIABLE, libsumo::RTYPE_OK, warning, outputStorage);
181 : return true;
182 : }
183 :
184 :
185 : /****************************************************************************/
|
