00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 INLINE DatagramIterator::
00022 DatagramIterator() :
00023 _datagram((Datagram *)NULL),
00024 _current_index(0) {
00025 }
00026
00027
00028
00029
00030
00031
00032 INLINE DatagramIterator::
00033 DatagramIterator(const Datagram &datagram, size_t offset) :
00034 _datagram(&datagram),
00035 _current_index(offset) {
00036 nassertv(_current_index <= _datagram->get_length());
00037 }
00038
00039
00040
00041
00042
00043
00044 INLINE DatagramIterator::
00045 DatagramIterator(const DatagramIterator ©) :
00046 _datagram(copy._datagram),
00047 _current_index(copy._current_index) {
00048 }
00049
00050
00051
00052
00053
00054
00055 INLINE void DatagramIterator::
00056 operator = (const DatagramIterator ©) {
00057 _datagram = copy._datagram;
00058 _current_index = copy._current_index;
00059 }
00060
00061
00062
00063
00064
00065 INLINE void DatagramIterator::assign(Datagram &datagram, size_t offset)
00066 {
00067 _datagram =&datagram;
00068 _current_index = offset;
00069 }
00070
00071
00072
00073
00074
00075 INLINE DatagramIterator::
00076 ~DatagramIterator() {
00077 }
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087 INLINE bool DatagramIterator::
00088 get_bool() {
00089 return get_uint8() != 0;
00090 }
00091
00092
00093
00094
00095
00096
00097 INLINE PN_int8 DatagramIterator::
00098 get_int8() {
00099 nassertr(_datagram != (const Datagram *)NULL, 0);
00100
00101 nassertr(_current_index < _datagram->get_length(), 0);
00102
00103 const char *ptr = (const char *)_datagram->get_data();
00104 PN_int8 tempvar = (PN_int8)ptr[_current_index];
00105 ++_current_index;
00106
00107 return tempvar;
00108 }
00109
00110
00111
00112
00113
00114
00115 INLINE PN_uint8 DatagramIterator::
00116 get_uint8() {
00117 nassertr(_datagram != (const Datagram *)NULL, 0);
00118
00119 nassertr(_current_index < _datagram->get_length(), 0);
00120
00121 const char *ptr = (const char *)_datagram->get_data();
00122 PN_uint8 tempvar = (PN_uint8)ptr[_current_index];
00123 ++_current_index;
00124
00125 return tempvar;
00126 }
00127
00128
00129
00130
00131
00132
00133 INLINE PN_int16 DatagramIterator::
00134 get_int16() {
00135 nassertr(_datagram != (const Datagram *)NULL, 0);
00136 nassertr(_current_index < _datagram->get_length(), 0);
00137
00138 PN_int16 tempvar;
00139
00140 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
00141
00142 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00143 s.store_value(&tempvar, sizeof(tempvar));
00144 _current_index += sizeof(tempvar);
00145
00146 return tempvar;
00147 }
00148
00149
00150
00151
00152
00153
00154 INLINE PN_int32 DatagramIterator::
00155 get_int32() {
00156 nassertr(_datagram != (const Datagram *)NULL, 0);
00157 nassertr(_current_index < _datagram->get_length(), 0);
00158
00159 PN_int32 tempvar;
00160
00161 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
00162
00163 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00164 s.store_value(&tempvar, sizeof(tempvar));
00165 _current_index += sizeof(tempvar);
00166
00167 return tempvar;
00168 }
00169
00170
00171
00172
00173
00174
00175 INLINE PN_int64 DatagramIterator::
00176 get_int64() {
00177 nassertr(_datagram != (const Datagram *)NULL, 0);
00178 nassertr(_current_index < _datagram->get_length(), 0);
00179
00180 PN_int64 tempvar;
00181
00182 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
00183
00184 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00185 s.store_value(&tempvar, sizeof(tempvar));
00186 _current_index += sizeof(tempvar);
00187
00188 return tempvar;
00189 }
00190
00191
00192
00193
00194
00195
00196 INLINE PN_uint16 DatagramIterator::
00197 get_uint16() {
00198 nassertr(_datagram != (const Datagram *)NULL, 0);
00199 nassertr(_current_index < _datagram->get_length(), 0);
00200
00201 PN_uint16 tempvar;
00202
00203 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
00204
00205 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00206 s.store_value(&tempvar, sizeof(tempvar));
00207 _current_index += sizeof(tempvar);
00208
00209 return tempvar;
00210 }
00211
00212
00213
00214
00215
00216
00217 INLINE PN_uint32 DatagramIterator::
00218 get_uint32() {
00219 nassertr(_datagram != (const Datagram *)NULL, 0);
00220 nassertr(_current_index < _datagram->get_length(), 0);
00221
00222 PN_uint32 tempvar;
00223
00224 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
00225
00226 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00227 s.store_value(&tempvar, sizeof(tempvar));
00228 _current_index += sizeof(tempvar);
00229
00230 return tempvar;
00231 }
00232
00233
00234
00235
00236
00237
00238 INLINE PN_uint64 DatagramIterator::
00239 get_uint64() {
00240 nassertr(_datagram != (const Datagram *)NULL, 0);
00241 nassertr(_current_index < _datagram->get_length(), 0);
00242
00243 PN_uint64 tempvar;
00244
00245 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
00246
00247 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00248 s.store_value(&tempvar, sizeof(tempvar));
00249 _current_index += sizeof(tempvar);
00250
00251 return tempvar;
00252 }
00253
00254
00255
00256
00257
00258
00259
00260 INLINE PN_float32 DatagramIterator::
00261 get_float32() {
00262 nassertr(_datagram != (const Datagram *)NULL, 0.0);
00263 nassertr(_current_index < _datagram->get_length(), 0.0);
00264
00265 PN_float32 tempvar;
00266
00267 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0.0);
00268
00269 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00270 s.store_value(&tempvar, sizeof(tempvar));
00271 _current_index += sizeof(tempvar);
00272
00273 return tempvar;
00274 }
00275
00276
00277
00278
00279
00280
00281 INLINE PN_float64 DatagramIterator::
00282 get_float64() {
00283 nassertr(_datagram != (const Datagram *)NULL, 0.0);
00284 nassertr(_current_index < _datagram->get_length(), 0.0);
00285
00286 PN_float64 tempvar;
00287
00288 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0.0);
00289
00290 LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00291 s.store_value(&tempvar, sizeof(tempvar));
00292 _current_index += sizeof(tempvar);
00293
00294 return tempvar;
00295 }
00296
00297
00298
00299
00300
00301
00302
00303
00304 INLINE PN_stdfloat DatagramIterator::
00305 get_stdfloat() {
00306 nassertr(_datagram != (const Datagram *)NULL, 0.0);
00307 if (_datagram->get_stdfloat_double()) {
00308 return (PN_stdfloat)get_float64();
00309 } else {
00310 return (PN_stdfloat)get_float32();
00311 }
00312 }
00313
00314
00315
00316
00317
00318
00319 INLINE PN_int16 DatagramIterator::
00320 get_be_int16() {
00321 nassertr(_datagram != (const Datagram *)NULL, 0);
00322 nassertr(_current_index < _datagram->get_length(), 0);
00323
00324 PN_int16 tempvar;
00325
00326 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
00327
00328 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00329 s.store_value(&tempvar, sizeof(tempvar));
00330 _current_index += sizeof(tempvar);
00331
00332 return tempvar;
00333 }
00334
00335
00336
00337
00338
00339
00340 INLINE PN_int32 DatagramIterator::
00341 get_be_int32() {
00342 nassertr(_datagram != (const Datagram *)NULL, 0);
00343 nassertr(_current_index < _datagram->get_length(), 0);
00344
00345 PN_int32 tempvar;
00346
00347 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
00348
00349 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00350 s.store_value(&tempvar, sizeof(tempvar));
00351 _current_index += sizeof(tempvar);
00352
00353 return tempvar;
00354 }
00355
00356
00357
00358
00359
00360
00361 INLINE PN_int64 DatagramIterator::
00362 get_be_int64() {
00363 nassertr(_datagram != (const Datagram *)NULL, 0);
00364 nassertr(_current_index < _datagram->get_length(), 0);
00365
00366 PN_int64 tempvar;
00367
00368 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
00369
00370 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00371 s.store_value(&tempvar, sizeof(tempvar));
00372 _current_index += sizeof(tempvar);
00373
00374 return tempvar;
00375 }
00376
00377
00378
00379
00380
00381
00382 INLINE PN_uint16 DatagramIterator::
00383 get_be_uint16() {
00384 nassertr(_datagram != (const Datagram *)NULL, 0);
00385 nassertr(_current_index < _datagram->get_length(), 0);
00386
00387 PN_uint16 tempvar;
00388
00389 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
00390
00391 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00392 s.store_value(&tempvar, sizeof(tempvar));
00393 _current_index += sizeof(tempvar);
00394
00395 return tempvar;
00396 }
00397
00398
00399
00400
00401
00402
00403 INLINE PN_uint32 DatagramIterator::
00404 get_be_uint32() {
00405 nassertr(_datagram != (const Datagram *)NULL, 0);
00406 nassertr(_current_index < _datagram->get_length(), 0);
00407
00408 PN_uint32 tempvar;
00409
00410 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
00411
00412 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00413 s.store_value(&tempvar, sizeof(tempvar));
00414 _current_index += sizeof(tempvar);
00415
00416 return tempvar;
00417 }
00418
00419
00420
00421
00422
00423
00424 INLINE PN_uint64 DatagramIterator::
00425 get_be_uint64() {
00426 nassertr(_datagram != (const Datagram *)NULL, 0);
00427 nassertr(_current_index < _datagram->get_length(), 0);
00428
00429 PN_uint64 tempvar;
00430
00431 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
00432
00433 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00434 s.store_value(&tempvar, sizeof(tempvar));
00435 _current_index += sizeof(tempvar);
00436
00437 return tempvar;
00438 }
00439
00440
00441
00442
00443
00444
00445
00446 INLINE PN_float32 DatagramIterator::
00447 get_be_float32() {
00448 nassertr(_datagram != (const Datagram *)NULL, 0.0);
00449 nassertr(_current_index < _datagram->get_length(), 0.0);
00450
00451 PN_float32 tempvar;
00452
00453 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0);
00454
00455 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00456 s.store_value(&tempvar, sizeof(tempvar));
00457 _current_index += sizeof(tempvar);
00458
00459 return tempvar;
00460 }
00461
00462
00463
00464
00465
00466
00467 INLINE PN_float64 DatagramIterator::
00468 get_be_float64() {
00469 nassertr(_datagram != (const Datagram *)NULL, 0.0);
00470 nassertr(_current_index < _datagram->get_length(), 0.0);
00471
00472 PN_float64 tempvar;
00473
00474 nassertr(_current_index + sizeof(tempvar) <= _datagram->get_length(), 0.0);
00475
00476 BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00477 s.store_value(&tempvar, sizeof(tempvar));
00478 _current_index += sizeof(tempvar);
00479
00480 return tempvar;
00481 }
00482
00483
00484
00485
00486
00487
00488
00489 INLINE void DatagramIterator::
00490 skip_bytes(size_t size) {
00491 nassertv(_datagram != (const Datagram *)NULL);
00492 nassertv((int)size >= 0);
00493 #ifndef NDEBUG
00494 if (_current_index + size > _datagram->get_length()) {
00495 nout << "datagram overflow: current_index = " << _current_index
00496 << " size = " << size << " length = " << _datagram->get_length() << "\n";
00497 _datagram->dump_hex(nout);
00498 }
00499 #endif
00500 nassertv(_current_index + size <= _datagram->get_length());
00501 _current_index += size;
00502 }
00503
00504
00505
00506
00507
00508
00509
00510 INLINE string DatagramIterator::
00511 get_remaining_bytes() const {
00512 nassertr(_datagram != (const Datagram *)NULL, "");
00513 nassertr(_current_index <= _datagram->get_length(), "");
00514
00515 const char *ptr = (const char *)_datagram->get_data();
00516 int remaining_size = _datagram->get_length() - _current_index;
00517 return string(ptr + _current_index, remaining_size);
00518 }
00519
00520
00521
00522
00523
00524
00525 INLINE int DatagramIterator::
00526 get_remaining_size() const {
00527 return _datagram->get_length() - _current_index;
00528 }
00529
00530
00531
00532
00533
00534
00535 INLINE const Datagram &DatagramIterator::
00536 get_datagram() const {
00537 return *_datagram;
00538 }
00539
00540
00541
00542
00543
00544
00545
00546 INLINE size_t DatagramIterator::
00547 get_current_index() const {
00548 return _current_index;
00549 }
00550
00551 INLINE void
00552 generic_read_datagram(bool &result, DatagramIterator &source) {
00553 result = source.get_bool();
00554 }
00555
00556 INLINE void
00557 generic_read_datagram(int &result, DatagramIterator &source) {
00558 result = source.get_int32();
00559 }
00560
00561 INLINE void
00562 generic_read_datagram(float &result, DatagramIterator &source) {
00563 result = source.get_float32();
00564 }
00565
00566 INLINE void
00567 generic_read_datagram(double &result, DatagramIterator &source) {
00568 result = source.get_float64();
00569 }
00570
00571 INLINE void
00572 generic_read_datagram(string &result, DatagramIterator &source) {
00573 result = source.get_string();
00574 }
00575
00576 INLINE void
00577 generic_read_datagram(wstring &result, DatagramIterator &source) {
00578 result = source.get_wstring();
00579 }
00580
00581