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