nevrax.org : docs

00001 
+00012 /* Copyright, 2000 Nevrax Ltd.
+00013  *
+00014  * This file is part of NEVRAX NEL.
+00015  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00016  * it under the terms of the GNU General Public License as published by
+00017  * the Free Software Foundation; either version 2, or (at your option)
+00018  * any later version.
+00019 
+00020  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00021  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00022  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00023  * General Public License for more details.
+00024 
+00025  * You should have received a copy of the GNU General Public License
+00026  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00027  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00028  * MA 02111-1307, USA.
+00029  */
+00030 
+00031 #ifndef NL_STREAM_INLINE_H
+00032 #define NL_STREAM_INLINE_H
+00033 
+00034 #include <stdio.h>
+00035 
+00036 #include "nel/misc/debug.h"
+00037 
+00038 
+00039 namespace       NLMISC
+00040 {
+00041 
+00042 
+00043 // ======================================================================================================
+00044 // ======================================================================================================
+00045 // IBasicStream Inline Implementation.
+00046 // ======================================================================================================
+00047 // ======================================================================================================
+00048 
+00049 
+00050 // ======================================================================================================
+00051 // ======================================================================================================
+00052 // ======================================================================================================
+00053 
+00054 // ======================================================================================================
+00055 inline  IStream::IStream(bool inputStream)
+00056 {
+00057         _InputStream= inputStream;
+00058 }
+00059 
+00060 
+00061 // ======================================================================================================
+00062 inline  bool            IStream::isReading() const
+00063 {
+00064         return _InputStream;
+00065 }
+00066 
+00067 
+00068 // ======================================================================================================
+00069 // ======================================================================================================
+00070 // ======================================================================================================
+00071 
+00072 // ======================================================================================================
+00073 inline  void            IStream::serial(uint8 &b) 
+00074 {
+00075         serialBuffer((uint8 *)&b, 1);
+00076 }
+00077 
+00078 // ======================================================================================================
+00079 inline  void            IStream::serial(sint8 &b) 
+00080 {
+00081         serialBuffer((uint8 *)&b, 1);
+00082 }
+00083 
+00084 // ======================================================================================================
+00085 inline  void            IStream::serial(uint16 &b) 
+00086 {
+00087 #ifdef NL_LITTLE_ENDIAN
+00088         serialBuffer((uint8 *)&b, 2);
+00089 #else // NL_LITTLE_ENDIAN
+00090         uint16  v;
+00091         if(isReading())
+00092         {
+00093                 serialBuffer((uint8 *)&v, 2);
+00094                 NLMISC_BSWAP16(v);
+00095                 b=v;
+00096         }
+00097         else
+00098         {
+00099                 v=b;
+00100                 NLMISC_BSWAP16(v);
+00101                 serialBuffer((uint8 *)&v, 2);
+00102         }
+00103 #endif // NL_LITTLE_ENDIAN
+00104 }
+00105 
+00106 // ======================================================================================================
+00107 inline  void            IStream::serial(sint16 &b) 
+00108 {
+00109 #ifdef NL_LITTLE_ENDIAN
+00110         serialBuffer((uint8 *)&b, 2);
+00111 #else // NL_LITTLE_ENDIAN
+00112         uint16  v;
+00113         if(isReading())
+00114         {
+00115                 serialBuffer((uint8 *)&v, 2);
+00116                 NLMISC_BSWAP16(v);
+00117                 b=v;
+00118         }
+00119         else
+00120         {
+00121                 v=b;
+00122                 NLMISC_BSWAP16(v);
+00123                 serialBuffer((uint8 *)&v, 2);
+00124         }
+00125 #endif // NL_LITTLE_ENDIAN
+00126 }
+00127 
+00128 // ======================================================================================================
+00129 inline  void            IStream::serial(uint32 &b) 
+00130 {
+00131 #ifdef NL_LITTLE_ENDIAN
+00132         serialBuffer((uint8 *)&b, 4);
+00133 #else // NL_LITTLE_ENDIAN
+00134         uint32  v;
+00135         if(isReading())
+00136         {
+00137                 serialBuffer((uint8 *)&v, 4);
+00138                 NLMISC_BSWAP32(v);
+00139                 b=v;
+00140         }
+00141         else
+00142         {
+00143                 v=b;
+00144                 NLMISC_BSWAP32(v);
+00145                 serialBuffer((uint8 *)&v, 4);
+00146         }
+00147 #endif // NL_LITTLE_ENDIAN
+00148 }
+00149 
+00150 // ======================================================================================================
+00151 inline  void            IStream::serial(sint32 &b) 
+00152 {
+00153 #ifdef NL_LITTLE_ENDIAN
+00154         serialBuffer((uint8 *)&b, 4);
+00155 #else // NL_LITTLE_ENDIAN
+00156         uint32  v;
+00157         if(isReading())
+00158         {
+00159                 serialBuffer((uint8 *)&v, 4);
+00160                 NLMISC_BSWAP32(v);
+00161                 b=v;
+00162         }
+00163         else
+00164         {
+00165                 v=b;
+00166                 NLMISC_BSWAP32(v);
+00167                 serialBuffer((uint8 *)&v, 4);
+00168         }
+00169 #endif // NL_LITTLE_ENDIAN
+00170 }
+00171 
+00172 // ======================================================================================================
+00173 inline  void            IStream::serial(uint64 &b) 
+00174 {
+00175 #ifdef NL_LITTLE_ENDIAN
+00176                 serialBuffer((uint8 *)&b, 8);
+00177 #else // NL_LITTLE_ENDIAN
+00178         uint64  v;
+00179         if(isReading())
+00180         {
+00181                 serialBuffer((uint8 *)&v, 8);
+00182                 NLMISC_BSWAP64(v);
+00183                 b=v;
+00184         }
+00185         else
+00186         {
+00187                 v=b;
+00188                 NLMISC_BSWAP64(v);
+00189                 serialBuffer((uint8 *)&v, 8);
+00190         }
+00191 #endif // NL_LITTLE_ENDIAN
+00192 }
+00193 
+00194 // ======================================================================================================
+00195 inline  void            IStream::serial(sint64 &b) 
+00196 {
+00197 #ifdef NL_LITTLE_ENDIAN
+00198         serialBuffer((uint8 *)&b, 8);
+00199 #else // NL_LITTLE_ENDIAN
+00200         uint64  v;
+00201         if(isReading())
+00202         {
+00203                 serialBuffer((uint8 *)&v, 8);
+00204                 NLMISC_BSWAP64(v);
+00205                 b=v;
+00206         }
+00207         else
+00208         {
+00209                 v=b;
+00210                 NLMISC_BSWAP64(v);
+00211                 serialBuffer((uint8 *)&v, 8);
+00212         }
+00213 #endif // NL_LITTLE_ENDIAN
+00214 }
+00215 
+00216 // ======================================================================================================
+00217 inline  void            IStream::serial(float &b) 
+00218 {
+00219 #ifdef NL_LITTLE_ENDIAN
+00220         serialBuffer((uint8 *)&b, 4);
+00221 #else // NL_LITTLE_ENDIAN
+00222         uint32  v;
+00223         if(isReading())
+00224         {
+00225                 serialBuffer((uint8 *)&v, 4);
+00226                 NLMISC_BSWAP32(v);
+00227                 b=*((float*)&v);
+00228         }
+00229         else
+00230         {
+00231                 v=*((uint32*)&b);
+00232                 NLMISC_BSWAP32(v);
+00233                 serialBuffer((uint8 *)&v, 4);
+00234         }
+00235 #endif // NL_LITTLE_ENDIAN
+00236 }
+00237 
+00238 // ======================================================================================================
+00239 inline  void            IStream::serial(double &b) 
+00240 {
+00241 #ifdef NL_LITTLE_ENDIAN
+00242         serialBuffer((uint8 *)&b, 8);
+00243 #else // NL_LITTLE_ENDIAN
+00244         uint64  v;
+00245         if(isReading())
+00246         {
+00247                 serialBuffer((uint8 *)&v, 8);
+00248                 NLMISC_BSWAP64(v);
+00249                 b=*((double*)&v);
+00250         }
+00251         else
+00252         {
+00253                 v=*((uint64*)&b);
+00254                 NLMISC_BSWAP64(v);
+00255                 serialBuffer((uint8 *)&v, 8);
+00256         }
+00257 #endif // NL_LITTLE_ENDIAN
+00258 }
+00259 
+00260 // ======================================================================================================
+00261 inline  void            IStream::serial(bool &b) 
+00262 {
+00263         serialBit(b);
+00264 }
+00265 
+00266 #ifndef NL_OS_CYGWIN
+00267 // ======================================================================================================
+00268 inline  void            IStream::serial(char &b) 
+00269 {
+00270         serialBuffer((uint8 *)&b, 1);
+00271 }
+00272 #endif
+00273 
+00274 // ======================================================================================================
+00275 inline  void            IStream::serial(std::string &b) 
+00276 {
+00277         sint32  len=0;
+00278         // Read/Write the length.
+00279         if(isReading())
+00280         {
+00281                 serial(len);
+00282                 nlassert( len<1000000 ); // limiting string size
+00283                 b.resize(len);
+00284         }
+00285         else
+00286         {
+00287                 len= b.size();
+00288                 serial(len);
+00289         }
+00290         // Read/Write the string.
+00291         for(sint i=0;i<len;i++)
+00292                 serial(b[i]);
+00293 }
+00294 
+00295 
+00296 // ======================================================================================================
+00297 inline  void            IStream::serial(ucstring &b) 
+00298 {
+00299         sint32  len=0;
+00300         // Read/Write the length.
+00301         if(isReading())
+00302         {
+00303                 serial(len);
+00304                 b.resize(len);
+00305         }
+00306         else
+00307         {
+00308                 len= b.size();
+00309                 serial(len);
+00310         }
+00311         // Read/Write the string.
+00312         for(sint i=0;i<len;i++)
+00313                 serial(b[i]);
+00314 }
+00315 
+00316 
+00317 
+00318 // ======================================================================================================
+00319 inline uint8                    IStream::serialBitField8(uint8  bf)
+00320 {
+00321         serial(bf);
+00322         return bf;
+00323 }
+00324 // ======================================================================================================
+00325 inline uint16                   IStream::serialBitField16(uint16  bf)
+00326 {
+00327         serial(bf);
+00328         return bf;
+00329 }
+00330 // ======================================================================================================
+00331 inline uint32                   IStream::serialBitField32(uint32  bf)
+00332 {
+00333         serial(bf);
+00334         return bf;
+00335 }
+00336 
+00337 
+00338 }
+00339 
+00340 
+00341 #endif // NL_STREAM_INLINE_H
+00342 
+00343 /* End of stream_inline.h */
+