adding a app-defined event seems to quit inner eventloops like eg the popup of the...

[wxWidgets.git] / interface / wx / file.h

diff --git a/interface/wx/file.h b/interface/wx/file.h
index cb74e2dfa8f8fa72f0d70bc7f8a97f2f8273eddf..9c01ebdd7d6f9e2e9228d0140ff8f67cbb59a54f 100644 (file)
--- a/interface/wx/file.h
+++ b/interface/wx/file.h
@@ -1,24 +1,24 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        file.h
 /////////////////////////////////////////////////////////////////////////////
 // Name:        file.h

-// Purpose:     interface of wxTempFile
+// Purpose:     interface of wxTempFile, wxFile

 // Author:      wxWidgets team
 // RCS-ID:      $Id$
 // Author:      wxWidgets team
 // RCS-ID:      $Id$

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

+

 /**
     @class wxTempFile
 /**
     @class wxTempFile

-    @wxheader{file.h}

 
     wxTempFile provides a relatively safe way to replace the contents of the
     existing file. The name is explained by the fact that it may be also used as
     just a temporary file if you don't replace the old file contents.
 
     Usually, when a program replaces the contents of some file it first opens it for
 
     wxTempFile provides a relatively safe way to replace the contents of the
     existing file. The name is explained by the fact that it may be also used as
     just a temporary file if you don't replace the old file contents.
 
     Usually, when a program replaces the contents of some file it first opens it for

-    writing, thus losing all of the old data and then starts recreating it. This
-    approach is not very safe because during the regeneration of the file bad things
-    may happen: the program may find that there is an internal error preventing it
-    from completing file generation, the user may interrupt it (especially if file
+    writing, thus losing all of the old data and then starts recreating it.
+    This approach is not very safe because during the regeneration of the file bad
+    things may happen: the program may find that there is an internal error preventing
+    it from completing file generation, the user may interrupt it (especially if file

     generation takes long time) and, finally, any other external interrupts (power
     supply failure or a disk error) will leave you without either the original file
     or the new one.
     generation takes long time) and, finally, any other external interrupts (power
     supply failure or a disk error) will leave you without either the original file
     or the new one.


@@ -28,20 +28,18 @@
     interrupts the program during the file generation, the old file won't be lost.
     Also, if the program discovers itself that it doesn't want to replace the old
     file there is no problem - in fact, wxTempFile will @b not replace the old
     interrupts the program during the file generation, the old file won't be lost.
     Also, if the program discovers itself that it doesn't want to replace the old
     file there is no problem - in fact, wxTempFile will @b not replace the old

-    file by default, you should explicitly call wxTempFile::Commit
-    to do it. Calling wxTempFile::Discard explicitly discards any
-    modifications: it closes and deletes the temporary file and leaves the original
-    file unchanged. If you don't call neither of Commit() and Discard(), the
-    destructor will call Discard() automatically.
+    file by default, you should explicitly call wxTempFile::Commit() to do it.
+    Calling wxTempFile::Discard() explicitly discards any modifications: it
+    closes and deletes the temporary file and leaves the original file unchanged.
+    If you call neither Commit() nor Discard(), the destructor will
+    call Discard() automatically.

 
     To summarize: if you want to replace another file, create an instance of
 
     To summarize: if you want to replace another file, create an instance of

-    wxTempFile passing the name of the file to be replaced to the constructor (you
-    may also use default constructor and pass the file name to
-    wxTempFile::Open). Then you can wxTempFile::write
-    to wxTempFile using wxFile-like functions and later call
-    Commit() to replace the old file (and close this one) or call Discard() to
-    cancel
-    the modifications.
+    wxTempFile passing the name of the file to be replaced to the constructor.
+    (You may also use default constructor and pass the file name to wxTempFile::Open.)
+    Then you can write to wxTempFile using wxFile-like functions and later call
+    wxTempFile::Commit() to replace the old file (and close this one) or call
+    wxTempFile::Discard() to cancel the modifications.

 
     @library{wxbase}
     @category{file}
 
     @library{wxbase}
     @category{file}


@@ -50,32 +48,46 @@ class wxTempFile
 {
 public:
     /**
 {
 public:
     /**

-        Associates wxTempFile with the file to be replaced and opens it. You should use
-        IsOpened() to verify if the constructor succeeded.
+        Associates wxTempFile with the file to be replaced and opens it.
+
+        @warning
+        You should use IsOpened() to verify that the constructor succeeded.

     */
     wxTempFile(const wxString& strName);
 
     /**
     */
     wxTempFile(const wxString& strName);
 
     /**

-        Destructor calls Discard() if temporary file
-        is still opened.
+        Destructor calls Discard() if temporary file is still open.

     */
     ~wxTempFile();
 
     /**
         Validate changes: deletes the old file of name m_strName and renames the new
     */
     ~wxTempFile();
 
     /**
         Validate changes: deletes the old file of name m_strName and renames the new

-        file to the old name. Returns @true if both actions succeeded. If @false is
-        returned it may unfortunately mean two quite different things: either that
-        either the old file couldn't be deleted or that the new file couldn't be renamed
-        to the old name.
+        file to the old name. Returns @true if both actions succeeded.
+
+        If @false is returned it may unfortunately mean two quite different things:
+        either that the old file couldn't be deleted or that the new file
+        couldn't be renamed to the old name.

     */
     bool Commit();
 
     /**
     */
     bool Commit();
 
     /**

-        Discard changes: the old file contents is not changed, temporary file is
-        deleted.
+        Discard changes: the old file contents are not changed, the temporary
+        file is deleted.

     */
     void Discard();
 
     */
     void Discard();
 

+    /**
+        Flush the data written to the file to disk.
+
+        This simply calls wxFile::Flush() for the underlying file and may be
+        necessary with file systems such as XFS and Ext4 under Linux. Calling
+        this function may however have serious performance implications and
+        also is not necessary with many other file systems so it is not done by
+        default -- but you can call it before calling Commit() to absolutely
+        ensure that the data was indeed written to the disk correctly.
+     */
+    bool Flush();
+

     /**
         Returns @true if the file was successfully opened.
     */
     /**
         Returns @true if the file was successfully opened.
     */


@@ -83,6 +95,12 @@ public:
 
     /**
         Returns the length of the file.
 
     /**
         Returns the length of the file.

+
+        This method may return ::wxInvalidOffset if the length couldn't be
+        determined or 0 even for non-empty files if the file is not seekable.
+
+        In general, the only way to determine if the file for which this function
+        returns 0 is really empty or not is to try reading from it.

     */
     wxFileOffset Length() const;
 
     */
     wxFileOffset Length() const;
 


@@ -90,9 +108,9 @@ public:
         Open the temporary file, returns @true on success, @false if an error
         occurred.
         @a strName is the name of file to be replaced. The temporary file is always
         Open the temporary file, returns @true on success, @false if an error
         occurred.
         @a strName is the name of file to be replaced. The temporary file is always

-        created in the directory where @a strName is. In particular, if
-        @a strName doesn't include the path, it is created in the current directory
-        and the program should have write access to it for the function to succeed.
+        created in the directory where @a strName is. In particular, if @a strName
+        doesn't include the path, it is created in the current directory and the
+        program should have write access to it for the function to succeed.

     */
     bool Open(const wxString& strName);
 
     */
     bool Open(const wxString& strName);
 


@@ -103,9 +121,8 @@ public:
                       wxSeekMode mode = wxFromStart);
 
     /**
                       wxSeekMode mode = wxFromStart);
 
     /**

-        Returns the current position or wxInvalidOffset if file is not opened or if
-        another
-        error occurred.
+        Returns the current position or ::wxInvalidOffset if file is not opened or
+        if another error occurred.

     */
     wxFileOffset Tell() const;
 
     */
     wxFileOffset Tell() const;
 


@@ -122,20 +139,19 @@ public:
 
 /**
     @class wxFile
 
 /**
     @class wxFile

-    @wxheader{file.h}

 
     A wxFile performs raw file I/O. This is a very small class designed to
     minimize the overhead of using it - in fact, there is hardly any overhead at
     all, but using it brings you automatic error checking and hides differences
     between platforms and compilers. wxFile also automatically closes the file in
 
     A wxFile performs raw file I/O. This is a very small class designed to
     minimize the overhead of using it - in fact, there is hardly any overhead at
     all, but using it brings you automatic error checking and hides differences
     between platforms and compilers. wxFile also automatically closes the file in

-    its destructor making it unnecessary to worry about forgetting to do it.
-    wxFile is a wrapper around @c file descriptor. - see also
-    wxFFile for a wrapper around @c FILE structure.
+    its destructor so you won't forget to do so.
+    wxFile is a wrapper around @c file descriptor. - see also wxFFile for a
+    wrapper around @c FILE structure.

 
 

-    @c wxFileOffset is used by the wxFile functions which require offsets as
-    parameter or return them. If the platform supports it, wxFileOffset is a typedef
-    for a native 64 bit integer, otherwise a 32 bit integer is used for
-    wxFileOffset.
+    ::wxFileOffset is used by the wxFile functions which require offsets as
+    parameter or return them. If the platform supports it, wxFileOffset is a
+    typedef for a native 64 bit integer, otherwise a 32 bit integer is used for
+    ::wxFileOffset.

 
     @library{wxbase}
     @category{file}
 
     @library{wxbase}
     @category{file}


@@ -143,44 +159,116 @@ public:
 class wxFile
 {
 public:
 class wxFile
 {
 public:

-    //@{
+

     /**
     /**

-        Associates the file with the given file descriptor, which has already been
-        opened.
+        The OpenMode enumeration defines the different modes for opening a file with wxFile.
+        It is also used with wxFile::Access function.
+    */
+    enum OpenMode {
+
+        /** Open file for reading or test if it can be opened for reading with Access() */
+        read,
+
+        /** Open file for writing deleting the contents of the file if it already exists
+            or test if it can be opened for writing with Access(). */
+        write,
+
+        /** Open file for reading and writing; cannot be used with Access() */
+        read_write,
+
+        /** Open file for appending: the file is opened for writing, but the old contents
+            of the file are not erased and the file pointer is initially placed at the end
+            of the file; cannot be used with Access().
+
+            This is the same as OpenMode::write if the file doesn't exist.
+        */
+        write_append,
+
+        /**
+            Open the file securely for writing (Uses O_EXCL | O_CREAT).
+            Will fail if the file already exists, else create and open it atomically.
+            Useful for opening temporary files without being vulnerable to race exploits.
+        */
+        write_excl
+    };
+
+    /**
+       Standard file descriptors
+    */
+    enum { fd_invalid = -1, fd_stdin, fd_stdout, fd_stderr };
+
+    /**
+       Default constructor.
+    */
+    wxFile();
+
+    /**
+        Opens a file with a filename.

 
         @param filename
             The filename.
         @param mode
 
         @param filename
             The filename.
         @param mode

-            The mode in which to open the file. May be one of read(), write() and
-        wxFile::read_write.
-        @param fd
-            An existing file descriptor (see Attach() for the list of predefined
-        descriptors)
+            The mode in which to open the file.
+
+        @warning
+        You should use IsOpened() to verify that the constructor succeeded.

     */
     */

-    wxFile();

     wxFile(const wxString& filename,
            wxFile::OpenMode mode = wxFile::read);
     wxFile(const wxString& filename,
            wxFile::OpenMode mode = wxFile::read);

+
+    /**
+        Associates the file with the given file descriptor, which has already been
+        opened. See Attach() for the list of predefined descriptors.
+
+        @param fd
+            An existing file descriptor.
+    */

     wxFile(int fd);
     wxFile(int fd);

-    //@}

 
     /**
         Destructor will close the file.
 
     /**
         Destructor will close the file.

-        @note it is not virtual so you should not use wxFile polymorphically.
+        @note This destructor is not virtual so you should not use wxFile polymorphically.

     */
     ~wxFile();
 
     /**
     */
     ~wxFile();
 
     /**

-        This function verifies if we may access the given file in specified mode. Only
-        values of read() or write() really make sense here.
+        Returns the error code for the last unsuccessful operation.
+
+        The error code is system-dependent and corresponds to the value of the
+        standard @c errno variable when the last error occurred.
+
+        Notice that only simple accessors such as IsOpened() and Eof() (and
+        this method itself) don't modify the last error value, all other
+        methods can potentially change it if an error occurs, including the
+        const ones such as Tell() or Length().
+
+        @since 2.9.2
+
+        @see ClearLastError()
+    */
+    int GetLastError() const;
+
+    /**
+        Resets the error code.
+
+        GetLastError() will return 0 until the next error occurs.
+
+        @since 2.9.2
+    */
+    void ClearLastError();
+
+    /**
+        This function verifies if we may access the given file in specified mode.
+        Only values of @c wxFile::read or @c wxFile::write really make sense here.

     */
     */

-    static bool Access(const wxString& name, OpenMode mode);
+    static bool Access(const wxString& name, wxFile::OpenMode mode);

 
     /**
 
     /**

-        Attaches an existing file descriptor to the wxFile object. Example of predefined
-        file descriptors are 0, 1 and 2 which correspond to stdin, stdout and stderr
-        (and
-        have symbolic names of @b wxFile::fd_stdin, @b wxFile::fd_stdout and @b
-        wxFile::fd_stderr).
+        Attaches an existing file descriptor to the wxFile object.
+        Examples of predefined file descriptors are 0, 1 and 2 which correspond to
+        stdin, stdout and stderr (and have symbolic names of @c wxFile::fd_stdin,
+        @c wxFile::fd_stdout and @c wxFile::fd_stderr).
+

         The descriptor should be already opened and it will be closed by wxFile
         object.
     */
         The descriptor should be already opened and it will be closed by wxFile
         object.
     */


@@ -189,56 +277,63 @@ public:
     /**
         Closes the file.
     */
     /**
         Closes the file.
     */

-    void Close();
+    bool Close();

 
     /**
 
     /**

-        Creates a file for writing. If the file already exists, setting @b overwrite to
-        @true
-        will ensure it is overwritten.
+        Creates a file for writing.
+
+        If the file already exists, setting @b overwrite to @true will ensure
+        it is overwritten.
+
+        @a access may be an OR combination of the ::wxPosixPermissions enumeration
+        values.

     */
     */

-    bool Create(const wxString& filename, bool overwrite = false,
+    bool Create(const wxString& filename,
+                bool overwrite = false,

                 int access = wxS_DEFAULT);
 
     /**
         Get back a file descriptor from wxFile object - the caller is responsible for
                 int access = wxS_DEFAULT);
 
     /**
         Get back a file descriptor from wxFile object - the caller is responsible for

-        closing the file if this
-        descriptor is opened. IsOpened() will return @false after call to Detach().
+        closing the file if this descriptor is opened.
+        IsOpened() will return @false after call to Detach().

     */
     void Detach();
 
     /**
         Returns @true if the end of the file has been reached.
     */
     void Detach();
 
     /**
         Returns @true if the end of the file has been reached.

-        Note that the behaviour of the file pointer based class
-        wxFFile is different as wxFFile::Eof
-        will return @true here only if an attempt has been made to read
-        @e past the last byte of the file, while wxFile::Eof() will return @true
-        even before such attempt is made if the file pointer is at the last position
-        in the file.
+        Note that the behaviour of the file pointer-based class wxFFile is
+        different as wxFFile::Eof() will return @true here only if an
+        attempt has been made to read @b past the last byte of the file, while
+        wxFile::Eof() will return @true even before such attempt is made if the
+        file pointer is at the last position in the file.
+

         Note also that this function doesn't work on unseekable file descriptors
         (examples include pipes, terminals and sockets under Unix) and an attempt to
         Note also that this function doesn't work on unseekable file descriptors
         (examples include pipes, terminals and sockets under Unix) and an attempt to

-        use it will result in an error message in such case. So, to read the entire
-        file into memory, you should write a loop which uses
-        Read() repeatedly and tests its return condition instead
-        of using Eof() as this will not work for special files under Unix.
+        use it will result in an error message.
+
+        So, to read the entire file into memory, you should write a loop which uses
+        Read() repeatedly and tests its return condition instead of using Eof()
+        as this will not work for special files under Unix.

     */
     bool Eof() const;
 
     /**
     */
     bool Eof() const;
 
     /**

-        Returns @true if the given name specifies an existing regular file (not a
-        directory or a link)
+        Returns @true if the given name specifies an existing regular file
+        (not a directory or a link).

     */
     static bool Exists(const wxString& filename);
 
     /**
         Flushes the file descriptor.
     */
     static bool Exists(const wxString& filename);
 
     /**
         Flushes the file descriptor.

-        Note that Flush() is not implemented on some Windows compilers
-        due to a missing fsync function, which reduces the usefulness of this function
+
+        Note that Flush() is not implemented on some Windows compilers due to a
+        missing fsync function, which reduces the usefulness of this function

         (it can still be called but it will do nothing on unsupported compilers).
     */
     bool Flush();
 
     /**
         (it can still be called but it will do nothing on unsupported compilers).
     */
     bool Flush();
 
     /**

-        Returns the type of the file. Possible return values are:
+        Returns the type of the file.

     */
     wxFileKind GetKind() const;
 
     */
     wxFileKind GetKind() const;
 


@@ -258,20 +353,24 @@ public:
         @param filename
             The filename.
         @param mode
         @param filename
             The filename.
         @param mode

-            The mode in which to open the file. May be one of read(), write() and
-        wxFile::read_write.
+            The mode in which to open the file.
+        @param access
+            An OR-combination of ::wxPosixPermissions enumeration values.

     */
     */

-    bool Open(const wxString& filename,
-              wxFile::OpenMode mode = wxFile::read);
+    bool Open(const wxString& filename, wxFile::OpenMode mode = wxFile::read,
+              int access = wxS_DEFAULT);

 
 

-    //@{

     /**
     /**

-        if there was an error.
+        Reads from the file into a memory buffer.
+
+        @param buffer
+           Buffer to write in
+        @param count
+           Bytes to read
+
+        @return The number of bytes read, or the symbol ::wxInvalidOffset.

     */
     */

-    size_t Read(void* buffer, size_t count);
-    Parameters Return value
-    The number of bytes read, or the symbol wxInvalidOffset();
-    //@}
+    ssize_t Read(void* buffer, size_t count);

 
     /**
         Seeks to the specified position.
 
     /**
         Seeks to the specified position.


@@ -281,39 +380,51 @@ public:
         @param mode
             One of wxFromStart, wxFromEnd, wxFromCurrent.
 
         @param mode
             One of wxFromStart, wxFromEnd, wxFromCurrent.
 

-        @return The actual offset position achieved, or wxInvalidOffset on
-                 failure.
+        @return The actual offset position achieved, or ::wxInvalidOffset on
+                failure.

     */
     wxFileOffset Seek(wxFileOffset ofs,
                       wxSeekMode mode = wxFromStart);
 
     /**
     */
     wxFileOffset Seek(wxFileOffset ofs,
                       wxSeekMode mode = wxFromStart);
 
     /**

-        Moves the file pointer to the specified number of bytes relative to the end of
-        the file. For example, @c SeekEnd(-5) would position the pointer 5
+        Moves the file pointer to the specified number of bytes relative to the
+        end of the file. For example, @c SeekEnd(-5) would position the pointer 5

         bytes before the end.
 
         @param ofs
             Number of bytes before the end of the file.
 
         bytes before the end.
 
         @param ofs
             Number of bytes before the end of the file.
 

-        @return The actual offset position achieved, or wxInvalidOffset on
-                 failure.
+        @return The actual offset position achieved, or ::wxInvalidOffset on
+                failure.

     */
     wxFileOffset SeekEnd(wxFileOffset ofs = 0);
 
     /**
     */
     wxFileOffset SeekEnd(wxFileOffset ofs = 0);
 
     /**

-        Returns the current position or wxInvalidOffset if file is not opened or if
-        another
-        error occurred.
+        Returns the current position or ::wxInvalidOffset if file is not opened or
+        if another error occurred.

     */
     wxFileOffset Tell() const;
 
     */
     wxFileOffset Tell() const;
 

+    /**
+       Write data to the file (descriptor).
+
+       @param buffer
+          Buffer from which to read data
+       @param count
+         Number of bytes to write
+
+       @return The number of bytes written.
+    */
+    size_t Write(const void *buffer, size_t count);
+

     /**
         Writes the contents of the string to the file, returns @true on success.
         The second argument is only meaningful in Unicode build of wxWidgets when
     /**
         Writes the contents of the string to the file, returns @true on success.
         The second argument is only meaningful in Unicode build of wxWidgets when

-        @a conv is used to convert @a s to multibyte representation.
+        @a conv is used to convert @a s to a multibyte representation.
+

         Note that this method only works with @c NUL-terminated strings, if you want
         to write data with embedded @c NULs to the file you should use the other
         Note that this method only works with @c NUL-terminated strings, if you want
         to write data with embedded @c NULs to the file you should use the other

-        @ref write() "Write() overload".
+        Write() overload.

     */
     bool Write(const wxString& s, const wxMBConv& conv = wxConvUTF8);
 
     */
     bool Write(const wxString& s, const wxMBConv& conv = wxConvUTF8);