2008-03-08 08:52:38 -05:00
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Name: datstrm.h
|
2008-04-17 03:06:20 -04:00
|
|
|
// Purpose: interface of wxDataInputStream and wxDataOutputStream
|
2008-03-08 08:52:38 -05:00
|
|
|
// Author: wxWidgets team
|
|
|
|
// RCS-ID: $Id$
|
2010-07-13 09:29:13 -04:00
|
|
|
// Licence: wxWindows licence
|
2008-03-08 08:52:38 -05:00
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
/**
|
|
|
|
@class wxDataOutputStream
|
2008-03-08 09:43:31 -05:00
|
|
|
|
2008-04-17 03:06:20 -04:00
|
|
|
This class provides functions that write binary data types in a portable
|
|
|
|
way. Data can be written in either big-endian or little-endian format,
|
|
|
|
little-endian being the default on all architectures.
|
2008-03-08 09:43:31 -05:00
|
|
|
|
2008-04-17 03:06:20 -04:00
|
|
|
If you want to write data to text files (or streams) use wxTextOutputStream
|
|
|
|
instead.
|
2008-03-08 09:43:31 -05:00
|
|
|
|
2008-04-17 03:06:20 -04:00
|
|
|
The "<<" operator is overloaded and you can use this class like a standard
|
|
|
|
C++ iostream. See wxDataInputStream for its usage and caveats.
|
2008-03-08 09:43:31 -05:00
|
|
|
|
2008-03-08 08:52:38 -05:00
|
|
|
@library{wxbase}
|
|
|
|
@category{streams}
|
2008-04-17 03:06:20 -04:00
|
|
|
|
|
|
|
@see wxDataInputStream
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
2008-03-08 09:43:31 -05:00
|
|
|
class wxDataOutputStream
|
2008-03-08 08:52:38 -05:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
2008-10-04 16:49:51 -04:00
|
|
|
Constructs a datastream object from an output stream.
|
|
|
|
Only write methods will be available.
|
2008-03-20 09:45:17 -04:00
|
|
|
|
2008-10-27 13:12:27 -04:00
|
|
|
Note that the @a conv parameter is only available in Unicode builds of wxWidgets.
|
2008-04-17 03:06:20 -04:00
|
|
|
|
|
|
|
@param stream
|
|
|
|
The output stream.
|
|
|
|
@param conv
|
2011-04-03 16:31:32 -04:00
|
|
|
Charset conversion object used to encoding Unicode strings
|
2008-04-17 03:06:20 -04:00
|
|
|
before writing them to the stream in Unicode mode (see
|
|
|
|
WriteString() for a detailed description). Note that you must not
|
|
|
|
destroy @a conv before you destroy this wxDataOutputStream
|
|
|
|
instance! It is recommended to use the default value (UTF-8).
|
|
|
|
*/
|
|
|
|
wxDataOutputStream(wxOutputStream& stream,
|
2009-01-11 14:53:49 -05:00
|
|
|
const wxMBConv& conv = wxConvUTF8);
|
2008-03-08 08:52:38 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
Destroys the wxDataOutputStream object.
|
|
|
|
*/
|
|
|
|
~wxDataOutputStream();
|
|
|
|
|
|
|
|
/**
|
2008-04-17 03:06:20 -04:00
|
|
|
If @a be_order is @true, all data will be written in big-endian order,
|
|
|
|
e.g. for reading on a Sparc or from Java-Streams (which always use
|
|
|
|
big-endian order), otherwise data will be written in little-endian
|
|
|
|
order.
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
|
|
|
void BigEndianOrdered(bool be_order);
|
2009-01-11 14:37:11 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
Returns the current text conversion class used for
|
|
|
|
writing strings.
|
|
|
|
*/
|
|
|
|
wxMBConv *GetConv() const;
|
2008-03-08 08:52:38 -05:00
|
|
|
|
2009-01-11 14:37:11 -05:00
|
|
|
/**
|
|
|
|
Sets the text conversion class used for writing strings.
|
|
|
|
*/
|
|
|
|
void SetConv( const wxMBConv &conv );
|
|
|
|
|
2008-04-17 03:06:20 -04:00
|
|
|
/**
|
|
|
|
Writes the single byte @a i8 to the stream.
|
|
|
|
*/
|
|
|
|
void Write8(wxUint8 i8);
|
|
|
|
/**
|
|
|
|
Writes an array of bytes to the stream. The amount of bytes to write is
|
|
|
|
specified with the @a size variable.
|
|
|
|
*/
|
|
|
|
void Write8(const wxUint8* buffer, size_t size);
|
|
|
|
|
|
|
|
/**
|
|
|
|
Writes the 16 bit unsigned integer @a i16 to the stream.
|
|
|
|
*/
|
|
|
|
void Write16(wxUint16 i16);
|
2008-03-08 08:52:38 -05:00
|
|
|
/**
|
|
|
|
Writes an array of 16 bit unsigned integer to the stream. The amount of
|
2008-03-09 08:33:59 -04:00
|
|
|
16 bit unsigned integer to write is specified with the @a size variable.
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
2008-03-09 08:33:59 -04:00
|
|
|
void Write16(const wxUint16* buffer, size_t size);
|
2008-03-08 08:52:38 -05:00
|
|
|
|
2008-04-17 03:06:20 -04:00
|
|
|
/**
|
|
|
|
Writes the 32 bit unsigned integer @a i32 to the stream.
|
|
|
|
*/
|
|
|
|
void Write32(wxUint32 i32);
|
2008-03-08 08:52:38 -05:00
|
|
|
/**
|
|
|
|
Writes an array of 32 bit unsigned integer to the stream. The amount of
|
2008-03-09 08:33:59 -04:00
|
|
|
32 bit unsigned integer to write is specified with the @a size variable.
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
2008-03-09 08:33:59 -04:00
|
|
|
void Write32(const wxUint32* buffer, size_t size);
|
2008-03-08 08:52:38 -05:00
|
|
|
|
2008-04-17 03:06:20 -04:00
|
|
|
/**
|
|
|
|
Writes the 64 bit unsigned integer @a i64 to the stream.
|
|
|
|
*/
|
|
|
|
void Write64(wxUint64 i64);
|
2008-03-08 08:52:38 -05:00
|
|
|
/**
|
|
|
|
Writes an array of 64 bit unsigned integer to the stream. The amount of
|
2008-03-09 08:33:59 -04:00
|
|
|
64 bit unsigned integer to write is specified with the @a size variable.
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
2008-03-09 08:33:59 -04:00
|
|
|
void Write64(const wxUint64* buffer, size_t size);
|
2008-03-08 08:52:38 -05:00
|
|
|
|
|
|
|
/**
|
2008-04-17 03:06:20 -04:00
|
|
|
Writes the double @a f to the stream using the IEEE format.
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
2008-04-17 03:06:20 -04:00
|
|
|
void WriteDouble(double f);
|
2008-03-08 08:52:38 -05:00
|
|
|
/**
|
|
|
|
Writes an array of double to the stream. The amount of double to write is
|
2008-03-09 08:33:59 -04:00
|
|
|
specified with the @a size variable.
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
2008-03-09 08:33:59 -04:00
|
|
|
void WriteDouble(const double* buffer, size_t size);
|
2008-03-08 08:52:38 -05:00
|
|
|
|
|
|
|
/**
|
2008-04-17 03:06:20 -04:00
|
|
|
Writes @a string to the stream. Actually, this method writes the size
|
|
|
|
of the string before writing @a string itself.
|
|
|
|
|
|
|
|
In ANSI build of wxWidgets, the string is written to the stream in
|
|
|
|
exactly same way it is represented in memory. In Unicode build,
|
|
|
|
however, the string is first converted to multibyte representation with
|
|
|
|
@e conv object passed to stream's constructor (consequently, ANSI
|
|
|
|
applications can read data written by Unicode application, as long as
|
|
|
|
they agree on encoding) and this representation is written to the
|
|
|
|
stream. UTF-8 is used by default.
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
|
|
|
void WriteString(const wxString& string);
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2008-03-10 11:24:38 -04:00
|
|
|
|
2008-03-08 08:52:38 -05:00
|
|
|
/**
|
|
|
|
@class wxDataInputStream
|
2008-03-08 09:43:31 -05:00
|
|
|
|
2008-04-17 03:06:20 -04:00
|
|
|
This class provides functions that read binary data types in a portable
|
|
|
|
way. Data can be read in either big-endian or little-endian format,
|
|
|
|
little-endian being the default on all architectures.
|
2008-03-08 09:43:31 -05:00
|
|
|
|
2008-04-17 03:06:20 -04:00
|
|
|
If you want to read data from text files (or streams) use wxTextInputStream
|
|
|
|
instead.
|
2008-03-08 09:43:31 -05:00
|
|
|
|
2008-04-17 03:06:20 -04:00
|
|
|
The ">>" operator is overloaded and you can use this class like a standard
|
|
|
|
C++ iostream. Note, however, that the arguments are the fixed size types
|
|
|
|
wxUint32, wxInt32 etc and on a typical 32-bit computer, none of these match
|
|
|
|
to the "long" type (wxInt32 is defined as signed int on 32-bit
|
|
|
|
architectures) so that you cannot use long. To avoid problems (here and
|
|
|
|
elsewhere), make use of the wxInt32, wxUint32, etc types.
|
2008-03-08 09:43:31 -05:00
|
|
|
|
2008-03-08 08:52:38 -05:00
|
|
|
For example:
|
2008-03-08 09:43:31 -05:00
|
|
|
|
2008-03-08 08:52:38 -05:00
|
|
|
@code
|
|
|
|
wxFileInputStream input( "mytext.dat" );
|
2008-04-17 03:06:20 -04:00
|
|
|
wxDataInputStream store( input );
|
|
|
|
wxUint8 i1;
|
|
|
|
float f2;
|
|
|
|
wxString line;
|
|
|
|
|
|
|
|
store >> i1; // read a 8 bit integer.
|
|
|
|
store >> i1 >> f2; // read a 8 bit integer followed by float.
|
|
|
|
store >> line; // read a text line
|
2008-03-08 08:52:38 -05:00
|
|
|
@endcode
|
2008-03-08 09:43:31 -05:00
|
|
|
|
2008-03-08 08:52:38 -05:00
|
|
|
@library{wxbase}
|
|
|
|
@category{streams}
|
2008-04-17 03:06:20 -04:00
|
|
|
|
|
|
|
@see wxDataOutputStream
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
2008-03-08 09:43:31 -05:00
|
|
|
class wxDataInputStream
|
2008-03-08 08:52:38 -05:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
2008-10-04 16:49:51 -04:00
|
|
|
Constructs a datastream object from an input stream.
|
|
|
|
Only read methods will be available.
|
2008-04-17 03:06:20 -04:00
|
|
|
|
2008-10-27 13:12:27 -04:00
|
|
|
Note that the @a conv parameter is only available in Unicode builds of wxWidgets.
|
2008-03-20 09:45:17 -04:00
|
|
|
|
2008-03-08 09:43:31 -05:00
|
|
|
@param stream
|
2008-03-09 08:33:59 -04:00
|
|
|
The input stream.
|
2008-03-08 09:43:31 -05:00
|
|
|
@param conv
|
2011-04-03 16:31:32 -04:00
|
|
|
Charset conversion object used to decode strings in Unicode
|
2008-04-17 03:06:20 -04:00
|
|
|
mode (see ReadString() for a detailed description). Note that you
|
|
|
|
must not destroy @a conv before you destroy this wxDataInputStream
|
|
|
|
instance!
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
2008-04-17 03:06:20 -04:00
|
|
|
wxDataInputStream(wxInputStream& stream,
|
2009-01-11 14:53:49 -05:00
|
|
|
const wxMBConv& conv = wxConvUTF8 );
|
2008-03-08 08:52:38 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
Destroys the wxDataInputStream object.
|
|
|
|
*/
|
|
|
|
~wxDataInputStream();
|
|
|
|
|
|
|
|
/**
|
2008-04-17 03:06:20 -04:00
|
|
|
If @a be_order is @true, all data will be read in big-endian order,
|
|
|
|
such as written by programs on a big endian architecture (e.g. Sparc)
|
|
|
|
or written by Java-Streams (which always use big-endian order).
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
|
|
|
void BigEndianOrdered(bool be_order);
|
|
|
|
|
2009-01-11 14:37:11 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
Returns the current text conversion class used for
|
|
|
|
reading strings.
|
|
|
|
*/
|
|
|
|
wxMBConv *GetConv() const;
|
|
|
|
|
2008-03-08 08:52:38 -05:00
|
|
|
/**
|
2008-04-17 03:06:20 -04:00
|
|
|
Reads a single byte from the stream.
|
|
|
|
*/
|
|
|
|
wxUint8 Read8();
|
|
|
|
/**
|
|
|
|
Reads bytes from the stream in a specified buffer. The amount of bytes
|
|
|
|
to read is specified by the @a size variable.
|
|
|
|
*/
|
|
|
|
void Read8(wxUint8* buffer, size_t size);
|
|
|
|
|
|
|
|
/**
|
|
|
|
Reads a 16 bit unsigned integer from the stream.
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
|
|
|
wxUint16 Read16();
|
2008-04-17 03:06:20 -04:00
|
|
|
/**
|
|
|
|
Reads 16 bit unsigned integers from the stream in a specified buffer.
|
|
|
|
The amount of 16 bit unsigned integers to read is specified by the
|
|
|
|
@a size variable.
|
|
|
|
*/
|
2008-03-09 08:33:59 -04:00
|
|
|
void Read16(wxUint16* buffer, size_t size);
|
2008-03-08 08:52:38 -05:00
|
|
|
|
|
|
|
/**
|
2008-04-17 03:06:20 -04:00
|
|
|
Reads a 32 bit unsigned integer from the stream.
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
|
|
|
wxUint32 Read32();
|
2008-04-17 03:06:20 -04:00
|
|
|
/**
|
|
|
|
Reads 32 bit unsigned integers from the stream in a specified buffer.
|
|
|
|
The amount of 32 bit unsigned integers to read is specified by the
|
|
|
|
@a size variable.
|
|
|
|
*/
|
2008-03-09 08:33:59 -04:00
|
|
|
void Read32(wxUint32* buffer, size_t size);
|
2008-03-08 08:52:38 -05:00
|
|
|
|
|
|
|
/**
|
2008-04-17 03:06:20 -04:00
|
|
|
Reads a 64 bit unsigned integer from the stream.
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
|
|
|
wxUint64 Read64();
|
|
|
|
/**
|
2008-04-17 03:06:20 -04:00
|
|
|
Reads 64 bit unsigned integers from the stream in a specified buffer.
|
|
|
|
The amount of 64 bit unsigned integers to read is specified by the
|
|
|
|
@a size variable.
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
2008-04-17 03:06:20 -04:00
|
|
|
void Read64(wxUint64* buffer, size_t size);
|
2008-03-08 08:52:38 -05:00
|
|
|
|
|
|
|
/**
|
2008-04-17 03:06:20 -04:00
|
|
|
Reads a double (IEEE encoded) from the stream.
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
|
|
|
double ReadDouble();
|
2008-04-17 03:06:20 -04:00
|
|
|
/**
|
|
|
|
Reads double data (IEEE encoded) from the stream in a specified buffer.
|
|
|
|
The amount of doubles to read is specified by the @a size variable.
|
|
|
|
*/
|
2008-03-09 08:33:59 -04:00
|
|
|
void ReadDouble(double* buffer, size_t size);
|
2008-03-08 08:52:38 -05:00
|
|
|
|
|
|
|
/**
|
2008-04-17 03:06:20 -04:00
|
|
|
Reads a string from a stream. Actually, this function first reads a
|
|
|
|
long integer specifying the length of the string (without the last null
|
|
|
|
character) and then reads the string.
|
|
|
|
|
|
|
|
In Unicode build of wxWidgets, the fuction first reads multibyte
|
|
|
|
(char*) string from the stream and then converts it to Unicode using
|
|
|
|
the @e conv object passed to constructor and returns the result as
|
2011-04-03 16:31:32 -04:00
|
|
|
wxString. You are responsible for using the same converter as when
|
2008-04-17 03:06:20 -04:00
|
|
|
writing the stream.
|
|
|
|
|
|
|
|
@see wxDataOutputStream::WriteString()
|
2008-03-08 08:52:38 -05:00
|
|
|
*/
|
|
|
|
wxString ReadString();
|
2009-01-11 14:37:11 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
Sets the text conversion class used for reading strings.
|
|
|
|
*/
|
|
|
|
void SetConv( const wxMBConv &conv );
|
2008-03-08 08:52:38 -05:00
|
|
|
};
|
2008-03-10 11:24:38 -04:00
|
|
|
|