interface/wx/textfile.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        textfile.h
   3 // Purpose:     interface of wxTextFile
   4 // Author:      wxWidgets team
   5 // RCS-ID:      $Id$
   6 // Licence:     wxWindows licence
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 // TODO: document wxTextBuffer
  10
  11 /**
  12     The line termination type.
  13 */
  14 enum wxTextFileType
  15 {
  16     wxTextFileType_None,  //!< incomplete (the last line of the file only)
  17     wxTextFileType_Unix,  //!< line is terminated with 'LF' = 0xA = 10 = '\\n'
  18     wxTextFileType_Dos,   //!< line is terminated with 'CR' 'LF'
  19     wxTextFileType_Mac,   //!< line is terminated with 'CR' = 0xD = 13 = '\\r'
  20     wxTextFileType_Os2    //!< line is terminated with 'CR' 'LF'
  21 };
  22
  23 /**
  24     @class wxTextFile
  25
  26     The wxTextFile is a simple class which allows to work with text files on line by
  27     line basis. It also understands the differences in line termination characters
  28     under different platforms and will not do anything bad to files with "non
  29     native" line termination sequences - in fact, it can be also used to modify the
  30     text files and change the line termination characters from one type (say DOS) to
  31     another (say Unix).
  32
  33     One word of warning: the class is not at all optimized for big files and thus
  34     it will load the file entirely into memory when opened. Of course, you should
  35     not work in this way with large files (as an estimation, anything over 1 Megabyte
  36     is surely too big for this class). On the other hand, it is not a serious
  37     limitation for small files like configuration files or program sources
  38     which are well handled by wxTextFile.
  39
  40     The typical things you may do with wxTextFile in order are:
  41
  42     - Create and open it: this is done with either wxTextFile::Create or wxTextFile::Open
  43       function which opens the file (name may be specified either as the argument to
  44       these functions or in the constructor), reads its contents in memory (in the
  45       case of wxTextFile::Open()) and closes it.
  46     - Work with the lines in the file: this may be done either with "direct
  47       access" functions like wxTextFile::GetLineCount and wxTextFile::GetLine
  48       (@e operator[] does exactly the same but looks more like array addressing)
  49       or with "sequential access" functions which include wxTextFile::GetFirstLine,
  50       wxTextFile::GetNextLine and also wxTextFile::GetLastLine, wxTextFile::GetPrevLine.
  51       For the sequential access functions the current line number is maintained: it is
  52       returned by wxTextFile::GetCurrentLine and may be changed with wxTextFile::GoToLine.
  53     - Add/remove lines to the file: wxTextFile::AddLine and wxTextFile::InsertLine
  54       add new lines while wxTextFile::RemoveLine deletes the existing ones.
  55       wxTextFile::Clear resets the file to empty.
  56     - Save your changes: notice that the changes you make to the file will @b not be
  57       saved automatically; calling wxTextFile::Close or doing nothing discards them!
  58       To save the changes you must explicitly call wxTextFile::Write - here, you may
  59       also change the line termination type if you wish.
  60
  61     @library{wxbase}
  62     @category{file}
  63
  64     @see wxFile
  65 */
  66 class wxTextFile
  67 {
  68 public:
  69     /**
  70         Default type for current platform determined at compile time.
  71      */
  72     static const wxTextFileType typeDefault;
  73
  74     /**
  75         Default constructor, use Create() or Open() with a file name parameter to
  76         initialize the object.
  77     */
  78     wxTextFile();
  79
  80     /**
  81         Constructor does not load the file into memory, use Open() to do it.
  82     */
  83     wxTextFile(const wxString& strFile);
  84
  85     /**
  86         Destructor does nothing.
  87     */
  88     virtual ~wxTextFile();
  89
  90     /**
  91         Adds a line to the end of file.
  92     */
  93     void AddLine(const wxString& str, wxTextFileType type = typeDefault);
  94
  95     /**
  96         Delete all lines from the file, set current line number to 0.
  97     */
  98     void Clear();
  99
 100     /**
 101         Closes the file and frees memory, @b "losing all changes".
 102         Use Write() if you want to save them.
 103     */
 104     bool Close();
 105
 106     /**
 107         Creates the file with the name which was given in the
 108         wxTextFile(const wxString&) constructor.
 109         The array of file lines is initially empty.
 110
 111         It will fail if the file already exists, Open() should be used in this case.
 112     */
 113     bool Create();
 114
 115     /**
 116         Creates the file with the given name.
 117         The array of file lines is initially empty.
 118
 119         It will fail if the file already exists, Open() should be used in this case.
 120     */
 121     bool Create(const wxString& strFile);
 122
 123     /**
 124         Returns @true if the current line is the last one.
 125     */
 126     bool Eof() const;
 127
 128     /**
 129         Return @true if file exists - the name of the file should have been specified
 130         in the constructor before calling Exists().
 131     */
 132     bool Exists() const;
 133
 134     /**
 135         Returns the current line: it has meaning only when you're using
 136         GetFirstLine()/GetNextLine() functions, it doesn't get updated when
 137         you're using "direct access" functions like GetLine().
 138         GetFirstLine() and GetLastLine() also change the value of the current line,
 139         as well as GoToLine().
 140     */
 141     size_t GetCurrentLine() const;
 142
 143     /**
 144         Get the line termination string corresponding to given constant.
 145
 146         @e typeDefault is the value defined during the compilation and corresponds
 147         to the native format of the platform, i.e. it will be @c wxTextFileType_Dos
 148         under Windows, @c wxTextFileType_Unix under Unix (including Mac OS X when
 149         compiling with the Apple Developer Tools) and @c wxTextFileType_Mac under
 150         Mac OS (including Mac OS X when compiling with CodeWarrior).
 151     */
 152     static const wxChar* GetEOL(wxTextFileType type = typeDefault);
 153
 154     /**
 155         This method together with GetNextLine() allows more "iterator-like"
 156         traversal of the list of lines, i.e. you may write something like:
 157
 158         @code
 159         wxTextFile file;
 160         ...
 161         for ( str = file.GetFirstLine(); !file.Eof(); str = file.GetNextLine() )
 162         {
 163             // do something with the current line in str
 164         }
 165         // do something with the last line in str
 166         @endcode
 167     */
 168     wxString& GetFirstLine();
 169
 170     /**
 171         Gets the last line of the file.
 172
 173         Together with GetPrevLine() it allows to enumerate the lines
 174         in the file from the end to the beginning like this:
 175
 176         @code
 177         wxTextFile file;
 178         ...
 179         for ( str = file.GetLastLine();
 180             file.GetCurrentLine() > 0;
 181             str = file.GetPrevLine() )
 182         {
 183             // do something with the current line in str
 184         }
 185         // do something with the first line in str
 186         @endcode
 187     */
 188     wxString& GetLastLine();
 189
 190     /**
 191         Retrieves the line number @a n from the file.
 192
 193         The returned line may be modified when non-const method is used but you
 194         shouldn't add line terminator at the end -- this will be done by
 195         wxTextFile itself.
 196     */
 197     //@{
 198     wxString& GetLine(size_t n);
 199     const wxString& GetLine(size_t n) const;
 200     //@}
 201
 202     /**
 203         Get the number of lines in the file.
 204     */
 205     size_t GetLineCount() const;
 206
 207     /**
 208         Get the type of the line (see also wxTextFile::GetEOL).
 209     */
 210     wxTextFileType GetLineType(size_t n) const;
 211
 212     /**
 213         Get the name of the file.
 214     */
 215     const wxString& GetName() const;
 216
 217     /**
 218         Gets the next line (see GetFirstLine() for the example).
 219     */
 220     wxString& GetNextLine();
 221
 222     /**
 223         Gets the previous line in the file.
 224     */
 225     wxString& GetPrevLine();
 226
 227     /**
 228         Changes the value returned by GetCurrentLine() and used by GetFirstLine()
 229         and GetNextLine().
 230     */
 231     void GoToLine(size_t n);
 232
 233     /**
 234         Guess the type of file (which is supposed to be opened).
 235
 236         If sufficiently many lines of the file are in DOS/Unix/Mac format,
 237         the corresponding value will be returned.
 238         If the detection mechanism fails @c wxTextFileType_None is returned.
 239     */
 240     wxTextFileType GuessType() const;
 241
 242     /**
 243         Insert a line before the line number @a n.
 244     */
 245     void InsertLine(const wxString& str, size_t n,
 246                     wxTextFileType type = typeDefault);
 247
 248     /**
 249         Returns @true if the file is currently opened.
 250     */
 251     bool IsOpened() const;
 252
 253     /**
 254         Opens the file with the name which was given in the wxTextFile(const wxString&)
 255         constructor and also loads file in memory on success.
 256
 257         It will fail if the file does not exist, Create() should be used in this case.
 258
 259         The @a conv argument is only meaningful in Unicode build of wxWidgets when
 260         it is used to convert the file to wide character representation.
 261     */
 262     bool Open(const wxMBConv& conv = wxConvAuto());
 263
 264     /**
 265         Opens the file with the given name and also loads file in memory on success.
 266
 267         It will fail if the file does not exist, Create() should be used in this case.
 268
 269         The @a conv argument is only meaningful in Unicode build of wxWidgets when
 270         it is used to convert the file to wide character representation.
 271     */
 272     bool Open(const wxString& strFile, const wxMBConv& conv = wxConvAuto());
 273
 274     /**
 275         Delete line number @a n from the file.
 276     */
 277     void RemoveLine(size_t n);
 278
 279     /**
 280         Change the file on disk.
 281
 282         The @a typeNew parameter allows you to change the file format
 283         (default argument means "don't change type") and may be used to convert,
 284         for example, DOS files to Unix.
 285
 286         The @a conv argument is only meaningful in Unicode build of wxWidgets when
 287         it is used to convert all lines to multibyte representation before writing
 288         them to physical file.
 289
 290         @return
 291             @true if operation succeeded, @false if it failed.
 292     */
 293     bool Write(wxTextFileType typeNew = wxTextFileType_None,
 294                const wxMBConv& conv = wxConvAuto());
 295
 296     /**
 297         The same as GetLine().
 298     */
 299     wxString& operator[](size_t n) const;
 300 };
 301