panda/src/express/datagramIterator.I Source File

00001 // Filename: datagramIterator.I
00002 // Created by:  drose (08May01)
00003 //
00004 ////////////////////////////////////////////////////////////////////
00005 //
00006 // PANDA 3D SOFTWARE
00007 // Copyright (c) 2001, Disney Enterprises, Inc.  All rights reserved
00008 //
00009 // All use of this software is subject to the terms of the Panda 3d
00010 // Software license.  You should have received a copy of this license
00011 // along with this source code; you will also find a current copy of
00012 // the license at http://www.panda3d.org/license.txt .
00013 //
00014 // To contact the maintainers of this program write to
00015 // panda3d@yahoogroups.com .
00016 //
00017 ////////////////////////////////////////////////////////////////////
00018 
00019 
00020 ////////////////////////////////////////////////////////////////////
00021 //     Function: DatagramIterator::Constructor
00022 //       Access: Public
00023 //  Description:
00024 ////////////////////////////////////////////////////////////////////
00025 INLINE DatagramIterator::
00026 DatagramIterator() :
00027   _datagram((Datagram *)NULL),
00028   _current_index(0)
00029 {
00030 }
00031 
00032 ////////////////////////////////////////////////////////////////////
00033 //     Function: DatagramIterator::Constructor
00034 //       Access: Public
00035 //  Description:
00036 ////////////////////////////////////////////////////////////////////
00037 INLINE DatagramIterator::
00038 DatagramIterator(const Datagram &datagram, size_t offset) :
00039   _datagram(&datagram),
00040   _current_index(offset)
00041 {
00042   nassertv(_current_index <= _datagram->get_length());
00043 }
00044 
00045 ////////////////////////////////////////////////////////////////////
00046 //     Function: DatagramIterator::Copy Constructor
00047 //       Access: Public
00048 //  Description:
00049 ////////////////////////////////////////////////////////////////////
00050 INLINE DatagramIterator::
00051 DatagramIterator(const DatagramIterator &copy) :
00052   _datagram(copy._datagram),
00053   _current_index(copy._current_index)
00054 {
00055 }
00056 
00057 ////////////////////////////////////////////////////////////////////
00058 //     Function: DatagramIterator::Copy Assignment Operator
00059 //       Access: Public
00060 //  Description:
00061 ////////////////////////////////////////////////////////////////////
00062 INLINE void DatagramIterator::
00063 operator = (const DatagramIterator &copy) {
00064   _datagram = copy._datagram;
00065   _current_index = copy._current_index;
00066 }
00067 
00068 ////////////////////////////////////////////////////////////////////
00069 //     Function: DatagramIterator::Destructor
00070 //       Access: Public
00071 //  Description:
00072 ////////////////////////////////////////////////////////////////////
00073 INLINE DatagramIterator::
00074 ~DatagramIterator() {
00075 }
00076 
00077 // Various ways to get data and increment the iterator...
00078 // Cut-and-paste-orama
00079 
00080 ////////////////////////////////////////////////////////////////////
00081 //     Function: DatagramIterator::get_bool
00082 //       Access: Public
00083 //  Description: Extracts a boolean value.
00084 ////////////////////////////////////////////////////////////////////
00085 INLINE bool DatagramIterator::
00086 get_bool() {
00087   return (get_uint8() != 0);
00088 }
00089 
00090 ////////////////////////////////////////////////////////////////////
00091 //     Function: DatagramIterator::get_int8
00092 //       Access: Public
00093 //  Description: Extracts a signed 8-bit integer.
00094 ////////////////////////////////////////////////////////////////////
00095 INLINE PN_int8 DatagramIterator::
00096 get_int8() {
00097   nassertr(_datagram != (const Datagram *)NULL &&
00098            _current_index < _datagram->get_length(), 0);
00099 
00100   const char *ptr = (const char *)_datagram->get_data();
00101   PN_int8 tempvar = (PN_int8)ptr[_current_index];
00102   _current_index++;
00103 
00104   return tempvar;
00105 }
00106 
00107 ////////////////////////////////////////////////////////////////////
00108 //     Function: DatagramIterator::get_uint8
00109 //       Access: Public
00110 //  Description: Extracts an unsigned 8-bit integer.
00111 ////////////////////////////////////////////////////////////////////
00112 INLINE PN_uint8 DatagramIterator::
00113 get_uint8() {
00114   nassertr(_datagram != (const Datagram *)NULL &&
00115            _current_index < _datagram->get_length(), 0);
00116 
00117   const char *ptr = (const char *)_datagram->get_data();
00118   PN_uint8 tempvar = (PN_uint8)ptr[_current_index];
00119   _current_index++;
00120 
00121   return tempvar;
00122 }
00123 
00124 ////////////////////////////////////////////////////////////////////
00125 //     Function: DatagramIterator::get_int16
00126 //       Access: Public
00127 //  Description: Extracts a signed 16-bit integer.
00128 ////////////////////////////////////////////////////////////////////
00129 INLINE PN_int16 DatagramIterator::
00130 get_int16() {
00131   nassertr(_datagram != (const Datagram *)NULL &&
00132            _current_index < _datagram->get_length(), 0);
00133 
00134   PN_int16 tempvar;
00135   LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00136   s.store_value(&tempvar, sizeof(tempvar));
00137   _current_index += sizeof(tempvar);
00138 
00139   return tempvar;
00140 }
00141 
00142 ////////////////////////////////////////////////////////////////////
00143 //     Function: DatagramIterator::get_int32
00144 //       Access: Public
00145 //  Description: Extracts a signed 32-bit integer.
00146 ////////////////////////////////////////////////////////////////////
00147 INLINE PN_int32 DatagramIterator::
00148 get_int32() {
00149   nassertr(_datagram != (const Datagram *)NULL &&
00150            _current_index < _datagram->get_length(), 0);
00151 
00152   PN_int32 tempvar;
00153   LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00154   s.store_value(&tempvar, sizeof(tempvar));
00155   _current_index += sizeof(tempvar);
00156 
00157   return tempvar;
00158 }
00159 
00160 ////////////////////////////////////////////////////////////////////
00161 //     Function: DatagramIterator::get_int64
00162 //       Access: Public
00163 //  Description: Extracts a signed 64-bit integer.
00164 ////////////////////////////////////////////////////////////////////
00165 INLINE PN_int64 DatagramIterator::
00166 get_int64() {
00167   nassertr(_datagram != (const Datagram *)NULL &&
00168            _current_index < _datagram->get_length(), 0);
00169 
00170   PN_int64 tempvar;
00171   LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00172   s.store_value(&tempvar, sizeof(tempvar));
00173   _current_index += sizeof(tempvar);
00174 
00175   return tempvar;
00176 }
00177 
00178 ////////////////////////////////////////////////////////////////////
00179 //     Function: DatagramIterator::get_uint16
00180 //       Access: Public
00181 //  Description: Extracts an unsigned 16-bit integer.
00182 ////////////////////////////////////////////////////////////////////
00183 INLINE PN_uint16 DatagramIterator::
00184 get_uint16() {
00185   nassertr(_datagram != (const Datagram *)NULL &&
00186            _current_index < _datagram->get_length(), 0);
00187 
00188   PN_uint16 tempvar;
00189   LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00190   s.store_value(&tempvar, sizeof(tempvar));
00191   _current_index += sizeof(tempvar);
00192 
00193   return tempvar;
00194 }
00195 
00196 ////////////////////////////////////////////////////////////////////
00197 //     Function: DatagramIterator::get_uint32
00198 //       Access: Public
00199 //  Description: Extracts an unsigned 32-bit integer.
00200 ////////////////////////////////////////////////////////////////////
00201 INLINE PN_uint32 DatagramIterator::
00202 get_uint32() {
00203   nassertr(_datagram != (const Datagram *)NULL &&
00204            _current_index < _datagram->get_length(), 0);
00205 
00206   PN_uint32 tempvar;
00207   LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00208   s.store_value(&tempvar, sizeof(tempvar));
00209   _current_index += sizeof(tempvar);
00210 
00211   return tempvar;
00212 }
00213 
00214 ////////////////////////////////////////////////////////////////////
00215 //     Function: DatagramIterator::get_uint64
00216 //       Access: Public
00217 //  Description: Extracts an unsigned 64-bit integer.
00218 ////////////////////////////////////////////////////////////////////
00219 INLINE PN_uint64 DatagramIterator::
00220 get_uint64() {
00221   nassertr(_datagram != (const Datagram *)NULL &&
00222            _current_index < _datagram->get_length(), 0);
00223 
00224   PN_uint64 tempvar;
00225   LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00226   s.store_value(&tempvar, sizeof(tempvar));
00227   _current_index += sizeof(tempvar);
00228 
00229   return tempvar;
00230 }
00231 
00232 ////////////////////////////////////////////////////////////////////
00233 //     Function: DatagramIterator::get_float32
00234 //       Access: Public
00235 //  Description: Extracts a 32-bit single-precision floating-point
00236 //               number.  Since this kind of float is not necessarily
00237 //               portable across different architectures, special care
00238 //               is required.
00239 ////////////////////////////////////////////////////////////////////
00240 INLINE float DatagramIterator::
00241 get_float32() {
00242   // For now, we assume the float format is portable across all
00243   // architectures we are concerned with.  If we come across one that
00244   // is different, we will have to convert.
00245   nassertr(sizeof(float) == 4, 0.0f);
00246   nassertr(_datagram != (const Datagram *)NULL &&
00247            _current_index < _datagram->get_length(), 0.0f);
00248 
00249   float tempvar;
00250   LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00251   s.store_value(&tempvar, sizeof(tempvar));
00252   _current_index += sizeof(tempvar);
00253 
00254   return tempvar;
00255 }
00256 
00257 ////////////////////////////////////////////////////////////////////
00258 //     Function: DatagramIterator::get_float64
00259 //       Access: Public
00260 //  Description: Extracts a 64-bit floating-point number.
00261 ////////////////////////////////////////////////////////////////////
00262 INLINE PN_float64 DatagramIterator::
00263 get_float64() {
00264   nassertr(_datagram != (const Datagram *)NULL &&
00265            _current_index < _datagram->get_length(), 0.0);
00266 
00267   PN_float64 tempvar;
00268   LittleEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00269   s.store_value(&tempvar, sizeof(tempvar));
00270   _current_index += sizeof(tempvar);
00271 
00272   return tempvar;
00273 }
00274 
00275 ////////////////////////////////////////////////////////////////////
00276 //     Function: DatagramIterator::get_be_int16
00277 //       Access: Public
00278 //  Description: Extracts a signed 16-bit big-endian integer.
00279 ////////////////////////////////////////////////////////////////////
00280 INLINE PN_int16 DatagramIterator::
00281 get_be_int16() {
00282   nassertr(_datagram != (const Datagram *)NULL &&
00283            _current_index < _datagram->get_length(), 0);
00284 
00285   PN_int16 tempvar;
00286   BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00287   s.store_value(&tempvar, sizeof(tempvar));
00288   _current_index += sizeof(tempvar);
00289 
00290   return tempvar;
00291 }
00292 
00293 ////////////////////////////////////////////////////////////////////
00294 //     Function: DatagramIterator::get_be_int32
00295 //       Access: Public
00296 //  Description: Extracts a signed 32-bit big-endian integer.
00297 ////////////////////////////////////////////////////////////////////
00298 INLINE PN_int32 DatagramIterator::
00299 get_be_int32() {
00300   nassertr(_datagram != (const Datagram *)NULL &&
00301            _current_index < _datagram->get_length(), 0);
00302 
00303   PN_int32 tempvar;
00304   BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00305   s.store_value(&tempvar, sizeof(tempvar));
00306   _current_index += sizeof(tempvar);
00307 
00308   return tempvar;
00309 }
00310 
00311 ////////////////////////////////////////////////////////////////////
00312 //     Function: DatagramIterator::get_be_int64
00313 //       Access: Public
00314 //  Description: Extracts a signed 64-bit big-endian integer.
00315 ////////////////////////////////////////////////////////////////////
00316 INLINE PN_int64 DatagramIterator::
00317 get_be_int64() {
00318   nassertr(_datagram != (const Datagram *)NULL &&
00319            _current_index < _datagram->get_length(), 0);
00320 
00321   PN_int64 tempvar;
00322   BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00323   s.store_value(&tempvar, sizeof(tempvar));
00324   _current_index += sizeof(tempvar);
00325 
00326   return tempvar;
00327 }
00328 
00329 ////////////////////////////////////////////////////////////////////
00330 //     Function: DatagramIterator::get_be_uint16
00331 //       Access: Public
00332 //  Description: Extracts an unsigned 16-bit big-endian integer.
00333 ////////////////////////////////////////////////////////////////////
00334 INLINE PN_uint16 DatagramIterator::
00335 get_be_uint16() {
00336   nassertr(_datagram != (const Datagram *)NULL &&
00337            _current_index < _datagram->get_length(), 0);
00338 
00339   PN_uint16 tempvar;
00340   BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00341   s.store_value(&tempvar, sizeof(tempvar));
00342   _current_index += sizeof(tempvar);
00343 
00344   return tempvar;
00345 }
00346 
00347 ////////////////////////////////////////////////////////////////////
00348 //     Function: DatagramIterator::get_be_uint32
00349 //       Access: Public
00350 //  Description: Extracts an unsigned 32-bit big-endian integer.
00351 ////////////////////////////////////////////////////////////////////
00352 INLINE PN_uint32 DatagramIterator::
00353 get_be_uint32() {
00354   nassertr(_datagram != (const Datagram *)NULL &&
00355            _current_index < _datagram->get_length(), 0);
00356 
00357   PN_uint32 tempvar;
00358   BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00359   s.store_value(&tempvar, sizeof(tempvar));
00360   _current_index += sizeof(tempvar);
00361 
00362   return tempvar;
00363 }
00364 
00365 ////////////////////////////////////////////////////////////////////
00366 //     Function: DatagramIterator::get_be_uint64
00367 //       Access: Public
00368 //  Description: Extracts an unsigned 64-bit big-endian integer.
00369 ////////////////////////////////////////////////////////////////////
00370 INLINE PN_uint64 DatagramIterator::
00371 get_be_uint64() {
00372   nassertr(_datagram != (const Datagram *)NULL &&
00373            _current_index < _datagram->get_length(), 0);
00374 
00375   PN_uint64 tempvar;
00376   BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00377   s.store_value(&tempvar, sizeof(tempvar));
00378   _current_index += sizeof(tempvar);
00379 
00380   return tempvar;
00381 }
00382 
00383 ////////////////////////////////////////////////////////////////////
00384 //     Function: DatagramIterator::get_be_float32
00385 //       Access: Public
00386 //  Description: Extracts a 32-bit big-endian single-precision
00387 //               floating-point number.  Since this kind of float is
00388 //               not necessarily portable across different
00389 //               architectures, special care is required.
00390 ////////////////////////////////////////////////////////////////////
00391 INLINE float DatagramIterator::
00392 get_be_float32() {
00393   // For now, we assume the float format is portable across all
00394   // architectures we are concerned with.  If we come across one that
00395   // is different, we will have to convert.
00396   nassertr(sizeof(float) == 4, 0.0f);
00397   nassertr(_datagram != (const Datagram *)NULL &&
00398            _current_index < _datagram->get_length(), 0.0f);
00399 
00400   float tempvar;
00401   BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00402   s.store_value(&tempvar, sizeof(tempvar));
00403   _current_index += sizeof(tempvar);
00404 
00405   return tempvar;
00406 }
00407 
00408 ////////////////////////////////////////////////////////////////////
00409 //     Function: DatagramIterator::get_be_float64
00410 //       Access: Public
00411 //  Description: Extracts a 64-bit big-endian floating-point number.
00412 ////////////////////////////////////////////////////////////////////
00413 INLINE PN_float64 DatagramIterator::
00414 get_be_float64() {
00415   nassertr(_datagram != (const Datagram *)NULL &&
00416            _current_index < _datagram->get_length(), 0.0);
00417 
00418   PN_float64 tempvar;
00419   BigEndian s(_datagram->get_data(), _current_index, sizeof(tempvar));
00420   s.store_value(&tempvar, sizeof(tempvar));
00421   _current_index += sizeof(tempvar);
00422 
00423   return tempvar;
00424 }
00425 
00426 ////////////////////////////////////////////////////////////////////
00427 //     Function: DatagramIterator::skip_bytes
00428 //       Access: Public
00429 //  Description: Skips over the indicated number of bytes in the
00430 //               datagram.
00431 ////////////////////////////////////////////////////////////////////
00432 INLINE void DatagramIterator::
00433 skip_bytes(size_t size) {
00434   nassertv((int)size >= 0);
00435   nassertv(_current_index + size <= _datagram->get_length());
00436   _current_index += size;
00437 }
00438 
00439 ////////////////////////////////////////////////////////////////////
00440 //     Function: DatagramIterator::get_remaining_bytes
00441 //       Access: Public
00442 //  Description: Returns the remaining bytes in the datagram as a
00443 //               string, but does not extract them from the iterator.
00444 ////////////////////////////////////////////////////////////////////
00445 INLINE string DatagramIterator::
00446 get_remaining_bytes() const {
00447   nassertr(_datagram != (const Datagram *)NULL &&
00448            _current_index <= _datagram->get_length(), "");
00449 
00450   const char *ptr = (const char *)_datagram->get_data();
00451   int remaining_size = _datagram->get_length() - _current_index;
00452   return string(ptr + _current_index, remaining_size);
00453 }
00454 
00455 ////////////////////////////////////////////////////////////////////
00456 //     Function: DatagramIterator::get_remaining_size
00457 //       Access: Public
00458 //  Description: Return the bytes left in the datagram.
00459 ////////////////////////////////////////////////////////////////////
00460 INLINE int DatagramIterator::
00461 get_remaining_size() const {
00462   return _datagram->get_length() - _current_index;
00463 }
00464 
00465 ////////////////////////////////////////////////////////////////////
00466 //     Function: DatagramIterator::get_datagram
00467 //       Access: Public
00468 //  Description: Return the datagram of this iterator.
00469 ////////////////////////////////////////////////////////////////////
00470 INLINE const Datagram &DatagramIterator::
00471 get_datagram() const {
00472   return *_datagram;
00473 }
00474 
00475 ////////////////////////////////////////////////////////////////////
00476 //     Function: DatagramIterator::get_current_index
00477 //       Access: Public
00478 //  Description: Returns the current position within the datagram of the
00479 //               next piece of data to extract.
00480 ////////////////////////////////////////////////////////////////////
00481 INLINE size_t DatagramIterator::
00482 get_current_index() const {
00483   return _current_index;
00484 }