Eclipse SUMO - Simulation of Urban MObility
SUMOSAXAttributesImpl_Binary.cpp
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 // Encapsulated xml-attributes that are retrieved from the sumo-binary-xml format (already typed)
18 /****************************************************************************/
19 
20 
21 // ===========================================================================
22 // included modules
23 // ===========================================================================
24 #include <config.h>
25 
26 #include <cassert>
27 #include <sstream>
28 #include <utils/common/RGBColor.h>
30 #include <utils/geom/Boundary.h>
36 
37 
38 // ===========================================================================
39 // class definitions
40 // ===========================================================================
42  const std::map<int, std::string>& predefinedTagsMML,
43  const std::string& objectType,
44  BinaryInputDevice* in, const char version) : SUMOSAXAttributes(objectType), myAttrIds(predefinedTagsMML) {
45  while (in->peek() == BinaryFormatter::BF_XML_ATTRIBUTE) {
46  int attr;
47  unsigned char attrByte;
48  *in >> attrByte;
49  attr = attrByte;
50  if (version > 1) {
52  *in >> attrByte;
53  attr += 256 * attrByte;
54  }
55  int type = in->peek();
56  switch (type) {
58  *in >> myCharValues[attr];
59  break;
61  *in >> myIntValues[attr];
62  break;
65  *in >> myFloatValues[attr];
66  break;
68  *in >> myStringValues[attr];
69  break;
71  int size;
72  *in >> size;
73  while (size > 0) {
74  const int type = in->peek();
78  throw ProcessError("Invalid binary file, only supporting position vectors.");
79  }
80  size--;
81  Position p;
82  *in >> p;
83  myPositionVectors[attr].push_back(p);
84  }
85  break;
86  }
88  *in >> myIntValues[attr];
89  break;
91  *in >> myIntValues[attr];
93  *in >> myCharValues[attr];
94  break;
99  Position p;
100  *in >> p;
101  myPositionVectors[attr].push_back(p);
102  break;
103  }
105  Position p;
106  *in >> p;
107  myPositionVectors[attr].push_back(p);
109  *in >> p;
110  myPositionVectors[attr].push_back(p);
111  break;
112  }
114  *in >> myIntValues[attr];
115  break;
117  *in >> myCharValues[attr];
118  break;
120  *in >> myCharValues[attr];
121  break;
123  std::ostringstream into(std::ios::binary);
124  int size;
125  *in >> size;
127  FileHelpers::writeInt(into, size);
128  if (size > 0) {
129  int intsToRead = size - 1;
130  int bitsOrEntry;
132  *in >> bitsOrEntry;
133  FileHelpers::writeInt(into, bitsOrEntry);
134  if (bitsOrEntry < 0) {
135  intsToRead = (-bitsOrEntry * (size - 1) - 1) / sizeof(int) / 8 + 2;
136  }
137  while (intsToRead > 0) {
139  *in >> bitsOrEntry;
140  FileHelpers::writeInt(into, bitsOrEntry);
141  intsToRead--;
142  }
143  }
144  myStringValues[attr] = into.str();
145  break;
146  }
147  default:
148  throw ProcessError("Binary file is invalid, attribute type is unknown.");
149  }
150  myAttrs.insert(attr);
151  }
152 }
153 
154 
156 }
157 
158 
159 bool
161  return myAttrs.find(id) != myAttrs.end();
162 }
163 
164 
165 bool
167  const std::map<int, char>::const_iterator i = myCharValues.find(id);
168  if (i == myCharValues.end()) {
169  throw EmptyData();
170  }
171  return i->second != 0;
172 }
173 
174 
175 int
177  const std::map<int, int>::const_iterator i = myIntValues.find(id);
178  if (i == myIntValues.end()) {
179  throw EmptyData();
180  }
181  return i->second;
182 }
183 
184 
185 long long int
187  return StringUtils::toLong(getString(id));
188 }
189 
190 
191 std::string
193  const std::map<int, std::string>::const_iterator i = myStringValues.find(id);
194  if (i == myStringValues.end()) {
195  throw EmptyData();
196  }
197  return i->second;
198 }
199 
200 
201 std::string
203  const std::string& str) const {
204  const std::map<int, std::string>::const_iterator i = myStringValues.find(id);
205  if (i == myStringValues.end()) {
206  return str;
207  }
208  return i->second;
209 }
210 
211 
212 double
214  const std::map<int, double>::const_iterator i = myFloatValues.find(id);
215  if (i == myFloatValues.end()) {
216  return StringUtils::toDouble(getString(id));
217  }
218  return i->second;
219 }
220 
221 
222 double
223 SUMOSAXAttributesImpl_Binary::getFloat(const std::string& /* id */) const {
224  throw ProcessError("not implemented for binary data");
225 }
226 
227 
228 bool
229 SUMOSAXAttributesImpl_Binary::hasAttribute(const std::string& /* id */) const {
230  throw ProcessError("not implemented for binary data");
231 }
232 
233 
234 std::string
236  const std::string& /* str */) const {
237  throw ProcessError("not implemented for binary data");
238 }
239 
240 
243  const std::map<int, char>::const_iterator i = myCharValues.find(SUMO_ATTR_FUNCTION);
244  if (i != myCharValues.end()) {
245  const char func = i->second;
246  if (func < (char)SUMOXMLDefinitions::EdgeFunctions.size()) {
247  return (SumoXMLEdgeFunc)func;
248  }
249  ok = false;
250  }
251  return EDGEFUNC_NORMAL;
252 }
253 
254 
257  const std::map<int, char>::const_iterator i = myCharValues.find(SUMO_ATTR_TYPE);
258  if (i != myCharValues.end()) {
259  const char type = i->second;
260  if (type < (char)SUMOXMLDefinitions::NodeTypes.size()) {
261  return (SumoXMLNodeType)type;
262  }
263  ok = false;
264  }
265  return NODETYPE_UNKNOWN;
266 }
267 
268 
271  try {
273  } catch (InvalidArgument) {
274  ok = false;
275  return RIGHT_OF_WAY_DEFAULT;
276  } catch (EmptyData) {
277  return RIGHT_OF_WAY_DEFAULT;
278  }
279 }
280 
281 
284  try {
286  } catch (InvalidArgument) {
287  ok = false;
288  return FRINGE_TYPE_DEFAULT;
289  } catch (EmptyData) {
290  return FRINGE_TYPE_DEFAULT;
291  }
292 }
293 
294 
295 RGBColor
297  const std::map<int, int>::const_iterator i = myIntValues.find(SUMO_ATTR_COLOR);
298  if (i == myIntValues.end()) {
299  throw EmptyData();
300  }
301  const int val = i->second;
302  return RGBColor(val & 0xff, (val >> 8) & 0xff, (val >> 16) & 0xff, (val >> 24) & 0xff);
303 }
304 
305 
308  const std::map<int, PositionVector>::const_iterator i = myPositionVectors.find(attr);
309  if (i == myPositionVectors.end() || i->second.size() == 0) {
310  throw EmptyData();
311  }
312  return i->second;
313 }
314 
315 
316 Boundary
318  const std::map<int, PositionVector>::const_iterator i = myPositionVectors.find(attr);
319  if (i == myPositionVectors.end() || i->second.size() == 0) {
320  throw EmptyData();
321  }
322  if (i->second.size() != 2) {
323  throw FormatException("boundary format");
324  }
325  return Boundary(i->second[0].x(), i->second[0].y(), i->second[1].x(), i->second[1].y());
326 }
327 
328 
329 std::string
331  if (myAttrIds.find(attr) == myAttrIds.end()) {
332  return "?";
333  }
334  return myAttrIds.find(attr)->second;
335 }
336 
337 
338 void
340  for (std::set<int>::const_iterator i = myAttrs.begin(); i != myAttrs.end(); ++i) {
341  os << " " << getName(*i);
342  os << "=\"" << getStringSecure(*i, "?") << "\"";
343  }
344 }
345 
346 std::vector<std::string>
348  std::vector<std::string> result;
349  for (std::set<int>::const_iterator i = myAttrs.begin(); i != myAttrs.end(); ++i) {
350  result.push_back(getName(*i));
351  }
352  return result;
353 }
354 
355 
358  std::map<std::string, std::string> attrs;
359  for (std::map<int, char>::const_iterator it = myCharValues.begin(); it != myCharValues.end(); ++it) {
360  const std::string attrName = myAttrIds.find(it->first)->second;
361  attrs[attrName] = toString(it->second);
362  }
363  for (std::map<int, int>::const_iterator it = myIntValues.begin(); it != myIntValues.end(); ++it) {
364  const std::string attrName = myAttrIds.find(it->first)->second;
365  attrs[attrName] = toString(it->second);
366  }
367  for (std::map<int, double>::const_iterator it = myFloatValues.begin(); it != myFloatValues.end(); ++it) {
368  const std::string attrName = myAttrIds.find(it->first)->second;
369  attrs[attrName] = toString(it->second);
370  }
371  for (std::map<int, std::string>::const_iterator it = myStringValues.begin(); it != myStringValues.end(); ++it) {
372  const std::string attrName = myAttrIds.find(it->first)->second;
373  attrs[attrName] = it->second;
374  }
375  for (std::map<int, PositionVector>::const_iterator it = myPositionVectors.begin(); it != myPositionVectors.end(); ++it) {
376  const std::string attrName = myAttrIds.find(it->first)->second;
377  attrs[attrName] = toString(it->second);
378  }
380 }
381 
382 /****************************************************************************/
383 
SUMO_ATTR_TYPE
Definition: SUMOXMLDefinitions.h:382
Boundary.h
FringeType
FringeType
algorithms for computing right of way
Definition: SUMOXMLDefinitions.h:1105
RIGHT_OF_WAY_DEFAULT
Definition: SUMOXMLDefinitions.h:1100
SUMOSAXAttributesImpl_Binary::serialize
void serialize(std::ostream &os) const
Prints all attribute names and values into the given stream.
Definition: SUMOSAXAttributesImpl_Binary.cpp:339
BinaryFormatter::BF_SCALED2INT_POSITION_3D
Definition: BinaryFormatter.h:98
SUMOSAXAttributesImpl_Binary::myIntValues
std::map< int, int > myIntValues
Map of attribute ids to integers.
Definition: SUMOSAXAttributesImpl_Binary.h:298
StringUtils::toDouble
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
Definition: StringUtils.cpp:313
SUMOSAXAttributesImpl_Binary::getFloat
double getFloat(int id) const
Returns the double-value of the named (by its enum-value) attribute.
Definition: SUMOSAXAttributesImpl_Binary.cpp:213
SUMOSAXAttributesImpl_Binary::myCharValues
std::map< int, char > myCharValues
Map of attribute ids to char.
Definition: SUMOSAXAttributesImpl_Binary.h:295
SUMOSAXAttributesImpl_Binary::myFloatValues
std::map< int, double > myFloatValues
Map of attribute ids to floats.
Definition: SUMOSAXAttributesImpl_Binary.h:301
SUMOSAXAttributesImpl_Binary::~SUMOSAXAttributesImpl_Binary
virtual ~SUMOSAXAttributesImpl_Binary()
Destructor.
Definition: SUMOSAXAttributesImpl_Binary.cpp:155
SUMOXMLDefinitions::RightOfWayValues
static StringBijection< RightOfWay > RightOfWayValues
righ of way algorithms
Definition: SUMOXMLDefinitions.h:1372
FileHelpers::writeInt
static std::ostream & writeInt(std::ostream &strm, int value)
Writes an integer binary.
Definition: FileHelpers.cpp:175
SUMOSAXAttributes::getObjectType
const std::string & getObjectType() const
return the objecttype to which these attributes belong
Definition: SUMOSAXAttributes.h:397
BinaryFormatter::BF_LANE
Definition: BinaryFormatter.h:78
SumoXMLEdgeFunc
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
Definition: SUMOXMLDefinitions.h:1074
SUMOSAXAttributesImpl_Binary::getString
std::string getString(int id) const
Returns the string-value of the named (by its enum-value) attribute.
Definition: SUMOSAXAttributesImpl_Binary.cpp:192
SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:701
NODETYPE_UNKNOWN
Definition: SUMOXMLDefinitions.h:1050
EmptyData
Definition: UtilExceptions.h:69
BinaryFormatter::BF_LIST
Definition: BinaryFormatter.h:68
BinaryFormatter::BF_NODE_TYPE
Definition: BinaryFormatter.h:88
BinaryFormatter::BF_BYTE
Definition: BinaryFormatter.h:60
SUMOSAXAttributesImpl_Binary::getColor
RGBColor getColor() const
Returns the value of the named attribute.
Definition: SUMOSAXAttributesImpl_Binary.cpp:296
FileHelpers::writeByte
static std::ostream & writeByte(std::ostream &strm, unsigned char value)
Writes a byte binary.
Definition: FileHelpers.cpp:189
PositionVector
A list of positions.
Definition: PositionVector.h:46
SUMOSAXAttributesImpl_Binary::myPositionVectors
std::map< int, PositionVector > myPositionVectors
Map of attribute ids to string.
Definition: SUMOSAXAttributesImpl_Binary.h:307
RGBColor.h
SUMOSAXAttributesImpl_Binary::myAttrs
std::set< int > myAttrs
the attributes which are set
Definition: SUMOSAXAttributesImpl_Binary.h:292
BinaryInputDevice::putback
void putback(char c)
Pushes a character back into the stream to be read by the next actual parse.
Definition: BinaryInputDevice.cpp:69
SUMO_ATTR_FUNCTION
Definition: SUMOXMLDefinitions.h:657
SUMOSAXAttributesImpl_Binary.h
BinaryInputDevice.h
RGBColor
Definition: RGBColor.h:40
BinaryFormatter::BF_SCALED2INT_POSITION_2D
Definition: BinaryFormatter.h:96
SUMOSAXAttributesImpl_Cached
Encapsulated Xerces-SAX-attributes.
Definition: SUMOSAXAttributesImpl_Cached.h:44
SUMOSAXAttributesImpl_Binary::getShape
PositionVector getShape(int attr) const
Tries to read given attribute assuming it is a PositionVector.
Definition: SUMOSAXAttributesImpl_Binary.cpp:307
SUMOSAXAttributesImpl_Binary::getRightOfWay
RightOfWay getRightOfWay(bool &ok) const
returns rightOfWay method
Definition: SUMOSAXAttributesImpl_Binary.cpp:270
SumoXMLNodeType
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
Definition: SUMOXMLDefinitions.h:1049
StringBijection::get
T get(const std::string &str) const
Definition: StringBijection.h:98
BinaryFormatter::BF_SCALED2INT
Definition: BinaryFormatter.h:94
SUMOSAXAttributesImpl_Binary::clone
SUMOSAXAttributes * clone() const
return a new deep-copy attributes object
Definition: SUMOSAXAttributesImpl_Binary.cpp:357
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:42
SUMOSAXAttributesImpl_Binary::getLong
long long int getLong(int id) const
Returns the long-value of the named (by its enum-value) attribute.
Definition: SUMOSAXAttributesImpl_Binary.cpp:186
ProcessError
Definition: UtilExceptions.h:40
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:39
SUMOSAXAttributesImpl_Binary::getBoundary
Boundary getBoundary(int attr) const
Tries to read given attribute assuming it is a Boundary.
Definition: SUMOSAXAttributesImpl_Binary.cpp:317
BinaryFormatter::BF_EDGE_FUNCTION
Definition: BinaryFormatter.h:90
StringBijection::size
int size() const
Definition: StringBijection.h:127
BinaryFormatter::BF_ROUTE
Definition: BinaryFormatter.h:92
EDGEFUNC_NORMAL
Definition: SUMOXMLDefinitions.h:1076
FormatException
Definition: UtilExceptions.h:82
BinaryFormatter::BF_POSITION_2D
Definition: BinaryFormatter.h:80
BinaryFormatter::BF_XML_ATTRIBUTE
Definition: BinaryFormatter.h:74
BinaryFormatter::BF_EDGE
Definition: BinaryFormatter.h:76
SUMOSAXAttributesImpl_Binary::myAttrIds
const std::map< int, std::string > & myAttrIds
Map of attribute ids to names.
Definition: SUMOSAXAttributesImpl_Binary.h:289
SUMOSAXAttributesImpl_Binary::getBool
bool getBool(int id) const
Returns the bool-value of the named (by its enum-value) attribute.
Definition: SUMOSAXAttributesImpl_Binary.cpp:166
BinaryFormatter::BF_INTEGER
Definition: BinaryFormatter.h:62
SUMOSAXAttributesImpl_Binary::getInt
int getInt(int id) const
Returns the int-value of the named (by its enum-value) attribute.
Definition: SUMOSAXAttributesImpl_Binary.cpp:176
BinaryFormatter::BF_POSITION_3D
Definition: BinaryFormatter.h:82
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:48
StringUtils.h
SUMOSAXAttributesImpl_Binary::hasAttribute
bool hasAttribute(int id) const
Returns the information whether the named (by its enum-value) attribute is within the current list.
Definition: SUMOSAXAttributesImpl_Binary.cpp:160
SUMOSAXAttributesImpl_Binary::getFringeType
FringeType getFringeType(bool &ok) const
returns fringe type
Definition: SUMOSAXAttributesImpl_Binary.cpp:283
InvalidArgument
Definition: UtilExceptions.h:57
RightOfWay
RightOfWay
algorithms for computing right of way
Definition: SUMOXMLDefinitions.h:1099
SUMOXMLDefinitions::EdgeFunctions
static StringBijection< SumoXMLEdgeFunc > EdgeFunctions
edge functions
Definition: SUMOXMLDefinitions.h:1366
BinaryInputDevice::peek
int peek()
Returns the next character to be read by an actual parse.
Definition: BinaryInputDevice.cpp:56
SUMO_ATTR_RIGHT_OF_WAY
How to compute right of way.
Definition: SUMOXMLDefinitions.h:695
SUMOSAXAttributesImpl_Cached.h
SUMOSAXAttributesImpl_Binary::getNodeType
SumoXMLNodeType getNodeType(bool &ok) const
Returns the value of the named attribute.
Definition: SUMOSAXAttributesImpl_Binary.cpp:256
BinaryFormatter::BF_STRING
Definition: BinaryFormatter.h:66
SUMOSAXAttributesImpl_Binary::getEdgeFunc
SumoXMLEdgeFunc getEdgeFunc(bool &ok) const
Returns the value of the named attribute.
Definition: SUMOSAXAttributesImpl_Binary.cpp:242
SUMOXMLDefinitions::FringeTypeValues
static StringBijection< FringeType > FringeTypeValues
fringe types
Definition: SUMOXMLDefinitions.h:1375
BinaryFormatter::BF_BOUNDARY
Definition: BinaryFormatter.h:84
config.h
FRINGE_TYPE_DEFAULT
Definition: SUMOXMLDefinitions.h:1108
SUMO_ATTR_FRINGE
Fringe type of node.
Definition: SUMOXMLDefinitions.h:697
StringUtils::toLong
static long long int toLong(const std::string &sData)
converts a string into the long value described by it by calling the char-type converter,...
Definition: StringUtils.cpp:265
BinaryFormatter::BF_FLOAT
Definition: BinaryFormatter.h:64
SUMOSAXAttributesImpl_Binary::getName
std::string getName(int attr) const
Converts the given attribute id into a man readable string.
Definition: SUMOSAXAttributesImpl_Binary.cpp:330
SUMOSAXAttributesImpl_Binary::myStringValues
std::map< int, std::string > myStringValues
Map of attribute ids to string.
Definition: SUMOSAXAttributesImpl_Binary.h:304
SUMOSAXAttributesImpl_Binary::getStringSecure
std::string getStringSecure(int id, const std::string &def) const
Returns the string-value of the named (by its enum-value) attribute.
Definition: SUMOSAXAttributesImpl_Binary.cpp:202
SUMOSAXAttributes
Encapsulated SAX-Attributes.
Definition: SUMOSAXAttributes.h:57
PositionVector.h
BinaryFormatter.h
SUMOSAXAttributesImpl_Binary::SUMOSAXAttributesImpl_Binary
SUMOSAXAttributesImpl_Binary(const std::map< int, std::string > &predefinedTagsMML, const std::string &objectType, BinaryInputDevice *in, const char version)
Constructor.
Definition: SUMOSAXAttributesImpl_Binary.cpp:41
SUMOXMLDefinitions::NodeTypes
static StringBijection< SumoXMLNodeType > NodeTypes
node types
Definition: SUMOXMLDefinitions.h:1363
BinaryInputDevice
Encapsulates binary reading operations on a file.
Definition: BinaryInputDevice.h:58
BinaryFormatter::BF_COLOR
Definition: BinaryFormatter.h:86
SUMOSAXAttributesImpl_Binary::getAttributeNames
std::vector< std::string > getAttributeNames() const
Retrieves all attribute names.
Definition: SUMOSAXAttributesImpl_Binary.cpp:347