interface/wx/textfile.h

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