itom
Loading...
Searching...
No Matches
fileUtils.h
1/* ********************************************************************
2 itom software
3 URL: http://www.uni-stuttgart.de/ito
4 Copyright (C) 2020, Institut für Technische Optik (ITO),
5 Universität Stuttgart, Germany
6
7 This file is part of itom and its software development toolkit (SDK).
8
9 itom is free software; you can redistribute it and/or modify it
10 under the terms of the GNU Library General Public Licence as published by
11 the Free Software Foundation; either version 2 of the Licence, or (at
12 your option) any later version.
13
14 In addition, as a special exception, the Institut für Technische
15 Optik (ITO) gives you certain additional rights.
16 These rights are described in the ITO LGPL Exception version 1.0,
17 which can be found in the file LGPL_EXCEPTION.txt in this package.
18
19 itom is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library
22 General Public Licence for more details.
23
24 You should have received a copy of the GNU Library General Public License
25 along with itom. If not, see <http://www.gnu.org/licenses/>.
26*********************************************************************** */
27
28#ifndef FILEUTILS_H
29#define FILEUTILS_H
30
31#include "retVal.h"
32#include "typeDefs.h"
33#include <qendian.h>
34#include <qiodevice.h>
35
36
37#if !defined(Q_MOC_RUN) || defined(ITOMCOMMONQT_MOC) //only moc this file in itomCommonQtLib but not in other libraries or executables linking against this itomCommonQtLib
38
39namespace ito
40{
41 //all these methods increment the input pointer by the size of the returned number
42 inline ito::int8 getInt8(const uchar **ppval);
43 inline ito::uint8 getUInt8(const uchar **ppval);
44 inline ito::int16 getInt16LE(const uchar **ppval);
45 inline ito::int16 getInt16BE(const uchar **ppval);
46 inline ito::uint16 getUInt16LE(const uchar **ppval);
47 inline ito::uint16 getUInt16BE(const uchar **ppval);
48 inline ito::int32 getInt32LE(const uchar **ppval);
49 inline ito::int16 getInt16BE(const uchar **ppval);
50 inline ito::uint32 getUInt32LE(const uchar **ppval);
51 inline ito::uint32 getUInt32BE(const uchar **ppval);
52 inline qint64 getInt64LE(const uchar **ppval);
53 inline qint64 getInt64BE(const uchar **ppval);
54 inline quint64 getUInt64LE(const uchar **ppval);
55 inline quint64 getUInt64BE(const uchar **ppval);
56 inline ito::float32 getFloat32LE(const uchar **ppval);
57 inline ito::float32 getFloat32BE(const uchar **ppval);
58 inline ito::float64 getFloat64LE(const uchar **ppval);
59 inline ito::float64 getFloat64BE(const uchar **ppval);
60
61 inline ito::int16 swapInt16(ito::int16 val);
62 inline ito::uint16 swapUInt16(ito::uint16 val);
63 inline ito::int32 swapInt32(ito::int32 val);
64 inline ito::uint32 swapUInt32(ito::uint32 val);
65 inline ito::float32 swapFloat32(ito::float32 val);
66 inline ito::float64 swapFloat64(ito::float64 val);
67
69 ito::RetVal ITOMCOMMONQT_EXPORT readFromDevice(QIODevice *device, char *data, qint64 numBytes);
70
71 //sources
72
73 //--------------------------------------------------------------------------------------------
74 inline ito::int8 getInt8(const uchar **ppval)
75 {
76 const ito::int8 *pval = (const ito::int8*)(*ppval);
77 ito::int8 v = *pval;
78 *ppval += sizeof(ito::uint8);
79 return v;
80 }
81
82 //--------------------------------------------------------------------------------------------
83 inline ito::uint8 getUInt8(const uchar **ppval)
84 {
85 const ito::uint8 *pval = (const ito::uint8*)(*ppval);
86 ito::uint8 v = *pval;
87 *ppval += sizeof(ito::uint8);
88 return v;
89 }
90
91 //--------------------------------------------------------------------------------------------
92 inline ito::int16 getInt16LE(const uchar **ppval)
93 {
94 const ito::int16 *pval = (const ito::int16*)(*ppval);
95 ito::int16 v = qFromLittleEndian(*pval);
96 *ppval += sizeof(ito::int16);
97 return v;
98 }
99
100 //--------------------------------------------------------------------------------------------
101 inline ito::int16 getInt16BE(const uchar **ppval)
102 {
103 const ito::int16 *pval = (const ito::int16*)(*ppval);
104 ito::int16 v = qFromBigEndian(*pval);
105 *ppval += sizeof(ito::int16);
106 return v;
107 }
108
109 //--------------------------------------------------------------------------------------------
110 inline ito::uint16 getUInt16LE(const uchar **ppval)
111 {
112 const ito::uint16 *pval = (const ito::uint16*)(*ppval);
113 ito::uint16 v = qFromLittleEndian(*pval);
114 *ppval += sizeof(ito::uint16);
115 return v;
116 }
117
118 //--------------------------------------------------------------------------------------------
119 inline ito::uint16 getUInt16BE(const uchar **ppval)
120 {
121 const ito::uint16 *pval = (const ito::uint16*)(*ppval);
122 ito::uint16 v = qFromBigEndian(*pval);
123 *ppval += sizeof(ito::uint16);
124 return v;
125 }
126
127 //--------------------------------------------------------------------------------------------
128 inline ito::int32 getInt32LE(const uchar **ppval)
129 {
130 const ito::int32 *pval = (const ito::int32*)(*ppval);
131 ito::int32 v = qFromLittleEndian(*pval);
132 *ppval += sizeof(ito::int32);
133 return v;
134 }
135
136 //--------------------------------------------------------------------------------------------
137 inline ito::int32 getInt32BE(const uchar **ppval)
138 {
139 const ito::int32 *pval = (const ito::int32*)(*ppval);
140 ito::int32 v = qFromBigEndian(*pval);
141 *ppval += sizeof(ito::int32);
142 return v;
143 }
144
145 //--------------------------------------------------------------------------------------------
146 inline ito::uint32 getUInt32LE(const uchar **ppval)
147 {
148 const ito::uint32 *pval = (const ito::uint32*)(*ppval);
149 ito::uint32 v = qFromLittleEndian(*pval);
150 *ppval += sizeof(ito::uint32);
151 return v;
152 }
153
154 //--------------------------------------------------------------------------------------------
155 inline ito::uint32 getUInt32BE(const uchar **ppval)
156 {
157 const ito::uint32 *pval = (const ito::uint32*)(*ppval);
158 ito::uint32 v = qFromBigEndian(*pval);
159 *ppval += sizeof(ito::uint32);
160 return v;
161 }
162
163 //--------------------------------------------------------------------------------------------
164 inline qint64 getInt64LE(const uchar **ppval)
165 {
166 const qint64 *pval = (const qint64*)(*ppval);
167 qint64 v = qFromLittleEndian(*pval);
168 *ppval += sizeof(qint64);
169 return v;
170 }
171
172 //--------------------------------------------------------------------------------------------
173 inline qint64 getInt64BE(const uchar **ppval)
174 {
175 const qint64 *pval = (const qint64*)(*ppval);
176 qint64 v = qFromBigEndian(*pval);
177 *ppval += sizeof(qint64);
178 return v;
179 }
180
181 //--------------------------------------------------------------------------------------------
182 inline quint64 getUInt64LE(const uchar **ppval)
183 {
184 const quint64 *pval = (const quint64*)(*ppval);
185 quint64 v = qFromLittleEndian(*pval);
186 *ppval += sizeof(quint64);
187 return v;
188 }
189
190 //--------------------------------------------------------------------------------------------
191 inline quint64 getUInt64BE(const uchar **ppval)
192 {
193 const quint64 *pval = (const quint64*)(*ppval);
194 quint64 v = qFromBigEndian(*pval);
195 *ppval += sizeof(quint64);
196 return v;
197 }
198
199 //--------------------------------------------------------------------------------------------
200 inline ito::float32 getFloat32LE(const uchar **ppval)
201 {
202 union
203 {
204 ito::uint8 pp[4];
205 ito::float32 f;
206 } z;
207
208#if (Q_BYTE_ORDER == Q_LITTLE_ENDIAN)
209 memcpy(z.pp, *ppval, sizeof(ito::float32));
210#else
211 z.pp[0] = (*ppval)[3];
212 z.pp[1] = (*ppval)[2];
213 z.pp[2] = (*ppval)[1];
214 z.pp[3] = (*ppval)[0];
215#endif
216 *ppval += sizeof(ito::float32);
217 return z.f;
218 }
219
220 //--------------------------------------------------------------------------------------------
221 inline ito::float32 getFloat32BE(const uchar **ppval)
222 {
223 union
224 {
225 ito::uint8 pp[4];
226 ito::float32 f;
227 } z;
228
229#if (Q_BYTE_ORDER == Q_BIG_ENDIAN)
230 memcpy(z.pp, *ppval, sizeof(ito::float32));
231#else
232 z.pp[0] = (*ppval)[3];
233 z.pp[1] = (*ppval)[2];
234 z.pp[2] = (*ppval)[1];
235 z.pp[3] = (*ppval)[0];
236#endif
237 *ppval += sizeof(ito::float32);
238 return z.f;
239 }
240
241 //--------------------------------------------------------------------------------------------
242 inline ito::float64 getFloat64LE(const uchar **ppval)
243 {
244 union
245 {
246 ito::uint8 pp[8];
247 ito::float64 d;
248 } z;
249
250#if (Q_BYTE_ORDER == Q_LITTLE_ENDIAN)
251 memcpy(z.pp, *ppval, sizeof(ito::float64));
252#else
253 z.pp[0] = (*ppval)[7];
254 z.pp[1] = (*ppval)[6];
255 z.pp[2] = (*ppval)[5];
256 z.pp[3] = (*ppval)[4];
257 z.pp[4] = (*ppval)[3];
258 z.pp[5] = (*ppval)[2];
259 z.pp[6] = (*ppval)[1];
260 z.pp[7] = (*ppval)[0];
261#endif
262 *ppval += sizeof(ito::float64);
263 return z.d;
264 }
265
266 //--------------------------------------------------------------------------------------------
267 inline ito::float64 getFloat64BE(const uchar **ppval)
268 {
269 union
270 {
271 ito::uint8 pp[8];
272 ito::float64 d;
273 } z;
274
275#if (Q_BYTE_ORDER == Q_BIG_ENDIAN)
276 memcpy(z.pp, *ppval, sizeof(ito::float64));
277#else
278 z.pp[0] = (*ppval)[7];
279 z.pp[1] = (*ppval)[6];
280 z.pp[2] = (*ppval)[5];
281 z.pp[3] = (*ppval)[4];
282 z.pp[4] = (*ppval)[3];
283 z.pp[5] = (*ppval)[2];
284 z.pp[6] = (*ppval)[1];
285 z.pp[7] = (*ppval)[0];
286#endif
287 *ppval += sizeof(ito::float64);
288 return z.d;
289 }
290
291
292
293
294
295 //--------------------------------------------------------------------------------------------
296 inline ito::uint16 swapUInt16(ito::uint16 val)
297 {
298 union s
299 {
300 char sa[2];
301 ito::uint16 res;
302 } temp;
303 temp.res = val;
304 s uint16out;
305 for (int teller = 0; teller<2; ++teller){
306 uint16out.sa[teller] = temp.sa[1 - teller];
307 }
308 return uint16out.res;
309 }
310
311 //--------------------------------------------------------------------------------------------
312 inline ito::int16 swapInt16(ito::int16 val)
313 {
314 union s
315 {
316 char sa[2];
317 ito::int16 res;
318 } temp;
319 temp.res = val;
320 s int16out;
321 for (int teller = 0; teller<2; ++teller){
322 int16out.sa[teller] = temp.sa[1 - teller];
323 }
324 return int16out.res;
325 }
326
327 //--------------------------------------------------------------------------------------------
328 inline ito::uint32 swapUInt32(ito::uint32 val)
329 {
330 union s
331 {
332 char sa[4];
333 ito::uint32 res;
334 } temp;
335 temp.res = val;
336 s uint32out;
337 for (int teller = 0; teller<4; ++teller){
338 uint32out.sa[teller] = temp.sa[3 - teller];
339 }
340 return uint32out.res;
341 }
342
343 //--------------------------------------------------------------------------------------------
344 inline ito::int32 swapInt32(ito::int32 val)
345 {
346 union s
347 {
348 char sa[4];
349 ito::int32 res;
350 } temp;
351 temp.res = val;
352 s int32out;
353 for (int teller = 0; teller<4; ++teller){
354 int32out.sa[teller] = temp.sa[3 - teller];
355 }
356 return int32out.res;
357 }
358
359 //--------------------------------------------------------------------------------------------
360 inline ito::float32 swapFloat32(ito::float32 val)
361 {
362 union s
363 {
364 char pp[4];
365 ito::float32 f;
366 } temp;
367
368 temp.f = val;
369 s float32out;
370 float32out.pp[0] = temp.pp[3];
371 float32out.pp[1] = temp.pp[2];
372 float32out.pp[2] = temp.pp[1];
373 float32out.pp[3] = temp.pp[0];
374 return float32out.f;
375 }
376
377 //--------------------------------------------------------------------------------------------
378 inline ito::float64 swapFloat64(ito::float64 val)
379 {
380 union s
381 {
382 char pp[8];
383 ito::float64 f;
384 } temp;
385
386 temp.f = val;
387 s float64out;
388 float64out.pp[0] = temp.pp[7];
389 float64out.pp[1] = temp.pp[6];
390 float64out.pp[2] = temp.pp[5];
391 float64out.pp[3] = temp.pp[4];
392 float64out.pp[4] = temp.pp[3];
393 float64out.pp[5] = temp.pp[2];
394 float64out.pp[6] = temp.pp[1];
395 float64out.pp[7] = temp.pp[0];
396 return float64out.f;
397 }
398
399}; // end namespace ito
400
401#endif //#if !defined(Q_MOC_RUN) || defined(ITOMCOMMONQT_MOC)
402
403#endif
ito::RetVal
Class for managing status values (like errors or warning)
Definition retVal.h:54
ito
Definition apiFunctionsGraph.cpp:40
ito::swapFloat64
ito::float64 swapFloat64(ito::float64 val)
reads exactly numBytes from device into data and returns an error if less or no data is available
Definition fileUtils.h:378