Eclipse SUMO - Simulation of Urban MObility
BinaryFormatter.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2012-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 /****************************************************************************/
16 // Static storage of an output device and its base (abstract) implementation
17 /****************************************************************************/
18 
19 
20 // ===========================================================================
21 // included modules
22 // ===========================================================================
23 #include <config.h>
24 
25 #ifdef HAVE_VERSION_H
26 #include <version.h>
27 #endif
28 
29 #include <utils/common/RGBColor.h>
30 #include <utils/common/ToString.h>
34 #include <utils/geom/Boundary.h>
35 #include "BinaryFormatter.h"
36 
37 
38 // ===========================================================================
39 // member method definitions
40 // ===========================================================================
42 }
43 
44 
45 void
48  FileHelpers::writeByte(into, 2);
51  writeStringList(into, SUMOXMLDefinitions::Tags.getStrings());
52  writeStringList(into, SUMOXMLDefinitions::Attrs.getStrings());
55 }
56 
57 
58 void
59 BinaryFormatter::writeStringList(std::ostream& into, const std::vector<std::string>& list) {
61  FileHelpers::writeInt(into, (int)list.size());
62  for (std::vector<std::string>::const_iterator it = list.begin(); it != list.end(); ++it) {
64  FileHelpers::writeString(into, *it);
65  }
66 }
67 
68 
69 bool
71  const std::string& rootElement,
72  const std::map<SumoXMLAttr, std::string>& attrs) {
73  if (myXMLStack.empty()) {
74  writeStaticHeader(into);
75  writeStringList(into, std::vector<std::string>());
76  writeStringList(into, std::vector<std::string>());
77  if (SUMOXMLDefinitions::Tags.hasString(rootElement)) {
78  openTag(into, rootElement);
79  for (std::map<SumoXMLAttr, std::string>::const_iterator it = attrs.begin(); it != attrs.end(); ++it) {
80  writeAttr(into, it->first, it->second);
81  }
82  return true;
83  }
84  }
85  return false;
86 }
87 
88 
89 void
90 BinaryFormatter::openTag(std::ostream& into, const std::string& xmlElement) {
91  if (SUMOXMLDefinitions::Tags.hasString(xmlElement)) {
92  openTag(into, (const SumoXMLTag)(SUMOXMLDefinitions::Tags.get(xmlElement)));
93  }
94 }
95 
96 
97 void
98 BinaryFormatter::openTag(std::ostream& into, const SumoXMLTag& xmlElement) {
99  myXMLStack.push_back(xmlElement);
101  const int tagNum = (int)xmlElement;
102  FileHelpers::writeByte(into, static_cast<unsigned char>(tagNum % 256));
103  FileHelpers::writeByte(into, static_cast<unsigned char>(tagNum / 256));
104 }
105 
106 
107 bool
108 BinaryFormatter::closeTag(std::ostream& into, const std::string& /*comment*/) {
109  if (!myXMLStack.empty()) {
111  myXMLStack.pop_back();
112  return true;
113  }
114  return false;
115 }
116 
117 
118 template<>
119 void BinaryFormatter::writeAttr(std::ostream& into, const SumoXMLAttr attr, const bool& val) {
121  FileHelpers::writeByte(into, val);
122 }
123 
124 
125 template<>
126 void BinaryFormatter::writeAttr(std::ostream& into, const SumoXMLAttr attr, const double& val) {
127  if (into.precision() == 2 && val < 2e7 && val > -2e7) { // 2e7 is roughly INT_MAX/100
129  FileHelpers::writeInt(into, int(val * 100. + .5));
130  } else {
132  FileHelpers::writeFloat(into, val);
133  }
134 }
135 
136 
137 template<>
138 void BinaryFormatter::writeAttr(std::ostream& into, const SumoXMLAttr attr, const int& val) {
140  FileHelpers::writeInt(into, val);
141 }
142 
143 
144 template<>
145 void BinaryFormatter::writeAttr(std::ostream& into, const SumoXMLAttr attr, const SumoXMLNodeType& val) {
147  FileHelpers::writeByte(into, static_cast<unsigned char>(val));
148 }
149 
150 
151 template<>
152 void BinaryFormatter::writeAttr(std::ostream& into, const SumoXMLAttr attr, const SumoXMLEdgeFunc& val) {
154  FileHelpers::writeByte(into, static_cast<unsigned char>(val));
155 }
156 
157 
158 void BinaryFormatter::writePosition(std::ostream& into, const Position& val) {
159  if (val.z() != 0.) {
160  if (into.precision() == 2 && val.x() < 2e7 && val.x() > -2e7 &&
161  val.y() < 2e7 && val.y() > -2e7 && val.z() < 2e7 && val.z() > -2e7) { // 2e7 is roughly INT_MAX/100
163  FileHelpers::writeInt(into, int(val.x() * 100. + .5));
164  FileHelpers::writeInt(into, int(val.y() * 100. + .5));
165  FileHelpers::writeInt(into, int(val.z() * 100. + .5));
166  } else {
168  FileHelpers::writeFloat(into, val.x());
169  FileHelpers::writeFloat(into, val.y());
170  FileHelpers::writeFloat(into, val.z());
171  }
172  } else {
173  if (into.precision() == 2 && val.x() < 2e7 && val.x() > -2e7 &&
174  val.y() < 2e7 && val.y() > -2e7) { // 2e7 is roughly INT_MAX/100
176  FileHelpers::writeInt(into, int(val.x() * 100. + .5));
177  FileHelpers::writeInt(into, int(val.y() * 100. + .5));
178  } else {
180  FileHelpers::writeFloat(into, val.x());
181  FileHelpers::writeFloat(into, val.y());
182  }
183  }
184 }
185 
186 
187 template<>
188 void BinaryFormatter::writeAttr(std::ostream& into, const SumoXMLAttr attr, const Position& val) {
190  writePosition(into, val);
191 }
192 
193 
194 template<>
195 void BinaryFormatter::writeAttr(std::ostream& into, const SumoXMLAttr attr, const PositionVector& val) {
197  FileHelpers::writeInt(into, static_cast<int>(val.size()));
198  for (PositionVector::const_iterator pos = val.begin(); pos != val.end(); ++pos) {
199  writePosition(into, *pos);
200  }
201 }
202 
203 
204 template<>
205 void BinaryFormatter::writeAttr(std::ostream& into, const SumoXMLAttr attr, const Boundary& val) {
207  FileHelpers::writeFloat(into, val.xmin());
208  FileHelpers::writeFloat(into, val.ymin());
209  FileHelpers::writeFloat(into, val.xmax());
210  FileHelpers::writeFloat(into, val.ymax());
211 }
212 
213 
214 template<>
215 void BinaryFormatter::writeAttr(std::ostream& into, const SumoXMLAttr attr, const RGBColor& val) {
217  FileHelpers::writeByte(into, val.red());
218  FileHelpers::writeByte(into, val.green());
219  FileHelpers::writeByte(into, val.blue());
220  FileHelpers::writeByte(into, val.alpha());
221 }
222 
223 
224 template<>
225 void BinaryFormatter::writeAttr(std::ostream& into, const SumoXMLAttr /* attr */, const std::vector<int>& val) {
227  FileHelpers::writeInt(into, (int)val.size());
228  for (std::vector<int>::const_iterator it = val.begin(); it != val.end(); ++it) {
230  FileHelpers::writeInt(into, *it);
231  }
232 }
233 
234 
235 /****************************************************************************/
RGBColor::alpha
unsigned char alpha() const
Returns the alpha-amount of the color.
Definition: RGBColor.h:82
Boundary.h
ToString.h
BinaryFormatter::BF_SCALED2INT_POSITION_3D
Definition: BinaryFormatter.h:97
Boundary::ymin
double ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:130
Position::z
double z() const
Returns the z-position.
Definition: Position.h:66
BinaryFormatter::BF_XML_TAG_START
Definition: BinaryFormatter.h:69
FileHelpers.h
BinaryFormatter::writeStaticHeader
static void writeStaticHeader(std::ostream &into)
writes the part of the header which is always unchanged.
Definition: BinaryFormatter.cpp:46
FileHelpers::writeInt
static std::ostream & writeInt(std::ostream &strm, int value)
Writes an integer binary.
Definition: FileHelpers.cpp:184
Boundary::xmax
double xmax() const
Returns maximum x-coordinate.
Definition: Boundary.cpp:124
SumoXMLEdgeFunc
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
Definition: SUMOXMLDefinitions.h:1079
BinaryFormatter::BF_LIST
Definition: BinaryFormatter.h:67
BinaryFormatter::BF_NODE_TYPE
Definition: BinaryFormatter.h:87
RGBColor::red
unsigned char red() const
Returns the red-amount of the color.
Definition: RGBColor.h:61
BinaryFormatter::BF_BYTE
Definition: BinaryFormatter.h:59
FileHelpers::writeFloat
static std::ostream & writeFloat(std::ostream &strm, double value)
Writes a float binary.
Definition: FileHelpers.cpp:191
FileHelpers::writeByte
static std::ostream & writeByte(std::ostream &strm, unsigned char value)
Writes a byte binary.
Definition: FileHelpers.cpp:198
PositionVector
A list of positions.
Definition: PositionVector.h:45
BinaryFormatter::BF_XML_TAG_END
Definition: BinaryFormatter.h:71
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:41
RGBColor.h
BinaryFormatter::closeTag
bool closeTag(std::ostream &into, const std::string &comment="")
Closes the most recently opened tag.
Definition: BinaryFormatter.cpp:108
RGBColor
Definition: RGBColor.h:39
Boundary::xmin
double xmin() const
Returns minimum x-coordinate.
Definition: Boundary.cpp:118
BinaryFormatter::BF_SCALED2INT_POSITION_2D
Definition: BinaryFormatter.h:95
FileHelpers::writeString
static std::ostream & writeString(std::ostream &strm, const std::string &value)
Writes a string binary.
Definition: FileHelpers.cpp:205
SumoXMLNodeType
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
Definition: SUMOXMLDefinitions.h:1054
BinaryFormatter::BF_SCALED2INT
Definition: BinaryFormatter.h:93
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:41
BinaryFormatter::openTag
void openTag(std::ostream &into, const std::string &xmlElement)
Opens an XML tag.
Definition: BinaryFormatter.cpp:90
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:38
Position::x
double x() const
Returns the x-position.
Definition: Position.h:56
BinaryFormatter::BF_EDGE_FUNCTION
Definition: BinaryFormatter.h:89
BinaryFormatter::writeStringList
static void writeStringList(std::ostream &into, const std::vector< std::string > &list)
writes a list of strings
Definition: BinaryFormatter.cpp:59
SUMOXMLDefinitions::Attrs
static StringBijection< int > Attrs
The names of SUMO-XML attributes for use in netbuild.
Definition: SUMOXMLDefinitions.h:1362
RGBColor::green
unsigned char green() const
Returns the green-amount of the color.
Definition: RGBColor.h:68
BinaryFormatter::BF_POSITION_2D
Definition: BinaryFormatter.h:79
BinaryFormatter::writeXMLHeader
bool writeXMLHeader(std::ostream &into, const std::string &rootElement, const std::map< SumoXMLAttr, std::string > &attrs)
Writes an XML header with optional configuration.
Definition: BinaryFormatter.cpp:70
BinaryFormatter::myXMLStack
std::vector< SumoXMLTag > myXMLStack
The stack of begun xml elements.
Definition: BinaryFormatter.h:254
BinaryFormatter::BF_INTEGER
Definition: BinaryFormatter.h:61
BinaryFormatter::BF_POSITION_3D
Definition: BinaryFormatter.h:81
BinaryFormatter::BinaryFormatter
BinaryFormatter()
Constructor.
Definition: BinaryFormatter.cpp:41
Position::y
double y() const
Returns the y-position.
Definition: Position.h:61
SUMOXMLDefinitions::Tags
static StringBijection< int > Tags
The names of SUMO-XML elements for use in netbuild.
Definition: SUMOXMLDefinitions.h:1359
RGBColor::blue
unsigned char blue() const
Returns the blue-amount of the color.
Definition: RGBColor.h:75
SUMOXMLDefinitions::EdgeFunctions
static StringBijection< SumoXMLEdgeFunc > EdgeFunctions
edge functions
Definition: SUMOXMLDefinitions.h:1371
BinaryFormatter::writeAttrHeader
static void writeAttrHeader(std::ostream &into, const SumoXMLAttr attr, const DataType type=BF_INVALID)
writes the header for an arbitrary attribute
Definition: BinaryFormatter.h:216
BinaryFormatter::BF_STRING
Definition: BinaryFormatter.h:65
BinaryFormatter::writePosition
static void writePosition(std::ostream &into, const Position &val)
writes a position
Definition: BinaryFormatter.cpp:158
BinaryFormatter::BF_BOUNDARY
Definition: BinaryFormatter.h:83
config.h
BinaryFormatter::writeAttr
static void writeAttr(dummy &into, const SumoXMLAttr attr, const T &val)
writes an arbitrary attribute
Definition: BinaryFormatter.h:290
BinaryFormatter::BF_FLOAT
Definition: BinaryFormatter.h:63
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition: SUMOXMLDefinitions.h:372
VERSION_STRING
#define VERSION_STRING
Definition: config.h:210
PositionVector.h
BinaryFormatter.h
SUMOXMLDefinitions.h
SUMOXMLDefinitions::NodeTypes
static StringBijection< SumoXMLNodeType > NodeTypes
node types
Definition: SUMOXMLDefinitions.h:1368
Boundary::ymax
double ymax() const
Returns maximum y-coordinate.
Definition: Boundary.cpp:136
BinaryFormatter::BF_COLOR
Definition: BinaryFormatter.h:85