interface/wx/file.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        file.h
   3 // Purpose:     interface of wxTempFile
   4 // Author:      wxWidgets team
   5 // RCS-ID:      $Id$
   6 // Licence:     wxWindows license
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 /**
  10     @class wxTempFile
  11
  12     wxTempFile provides a relatively safe way to replace the contents of the
  13     existing file. The name is explained by the fact that it may be also used as
  14     just a temporary file if you don't replace the old file contents.
  15
  16     Usually, when a program replaces the contents of some file it first opens it for
  17     writing, thus losing all of the old data and then starts recreating it. This
  18     approach is not very safe because during the regeneration of the file bad things
  19     may happen: the program may find that there is an internal error preventing it
  20     from completing file generation, the user may interrupt it (especially if file
  21     generation takes long time) and, finally, any other external interrupts (power
  22     supply failure or a disk error) will leave you without either the original file
  23     or the new one.
  24
  25     wxTempFile addresses this problem by creating a temporary file which is meant to
  26     replace the original file - but only after it is fully written. So, if the user
  27     interrupts the program during the file generation, the old file won't be lost.
  28     Also, if the program discovers itself that it doesn't want to replace the old
  29     file there is no problem - in fact, wxTempFile will @b not replace the old
  30     file by default, you should explicitly call wxTempFile::Commit
  31     to do it. Calling wxTempFile::Discard explicitly discards any
  32     modifications: it closes and deletes the temporary file and leaves the original
  33     file unchanged. If you don't call neither of Commit() and Discard(), the
  34     destructor will call Discard() automatically.
  35
  36     To summarize: if you want to replace another file, create an instance of
  37     wxTempFile passing the name of the file to be replaced to the constructor (you
  38     may also use default constructor and pass the file name to
  39     wxTempFile::Open). Then you can wxTempFile::write
  40     to wxTempFile using wxFile-like functions and later call
  41     Commit() to replace the old file (and close this one) or call Discard() to
  42     cancel
  43     the modifications.
  44
  45     @library{wxbase}
  46     @category{file}
  47 */
  48 class wxTempFile
  49 {
  50 public:
  51     /**
  52         Associates wxTempFile with the file to be replaced and opens it. You should use
  53         IsOpened() to verify if the constructor succeeded.
  54     */
  55     wxTempFile(const wxString& strName);
  56
  57     /**
  58         Destructor calls Discard() if temporary file
  59         is still opened.
  60     */
  61     ~wxTempFile();
  62
  63     /**
  64         Validate changes: deletes the old file of name m_strName and renames the new
  65         file to the old name. Returns @true if both actions succeeded. If @false is
  66         returned it may unfortunately mean two quite different things: either that
  67         either the old file couldn't be deleted or that the new file couldn't be renamed
  68         to the old name.
  69     */
  70     bool Commit();
  71
  72     /**
  73         Discard changes: the old file contents is not changed, temporary file is
  74         deleted.
  75     */
  76     void Discard();
  77
  78     /**
  79         Returns @true if the file was successfully opened.
  80     */
  81     bool IsOpened() const;
  82
  83     /**
  84         Returns the length of the file.
  85     */
  86     wxFileOffset Length() const;
  87
  88     /**
  89         Open the temporary file, returns @true on success, @false if an error
  90         occurred.
  91         @a strName is the name of file to be replaced. The temporary file is always
  92         created in the directory where @a strName is. In particular, if
  93         @a strName doesn't include the path, it is created in the current directory
  94         and the program should have write access to it for the function to succeed.
  95     */
  96     bool Open(const wxString& strName);
  97
  98     /**
  99         Seeks to the specified position.
 100     */
 101     wxFileOffset Seek(wxFileOffset ofs,
 102                       wxSeekMode mode = wxFromStart);
 103
 104     /**
 105         Returns the current position or wxInvalidOffset if file is not opened or if
 106         another
 107         error occurred.
 108     */
 109     wxFileOffset Tell() const;
 110
 111     /**
 112         Write to the file, return @true on success, @false on failure.
 113         The second argument is only meaningful in Unicode build of wxWidgets when
 114         @a conv is used to convert @a str to multibyte representation.
 115     */
 116     bool Write(const wxString& str,
 117                const wxMBConv& conv = wxConvUTF8);
 118 };
 119
 120
 121
 122 /**
 123     @class wxFile
 124
 125     A wxFile performs raw file I/O. This is a very small class designed to
 126     minimize the overhead of using it - in fact, there is hardly any overhead at
 127     all, but using it brings you automatic error checking and hides differences
 128     between platforms and compilers. wxFile also automatically closes the file in
 129     its destructor making it unnecessary to worry about forgetting to do it.
 130     wxFile is a wrapper around @c file descriptor. - see also
 131     wxFFile for a wrapper around @c FILE structure.
 132
 133     @c wxFileOffset is used by the wxFile functions which require offsets as
 134     parameter or return them. If the platform supports it, wxFileOffset is a typedef
 135     for a native 64 bit integer, otherwise a 32 bit integer is used for
 136     wxFileOffset.
 137
 138     @library{wxbase}
 139     @category{file}
 140 */
 141 class wxFile
 142 {
 143 public:
 144     /**
 145       Opening mode
 146     */
 147     enum OpenMode { read, write, read_write, write_append, write_excl };
 148
 149     /**
 150        Standard file descriptors
 151     */
 152     enum { fd_invalid = -1, fd_stdin, fd_stdout, fd_stderr };
 153
 154     /**
 155        Default constructor.
 156     */
 157     wxFile();
 158
 159     /**
 160         Opens a file with a filename.
 161
 162         @param filename
 163             The filename.
 164         @param mode
 165             The mode in which to open the file. May be one of @c wxFile::read,
 166             @c wxFile::write and @c wxFile::read_write.
 167     */
 168     wxFile(const wxString& filename,
 169            wxFile::OpenMode mode = wxFile::read);
 170     /**
 171         Associates the file with the given file descriptor, which has already been
 172         opened. See Attach() for the list of predefined descriptors.
 173
 174         @param fd
 175             An existing file descriptor.
 176     */
 177     wxFile(int fd);
 178
 179     /**
 180         Destructor will close the file.
 181         @note it is not virtual so you should not use wxFile polymorphically.
 182     */
 183     ~wxFile();
 184
 185     /**
 186         This function verifies if we may access the given file in specified mode.
 187         Only values of @c wxFile::read or @c wxFile::write really make sense here.
 188     */
 189     static bool Access(const wxString& name, OpenMode mode);
 190
 191     /**
 192         Attaches an existing file descriptor to the wxFile object. Example of
 193         predefined file descriptors are 0, 1 and 2 which correspond to stdin,
 194         stdout and stderr (and have symbolic names of @c wxFile::fd_stdin,
 195         @c wxFile::fd_stdout and @c wxFile::fd_stderr).
 196
 197         The descriptor should be already opened and it will be closed by wxFile
 198         object.
 199     */
 200     void Attach(int fd);
 201
 202     /**
 203         Closes the file.
 204     */
 205     void Close();
 206
 207     /**
 208         Creates a file for writing. If the file already exists, setting @b overwrite to
 209         @true
 210         will ensure it is overwritten.
 211     */
 212     bool Create(const wxString& filename, bool overwrite = false,
 213                 int access = wxS_DEFAULT);
 214
 215     /**
 216         Get back a file descriptor from wxFile object - the caller is responsible for
 217         closing the file if this
 218         descriptor is opened. IsOpened() will return @false after call to Detach().
 219     */
 220     void Detach();
 221
 222     /**
 223         Returns @true if the end of the file has been reached.
 224         Note that the behaviour of the file pointer based class
 225         wxFFile is different as wxFFile::Eof will return @true here only if an
 226         attempt has been made to read @b past the last byte of the file, while
 227         wxFile::Eof() will return @true even before such attempt is made if the
 228         file pointer is at the last position in the file.
 229
 230         Note also that this function doesn't work on unseekable file descriptors
 231         (examples include pipes, terminals and sockets under Unix) and an attempt to
 232         use it will result in an error message in such case. So, to read the entire
 233         file into memory, you should write a loop which uses
 234         Read() repeatedly and tests its return condition instead
 235         of using Eof() as this will not work for special files under Unix.
 236     */
 237     bool Eof() const;
 238
 239     /**
 240         Returns @true if the given name specifies an existing regular file (not a
 241         directory or a link)
 242     */
 243     static bool Exists(const wxString& filename);
 244
 245     /**
 246         Flushes the file descriptor.
 247         Note that Flush() is not implemented on some Windows compilers
 248         due to a missing fsync function, which reduces the usefulness of this function
 249         (it can still be called but it will do nothing on unsupported compilers).
 250     */
 251     bool Flush();
 252
 253     /**
 254         Returns the type of the file. Possible return values are:
 255     */
 256     wxFileKind GetKind() const;
 257
 258     /**
 259         Returns @true if the file has been opened.
 260     */
 261     bool IsOpened() const;
 262
 263     /**
 264         Returns the length of the file.
 265     */
 266     wxFileOffset Length() const;
 267
 268     /**
 269         Opens the file, returning @true if successful.
 270
 271         @param filename
 272             The filename.
 273         @param mode
 274             The mode in which to open the file. May be one of read(), write() and
 275         wxFile::read_write.
 276     */
 277     bool Open(const wxString& filename,
 278               wxFile::OpenMode mode = wxFile::read);
 279
 280     /**
 281         Reads from the file into a memory buffer.
 282
 283         @param buffer
 284            Buffer to write in
 285         @param count
 286            Bytes to read
 287
 288         @return The number of bytes read, or the symbol wxInvalidOffset
 289     */
 290     size_t Read(void* buffer, size_t count);
 291
 292     /**
 293         Seeks to the specified position.
 294
 295         @param ofs
 296             Offset to seek to.
 297         @param mode
 298             One of wxFromStart, wxFromEnd, wxFromCurrent.
 299
 300         @return The actual offset position achieved, or wxInvalidOffset on
 301                  failure.
 302     */
 303     wxFileOffset Seek(wxFileOffset ofs,
 304                       wxSeekMode mode = wxFromStart);
 305
 306     /**
 307         Moves the file pointer to the specified number of bytes relative to the end of
 308         the file. For example, @c SeekEnd(-5) would position the pointer 5
 309         bytes before the end.
 310
 311         @param ofs
 312             Number of bytes before the end of the file.
 313
 314         @return The actual offset position achieved, or wxInvalidOffset on
 315                  failure.
 316     */
 317     wxFileOffset SeekEnd(wxFileOffset ofs = 0);
 318
 319     /**
 320         Returns the current position or wxInvalidOffset if file is not opened or
 321         if another  error occurred.
 322     */
 323     wxFileOffset Tell() const;
 324
 325     /**
 326        Write data to the file (descriptor).
 327
 328        @buffer
 329           Buffer from which to read data
 330        @param count
 331          Number of bytes to write
 332
 333        @return The number of bytes written.
 334     */
 335     size_t Write(const void *buffer, size_t count);
 336
 337     /**
 338         Writes the contents of the string to the file, returns @true on success.
 339         The second argument is only meaningful in Unicode build of wxWidgets when
 340         @a conv is used to convert @a s to a multibyte representation.
 341         Note that this method only works with @c NUL-terminated strings, if you want
 342         to write data with embedded @c NULs to the file you should use the other
 343         Write() overload.
 344     */
 345     bool Write(const wxString& s, const wxMBConv& conv = wxConvUTF8);
 346
 347     /**
 348         Returns the file descriptor associated with the file.
 349     */
 350     int fd() const;
 351 };
 352