interface/textfile.h

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