Eclipse SUMO - Simulation of Urban MObility
ToString.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2002-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
18 // -------------------
19 /****************************************************************************/
20 #ifndef ToString_h
21 #define ToString_h
22 
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 
28 #include <sstream>
29 #include <string>
30 #include <iomanip>
31 #include <algorithm>
32 #include <list>
35 #include <utils/common/Named.h>
37 #include "StdDefs.h"
38 
39 
40 // ===========================================================================
41 // class definitions
42 // ===========================================================================
47 template <class T>
48 inline std::string toString(const T& t, std::streamsize accuracy = gPrecision) {
49  std::ostringstream oss;
50  oss.setf(std::ios::fixed, std::ios::floatfield);
51  oss << std::setprecision(accuracy);
52  oss << t;
53  return oss.str();
54 }
55 
56 
57 template<typename T>
58 inline std::string toHex(const T i, std::streamsize numDigits = 0) {
59  // taken from http://stackoverflow.com/questions/5100718/int-to-hex-string-in-c
60  std::stringstream stream;
61  stream << "0x" << std::setfill('0') << std::setw(numDigits == 0 ? sizeof(T) * 2 : numDigits) << std::hex << i;
62  return stream.str();
63 }
64 
65 
66 inline std::string toString(const Named* obj, std::streamsize accuracy) {
67  UNUSED_PARAMETER(accuracy);
68  return Named::getIDSecure(obj);
69 }
70 
71 
72 template <>
73 inline std::string toString<SumoXMLTag>(const SumoXMLTag& tag, std::streamsize accuracy) {
74  UNUSED_PARAMETER(accuracy);
76 }
77 
78 
79 template <>
80 inline std::string toString<SumoXMLAttr>(const SumoXMLAttr& attr, std::streamsize accuracy) {
81  UNUSED_PARAMETER(accuracy);
83 }
84 
85 
86 template <>
87 inline std::string toString<SumoXMLNodeType>(const SumoXMLNodeType& nodeType, std::streamsize accuracy) {
88  UNUSED_PARAMETER(accuracy);
90 }
91 
92 
93 template <>
94 inline std::string toString<SumoXMLEdgeFunc>(const SumoXMLEdgeFunc& edgeFunc, std::streamsize accuracy) {
95  UNUSED_PARAMETER(accuracy);
97 }
98 
99 
100 template <>
101 inline std::string toString<SUMOVehicleClass>(const SUMOVehicleClass& vClass, std::streamsize accuracy) {
102  UNUSED_PARAMETER(accuracy);
103  return SumoVehicleClassStrings.getString(vClass);
104 }
105 
106 
107 template <>
108 inline std::string toString<LaneSpreadFunction>(const LaneSpreadFunction& lsf, std::streamsize accuracy) {
109  UNUSED_PARAMETER(accuracy);
111 }
112 
113 template <>
114 inline std::string toString<RightOfWay>(const RightOfWay& row, std::streamsize accuracy) {
115  UNUSED_PARAMETER(accuracy);
117 }
118 
119 template <>
120 inline std::string toString<FringeType>(const FringeType& fringeType, std::streamsize accuracy) {
121  UNUSED_PARAMETER(accuracy);
123 }
124 
125 template <>
126 inline std::string toString<PersonMode>(const PersonMode& personMode, std::streamsize accuracy) {
127  UNUSED_PARAMETER(accuracy);
129 }
130 
131 template <>
132 inline std::string toString<LinkState>(const LinkState& linkState, std::streamsize accuracy) {
133  UNUSED_PARAMETER(accuracy);
134  return SUMOXMLDefinitions::LinkStates.getString(linkState);
135 }
136 
137 
138 template <>
139 inline std::string toString<LinkDirection>(const LinkDirection& linkDir, std::streamsize accuracy) {
140  UNUSED_PARAMETER(accuracy);
142 }
143 
144 
145 template <>
146 inline std::string toString<TrafficLightType>(const TrafficLightType& type, std::streamsize accuracy) {
147  UNUSED_PARAMETER(accuracy);
149 }
150 
151 
152 template <>
153 inline std::string toString<LaneChangeModel>(const LaneChangeModel& model, std::streamsize accuracy) {
154  UNUSED_PARAMETER(accuracy);
156 }
157 
158 template <>
159 inline std::string toString<LateralAlignment>(const LateralAlignment& latA, std::streamsize accuracy) {
160  UNUSED_PARAMETER(accuracy);
162 }
163 
164 template <>
165 inline std::string toString<LaneChangeAction>(const LaneChangeAction& action, std::streamsize accuracy) {
166  UNUSED_PARAMETER(accuracy);
167  std::vector<std::string> strings = SUMOXMLDefinitions::LaneChangeActions.getStrings();
168  bool hadOne = false;
169  std::ostringstream oss;
170  for (std::vector<std::string>::const_iterator it = strings.begin(); it != strings.end(); ++it) {
171  if ((action & SUMOXMLDefinitions::LaneChangeActions.get(*it)) != 0) {
172  if (hadOne) {
173  oss << "|";
174  } else {
175  hadOne = true;
176  }
177  oss << (*it);
178  }
179  }
180  return oss.str();
181 }
182 
183 template <>
184 inline std::string toString<Distribution_Parameterized>(const Distribution_Parameterized& dist, std::streamsize accuracy) {
185  return dist.toStr(accuracy);
186 }
187 
188 template <typename V>
189 inline std::string toString(const std::vector<V*>& v, std::streamsize accuracy = gPrecision) {
190  return toString<V>(v.begin(), v.end(), accuracy);
191 }
192 
193 template <typename V>
194 inline std::string toString(const typename std::vector<V*>::const_iterator& b, const typename std::vector<V*>::const_iterator& e, std::streamsize accuracy = gPrecision) {
195  UNUSED_PARAMETER(accuracy);
196  std::ostringstream oss;
197  for (typename std::vector<V*>::const_iterator it = b; it != e; ++it) {
198  if (it != b) {
199  oss << " ";
200  }
201  oss << Named::getIDSecure(*it);
202  }
203  return oss.str();
204 }
205 
206 template <typename V>
207 inline std::string toString(const std::list<V*>& v, std::streamsize accuracy = gPrecision) {
208  return toString<V>(v.begin(), v.end(), accuracy);
209 }
210 
211 template <typename V>
212 inline std::string toString(const typename std::list<V*>::const_iterator& b, const typename std::list<V*>::const_iterator& e, std::streamsize accuracy = gPrecision) {
213  UNUSED_PARAMETER(accuracy);
214  std::ostringstream oss;
215  for (typename std::list<V*>::const_iterator it = b; it != e; ++it) {
216  if (it != b) {
217  oss << " ";
218  }
219  oss << Named::getIDSecure(*it);
220  }
221  return oss.str();
222 }
223 
224 
225 
226 //template <typename V>
227 //inline std::string toString(const std::vector<V>& v, std::streamsize accuracy = gPrecision) {
228 // return toString<V>(v.begin(), v.end(), accuracy);
229 //}
230 //
231 //
232 //template <typename V>
233 //inline std::string toString(const typename std::vector<V>::const_iterator& b, const typename std::vector<V>::const_iterator& e, std::streamsize accuracy = gPrecision) {
234 // UNUSED_PARAMETER(accuracy);
235 // std::ostringstream oss;
236 // for (typename std::vector<V>::const_iterator it = b; it != e; ++it) {
237 // if (it != b) {
238 // oss << " ";
239 // }
240 // oss << Named::getIDSecure(*it);
241 // }
242 // return oss.str();
243 //}
244 
245 
246 template <typename T, typename T_BETWEEN>
247 inline std::string joinToString(const std::vector<T>& v, const T_BETWEEN& between, std::streamsize accuracy = gPrecision) {
248  std::ostringstream oss;
249  bool connect = false;
250  for (typename std::vector<T>::const_iterator it = v.begin(); it != v.end(); ++it) {
251  if (connect) {
252  oss << toString(between, accuracy);
253  } else {
254  connect = true;
255  }
256  oss << toString(*it, accuracy);
257  }
258  return oss.str();
259 }
260 
261 
262 template <typename T, typename T_BETWEEN>
263 inline std::string joinToStringSorting(const std::vector<T>& v, const T_BETWEEN& between, std::streamsize accuracy = gPrecision) {
264  std::vector<T> sorted(v);
265  std::sort(sorted.begin(), sorted.end());
266  return joinToString(sorted, between, accuracy);
267 }
268 
269 
270 template <typename T, typename T_BETWEEN>
271 inline std::string joinNamedToStringSorting(const std::set<T*>& ns, const T_BETWEEN& between) {
272  std::vector<std::string> ids;
273  for (T* n : ns) {
274  ids.push_back(Named::getIDSecure(n));
275  }
276  return joinToStringSorting(ids, between);
277 }
278 
279 
280 template <typename T, typename C, typename T_BETWEEN>
281 inline std::string joinNamedToString(const std::set<T*, C>& ns, const T_BETWEEN& between) {
282  std::vector<std::string> ids;
283  for (T* n : ns) {
284  ids.push_back(Named::getIDSecure(n));
285  }
286  return joinToString(ids, between);
287 }
288 
289 
290 template <typename V>
291 inline std::string toString(const std::set<V*>& v, std::streamsize accuracy = gPrecision) {
292  UNUSED_PARAMETER(accuracy);
293  std::vector<std::string> ids;
294  for (typename std::set<V*>::const_iterator it = v.begin(); it != v.end(); ++it) {
295  ids.push_back((*it)->getID());
296  }
297  return joinToStringSorting(ids, " ");
298 }
299 
300 
301 template <>
302 inline std::string toString(const std::vector<int>& v, std::streamsize accuracy) {
303  return joinToString(v, " ", accuracy);
304 }
305 
306 
307 template <>
308 inline std::string toString(const std::vector<long long int>& v, std::streamsize accuracy) {
309  return joinToString(v, " ", accuracy);
310 }
311 
312 
313 template <>
314 inline std::string toString(const std::vector<double>& v, std::streamsize accuracy) {
315  return joinToString(v, " ", accuracy);
316 }
317 
318 
319 template <typename T, typename T_BETWEEN>
320 inline std::string joinToString(const std::set<T>& s, const T_BETWEEN& between, std::streamsize accuracy = gPrecision) {
321  std::ostringstream oss;
322  bool connect = false;
323  for (typename std::set<T>::const_iterator it = s.begin(); it != s.end(); ++it) {
324  if (connect) {
325  oss << toString(between, accuracy);
326  } else {
327  connect = true;
328  }
329  oss << toString(*it, accuracy);
330  }
331  return oss.str();
332 }
333 
334 
335 template <>
336 inline std::string toString(const std::vector<std::string>& v, std::streamsize) {
337  return joinToString(v, " ");
338 }
339 
340 
341 template <>
342 inline std::string toString(const std::set<std::string>& v, std::streamsize) {
343  return joinToString(v, " ");
344 }
345 
346 
347 template <typename KEY, typename VAL, typename T_BETWEEN, typename T_BETWEEN_KEYVAL>
348 inline std::string joinToString(const std::map<KEY, VAL>& s, const T_BETWEEN& between, const T_BETWEEN_KEYVAL& between_keyval, std::streamsize accuracy = gPrecision) {
349  std::ostringstream oss;
350  bool connect = false;
351  for (typename std::map<KEY, VAL>::const_iterator it = s.begin(); it != s.end(); ++it) {
352  if (connect) {
353  oss << toString(between, accuracy);
354  } else {
355  connect = true;
356  }
357  oss << toString(it->first, accuracy) << between_keyval << toString(it->second, accuracy);
358  }
359  return oss.str();
360 }
361 
362 
363 template <>
364 inline std::string toString(const std::map<std::string, std::string>& v, std::streamsize) {
365  return joinToString(v, ", ", ":");
366 }
367 
368 
369 #endif
370 
371 /****************************************************************************/
372 
toString< LaneChangeAction >
std::string toString< LaneChangeAction >(const LaneChangeAction &action, std::streamsize accuracy)
Definition: ToString.h:165
UNUSED_PARAMETER
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:32
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:134
SUMOXMLDefinitions::LaneChangeModels
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
Definition: SUMOXMLDefinitions.h:1390
Distribution_Parameterized
Definition: Distribution_Parameterized.h:43
FringeType
FringeType
algorithms for computing right of way
Definition: SUMOXMLDefinitions.h:1105
joinToStringSorting
std::string joinToStringSorting(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition: ToString.h:263
SUMOXMLDefinitions::LinkStates
static StringBijection< LinkState > LinkStates
link states
Definition: SUMOXMLDefinitions.h:1381
Named
Base class for objects which have an id.
Definition: Named.h:57
SUMOXMLDefinitions::LaneChangeActions
static StringBijection< LaneChangeAction > LaneChangeActions
lane change actions
Definition: SUMOXMLDefinitions.h:1399
StringBijection::getString
const std::string & getString(const T key) const
Definition: StringBijection.h:107
LateralAlignment
LateralAlignment
Numbers representing special SUMO-XML-attribute values Information how vehicles align themselves with...
Definition: SUMOXMLDefinitions.h:1323
toString< SumoXMLTag >
std::string toString< SumoXMLTag >(const SumoXMLTag &tag, std::streamsize accuracy)
Definition: ToString.h:73
LaneChangeModel
LaneChangeModel
Definition: SUMOXMLDefinitions.h:1298
toString< TrafficLightType >
std::string toString< TrafficLightType >(const TrafficLightType &type, std::streamsize accuracy)
Definition: ToString.h:146
StringBijection::getStrings
std::vector< std::string > getStrings() const
Definition: StringBijection.h:132
SUMOXMLDefinitions::RightOfWayValues
static StringBijection< RightOfWay > RightOfWayValues
righ of way algorithms
Definition: SUMOXMLDefinitions.h:1372
TrafficLightType
TrafficLightType
Definition: SUMOXMLDefinitions.h:1192
SumoXMLEdgeFunc
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
Definition: SUMOXMLDefinitions.h:1074
LinkDirection
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)....
Definition: SUMOXMLDefinitions.h:1171
SUMOXMLDefinitions::LinkDirections
static StringBijection< LinkDirection > LinkDirections
link directions
Definition: SUMOXMLDefinitions.h:1384
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:42
SumoVehicleClassStrings
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
toString< Distribution_Parameterized >
std::string toString< Distribution_Parameterized >(const Distribution_Parameterized &dist, std::streamsize accuracy)
Definition: ToString.h:184
LinkState
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic,...
Definition: SUMOXMLDefinitions.h:1132
LaneChangeAction
LaneChangeAction
The state of a vehicle's lane-change behavior.
Definition: SUMOXMLDefinitions.h:1213
SumoXMLNodeType
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
Definition: SUMOXMLDefinitions.h:1049
Named.h
joinNamedToString
std::string joinNamedToString(const std::set< T *, C > &ns, const T_BETWEEN &between)
Definition: ToString.h:281
SUMOVehicleClass.h
toHex
std::string toHex(const T i, std::streamsize numDigits=0)
Definition: ToString.h:58
SUMOXMLDefinitions::PersonModeValues
static StringBijection< PersonMode > PersonModeValues
person modes
Definition: SUMOXMLDefinitions.h:1378
SUMOXMLDefinitions::Attrs
static StringBijection< int > Attrs
The names of SUMO-XML attributes for use in netbuild.
Definition: SUMOXMLDefinitions.h:1357
PersonMode
PersonMode
travel modes for persons
Definition: SUMOXMLDefinitions.h:1112
toString< PersonMode >
std::string toString< PersonMode >(const PersonMode &personMode, std::streamsize accuracy)
Definition: ToString.h:126
toString< SUMOVehicleClass >
std::string toString< SUMOVehicleClass >(const SUMOVehicleClass &vClass, std::streamsize accuracy)
Definition: ToString.h:101
toString< SumoXMLEdgeFunc >
std::string toString< SumoXMLEdgeFunc >(const SumoXMLEdgeFunc &edgeFunc, std::streamsize accuracy)
Definition: ToString.h:94
Distribution_Parameterized.h
toString< LinkState >
std::string toString< LinkState >(const LinkState &linkState, std::streamsize accuracy)
Definition: ToString.h:132
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:48
toString< LateralAlignment >
std::string toString< LateralAlignment >(const LateralAlignment &latA, std::streamsize accuracy)
Definition: ToString.h:159
Distribution_Parameterized::toStr
std::string toStr(std::streamsize accuracy) const
Returns the string representation of this distribution.
Definition: Distribution_Parameterized.cpp:123
SUMOXMLDefinitions::Tags
static StringBijection< int > Tags
The names of SUMO-XML elements for use in netbuild.
Definition: SUMOXMLDefinitions.h:1354
RightOfWay
RightOfWay
algorithms for computing right of way
Definition: SUMOXMLDefinitions.h:1099
SUMOXMLDefinitions::EdgeFunctions
static StringBijection< SumoXMLEdgeFunc > EdgeFunctions
edge functions
Definition: SUMOXMLDefinitions.h:1366
joinNamedToStringSorting
std::string joinNamedToStringSorting(const std::set< T * > &ns, const T_BETWEEN &between)
Definition: ToString.h:271
joinToString
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition: ToString.h:247
SUMOXMLDefinitions::TrafficLightTypes
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
Definition: SUMOXMLDefinitions.h:1387
LaneSpreadFunction
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge's lateral offset shal...
Definition: SUMOXMLDefinitions.h:1092
toString< FringeType >
std::string toString< FringeType >(const FringeType &fringeType, std::streamsize accuracy)
Definition: ToString.h:120
SUMOXMLDefinitions::FringeTypeValues
static StringBijection< FringeType > FringeTypeValues
fringe types
Definition: SUMOXMLDefinitions.h:1375
SUMOXMLDefinitions::LaneSpreadFunctions
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
lane spread functions
Definition: SUMOXMLDefinitions.h:1369
Named::getIDSecure
static std::string getIDSecure(const T *obj, const std::string &fallBack="NULL")
get an identifier for Named-like object which may be Null
Definition: Named.h:70
toString< SumoXMLAttr >
std::string toString< SumoXMLAttr >(const SumoXMLAttr &attr, std::streamsize accuracy)
Definition: ToString.h:80
toString< LinkDirection >
std::string toString< LinkDirection >(const LinkDirection &linkDir, std::streamsize accuracy)
Definition: ToString.h:139
gPrecision
int gPrecision
the precision for floating point outputs
Definition: StdDefs.cpp:27
StdDefs.h
SUMOXMLDefinitions::LateralAlignments
static StringBijection< LateralAlignment > LateralAlignments
lateral alignments
Definition: SUMOXMLDefinitions.h:1396
toString< LaneChangeModel >
std::string toString< LaneChangeModel >(const LaneChangeModel &model, std::streamsize accuracy)
Definition: ToString.h:153
toString< SumoXMLNodeType >
std::string toString< SumoXMLNodeType >(const SumoXMLNodeType &nodeType, std::streamsize accuracy)
Definition: ToString.h:87
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition: SUMOXMLDefinitions.h:373
toString< LaneSpreadFunction >
std::string toString< LaneSpreadFunction >(const LaneSpreadFunction &lsf, std::streamsize accuracy)
Definition: ToString.h:108
SUMOXMLDefinitions.h
SUMOXMLDefinitions::NodeTypes
static StringBijection< SumoXMLNodeType > NodeTypes
node types
Definition: SUMOXMLDefinitions.h:1363
toString< RightOfWay >
std::string toString< RightOfWay >(const RightOfWay &row, std::streamsize accuracy)
Definition: ToString.h:114