cisst-saw
Toggle main menu visibility
Loading...
Searching...
No Matches
tmp
cisst-saw
cisst
cisstCommon
cmnDataFunctionsMacros.h
Go to the documentation of this file.
1
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */
3
4
/*
5
Author(s): Anton Deguet
6
Created on: 2011-06-27
7
8
(C) Copyright 2011-2018 Johns Hopkins University (JHU), All Rights Reserved.
9
10
--- begin cisst license - do not edit ---
11
12
This software is provided "as is" under an open source license, with
13
no warranty. The complete license can be found in license.txt and
14
http://www.cisst.org/cisst/license.txt.
15
16
--- end cisst license ---
17
18
*/
19
20
#pragma once
21
#ifndef _cmnDataFunctionsMacros_h
22
#define _cmnDataFunctionsMacros_h
23
24
31
#define CMN_DATA_COPY_USING_ASSIGN(_type) \
32
static void Copy(_type & data, \
33
const _type & source) { \
34
data = source; \
35
}
36
37
39
#define CMN_DATA_SERIALIZE_DESCRIPTION(_type, _description) \
40
static std::string SerializeDescription(const _type & CMN_UNUSED(data), \
41
const char CMN_UNUSED(delimiter) = ',', \
42
const std::string & userDescription = "") \
43
{ \
44
return (userDescription == "" ? "{"#_description"}" : (userDescription + ":{"#_description"}")); \
45
}
46
47
48
#define CMN_DATA_SERIALIZE_BINARY_BYTE_SIZE_USING_SIZEOF(_type) \
49
static size_t SerializeBinaryByteSize(const _type & CMN_UNUSED(data)) \
50
{ \
51
return sizeof(_type); \
52
}
53
60
#define CMN_DATA_SERIALIZE_BINARY_BUFFER_USING_CAST_TO_CHAR(_type) \
61
static size_t SerializeBinary(const _type & data, \
62
char * buffer, size_t bufferSize) \
63
{ \
64
const size_t sizeOfData = cmnData<_type>::SerializeBinaryByteSize(data); \
65
if (bufferSize < sizeOfData) { \
66
return 0; \
67
} \
68
*(reinterpret_cast<_type *>(buffer)) = data; \
69
bufferSize -= sizeOfData; \
70
return sizeOfData; \
71
}
72
73
#define CMN_DATA_DE_SERIALIZE_BINARY_BUFFER_USING_CAST_TO_CHAR_NO_BYTE_SWAP(_type) \
74
static size_t DeSerializeBinary(_type & data, const char * buffer, size_t bufferSize, \
75
const cmnDataFormat & CMN_UNUSED(localFormat), \
76
const cmnDataFormat & CMN_UNUSED(remoteFormat)) \
77
{ \
78
const size_t sizeOfData = cmnData<_type>::SerializeBinaryByteSize(data); \
79
if (bufferSize < sizeOfData) { \
80
return 0; \
81
} \
82
data = *(reinterpret_cast<const _type *>(buffer)); \
83
bufferSize -= sizeOfData; \
84
return sizeOfData; \
85
}
86
87
#define CMN_DATA_DE_SERIALIZE_BINARY_BUFFER_USING_CAST_TO_CHAR_AND_BYTE_SWAP(_type) \
88
static size_t DeSerializeBinary(_type & data, const char * buffer, size_t bufferSize, \
89
const cmnDataFormat & localFormat, \
90
const cmnDataFormat & remoteFormat) \
91
{ \
92
const size_t sizeOfData = cmnData<_type>::SerializeBinaryByteSize(data); \
93
if (bufferSize < sizeOfData) { \
94
return 0; \
95
} \
96
data = *(reinterpret_cast<const _type *>(buffer)); \
97
if (remoteFormat.GetEndianness() != localFormat.GetEndianness()) { \
98
cmnDataByteSwap(data); \
99
} \
100
bufferSize -= sizeOfData; \
101
return sizeOfData; \
102
}
103
110
#define CMN_DATA_SERIALIZE_BINARY_STREAM_USING_CAST_TO_CHAR(_type) \
111
static void SerializeBinary(const _type & data, \
112
std::ostream & outputStream) \
113
CISST_THROW(std::runtime_error) \
114
{ \
115
outputStream.write(reinterpret_cast<const char *>(&data), \
116
sizeof(_type)); \
117
if (outputStream.fail()) { \
118
cmnThrow("cmnData::SerializeBinary(" #_type "): error occured with std::ostream::write"); \
119
} \
120
}
121
122
123
#define CMN_DATA_DE_SERIALIZE_BINARY_STREAM_USING_CAST_TO_CHAR_NO_BYTE_SWAP(_type) \
124
static void DeSerializeBinary(_type & data, \
125
std::istream & inputStream, \
126
const cmnDataFormat & CMN_UNUSED(localFormat), \
127
const cmnDataFormat & CMN_UNUSED(remoteFormat)) \
128
CISST_THROW(std::runtime_error) \
129
{ \
130
inputStream.read(reinterpret_cast<char *>(&data), \
131
sizeof(_type)); \
132
if (inputStream.fail()) { \
133
cmnThrow("cmnData::DeSerializeBinary(" #_type "): error occured with std::istream::read"); \
134
} \
135
}
136
137
138
#define CMN_DATA_DE_SERIALIZE_BINARY_STREAM_USING_CAST_TO_CHAR_AND_BYTE_SWAP(_type) \
139
static void DeSerializeBinary(_type & data, \
140
std::istream & inputStream, \
141
const cmnDataFormat & localFormat, \
142
const cmnDataFormat & remoteFormat) \
143
CISST_THROW(std::runtime_error) \
144
{ \
145
inputStream.read(reinterpret_cast<char *>(&data), \
146
sizeof(_type)); \
147
if (inputStream.fail()) { \
148
cmnThrow("cmnData::DeSerializeBinary(" #_type "): error occured with std::istream::read"); \
149
} \
150
if (remoteFormat.GetEndianness() != localFormat.GetEndianness()) { \
151
cmnDataByteSwap(data); \
152
} \
153
}
154
155
158
#define CMN_DATA_SERIALIZE_TEXT_USING_STREAM_OUT(_type) \
159
static void SerializeText(const _type & data, \
160
std::ostream & outputStream, \
161
const char CMN_UNUSED(delimiter) = ',') \
162
CISST_THROW(std::runtime_error) \
163
{ \
164
outputStream << data; \
165
if (outputStream.fail()) { \
166
cmnThrow("cmnData::SerializeText(" #_type "): error occured with std::ostream::write"); \
167
} \
168
}
169
170
173
#define CMN_DATA_DE_SERIALIZE_TEXT_USING_STREAM_IN(_type) \
174
static void DeSerializeText(_type & data, \
175
std::istream & inputStream, \
176
const char CMN_UNUSED(delimiter) = ',') \
177
CISST_THROW(std::runtime_error) \
178
{ \
179
inputStream >> data; \
180
if (inputStream.fail()) { \
181
cmnThrow("cmnData::DeSerializeText(" #_type "): error occured with std::istream::read"); \
182
} \
183
}
184
185
188
#define CMN_DATA_HUMAN_READABLE_USING_STREAM_OUT(_type) \
189
static std::string HumanReadable(const _type & data) \
190
{ \
191
std::stringstream stringStream; \
192
stringStream << data; \
193
return stringStream.str(); \
194
}
195
196
200
#define CMN_DATA_SCALAR_DESCRIPTION(_type, _description) \
201
static std::string ScalarDescription(const _type & CMN_UNUSED(data), \
202
const size_t CMN_UNUSED(index), \
203
const std::string & userDescription = "") \
204
CISST_THROW(std::out_of_range) { \
205
return (userDescription == "" ? "{"#_description"}" : (userDescription + ":{"#_description"}")); \
206
}
207
209
#define CMN_DATA_SCALAR_USING_STATIC_CAST(_type) \
210
static double Scalar(const _type & data, const size_t CMN_UNUSED(index)) \
211
CISST_THROW(std::out_of_range) { \
212
return static_cast<double>(data); \
213
}
214
216
#define CMN_DATA_SCALAR_NUMBER_IS_ONE(_type) \
217
static size_t ScalarNumber(const _type & CMN_UNUSED(data)) { \
218
return 1; \
219
}
220
221
#define CMN_DATA_SCALAR_NUMBER_IS_FIXED_TRUE(_type) \
222
static bool ScalarNumberIsFixed(const _type & CMN_UNUSED(data)) { \
223
return true; \
224
}
225
226
#define CMN_DATA_IS_SPECIALIZED_TRUE(_type) \
227
enum {IS_SPECIALIZED = 1};
228
229
#define CMN_DATA_SPECIALIZE_ALL_NO_BYTE_SWAP(type, description) \
230
template <> \
231
class cmnData<type> { \
232
public: \
233
CMN_DATA_IS_SPECIALIZED_TRUE(type) \
234
CMN_DATA_COPY_USING_ASSIGN(type) \
235
CMN_DATA_SERIALIZE_DESCRIPTION(type, description) \
236
CMN_DATA_SERIALIZE_BINARY_BYTE_SIZE_USING_SIZEOF(type) \
237
CMN_DATA_SERIALIZE_BINARY_BUFFER_USING_CAST_TO_CHAR(type) \
238
CMN_DATA_DE_SERIALIZE_BINARY_BUFFER_USING_CAST_TO_CHAR_NO_BYTE_SWAP(type) \
239
CMN_DATA_SERIALIZE_BINARY_STREAM_USING_CAST_TO_CHAR(type) \
240
CMN_DATA_DE_SERIALIZE_BINARY_STREAM_USING_CAST_TO_CHAR_NO_BYTE_SWAP(type) \
241
CMN_DATA_SERIALIZE_TEXT_USING_STREAM_OUT(type) \
242
CMN_DATA_DE_SERIALIZE_TEXT_USING_STREAM_IN(type) \
243
CMN_DATA_HUMAN_READABLE_USING_STREAM_OUT(type) \
244
CMN_DATA_SCALAR_DESCRIPTION(type, description) \
245
CMN_DATA_SCALAR_USING_STATIC_CAST(type) \
246
CMN_DATA_SCALAR_NUMBER_IS_ONE(type) \
247
CMN_DATA_SCALAR_NUMBER_IS_FIXED_TRUE(type) \
248
};
249
250
#define CMN_DATA_SPECIALIZE_ALL_BYTE_SWAP(type, description) \
251
template <> \
252
class cmnData<type> { \
253
public: \
254
CMN_DATA_IS_SPECIALIZED_TRUE(type) \
255
CMN_DATA_COPY_USING_ASSIGN(type) \
256
CMN_DATA_SERIALIZE_DESCRIPTION(type, description) \
257
CMN_DATA_SERIALIZE_BINARY_BYTE_SIZE_USING_SIZEOF(type) \
258
CMN_DATA_SERIALIZE_BINARY_BUFFER_USING_CAST_TO_CHAR(type) \
259
CMN_DATA_DE_SERIALIZE_BINARY_BUFFER_USING_CAST_TO_CHAR_AND_BYTE_SWAP(type) \
260
CMN_DATA_SERIALIZE_BINARY_STREAM_USING_CAST_TO_CHAR(type) \
261
CMN_DATA_DE_SERIALIZE_BINARY_STREAM_USING_CAST_TO_CHAR_AND_BYTE_SWAP(type) \
262
CMN_DATA_SERIALIZE_TEXT_USING_STREAM_OUT(type) \
263
CMN_DATA_DE_SERIALIZE_TEXT_USING_STREAM_IN(type) \
264
CMN_DATA_HUMAN_READABLE_USING_STREAM_OUT(type) \
265
CMN_DATA_SCALAR_DESCRIPTION(type, description) \
266
CMN_DATA_SCALAR_USING_STATIC_CAST(type) \
267
CMN_DATA_SCALAR_NUMBER_IS_ONE(type) \
268
CMN_DATA_SCALAR_NUMBER_IS_FIXED_TRUE(type) \
269
};
270
271
#endif
// _cmnDataFunctionsMacros_h
Generated by
1.18.0
1.18.0
1.18.0