1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
|
/***********************************************/
/**
* @file archive.h
*
* @brief Interface for streaming of data in different formats.
*
* @author Torsten Mayer-Guerr
* @date 2005-01-01
*
*/
/***********************************************/
#ifndef __GROOPS_ARCHIVE__
#define __GROOPS_ARCHIVE__
#include "base/importStd.h"
/** @defgroup archiveGroup Archive
* @brief Streaming of data in different formats.
* @ingroup inputOutputGroup */
/// @{
/***** TYPES ***********************************/
class Time;
class Angle;
class Vector;
class Matrix;
class MatrixSlice;
class const_MatrixSlice;
class SphericalHarmonics;
class Doodson;
class GnssType;
class Vector3d;
class Tensor3d;
class Rotary3d;
class Transform3d;
class Ellipsoid;
/***** CLASS ***********************************/
/** @brief Identifier for values in archives.
* Values need an identifier in xml format. */
template<typename T> class const_NameValue
{
const char *_name;
const T *_value;
public:
const_NameValue(const char *name, const T &value) : _name(name), _value(&value) {} //!< Constructor
const char *name() const {return _name;} //!< name
const T &value() const {return *_value;} //!< value
};
/** @brief Adapter for const_NameValue. */
template<typename T>
inline const const_NameValue<T> nameValue(const char *name, const T &x) {return const_NameValue<T>(name,x);}
/***** CLASS ***********************************/
/** @brief Identifier for values in archives.
* Values need an identifier in xml format. */
template<typename T> class NameValue
{
const char *_name;
T *_value;
public:
NameValue(const char *name, T &value) : _name(name), _value(&value) {} //!< Constructor
const char *name() const {return _name;} //!< name
T &value() const {return *_value;} //!< value
};
/** @brief Adapter for NameValue. */
template<typename T>
inline const NameValue<T> nameValue(const char *name, T &x) {return NameValue<T>(name,x);}
/***** CLASS ***********************************/
/** @brief Grouping values in archives.
* It is used in xml format. */
class BeginGroup
{
public:
const char *name; //!< name
BeginGroup(const char *_name) : name(_name) {} //!< Constructor
};
/** @brief Adapter for BeginGroup. */
inline const BeginGroup beginGroup(const char *name) {return BeginGroup(name);}
/***** CLASS ***********************************/
/** @brief Grouping values in archives.
* It is used in xml format. */
class EndGroup
{
public:
const char *name; //!< name
EndGroup(const char *_name) : name(_name) {} //!< Constructor
};
/** @brief Adapter for EndGroup. */
inline const EndGroup endGroup(const char *name) {return EndGroup(name);}
/***********************************************/
/***** CLASS ***********************************/
/***********************************************/
/** @brief Abstract interface for output archives. */
class OutArchive
{
public:
virtual ~OutArchive() {}
enum ArchiveType {ASCII, XML, JSON, BINARY};
virtual ArchiveType archiveType() const = 0;
template<typename T> OutArchive &operator<<(const NameValue<T> &nv);
template<typename T> OutArchive &operator<<(const const_NameValue<T> &nv);
OutArchive &operator<<(const BeginGroup &gr);
OutArchive &operator<<(const EndGroup &gr);
virtual void save(const std::string &x) = 0;
virtual void save(const Int &x) = 0;
virtual void save(const UInt &x) = 0;
virtual void save(const Double &x) = 0;
virtual void save(const Bool &x) = 0;
virtual void save(const Time &x) = 0;
virtual void save(const Angle &x) = 0;
virtual void save(const Vector &x) = 0;
virtual void save(const const_MatrixSlice &x) = 0;
virtual void save(const SphericalHarmonics &x) = 0;
virtual void save(const Doodson &x) = 0;
virtual void save(const GnssType &x) = 0;
virtual void startTag(const std::string &/*name*/) {}
virtual void endTag (const std::string &/*name*/) {}
virtual void endLine() {}
virtual void comment(const std::string &/*text*/) {}
};
/***** CLASS ***********************************/
/** @brief Abstract interface for input archives. */
class InArchive
{
protected:
static UInt versionStr2version(const std::string &str);
public:
virtual ~InArchive() {}
template<typename T>
InArchive &operator>>(const NameValue<T> &nv);
InArchive &operator>>(const BeginGroup &gr);
InArchive &operator>>(const EndGroup &gr);
enum ArchiveType {ASCII, XML, JSON, BINARY};
virtual ArchiveType archiveType() const = 0;
virtual std::string type() const = 0;
virtual UInt version() const = 0;
virtual void startTag(const std::string &/*name*/) {}
virtual void endTag (const std::string &/*name*/) {}
virtual void load(std::string &x) = 0;
virtual void load(Int &x) = 0;
virtual void load(UInt &x) = 0;
virtual void load(Double &x) = 0;
virtual void load(Bool &x) = 0;
virtual void load(Time &x) = 0;
virtual void load(Angle &x) = 0;
virtual void load(Vector &x) = 0;
virtual void load(Matrix &x) = 0;
virtual void load(SphericalHarmonics &x) = 0;
virtual void load(Doodson &x) = 0;
virtual void load(GnssType &x) = 0;
};
/***** FUNCTIONS *******************************/
template<typename T> void save(OutArchive &ar, const std::vector<T> &x);
template<typename T> inline void save(OutArchive &ar, const T &x) {x.save(ar);}
template<> inline void save(OutArchive &ar, const std::string &x) {ar.save(x);}
template<> inline void save(OutArchive &ar, const Int &x) {ar.save(x);}
template<> inline void save(OutArchive &ar, const UInt &x) {ar.save(x);}
template<> inline void save(OutArchive &ar, const Double &x) {ar.save(x);}
template<> inline void save(OutArchive &ar, const Bool &x) {ar.save(x);}
template<> inline void save(OutArchive &ar, const Time &x) {ar.save(x);}
template<> inline void save(OutArchive &ar, const Angle &x) {ar.save(x);}
template<> inline void save(OutArchive &ar, const Vector &x) {ar.save(x);}
template<> inline void save(OutArchive &ar, const Matrix &x) {ar.save(x);}
template<> inline void save(OutArchive &ar, const MatrixSlice &x) {ar.save(x);}
template<> inline void save(OutArchive &ar, const const_MatrixSlice &x) {ar.save(x);}
template<> inline void save(OutArchive &ar, const SphericalHarmonics &x) {ar.save(x);}
template<> inline void save(OutArchive &ar, const Doodson &x) {ar.save(x);}
template<> inline void save(OutArchive &ar, const GnssType &x) {ar.save(x);}
template<> void save(OutArchive &ar, const Vector3d &x);
template<> void save(OutArchive &ar, const Tensor3d &x);
template<> void save(OutArchive &ar, const Rotary3d &x);
template<> void save(OutArchive &ar, const Transform3d &x);
template<> void save(OutArchive &ar, const Ellipsoid &x);
template<typename T> void load(InArchive &ar, std::vector<T> &x);
template<typename T> inline void load(InArchive &ar, T &x) {x.load(ar);}
template<> inline void load(InArchive &ar, std::string &x) {ar.load(x);}
template<> inline void load(InArchive &ar, Int &x) {ar.load(x);}
template<> inline void load(InArchive &ar, UInt &x) {ar.load(x);}
template<> inline void load(InArchive &ar, Double &x) {ar.load(x);}
template<> inline void load(InArchive &ar, Bool &x) {ar.load(x);}
template<> inline void load(InArchive &ar, Time &x) {ar.load(x);}
template<> inline void load(InArchive &ar, Angle &x) {ar.load(x);}
template<> inline void load(InArchive &ar, Vector &x) {ar.load(x);}
template<> inline void load(InArchive &ar, Matrix &x) {ar.load(x);}
template<> inline void load(InArchive &ar, SphericalHarmonics &x) {ar.load(x);}
template<> inline void load(InArchive &ar, Doodson &x) {ar.load(x);}
template<> inline void load(InArchive &ar, GnssType &x) {ar.load(x);}
template<> void load(InArchive &ar, Vector3d &x);
template<> void load(InArchive &ar, Tensor3d &x);
template<> void load(InArchive &ar, Rotary3d &x);
template<> void load(InArchive &ar, Transform3d &x);
template<> void load(InArchive &ar, Ellipsoid &x);
/// @}
/***********************************************/
/***** INLINES ***********************************/
/***********************************************/
template<typename T> void save(OutArchive &ar, const std::vector<T> &x)
{
UInt size = x.size();
ar<<nameValue("count", size);
ar.endLine();
for(UInt i=0; i<size; i++)
{
ar<<nameValue("cell", const_cast<std::vector<T>&>(x).at(i));
ar.endLine();
}
}
/***********************************************/
template<typename T> void load(InArchive &ar, std::vector<T> &x)
{
UInt size;
ar>>nameValue("count", size);
x.resize(size);
for(UInt i=0; i<size; i++)
ar>>nameValue("cell", x.at(i));
}
/***********************************************/
/***********************************************/
inline OutArchive &OutArchive::operator<<(const BeginGroup &gr)
{
startTag(gr.name);
endLine();
return *this;
}
/***********************************************/
inline InArchive &InArchive::operator>>(const BeginGroup &gr)
{
startTag(gr.name);
return *this;
}
/***********************************************/
inline OutArchive &OutArchive::operator<<(const EndGroup &gr)
{
endTag(gr.name);
endLine();
return *this;
}
/***********************************************/
inline InArchive &InArchive::operator>>(const EndGroup &gr)
{
endTag(gr.name);
return *this;
}
/***********************************************/
template<typename T>
inline OutArchive &OutArchive::operator<<(const const_NameValue<T> &nv)
{
startTag(nv.name());
::save(*this,nv.value());
endTag(nv.name());
return *this;
}
/***********************************************/
template<typename T>
inline OutArchive &OutArchive::operator<<(const NameValue<T> &nv)
{
startTag(nv.name());
::save(*this,nv.value());
endTag(nv.name());
return *this;
}
/***********************************************/
template<typename T>
inline InArchive &InArchive::operator>>(const NameValue<T> &nv)
{
startTag(nv.name());
::load(*this,nv.value());
endTag(nv.name());
return *this;
}
/***********************************************/
/***********************************************/
#endif
|
