Main Page   Modules   Class Hierarchy   Data Structures   File List   Data Fields   Globals   Related Pages  

oscl_bin_stream.h

Go to the documentation of this file.
00001 // -*- c++ -*-
00002 // = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
00003 
00004 //                 O S C L _ B I N _ S T R E A M
00005 
00006 // = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
00007 
00021 /*
00022 **   File:   oscl_bin_stream.h
00023 **
00024 **   Description:
00025 **       This module defines a set of binary stream classes to provide portability of code accross
00026 **       different platforms and compilers. Output and input stream classes are defined both for
00027 **       little endian and big endian byte orders. These classes should be used when sharing
00028 **       information across platforms (e.g. sending messages) instead of C structures. The classes
00029 **       will read/write in the correct byte order regardless of the platform you are running on.
00030 **       The classes are:
00031 **           OsclBinIStreamBigEndian - Input stream for big endian byte order.
00032 **           OsclBinIStreamLittleEndian - Input stream for little endian byte order.
00033 **           OsclBinOStreamBigEndian - Output stream for big endian byte order.
00034 **           OsclBinIStreamLittleEndian - Input stream for little endian byte order.
00035 **
00036 **      The preprocessor defined constants BYTE_ORDER_BIG_ENDIAN, BYTE_ORDER_LITTLE_ENDIAN are defined
00037 **      in oscl_base.h and tell this module the byte order used by the native platform. This is used
00038 **      to decide if we can do a straight copy or we need to manipulate the field one byte at a time.
00039 **      The preprocessor defined constant INTEGERS_BYTE_ALIGNED tells us if the platform supports
00040 **      accessing integers at any address.
00041 */
00042 #ifndef OSCL_BIN_STREAM_H_INCLUDED
00043 #define OSCL_BIN_STREAM_H_INCLUDED
00044 
00045 /*
00046 ** Includes
00047 */
00048 #ifndef OSCL_BASE_H_INCLUDED
00049 #include "oscl_base.h"
00050 #endif
00051 
00052 
00053 
00054 /*
00055 ** Classes
00056 */
00057 
00058 class OsclBinStream
00059 {
00060     public:
00061         OsclBinStream()
00062                 : state(GOOD_STATE),
00063                 pBasePosition(0),
00064                 pPosition(0)
00065         {
00066         }
00067 
00069 
00072         bool good();
00073 
00075 
00078         bool eof();
00079 
00081 
00084         bool fail();
00085 
00086 
00088 
00092         void Attach(void * buffer, uint32 l_length);
00093 
00095 
00100         void Attach(const uint32 numFragments, const OsclMemoryFragment * fragPtr);
00101 
00102 
00104 
00108         uint32 tellg();
00109 
00111 
00114         void Seek(uint32 absPosition);
00115 
00117 
00120         uint32 PositionInBlock();
00121 
00122 
00124 
00127         void seekFromCurrentPosition(int32 offset);
00128 
00129 
00130 
00131     protected:
00132 
00133         /*
00134         ** Description:
00135         **      Reserves space for storing/reading. If no space is available it sets the stream state
00136         **      to fail and returns false. If the end of the stream has been reached, it sets the state
00137         **      to end of stream.
00138         **
00139         ** Returns: true if space was successfully reserved.
00140         ** Side effects: None.
00141         */
00142         bool ReserveSpace(uint32 size);
00143 
00144         bool HaveRoomInCurrentBlock(uint32 size);
00145 
00146         typedef enum
00147         {
00148             GOOD_STATE,
00149             EOF_STATE,
00150             FAIL_STATE
00151         } state_t;
00152 
00153         state_t state;
00154 
00155         /* Position of the beginning of the data buffer */
00156         uint8 * pBasePosition;
00157 
00158         /* Current data buffer position */
00159         uint8 * pPosition;
00160 
00161         /* length of data buffer */
00162         uint32            length;
00163 
00164         const OsclMemoryFragment *  nextFragPtr;
00165         int               fragsLeft;
00166 
00167         const OsclMemoryFragment *  firstFragPtr;
00168         int               numFrags;
00169         OsclMemoryFragment   specialFragBuffer;
00170 
00171 };
00172 
00173 /*
00174 ** Class OsclBinIStream
00175 **      This class implements the basic stream functions for an input stream.
00176 */
00177 class OsclBinIStream : public OsclBinStream
00178 {
00179     private:
00180     public:
00181         /*
00182         ** Description:
00183         **      Constructor.
00184         **
00185         ** Returns: None.
00186         ** Side effects: None.
00187         */
00188         OsclBinIStream()
00189         {
00190         }
00191 
00192         /*
00193         ** Description:
00194         **      Destructor.
00195         **
00196         ** Returns: None.
00197         ** Side effects: None.
00198         */
00199         ~OsclBinIStream()
00200         {
00201         }
00202 
00204 
00207         uint8 Read_uint8();
00208 
00210 
00214         OsclBinIStream & get(
00215             int8 * data,
00216             int32 size
00217         );
00218 
00219     protected:
00220 
00221 
00222 };
00223 
00224 /*
00225 ** Class OsclBinIStreamLittleEndian
00226 **      This class implements a binary input stream using little endian byte ordering
00227 */
00228 class OsclBinIStreamLittleEndian : public OsclBinIStream
00229 {
00230     public:
00231         OsclBinIStreamLittleEndian()
00232         {
00233         }
00234 
00236         OsclBinIStreamLittleEndian & operator>>(int8 & data);
00237 
00239         OsclBinIStreamLittleEndian & operator>>(uint8 & data);
00240 
00242         OsclBinIStreamLittleEndian & operator>>(int16 & data);
00243 
00245         OsclBinIStreamLittleEndian & operator>>(uint16 & data);
00246 
00248         OsclBinIStreamLittleEndian & operator>>(int32 & data);
00249 
00251         OsclBinIStreamLittleEndian & operator>>(uint32 & data);
00252 
00253     protected:
00254 
00255         /*
00256         ** Description:
00257         **      Reads an unsigned short from the stream.
00258         **
00259         ** Returns: Unsigned short read from the stream.
00260         ** Side effects: None.
00261         */
00262         uint16 Read_uint16();
00263         /*
00264         ** Description:
00265         **      Reads an unsigned long from the stream.
00266         **
00267         ** Returns: Unsigned long read from the stream.
00268         ** Side effects: None.
00269         */
00270         uint32 Read_uint32();
00271 };
00272 
00273 
00274 /*
00275 ** Class OsclBinIStreamBigEndian
00276 **      This class implements a binary input stream using big endian byte ordering
00277 */
00278 class OsclBinIStreamBigEndian : public OsclBinIStream
00279 {
00280     public:
00281         OsclBinIStreamBigEndian()
00282         {
00283         }
00284 
00285         void Read(int8 & data);
00286 
00287         void Read(uint8 & data);
00288 
00289         void Read(int16 & data);
00290 
00291         void Read(uint16 & data);
00292 
00293         void Read(int32 & data);
00294 
00295         void Read(uint32 & data);
00296 
00298         OsclBinIStreamBigEndian & operator>>(int8 & data);
00299 
00301         OsclBinIStream & operator>>(uint8 & data);
00302 
00304         OsclBinIStreamBigEndian & operator>>(int16 & data);
00305 
00307         OsclBinIStreamBigEndian & operator>>(uint16 & data);
00308 
00310         OsclBinIStreamBigEndian & operator>>(int32 & data);
00311 
00313         OsclBinIStreamBigEndian & operator>>(uint32 & data);
00314 
00316 
00319         uint16 Read_uint16();
00320 
00322 
00325         uint32 Read_uint32();
00326     protected:
00327 
00328 };
00329 
00330 
00332 class OsclBinOStream : public OsclBinStream
00333 {
00334     public:
00335         OsclBinOStream()
00336         {
00337         }
00338 
00339         virtual ~OsclBinOStream()
00340         {
00341         }
00342 
00344         OsclBinOStream & write(
00345             const int8 * data,      /* data to store */
00346             int32 size      /* length of data to store */
00347         );
00348 
00349     protected:
00350 };
00351 
00353 class OsclBinOStreamLittleEndian : public OsclBinOStream
00354 {
00355     public:
00356         OsclBinOStreamLittleEndian()
00357         {
00358         }
00359 
00361         OsclBinOStreamLittleEndian & operator<<(const int8 & data);
00362 
00364         OsclBinOStreamLittleEndian & operator<<(const uint8 & data);
00365 
00367         OsclBinOStreamLittleEndian & operator<<(const int16 & data);
00368 
00370         OsclBinOStreamLittleEndian & operator<<(const uint16 & data);
00371 
00373         OsclBinOStreamLittleEndian & operator<<(const int32 & data);
00374 
00376         OsclBinOStreamLittleEndian & operator<<(const uint32 & data);
00377 
00378     protected:
00379 
00381         void WriteUnsignedShort(const uint16 data);
00382 
00384         void WriteUnsignedLong(const uint32 data);
00385 
00386 };
00387 
00388 
00390 class OsclBinOStreamBigEndian : public OsclBinOStream
00391 {
00392     public:
00393         OsclBinOStreamBigEndian()
00394         {
00395         }
00396 
00398         OsclBinOStreamBigEndian & operator<<(const int8 & data);
00399 
00401         OsclBinOStreamBigEndian & operator<<(const uint8 & data);
00402 
00404         OsclBinOStreamBigEndian & operator<<(const int16 & data);
00405 
00407         OsclBinOStreamBigEndian & operator<<(const uint16 & data);
00408 
00410         OsclBinOStreamBigEndian & operator<<(const int32 & data);
00411 
00413         OsclBinOStreamBigEndian & operator<<(const uint32 & data);
00414 
00415     protected:
00416 
00417         /*
00418         ** Description:
00419         **      Writes 'data' (unsigned short) to the stream.
00420         **
00421         ** Returns: None.
00422         ** Side effects: None.
00423         */
00424         void WriteUnsignedShort(const uint16 data);
00425 
00426         /*
00427         ** Description:
00428         **      Writes 'data' (unsigned long) to the stream.
00429         **
00430         ** Returns: None.
00431         ** Side effects: None.
00432         */
00433         void WriteUnsignedLong(const uint32 data);
00434 };
00435 
00436 #if (!OSCL_DISABLE_INLINES)
00437 #include "oscl_bin_stream.inl"
00438 #endif
00439 
00440 #endif
00441 

OSCL API
Posting Version: CORE_8.000.1.1_RC4