]>
git.saurik.com Git - wxWidgets.git/blob - interface/wx/datstrm.h
1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: interface of wxDataInputStream and wxDataOutputStream
4 // Author: wxWidgets team
6 // Licence: wxWindows licence
7 /////////////////////////////////////////////////////////////////////////////
10 @class wxDataOutputStream
12 This class provides functions that write binary data types in a portable
13 way. Data can be written in either big-endian or little-endian format,
14 little-endian being the default on all architectures.
16 If you want to write data to text files (or streams) use wxTextOutputStream
19 The "<<" operator is overloaded and you can use this class like a standard
20 C++ iostream. See wxDataInputStream for its usage and caveats.
25 @see wxDataInputStream
27 class wxDataOutputStream
31 Constructs a datastream object from an output stream.
32 Only write methods will be available.
34 Note that the @a conv parameter is only available in Unicode builds of wxWidgets.
39 Charset conversion object used to encoding Unicode strings
40 before writing them to the stream in Unicode mode (see
41 WriteString() for a detailed description). Note that you must not
42 destroy @a conv before you destroy this wxDataOutputStream
43 instance! It is recommended to use the default value (UTF-8).
45 wxDataOutputStream(wxOutputStream
& stream
,
46 const wxMBConv
& conv
= wxConvUTF8
);
49 Destroys the wxDataOutputStream object.
51 ~wxDataOutputStream();
54 If @a be_order is @true, all data will be written in big-endian order,
55 e.g. for reading on a Sparc or from Java-Streams (which always use
56 big-endian order), otherwise data will be written in little-endian
59 void BigEndianOrdered(bool be_order
);
62 Returns the current text conversion class used for
65 wxMBConv
*GetConv() const;
68 Sets the text conversion class used for writing strings.
70 void SetConv( const wxMBConv
&conv
);
73 Writes the single byte @a i8 to the stream.
75 void Write8(wxUint8 i8
);
77 Writes an array of bytes to the stream. The amount of bytes to write is
78 specified with the @a size variable.
80 void Write8(const wxUint8
* buffer
, size_t size
);
83 Writes the 16 bit unsigned integer @a i16 to the stream.
85 void Write16(wxUint16 i16
);
87 Writes an array of 16 bit unsigned integer to the stream. The amount of
88 16 bit unsigned integer to write is specified with the @a size variable.
90 void Write16(const wxUint16
* buffer
, size_t size
);
93 Writes the 32 bit unsigned integer @a i32 to the stream.
95 void Write32(wxUint32 i32
);
97 Writes an array of 32 bit unsigned integer to the stream. The amount of
98 32 bit unsigned integer to write is specified with the @a size variable.
100 void Write32(const wxUint32
* buffer
, size_t size
);
103 Writes the 64 bit unsigned integer @a i64 to the stream.
105 void Write64(wxUint64 i64
);
107 Writes an array of 64 bit unsigned integer to the stream. The amount of
108 64 bit unsigned integer to write is specified with the @a size variable.
110 void Write64(const wxUint64
* buffer
, size_t size
);
113 Writes the double @a f to the stream using the IEEE format.
115 void WriteDouble(double f
);
117 Writes an array of double to the stream. The amount of double to write is
118 specified with the @a size variable.
120 void WriteDouble(const double* buffer
, size_t size
);
123 Writes @a string to the stream. Actually, this method writes the size
124 of the string before writing @a string itself.
126 In ANSI build of wxWidgets, the string is written to the stream in
127 exactly same way it is represented in memory. In Unicode build,
128 however, the string is first converted to multibyte representation with
129 @e conv object passed to stream's constructor (consequently, ANSI
130 applications can read data written by Unicode application, as long as
131 they agree on encoding) and this representation is written to the
132 stream. UTF-8 is used by default.
134 void WriteString(const wxString
& string
);
140 @class wxDataInputStream
142 This class provides functions that read binary data types in a portable
143 way. Data can be read in either big-endian or little-endian format,
144 little-endian being the default on all architectures.
146 If you want to read data from text files (or streams) use wxTextInputStream
149 The ">>" operator is overloaded and you can use this class like a standard
150 C++ iostream. Note, however, that the arguments are the fixed size types
151 wxUint32, wxInt32 etc and on a typical 32-bit computer, none of these match
152 to the "long" type (wxInt32 is defined as signed int on 32-bit
153 architectures) so that you cannot use long. To avoid problems (here and
154 elsewhere), make use of the wxInt32, wxUint32, etc types.
159 wxFileInputStream input( "mytext.dat" );
160 wxDataInputStream store( input );
165 store >> i1; // read a 8 bit integer.
166 store >> i1 >> f2; // read a 8 bit integer followed by float.
167 store >> line; // read a text line
173 @see wxDataOutputStream
175 class wxDataInputStream
179 Constructs a datastream object from an input stream.
180 Only read methods will be available.
182 Note that the @a conv parameter is only available in Unicode builds of wxWidgets.
187 Charset conversion object used to decode strings in Unicode
188 mode (see ReadString() for a detailed description). Note that you
189 must not destroy @a conv before you destroy this wxDataInputStream
192 wxDataInputStream(wxInputStream
& stream
,
193 const wxMBConv
& conv
= wxConvUTF8
);
196 Destroys the wxDataInputStream object.
198 ~wxDataInputStream();
201 If @a be_order is @true, all data will be read in big-endian order,
202 such as written by programs on a big endian architecture (e.g. Sparc)
203 or written by Java-Streams (which always use big-endian order).
205 void BigEndianOrdered(bool be_order
);
209 Returns the current text conversion class used for
212 wxMBConv
*GetConv() const;
215 Reads a single byte from the stream.
219 Reads bytes from the stream in a specified buffer. The amount of bytes
220 to read is specified by the @a size variable.
222 void Read8(wxUint8
* buffer
, size_t size
);
225 Reads a 16 bit unsigned integer from the stream.
229 Reads 16 bit unsigned integers from the stream in a specified buffer.
230 The amount of 16 bit unsigned integers to read is specified by the
233 void Read16(wxUint16
* buffer
, size_t size
);
236 Reads a 32 bit unsigned integer from the stream.
240 Reads 32 bit unsigned integers from the stream in a specified buffer.
241 The amount of 32 bit unsigned integers to read is specified by the
244 void Read32(wxUint32
* buffer
, size_t size
);
247 Reads a 64 bit unsigned integer from the stream.
251 Reads 64 bit unsigned integers from the stream in a specified buffer.
252 The amount of 64 bit unsigned integers to read is specified by the
255 void Read64(wxUint64
* buffer
, size_t size
);
258 Reads a double (IEEE encoded) from the stream.
262 Reads double data (IEEE encoded) from the stream in a specified buffer.
263 The amount of doubles to read is specified by the @a size variable.
265 void ReadDouble(double* buffer
, size_t size
);
268 Reads a string from a stream. Actually, this function first reads a
269 long integer specifying the length of the string (without the last null
270 character) and then reads the string.
272 In Unicode build of wxWidgets, the fuction first reads multibyte
273 (char*) string from the stream and then converts it to Unicode using
274 the @e conv object passed to constructor and returns the result as
275 wxString. You are responsible for using the same converter as when
278 @see wxDataOutputStream::WriteString()
280 wxString
ReadString();
283 Sets the text conversion class used for reading strings.
285 void SetConv( const wxMBConv
&conv
);