initial commit

Signed-off-by: Peter Siegmund <mars3142@noreply.mars3142.dev>

libs/wxWidgets-3.3.1/interface/wx/txtstrm.h

@@ -0,0 +1,479 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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 an 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);
+
+///@}