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