480 lines
12 KiB
Objective-C
480 lines
12 KiB
Objective-C
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: txtstrm.h
|
|
// Purpose: interface of wxTextInputStream
|
|
// Author: wxWidgets team
|
|
// Licence: wxWindows licence
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
/**
|
|
@class wxTextInputStream
|
|
|
|
This class provides functions that reads text data using an input stream,
|
|
allowing you to read text, floats, and integers.
|
|
|
|
The wxTextInputStream correctly reads text files (or streams) in DOS,
|
|
Macintosh and Unix formats and reports a single newline char as a line
|
|
ending.
|
|
|
|
wxTextInputStream::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 int on 32-bit
|
|
architectures) so that you cannot use long. To avoid problems (here and
|
|
elsewhere), make use of wxInt32, wxUint32 and similar types.
|
|
|
|
If you're scanning through a file using wxTextInputStream, you should check
|
|
for @c EOF @b before reading the next item (word / number), because
|
|
otherwise the last item may get lost. You should however be prepared to
|
|
receive an empty item (empty string / zero number) at the end of file,
|
|
especially on Windows systems. This is unavoidable because most (but not
|
|
all) files end with whitespace (i.e. usually a newline).
|
|
|
|
For example:
|
|
|
|
@code
|
|
wxFileInputStream input( "mytext.txt" );
|
|
wxTextInputStream text( input );
|
|
wxUint8 i1;
|
|
float f2;
|
|
wxString word;
|
|
|
|
text >> i1; // read a 8 bit integer.
|
|
text >> i1 >> f2; // read a 8 bit integer followed by float.
|
|
text >> word; // read a word
|
|
@endcode
|
|
|
|
@library{wxbase}
|
|
@category{streams}
|
|
|
|
@see wxTextOutputStream
|
|
*/
|
|
class wxTextInputStream
|
|
{
|
|
public:
|
|
/**
|
|
Constructs a text stream associated to the given input stream.
|
|
|
|
@param stream
|
|
The underlying input stream.
|
|
@param sep
|
|
The initial string separator characters.
|
|
@param conv
|
|
<b>In Unicode build only:</b> The encoding converter used to
|
|
convert the bytes in the underlying input stream to characters.
|
|
*/
|
|
wxTextInputStream(wxInputStream& stream, const wxString& sep = " \t",
|
|
const wxMBConv& conv = wxConvAuto());
|
|
|
|
/**
|
|
Destructor.
|
|
*/
|
|
~wxTextInputStream();
|
|
|
|
/**
|
|
Returns a pointer to the underlying input stream object.
|
|
|
|
@since 2.9.2
|
|
*/
|
|
const wxInputStream& GetInputStream() const;
|
|
|
|
/**
|
|
Reads a character, returns 0 if there are no more characters in the
|
|
stream.
|
|
*/
|
|
wxChar GetChar();
|
|
|
|
/**
|
|
Reads a unsigned 16 bit integer from the stream.
|
|
|
|
See Read8() for the description of the @a base parameter.
|
|
*/
|
|
wxUint16 Read16(int base = 10);
|
|
|
|
/**
|
|
Reads a signed 16 bit integer from the stream.
|
|
|
|
See Read8() for the description of the @a base parameter.
|
|
*/
|
|
wxInt16 Read16S(int base = 10);
|
|
|
|
/**
|
|
Reads a 32 bit unsigned integer from the stream.
|
|
|
|
See Read8() for the description of the @a base parameter.
|
|
*/
|
|
wxUint32 Read32(int base = 10);
|
|
|
|
/**
|
|
Reads a 32 bit signed integer from the stream.
|
|
|
|
See Read8() for the description of the @a base parameter.
|
|
*/
|
|
wxInt32 Read32S(int base = 10);
|
|
|
|
/**
|
|
Reads a 64 bit unsigned integer from the stream.
|
|
|
|
See Read8() for the description of the @a base parameter.
|
|
|
|
@since 3.1.0
|
|
*/
|
|
wxUint64 Read64(int base = 10);
|
|
|
|
/**
|
|
Reads a 64 bit signed integer from the stream.
|
|
|
|
See Read8() for the description of the @a base parameter.
|
|
|
|
@since 3.1.0
|
|
*/
|
|
wxInt64 Read64S(int base = 10);
|
|
|
|
/**
|
|
Reads a single unsigned byte from the stream, given in base @a base.
|
|
|
|
The value of @a base must be comprised between 2 and 36, inclusive, or
|
|
be a special value 0 which means that the usual rules of C numbers are
|
|
applied: if the number starts with @c 0x it is considered to be in base
|
|
16, if it starts with 0 - in base 8 and in base 10 otherwise. Note that
|
|
you may not want to specify the base 0 if you are parsing the numbers
|
|
which may have leading zeroes as they can yield unexpected (to the user
|
|
not familiar with C) results.
|
|
*/
|
|
wxUint8 Read8(int base = 10);
|
|
|
|
/**
|
|
Reads a single signed byte from the stream.
|
|
|
|
See Read8() for the description of the @a base parameter.
|
|
*/
|
|
wxInt8 Read8S(int base = 10);
|
|
|
|
/**
|
|
Reads a double (IEEE encoded) from the stream.
|
|
*/
|
|
double ReadDouble();
|
|
|
|
/**
|
|
Reads a line from the input stream and returns it (without the end of
|
|
line character).
|
|
*/
|
|
wxString ReadLine();
|
|
|
|
/**
|
|
@deprecated Use ReadLine() or ReadWord() instead.
|
|
|
|
Same as ReadLine().
|
|
*/
|
|
wxString ReadString();
|
|
|
|
/**
|
|
Reads a word (a sequence of characters until the next separator) from
|
|
the input stream.
|
|
|
|
@see SetStringSeparators()
|
|
*/
|
|
wxString ReadWord();
|
|
|
|
/**
|
|
Sets the characters which are used to define the word boundaries in
|
|
ReadWord().
|
|
|
|
The default separators are the @c space and @c TAB characters.
|
|
*/
|
|
void SetStringSeparators(const wxString& sep);
|
|
|
|
/**
|
|
Uses ReadWord() to extract @a word.
|
|
*/
|
|
wxTextInputStream& operator>>(wxString& word);
|
|
|
|
/**
|
|
Extracts the next char in the stream.
|
|
*/
|
|
wxTextInputStream& operator>>(char& c);
|
|
|
|
/**
|
|
Uses GetChar() to extract @a wc.
|
|
@note Only available in Unicode builds.
|
|
*/
|
|
wxTextInputStream& operator>>(wchar_t& wc);
|
|
|
|
/**
|
|
Uses Read16S() to extract @a i.
|
|
*/
|
|
wxTextInputStream& operator>>(wxInt16& i);
|
|
|
|
/**
|
|
Uses Read32S() to extract @a i.
|
|
*/
|
|
wxTextInputStream& operator>>(wxInt32& i);
|
|
|
|
/**
|
|
Uses Read64S() to extract @a i.
|
|
*/
|
|
wxTextInputStream& operator>>(wxInt64& i);
|
|
|
|
/**
|
|
Uses Read16() to extract @a i.
|
|
*/
|
|
wxTextInputStream& operator>>(wxUint16& i);
|
|
|
|
/**
|
|
Uses Read32() to extract @a i.
|
|
*/
|
|
wxTextInputStream& operator>>(wxUint32& i);
|
|
|
|
/**
|
|
Uses Read64() to extract @a i.
|
|
*/
|
|
wxTextInputStream& operator>>(wxUint64& i);
|
|
|
|
/**
|
|
Uses ReadDouble() to extract @a i.
|
|
*/
|
|
wxTextInputStream& operator>>(double& i);
|
|
|
|
/**
|
|
Uses truncated result of ReadDouble() to extract @a f.
|
|
*/
|
|
wxTextInputStream& operator>>(float& f);
|
|
|
|
/**
|
|
Calls @c func(*this).
|
|
*/
|
|
wxTextInputStream& operator>>(__wxTextInputManip func);
|
|
};
|
|
|
|
|
|
/**
|
|
Specifies the end-of-line characters to use with wxTextOutputStream.
|
|
*/
|
|
enum wxEOL
|
|
{
|
|
/**
|
|
Specifies wxTextOutputStream to use the native end-of-line characters.
|
|
*/
|
|
wxEOL_NATIVE,
|
|
|
|
/**
|
|
Specifies wxTextOutputStream to use Unix end-of-line characters.
|
|
*/
|
|
wxEOL_UNIX,
|
|
|
|
/**
|
|
Specifies wxTextOutputStream to use Mac end-of-line characters.
|
|
*/
|
|
wxEOL_MAC,
|
|
|
|
/**
|
|
Specifies wxTextOutputStream to use DOS end-of-line characters.
|
|
*/
|
|
wxEOL_DOS
|
|
};
|
|
|
|
|
|
/**
|
|
@class wxTextOutputStream
|
|
|
|
This class provides functions that write text data using an output stream,
|
|
allowing you to write text, floats, and integers.
|
|
|
|
You can also simulate the C++ @c std::cout class:
|
|
|
|
@code
|
|
wxFFileOutputStream output( stderr );
|
|
wxTextOutputStream cout( output );
|
|
|
|
cout << "This is a text line" << endl;
|
|
cout << 1234;
|
|
cout << 1.23456;
|
|
@endcode
|
|
|
|
The wxTextOutputStream writes text files (or streams) on Windows or Unix in
|
|
their native formats (concerning the line ending).
|
|
|
|
@library{wxbase}
|
|
@category{streams}
|
|
|
|
@see wxTextInputStream
|
|
*/
|
|
class wxTextOutputStream
|
|
{
|
|
public:
|
|
/**
|
|
Constructs a text stream object associated to the given output stream.
|
|
|
|
@param stream
|
|
The output stream.
|
|
@param mode
|
|
The end-of-line mode. One of ::wxEOL_NATIVE, ::wxEOL_DOS,
|
|
::wxEOL_MAC and ::wxEOL_UNIX.
|
|
@param conv
|
|
<b>In Unicode build only:</b> The object used to convert
|
|
Unicode text into ASCII characters written to the output stream.
|
|
*/
|
|
wxTextOutputStream(wxOutputStream& stream,
|
|
wxEOL mode = wxEOL_NATIVE,
|
|
const wxMBConv& conv = wxConvAuto());
|
|
|
|
/**
|
|
Destroys the wxTextOutputStream object.
|
|
|
|
Also calls Flush().
|
|
*/
|
|
virtual ~wxTextOutputStream();
|
|
|
|
/**
|
|
Flushes the stream.
|
|
|
|
This method should be called when using stateful encodings (currently
|
|
the only example of such encoding in wxWidgets is wxMBConvUTF7) to
|
|
write the end of the encoded data to the stream.
|
|
|
|
@since 2.9.0
|
|
*/
|
|
void Flush();
|
|
|
|
/**
|
|
Returns a pointer to the underlying output stream object.
|
|
|
|
@since 2.9.2
|
|
*/
|
|
const wxOutputStream& GetOutputStream() const;
|
|
|
|
/**
|
|
Returns the end-of-line mode. One of ::wxEOL_DOS, ::wxEOL_MAC and
|
|
::wxEOL_UNIX.
|
|
*/
|
|
wxEOL GetMode();
|
|
|
|
/**
|
|
Writes a character to the stream.
|
|
*/
|
|
wxTextOutputStream& PutChar(wxChar c);
|
|
|
|
/**
|
|
Set the end-of-line mode. One of ::wxEOL_NATIVE, ::wxEOL_DOS,
|
|
::wxEOL_MAC and ::wxEOL_UNIX.
|
|
*/
|
|
void SetMode(wxEOL mode = wxEOL_NATIVE);
|
|
|
|
/**
|
|
Writes @a i to the stream using wxString::operator<<().
|
|
|
|
@since 3.1.0
|
|
*/
|
|
template<typename T>
|
|
void Write(const T& i);
|
|
|
|
/**
|
|
Writes the 64 bit unsigned integer @a i64 to the stream.
|
|
|
|
@since 3.1.0
|
|
*/
|
|
void Write64(wxUint64 i64);
|
|
|
|
/**
|
|
Writes the 32 bit unsigned integer @a i32 to the stream.
|
|
*/
|
|
void Write32(wxUint32 i32);
|
|
|
|
/**
|
|
Writes the 16 bit unsigned integer @a i16 to the stream.
|
|
*/
|
|
void Write16(wxUint16 i16);
|
|
|
|
/**
|
|
Writes the single unsigned byte @a i8 to the stream.
|
|
*/
|
|
void Write8(wxUint8 i8);
|
|
|
|
/**
|
|
Writes the double @a f to the stream using the IEEE format.
|
|
*/
|
|
virtual void WriteDouble(double f);
|
|
|
|
/**
|
|
Writes @a string as a line. Depending on the end-of-line mode the end of
|
|
line ('\\n') characters in the string are converted to the correct line
|
|
ending terminator.
|
|
*/
|
|
virtual void WriteString(const wxString& string);
|
|
|
|
/**
|
|
Uses WriteString() to insert @a string.
|
|
*/
|
|
wxTextOutputStream& operator<<(const wxString& string);
|
|
|
|
/**
|
|
Uses WriteString() to insert @a c as ASCII.
|
|
*/
|
|
wxTextOutputStream& operator<<(char c);
|
|
|
|
/**
|
|
Uses PutChar() to insert @a wc.
|
|
@note Only available in Unicode builds.
|
|
*/
|
|
wxTextOutputStream& operator<<(wchar_t wc);
|
|
|
|
/**
|
|
Uses Write() to insert @a c.
|
|
*/
|
|
wxTextOutputStream& operator<<(wxInt16 c);
|
|
|
|
/**
|
|
Uses Write() to insert @a c.
|
|
*/
|
|
wxTextOutputStream& operator<<(wxInt32 c);
|
|
|
|
/**
|
|
Uses Write() to insert @a c.
|
|
*/
|
|
wxTextOutputStream& operator<<(wxInt64 c);
|
|
|
|
/**
|
|
Uses Write() to insert @a c.
|
|
*/
|
|
wxTextOutputStream& operator<<(wxUint16 c);
|
|
|
|
/**
|
|
Uses Write() to insert @a c.
|
|
*/
|
|
wxTextOutputStream& operator<<(wxUint32 c);
|
|
|
|
/**
|
|
Uses Write() to insert @a c.
|
|
*/
|
|
wxTextOutputStream& operator<<(wxUint64 c);
|
|
|
|
/**
|
|
Uses Write() to insert @a f.
|
|
*/
|
|
wxTextOutputStream& operator<<(double f);
|
|
|
|
/**
|
|
Uses Write() to insert @a f.
|
|
*/
|
|
wxTextOutputStream& operator<<(float f);
|
|
|
|
/**
|
|
Calls @c func(*this).
|
|
*/
|
|
wxTextOutputStream& operator<<(__wxTextOutputManip func);
|
|
};
|
|
|
|
|
|
/** @addtogroup group_funcmacro_misc */
|
|
//@{
|
|
|
|
/**
|
|
Writes @c '\\n' to @a stream.
|
|
|
|
@header{wx/textstrm.h}
|
|
*/
|
|
wxTextOutputStream& endl(wxTextOutputStream& stream);
|
|
|
|
//@}
|