Eclipse SUMO - Simulation of Urban MObility
libtraci/Lane.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2017-2020 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 /****************************************************************************/
23 // C++ TraCI client API implementation
24 /****************************************************************************/
25 #include <config.h>
26 
27 #define LIBTRACI 1
28 #include <libsumo/Lane.h>
29 #include <libsumo/TraCIConstants.h>
30 #include "Connection.h"
31 #include "Domain.h"
32 
33 
34 namespace libtraci {
35 
36 typedef Domain<libsumo::CMD_GET_LANE_VARIABLE, libsumo::CMD_SET_LANE_VARIABLE> Dom;
37 
38 
39 
40 // ===========================================================================
41 // static member definitions
42 // ===========================================================================
43 std::vector<std::string>
44 Lane::getIDList() {
46 }
47 
48 
49 int
50 Lane::getIDCount() {
51  return Dom::getInt(libsumo::ID_COUNT, "");
52 }
53 
54 
55 std::string
56 Lane::getEdgeID(std::string laneID) {
57  return Dom::getString(libsumo::LANE_EDGE_ID, laneID);
58 }
59 
60 
61 double
62 Lane::getLength(std::string laneID) {
63  return Dom::getDouble(libsumo::VAR_LENGTH, laneID);
64 }
65 
66 
67 double
68 Lane::getMaxSpeed(std::string laneID) {
69  return Dom::getDouble(libsumo::VAR_MAXSPEED, laneID);
70 }
71 
72 
73 int
74 Lane::getLinkNumber(std::string laneID) {
75  return Dom::getInt(libsumo::LANE_LINK_NUMBER, laneID);
76 }
77 
78 
79 std::vector<libsumo::TraCIConnection>
80 Lane::getLinks(std::string laneID) {
81  std::vector<libsumo::TraCIConnection> ret;
84  sto.readUnsignedByte();
85  sto.readInt();
86 
87  int linkNo = sto.readInt();
88  for (int i = 0; i < linkNo; ++i) {
89 
90  sto.readUnsignedByte();
91  std::string approachedLane = sto.readString();
92 
93  sto.readUnsignedByte();
94  std::string approachedLaneInternal = sto.readString();
95 
96  sto.readUnsignedByte();
97  bool hasPrio = sto.readUnsignedByte() != 0;
98 
99  sto.readUnsignedByte();
100  bool isOpen = sto.readUnsignedByte() != 0;
101 
102  sto.readUnsignedByte();
103  bool hasFoe = sto.readUnsignedByte() != 0;
104 
105  sto.readUnsignedByte();
106  std::string state = sto.readString();
107 
108  sto.readUnsignedByte();
109  std::string direction = sto.readString();
110 
111  sto.readUnsignedByte();
112  double length = sto.readDouble();
113 
114  ret.push_back(libsumo::TraCIConnection(approachedLane,
115  hasPrio,
116  isOpen,
117  hasFoe,
118  approachedLaneInternal,
119  state,
120  direction,
121  length));
122 
123  }
124 
125  }
126  return ret;
127 }
128 
129 
130 std::vector<std::string>
131 Lane::getAllowed(std::string laneID) {
133 }
134 
135 
136 std::vector<std::string>
137 Lane::getDisallowed(std::string laneID) {
138  return Dom::getStringVector(libsumo::LANE_DISALLOWED, laneID); // negation yields disallowed
139 }
140 
141 
143 Lane::getShape(std::string laneID) {
144  return Dom::getPolygon(libsumo::VAR_SHAPE, laneID);
145 }
146 
147 
148 double
149 Lane::getWidth(std::string laneID) {
150  return Dom::getDouble(libsumo::VAR_WIDTH, laneID);
151 }
152 
153 
154 double
155 Lane::getCO2Emission(std::string laneID) {
157 }
158 
159 
160 double
161 Lane::getCOEmission(std::string laneID) {
162  return Dom::getDouble(libsumo::VAR_COEMISSION, laneID);
163 }
164 
165 
166 double
167 Lane::getHCEmission(std::string laneID) {
168  return Dom::getDouble(libsumo::VAR_COEMISSION, laneID);
169 }
170 
171 
172 double
173 Lane::getPMxEmission(std::string laneID) {
175 }
176 
177 
178 double
179 Lane::getNOxEmission(std::string laneID) {
181 }
182 
183 double
184 Lane::getFuelConsumption(std::string laneID) {
186 }
187 
188 
189 double
190 Lane::getNoiseEmission(std::string laneID) {
192 }
193 
194 
195 double
196 Lane::getElectricityConsumption(std::string laneID) {
198 }
199 
200 
201 double
202 Lane::getLastStepMeanSpeed(std::string laneID) {
204 }
205 
206 
207 double
208 Lane::getLastStepOccupancy(std::string laneID) {
210 }
211 
212 
213 double
214 Lane::getLastStepLength(std::string laneID) {
216 }
217 
218 
219 double
220 Lane::getWaitingTime(std::string laneID) {
222 }
223 
224 
225 double
226 Lane::getTraveltime(std::string laneID) {
228 }
229 
230 
231 int
232 Lane::getLastStepVehicleNumber(std::string laneID) {
234 }
235 
236 int
237 Lane::getLastStepHaltingNumber(std::string laneID) {
239 }
240 
241 
242 std::vector<std::string>
243 Lane::getLastStepVehicleIDs(std::string laneID) {
245 }
246 
247 
248 std::vector<std::string>
249 Lane::getFoes(const std::string& laneID, const std::string& toLaneID) {
250  std::vector<std::string> r;
251  tcpip::Storage content;
253  content.writeString(toLaneID);
256  const int size = ret.readInt();
257  for (int i = 0; i < size; ++i) {
258  r.push_back(ret.readString());
259  }
260  }
261  return r;
262 }
263 
264 // XXX: there seems to be no "Dom::getFoes"
265 std::vector<std::string>
266 Lane::getInternalFoes(const std::string& laneID) {
267  //tcpip::Storage content;
268  //content.writeUnsignedByte(libsumo::TYPE_STRING);
269  //content.writeString("");
270  //return Dom::getStringVector(libsumo::VAR_FOES, laneID, &content);
271  return getFoes(laneID, "");
272  //return Dom::getFoes(laneID, "");
273 }
274 
275 
276 void
277 Lane::setAllowed(std::string laneID, std::string allowedClass) {
278  Dom::setString(libsumo::LANE_ALLOWED, laneID, allowedClass);
279 }
280 
281 
282 void
283 Lane::setAllowed(std::string laneID, std::vector<std::string> allowedClasses) {
284  Dom::setStringVector(libsumo::LANE_ALLOWED, laneID, allowedClasses);
285 }
286 
287 
288 void
289 Lane::setDisallowed(std::string laneID, std::vector<std::string> disallowedClasses) {
290  Dom::setStringVector(libsumo::LANE_DISALLOWED, laneID, disallowedClasses);
291 }
292 
293 
294 void
295 Lane::setMaxSpeed(std::string laneID, double speed) {
296  Dom::setDouble(libsumo::VAR_MAXSPEED, laneID, speed);
297 }
298 
299 
300 void
301 Lane::setLength(std::string laneID, double length) {
302  Dom::setDouble(libsumo::VAR_LENGTH, laneID, length);
303 }
304 
305 
308 
309 }
310 
311 
312 /****************************************************************************/
#define LIBTRACI_SUBSCRIPTION_IMPLEMENTATION(CLASS, DOMAIN)
Definition: Domain.h:36
#define LIBTRACI_PARAMETER_IMPLEMENTATION(CLASS, DOMAIN)
Definition: Domain.h:74
C++ TraCI client API implementation.
static Connection & getActive()
Definition: Connection.h:53
tcpip::Storage & doCommand(int command, int var, const std::string &id, tcpip::Storage *add=nullptr)
Definition: Connection.cpp:366
static void setDouble(int var, const std::string &id, double value)
Definition: Domain.h:156
static void setStringVector(int var, const std::string &id, const std::vector< std::string > &value)
Definition: Domain.h:164
static std::vector< std::string > getStringVector(int var, const std::string &id, tcpip::Storage *add=nullptr)
Definition: Domain.h:140
static std::string getString(int var, const std::string &id, tcpip::Storage *add=nullptr)
Definition: Domain.h:136
static int getInt(int var, const std::string &id, tcpip::Storage *add=nullptr)
Definition: Domain.h:116
static libsumo::TraCIPositionVector getPolygon(int var, const std::string &id, tcpip::Storage *add=nullptr)
Definition: Domain.h:124
static double getDouble(int var, const std::string &id, tcpip::Storage *add=nullptr)
Definition: Domain.h:120
static void setString(int var, const std::string &id, const std::string &value)
Definition: Domain.h:160
virtual std::string readString()
Definition: storage.cpp:175
virtual void writeString(const std::string &s)
Definition: storage.cpp:192
virtual int readUnsignedByte()
Definition: storage.cpp:150
virtual void writeUnsignedByte(int)
Definition: storage.cpp:160
virtual double readDouble()
Definition: storage.cpp:357
virtual int readInt()
Definition: storage.cpp:306
TRACI_CONST int LAST_STEP_VEHICLE_ID_LIST
TRACI_CONST int LAST_STEP_VEHICLE_NUMBER
TRACI_CONST int VAR_NOXEMISSION
TRACI_CONST int LANE_LINKS
TRACI_CONST int TRACI_ID_LIST
TRACI_CONST int VAR_WAITING_TIME
TRACI_CONST int LANE_LINK_NUMBER
TRACI_CONST int LAST_STEP_LENGTH
TRACI_CONST int TYPE_COMPOUND
TRACI_CONST int LANE_EDGE_ID
std::vector< TraCIPosition > TraCIPositionVector
Definition: TraCIDefs.h:196
TRACI_CONST int VAR_PMXEMISSION
TRACI_CONST int VAR_COEMISSION
TRACI_CONST int VAR_WIDTH
TRACI_CONST int VAR_MAXSPEED
TRACI_CONST int LAST_STEP_MEAN_SPEED
TRACI_CONST int VAR_CO2EMISSION
TRACI_CONST int TYPE_STRINGLIST
TRACI_CONST int VAR_FUELCONSUMPTION
TRACI_CONST int VAR_SHAPE
TRACI_CONST int LAST_STEP_VEHICLE_HALTING_NUMBER
TRACI_CONST int VAR_LENGTH
TRACI_CONST int ID_COUNT
TRACI_CONST int LAST_STEP_OCCUPANCY
TRACI_CONST int VAR_NOISEEMISSION
TRACI_CONST int CMD_GET_LANE_VARIABLE
TRACI_CONST int LANE_DISALLOWED
TRACI_CONST int VAR_CURRENT_TRAVELTIME
TRACI_CONST int VAR_FOES
TRACI_CONST int LANE_ALLOWED
TRACI_CONST int VAR_ELECTRICITYCONSUMPTION
TRACI_CONST int TYPE_STRING
Domain< libsumo::CMD_GET_BUSSTOP_VARIABLE, libsumo::CMD_SET_BUSSTOP_VARIABLE > Dom