Panda3D
Loading...
Searching...
No Matches
datagramIterator.I
Go to the documentation of this file.
1/**
2 * PANDA 3D SOFTWARE
3 * Copyright (c) Carnegie Mellon University. All rights reserved.
4 *
5 * All use of this software is subject to the terms of the revised BSD
6 * license. You should have received a copy of this license along
7 * with this source code in a file named "LICENSE."
8 *
9 * @file datagramIterator.I
10 * @author drose
11 * @date 2001-05-08
12 */
13
14/**
15 *
16 */
17INLINE DatagramIterator::
18DatagramIterator() :
19 _datagram(nullptr),
20 _current_index(0) {
21}
22
23/**
24 *
25 */
26INLINE DatagramIterator::
27DatagramIterator(const Datagram &datagram, size_t offset) :
28 _datagram(&datagram),
29 _current_index(offset) {
30 nassertv(_current_index <= _datagram->get_length());
31}
32
33/**
34 * direct Assignment to a Datagram
35 */
37assign(Datagram &datagram, size_t offset) {
38 _datagram = &datagram;
39 _current_index = offset;
40}
41
42// Various ways to get data and increment the iterator... Cut-and-paste-orama
43
44/**
45 * Extracts a boolean value.
46 */
48get_bool() {
49 return get_uint8() != 0;
50}
51
52/**
53 * Extracts a signed 8-bit integer.
54 */
55INLINE int8_t DatagramIterator::
56get_int8() {
57 nassertr(_datagram != nullptr, 0);
58 // Avoid reading junk data off the end of the datagram:
59 nassertr(_current_index < _datagram->get_length(), 0);
60 // Get the Data:
61 const char *ptr = (const char *)_datagram->get_data();
62 int8_t tempvar = (int8_t)ptr[_current_index];
63 ++_current_index;
64
65 return tempvar;
66}
67
68/**
69 * Extracts an unsigned 8-bit integer.
70 */
71INLINE uint8_t DatagramIterator::
72get_uint8() {
73 nassertr(_datagram != nullptr, 0);
74 // Avoid reading junk data off the end of the datagram:
75 nassertr(_current_index < _datagram->get_length(), 0);
76 // Get the Data:
77 const char *ptr = (const char *)_datagram->get_data();
78 uint8_t tempvar = (uint8_t)ptr[_current_index];
79 ++_current_index;
80
81 return tempvar;
82}
83
84/**
85 * Extracts a signed 16-bit integer.
86 */
87INLINE int16_t DatagramIterator::
88get_int16() {
89 nassertr(_datagram != nullptr, 0);
90 nassertr(_current_index < _datagram->get_length(), 0);
91
92 int16_t tempvar;
93 // Avoid reading junk data off the end of the datagram:
94 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
95 // Get the Data:
96 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
97 s.store_value(&tempvar, sizeof(tempvar));
98 _current_index += sizeof(tempvar);
99
100 return tempvar;
101}
102
103/**
104 * Extracts a signed 32-bit integer.
105 */
106INLINE int32_t DatagramIterator::
107get_int32() {
108 nassertr(_datagram != nullptr, 0);
109 nassertr(_current_index < _datagram->get_length(), 0);
110
111 int32_t tempvar;
112 // Avoid reading junk data off the end of the datagram:
113 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
114 // Get the Data:
115 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
116 s.store_value(&tempvar, sizeof(tempvar));
117 _current_index += sizeof(tempvar);
118
119 return tempvar;
120}
121
122/**
123 * Extracts a signed 64-bit integer.
124 */
125INLINE int64_t DatagramIterator::
126get_int64() {
127 nassertr(_datagram != nullptr, 0);
128 nassertr(_current_index < _datagram->get_length(), 0);
129
130 int64_t tempvar;
131 // Avoid reading junk data off the end of the datagram:
132 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
133 // Get the Data:
134 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
135 s.store_value(&tempvar, sizeof(tempvar));
136 _current_index += sizeof(tempvar);
137
138 return tempvar;
139}
140
141/**
142 * Extracts an unsigned 16-bit integer.
143 */
144INLINE uint16_t DatagramIterator::
145get_uint16() {
146 nassertr(_datagram != nullptr, 0);
147 nassertr(_current_index < _datagram->get_length(), 0);
148
149 uint16_t tempvar;
150 // Avoid reading junk data off the end of the datagram:
151 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
152 // Get the Data:
153 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
154 s.store_value(&tempvar, sizeof(tempvar));
155 _current_index += sizeof(tempvar);
156
157 return tempvar;
158}
159
160/**
161 * Extracts an unsigned 32-bit integer.
162 */
163INLINE uint32_t DatagramIterator::
164get_uint32() {
165 nassertr(_datagram != nullptr, 0);
166 nassertr(_current_index < _datagram->get_length(), 0);
167
168 uint32_t tempvar;
169 // Avoid reading junk data off the end of the datagram:
170 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
171 // Get the Data:
172 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
173 s.store_value(&tempvar, sizeof(tempvar));
174 _current_index += sizeof(tempvar);
175
176 return tempvar;
177}
178
179/**
180 * Extracts an unsigned 64-bit integer.
181 */
182INLINE uint64_t DatagramIterator::
183get_uint64() {
184 nassertr(_datagram != nullptr, 0);
185 nassertr(_current_index < _datagram->get_length(), 0);
186
187 uint64_t tempvar;
188 // Avoid reading junk data off the end of the datagram:
189 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
190 // Get the Data:
191 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
192 s.store_value(&tempvar, sizeof(tempvar));
193 _current_index += sizeof(tempvar);
194
195 return tempvar;
196}
197
198/**
199 * Extracts a 32-bit single-precision floating-point number.
200 */
201INLINE PN_float32 DatagramIterator::
202get_float32() {
203 nassertr(_datagram != nullptr, 0.0);
204 nassertr(_current_index < _datagram->get_length(), 0.0);
205
206 PN_float32 tempvar;
207 // Avoid reading junk data off the end of the datagram:
208 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0.0);
209 // Get the Data:
210 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
211 s.store_value(&tempvar, sizeof(tempvar));
212 _current_index += sizeof(tempvar);
213
214 return tempvar;
215}
216
217/**
218 * Extracts a 64-bit floating-point number.
219 */
220INLINE PN_float64 DatagramIterator::
221get_float64() {
222 nassertr(_datagram != nullptr, 0.0);
223 nassertr(_current_index < _datagram->get_length(), 0.0);
224
225 PN_float64 tempvar;
226 // Avoid reading junk data off the end of the datagram:
227 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0.0);
228 // Get the Data:
229 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
230 s.store_value(&tempvar, sizeof(tempvar));
231 _current_index += sizeof(tempvar);
232
233 return tempvar;
234}
235
236
237/**
238 * Extracts either a 32-bit or a 64-bit floating-point number, according to
239 * Datagram::set_stdfloat_double().
240 */
241INLINE PN_stdfloat DatagramIterator::
242get_stdfloat() {
243 nassertr(_datagram != nullptr, 0.0);
244 if (_datagram->get_stdfloat_double()) {
245 return (PN_stdfloat)get_float64();
246 } else {
247 return (PN_stdfloat)get_float32();
248 }
249}
250
251/**
252 * Extracts a signed 16-bit big-endian integer.
253 */
254INLINE int16_t DatagramIterator::
255get_be_int16() {
256 nassertr(_datagram != nullptr, 0);
257 nassertr(_current_index < _datagram->get_length(), 0);
258
259 int16_t tempvar;
260 // Avoid reading junk data off the end of the datagram:
261 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
262 // Get the Data:
263 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
264 s.store_value(&tempvar, sizeof(tempvar));
265 _current_index += sizeof(tempvar);
266
267 return tempvar;
268}
269
270/**
271 * Extracts a signed 32-bit big-endian integer.
272 */
273INLINE int32_t DatagramIterator::
274get_be_int32() {
275 nassertr(_datagram != nullptr, 0);
276 nassertr(_current_index < _datagram->get_length(), 0);
277
278 int32_t tempvar;
279 // Avoid reading junk data off the end of the datagram:
280 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
281 // Get the Data:
282 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
283 s.store_value(&tempvar, sizeof(tempvar));
284 _current_index += sizeof(tempvar);
285
286 return tempvar;
287}
288
289/**
290 * Extracts a signed 64-bit big-endian integer.
291 */
292INLINE int64_t DatagramIterator::
293get_be_int64() {
294 nassertr(_datagram != nullptr, 0);
295 nassertr(_current_index < _datagram->get_length(), 0);
296
297 int64_t tempvar;
298 // Avoid reading junk data off the end of the datagram:
299 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
300 // Get the Data:
301 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
302 s.store_value(&tempvar, sizeof(tempvar));
303 _current_index += sizeof(tempvar);
304
305 return tempvar;
306}
307
308/**
309 * Extracts an unsigned 16-bit big-endian integer.
310 */
311INLINE uint16_t DatagramIterator::
313 nassertr(_datagram != nullptr, 0);
314 nassertr(_current_index < _datagram->get_length(), 0);
315
316 uint16_t tempvar;
317 // Avoid reading junk data off the end of the datagram:
318 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
319 // Get the Data:
320 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
321 s.store_value(&tempvar, sizeof(tempvar));
322 _current_index += sizeof(tempvar);
323
324 return tempvar;
325}
326
327/**
328 * Extracts an unsigned 32-bit big-endian integer.
329 */
330INLINE uint32_t DatagramIterator::
332 nassertr(_datagram != nullptr, 0);
333 nassertr(_current_index < _datagram->get_length(), 0);
334
335 uint32_t tempvar;
336 // Avoid reading junk data off the end of the datagram:
337 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
338 // Get the Data:
339 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
340 s.store_value(&tempvar, sizeof(tempvar));
341 _current_index += sizeof(tempvar);
342
343 return tempvar;
344}
345
346/**
347 * Extracts an unsigned 64-bit big-endian integer.
348 */
349INLINE uint64_t DatagramIterator::
351 nassertr(_datagram != nullptr, 0);
352 nassertr(_current_index < _datagram->get_length(), 0);
353
354 uint64_t tempvar;
355 // Avoid reading junk data off the end of the datagram:
356 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
357 // Get the Data:
358 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
359 s.store_value(&tempvar, sizeof(tempvar));
360 _current_index += sizeof(tempvar);
361
362 return tempvar;
363}
364
365/**
366 * Extracts a 32-bit big-endian single-precision floating-point number.
367 */
368INLINE PN_float32 DatagramIterator::
370 nassertr(_datagram != nullptr, 0.0);
371 nassertr(_current_index < _datagram->get_length(), 0.0);
372
373 PN_float32 tempvar;
374 // Avoid reading junk data off the end of the datagram:
375 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
376 // Get the Data:
377 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
378 s.store_value(&tempvar, sizeof(tempvar));
379 _current_index += sizeof(tempvar);
380
381 return tempvar;
382}
383
384/**
385 * Extracts a 64-bit big-endian floating-point number.
386 */
387INLINE PN_float64 DatagramIterator::
389 nassertr(_datagram != nullptr, 0.0);
390 nassertr(_current_index < _datagram->get_length(), 0.0);
391
392 PN_float64 tempvar;
393 // Avoid reading junk data off the end of the datagram:
394 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0.0);
395 // Get the Data:
396 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
397 s.store_value(&tempvar, sizeof(tempvar));
398 _current_index += sizeof(tempvar);
399
400 return tempvar;
401}
402
403/**
404 * Extracts a variable-length binary blob.
405 */
406INLINE vector_uchar DatagramIterator::
407get_blob() {
408 return extract_bytes(get_uint16());
409}
410
411/**
412 * Extracts a variable-length binary blob with a 32-bit size field.
413 */
414INLINE vector_uchar DatagramIterator::
415get_blob32() {
416 return extract_bytes(get_uint32());
417}
418
419/**
420 * Skips over the indicated number of bytes in the datagram.
421 */
423skip_bytes(size_t size) {
424 nassertv(_datagram != nullptr);
425 nassertv((int)size >= 0);
426#ifndef NDEBUG
427 if (_current_index + size > _datagram->get_length()) {
428 nout << "datagram overflow: current_index = " << _current_index
429 << " size = " << size << " length = " << _datagram->get_length() << "\n";
430 _datagram->dump_hex(nout);
431 }
432#endif
433 nassertv(_current_index + size <= _datagram->get_length());
434 _current_index += size;
435}
436
437/**
438 * Returns the remaining bytes in the datagram as a string, but does not
439 * extract them from the iterator.
440 */
441INLINE vector_uchar DatagramIterator::
442get_remaining_bytes() const {
443 nassertr(_datagram != nullptr, vector_uchar());
444 nassertr(_current_index <= _datagram->get_length(), vector_uchar());
445
446 const unsigned char *ptr = (const unsigned char *)_datagram->get_data();
447 return vector_uchar(ptr + _current_index, ptr + _datagram->get_length());
448}
449
450/**
451 * Return the bytes left in the datagram.
452 */
454get_remaining_size() const {
455 return _datagram->get_length() - _current_index;
456}
457
458/**
459 * Return the datagram of this iterator.
460 */
462get_datagram() const {
463 return *_datagram;
464}
465
466/**
467 * Returns the current position within the datagram of the next piece of data
468 * to extract.
469 */
471get_current_index() const {
472 return _current_index;
473}
474
475INLINE void
476generic_read_datagram(bool &result, DatagramIterator &source) {
477 result = source.get_bool();
478}
479
480INLINE void
481generic_read_datagram(int &result, DatagramIterator &source) {
482 result = source.get_int32();
483}
484
485INLINE void
486generic_read_datagram(float &result, DatagramIterator &source) {
487 result = source.get_float32();
488}
489
490INLINE void
491generic_read_datagram(double &result, DatagramIterator &source) {
492 result = source.get_float64();
493}
494
495INLINE void
496generic_read_datagram(std::string &result, DatagramIterator &source) {
497 result = source.get_string();
498}
499
500INLINE void
501generic_read_datagram(std::wstring &result, DatagramIterator &source) {
502 result = source.get_wstring();
503}
504
505INLINE void
506generic_read_datagram(vector_uchar &result, DatagramIterator &source) {
507 result = source.get_blob();
508}
A class to retrieve the individual data elements previously stored in a Datagram.
void skip_bytes(size_t size)
Skips over the indicated number of bytes in the datagram.
uint8_t get_uint8()
Extracts an unsigned 8-bit integer.
PN_float32 get_float32()
Extracts a 32-bit single-precision floating-point number.
void assign(Datagram &datagram, size_t offset=0)
direct Assignment to a Datagram
vector_uchar get_blob32()
Extracts a variable-length binary blob with a 32-bit size field.
uint16_t get_be_uint16()
Extracts an unsigned 16-bit big-endian integer.
int16_t get_int16()
Extracts a signed 16-bit integer.
uint32_t get_be_uint32()
Extracts an unsigned 32-bit big-endian integer.
int32_t get_be_int32()
Extracts a signed 32-bit big-endian integer.
uint64_t get_uint64()
Extracts an unsigned 64-bit integer.
PN_stdfloat get_stdfloat()
Extracts either a 32-bit or a 64-bit floating-point number, according to Datagram::set_stdfloat_doubl...
uint16_t get_uint16()
Extracts an unsigned 16-bit integer.
PN_float32 get_be_float32()
Extracts a 32-bit big-endian single-precision floating-point number.
int64_t get_int64()
Extracts a signed 64-bit integer.
std::wstring get_wstring()
Extracts a variable-length wstring (with a 32-bit length field).
vector_uchar extract_bytes(size_t size)
Extracts the indicated number of bytes in the datagram and returns them as a string.
uint32_t get_uint32()
Extracts an unsigned 32-bit integer.
vector_uchar get_remaining_bytes() const
Returns the remaining bytes in the datagram as a string, but does not extract them from the iterator.
int8_t get_int8()
Extracts a signed 8-bit integer.
PN_float64 get_float64()
Extracts a 64-bit floating-point number.
uint64_t get_be_uint64()
Extracts an unsigned 64-bit big-endian integer.
bool get_bool()
Extracts a boolean value.
std::string get_string()
Extracts a variable-length string.
PN_float64 get_be_float64()
Extracts a 64-bit big-endian floating-point number.
int16_t get_be_int16()
Extracts a signed 16-bit big-endian integer.
const Datagram & get_datagram() const
Return the datagram of this iterator.
int32_t get_int32()
Extracts a signed 32-bit integer.
vector_uchar get_blob()
Extracts a variable-length binary blob.
size_t get_current_index() const
Returns the current position within the datagram of the next piece of data to extract.
int64_t get_be_int64()
Extracts a signed 64-bit big-endian integer.
size_t get_remaining_size() const
Return the bytes left in the datagram.
An ordered list of data elements, formatted in memory for transmission over a socket or writing to a ...
Definition datagram.h:38
size_t get_length() const
Returns the number of bytes in the datagram.
Definition datagram.I:335
bool get_stdfloat_double() const
Returns the stdfloat_double flag.
Definition datagram.I:403
void dump_hex(std::ostream &out, unsigned int indent=0) const
Writes a representation of the entire datagram contents, as a sequence of hex (and ASCII) values.
Definition datagram.cxx:44
const void * get_data() const
Returns a pointer to the beginning of the datagram's data.
Definition datagram.I:327
NativeNumericData and ReversedNumericData work together to provide a sneaky interface for automatical...
void store_value(void *dest, size_t length) const
Copies the data, with byte reversal if appropriate, into the indicated numeric variable,...
NativeNumericData and ReversedNumericData work together to provide a sneaky interface for automatical...
void store_value(void *dest, size_t length) const
Copies the data, with byte reversal if appropriate, into the indicated numeric variable,...