Chameleon

Chameleon Svn Source Tree

Root/branches/xZenu/src/util/doxygen/qtools/qfile.cpp

Source at commit 1322 created 9 years 5 months ago.
By meklort, Add doxygen to utils folder
1/****************************************************************************
2**
3**
4** Implementation of QFile class
5**
6** Created : 930812
7**
8** Copyright (C) 1992-2000 Trolltech AS. All rights reserved.
9**
10** This file is part of the tools module of the Qt GUI Toolkit.
11**
12** This file may be distributed under the terms of the Q Public License
13** as defined by Trolltech AS of Norway and appearing in the file
14** LICENSE.QPL included in the packaging of this file.
15**
16** This file may be distributed and/or modified under the terms of the
17** GNU General Public License version 2 as published by the Free Software
18** Foundation and appearing in the file LICENSE.GPL included in the
19** packaging of this file.
20**
21** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
22** licenses may use this file in accordance with the Qt Commercial License
23** Agreement provided with the Software.
24**
25** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
26** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
27**
28** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
29** information about Qt Commercial License Agreements.
30** See http://www.trolltech.com/qpl/ for QPL licensing information.
31** See http://www.trolltech.com/gpl/ for GPL licensing information.
32**
33** Contact info@trolltech.com if any conditions of this licensing are
34** not clear to you.
35**
36**********************************************************************/
37
38#include "qglobal.h"
39#if defined(_OS_WIN32_)
40#ifdef UNICODE
41#ifndef _UNICODE
42#define _UNICODE
43#endif
44#endif
45#endif
46
47#include "qfile.h"
48#include "qfiledefs_p.h"
49
50extern bool qt_file_access( const QString& fn, int t );
51
52// NOT REVISED
53/*!
54 \class QFile qfile.h
55 \brief The QFile class is an I/O device that operates on files.
56
57 \ingroup io
58
59 QFile is an I/O device for reading and writing binary and text files.A
60 QFile may be used by itself (readBlock and writeBlock) or by more
61 conveniently using QDataStream or QTextStream.
62
63 Here is a code fragment that uses QTextStream to read a text
64 file line by line. It prints each line with a line number.
65 \code
66 QFile f("file.txt");
67 if ( f.open(IO_ReadOnly) ) { // file opened successfully
68QTextStream t( &f ); // use a text stream
69QString s;
70int n = 1;
71while ( !t.eof() ) { // until end of file...
72 s = t.readLine(); // line of text excluding '\n'
73 printf( "%3d: %s\n", n++, (const char *)s );
74}
75f.close();
76 }
77 \endcode
78
79 The QFileInfo class holds detailed information about a file, such as
80 access permissions, file dates and file types.
81
82 The QDir class manages directories and lists of file names.
83
84 \sa QDataStream, QTextStream
85*/
86
87
88/*!
89 Constructs a QFile with no name.
90*/
91
92QFile::QFile()
93{
94 init();
95}
96
97/*!
98 Constructs a QFile with a file name \e name.
99 \sa setName()
100*/
101
102QFile::QFile( const QString &name )
103 : fn(name)
104{
105 init();
106}
107
108
109/*!
110 Destructs a QFile. Calls close().
111*/
112
113QFile::~QFile()
114{
115 close();
116}
117
118
119/*!
120 \internal
121 Initialize internal data.
122*/
123
124void QFile::init()
125{
126 setFlags( IO_Direct );
127 setStatus( IO_Ok );
128 fh = 0;
129 fd = 0;
130 length = 0;
131 ioIndex = 0;
132 ext_f = FALSE;// not an external file handle
133}
134
135
136/*!
137 \fn QString QFile::name() const
138 Returns the name set by setName().
139 \sa setName(), QFileInfo::fileName()
140*/
141
142/*!
143 Sets the name of the file. The name can include an absolute directory
144 path or it can be a name or a path relative to the current directory.
145
146 Do not call this function if the file has already been opened.
147
148 Note that if the name is relative QFile does not associate it with the
149 current directory. If you change directory before calling open(), open
150 uses the new current directory.
151
152 Example:
153 \code
154 QFile f;
155 QDir::setCurrent( "/tmp" );
156 f.setName( "readme.txt" );
157 QDir::setCurrent( "/home" );
158 f.open( IO_ReadOnly ); // opens "/home/readme.txt" under UNIX
159 \endcode
160
161 Also note that the directory separator '/' works for all operating
162 systems supported by Qt.
163
164 \sa name(), QFileInfo, QDir
165*/
166
167void QFile::setName( const QString &name )
168{
169 if ( isOpen() ) {
170#if defined(CHECK_STATE)
171qWarning( "QFile::setName: File is open" );
172#endif
173close();
174 }
175 fn = name;
176}
177
178/*!
179 Returns TRUE if this file exists, otherwise FALSE.
180 \sa name()
181*/
182
183bool QFile::exists() const
184{
185 return qt_file_access( fn, F_OK );
186}
187
188/*!
189 Returns TRUE if the file given by \e fileName exists, otherwise FALSE.
190*/
191
192bool QFile::exists( const QString &fileName )
193{
194 return qt_file_access( fileName, F_OK );
195}
196
197
198/*!
199 Removes the file specified by the file name currently set.
200 Returns TRUE if successful, otherwise FALSE.
201
202 The file is closed before it is removed.
203*/
204
205bool QFile::remove()
206{
207 close();
208 return remove( fn );
209}
210
211#if defined(_OS_MAC_) || defined(_OS_MSDOS_) || defined(_OS_WIN32_) || defined(_OS_OS2_) || defined(_OS_CYGWIN_)
212# define HAS_TEXT_FILEMODE// has translate/text filemode
213#endif
214#if defined(O_NONBLOCK)
215# define HAS_ASYNC_FILEMODE
216# define OPEN_ASYNC O_NONBLOCK
217#elif defined(O_NDELAY)
218# define HAS_ASYNC_FILEMODE
219# define OPEN_ASYNC O_NDELAY
220#endif
221
222/*!
223 Flushes the file buffer to the disk.
224
225 close() also flushes the file buffer.
226*/
227
228void QFile::flush()
229{
230 if ( isOpen() && fh )// can only flush open/buffered
231fflush( fh );// file
232}
233
234/*!
235 Returns TRUE if the end of file has been reached, otherwise FALSE.
236 \sa size()
237*/
238
239bool QFile::atEnd() const
240{
241 if ( !isOpen() ) {
242#if defined(CHECK_STATE)
243qWarning( "QFile::atEnd: File is not open" );
244#endif
245return FALSE;
246 }
247 if ( isDirectAccess() && !isTranslated() ) {
248if ( at() < length )
249 return FALSE;
250 }
251 return QIODevice::atEnd();
252}
253
254/*!
255 Reads a line of text.
256
257 Reads bytes from the file until end-of-line is reached, or up to \a
258 maxlen bytes, and returns the number of bytes read, or -1 in case of
259 error. The terminating newline is not stripped.
260
261 This function is efficient only for buffered files. Avoid
262 readLine() for files that have been opened with the \c IO_Raw
263 flag.
264
265 \sa readBlock(), QTextStream::readLine()
266*/
267
268int QFile::readLine( char *p, uint maxlen )
269{
270 if ( maxlen == 0 )// application bug?
271return 0;
272#if defined(CHECK_STATE)
273 CHECK_PTR( p );
274 if ( !isOpen() ) {// file not open
275qWarning( "QFile::readLine: File not open" );
276return -1;
277 }
278 if ( !isReadable() ) {// reading not permitted
279qWarning( "QFile::readLine: Read operation not permitted" );
280return -1;
281 }
282#endif
283 int nread;// number of bytes read
284 if ( isRaw() ) {// raw file
285nread = QIODevice::readLine( p, maxlen );
286 } else {// buffered file
287p = fgets( p, maxlen, fh );
288if ( p ) {
289 nread = qstrlen( p );
290 ioIndex += nread;
291} else {
292 nread = -1;
293 setStatus(IO_ReadError);
294}
295 }
296 return nread;
297}
298
299
300/*!
301 Reads a line of text.
302
303 Reads bytes from the file until end-of-line is reached, or up to \a
304 maxlen bytes, and returns the number of bytes read, or -1 in case of
305 error. The terminating newline is not stripped.
306
307 This function is efficient only for buffered files. Avoid
308 readLine() for files that have been opened with the \c IO_Raw
309 flag.
310
311 Note that the string is read as plain Latin1 bytes, not Unicode.
312
313 \sa readBlock(), QTextStream::readLine()
314*/
315
316int QFile::readLine( QString& s, uint maxlen )
317{
318 QByteArray ba(maxlen);
319 int l = readLine(ba.data(),maxlen);
320 if ( l >= 0 ) {
321ba.truncate(l);
322s = QString(ba);
323 }
324 return l;
325}
326
327
328/*!
329 Reads a single byte/character from the file.
330
331 Returns the byte/character read, or -1 if the end of the file has been
332 reached.
333
334 \sa putch(), ungetch()
335*/
336
337int QFile::getch()
338{
339#if defined(CHECK_STATE)
340 if ( !isOpen() ) {// file not open
341qWarning( "QFile::getch: File not open" );
342return EOF;
343 }
344 if ( !isReadable() ) {// reading not permitted
345qWarning( "QFile::getch: Read operation not permitted" );
346return EOF;
347 }
348#endif
349
350 int ch;
351
352 if ( !ungetchBuffer.isEmpty() ) {
353int len = ungetchBuffer.length();
354ch = ungetchBuffer[ len-1 ];
355ungetchBuffer.truncate( len - 1 );
356return ch;
357 }
358
359 if ( isRaw() ) {// raw file (inefficient)
360char buf[1];
361ch = readBlock( buf, 1 ) == 1 ? buf[0] : EOF;
362 } else {// buffered file
363if ( (ch = getc( fh )) != EOF )
364 ioIndex++;
365else
366 setStatus(IO_ReadError);
367 }
368 return ch;
369}
370
371/*!
372 \fn int QFile::writeBlock( const QByteArray& data )
373 \reimp
374 \internal
375 Should be removed in 3.0
376*/
377
378/*!
379 Writes the character \e ch to the file.
380
381 Returns \e ch, or -1 if some error occurred.
382
383 \sa getch(), ungetch()
384*/
385
386int QFile::putch( int ch )
387{
388#if defined(CHECK_STATE)
389 if ( !isOpen() ) {// file not open
390qWarning( "QFile::putch: File not open" );
391return EOF;
392 }
393 if ( !isWritable() ) {// writing not permitted
394qWarning( "QFile::putch: Write operation not permitted" );
395return EOF;
396 }
397#endif
398 if ( isRaw() ) {// raw file (inefficient)
399char buf[1];
400buf[0] = ch;
401ch = writeBlock( buf, 1 ) == 1 ? ch : EOF;
402 } else {// buffered file
403if ( (ch = putc( ch, fh )) != EOF ) {
404 ioIndex++;
405 if ( ioIndex > length )// update file length
406length = ioIndex;
407} else {
408 setStatus(IO_WriteError);
409}
410 }
411 return ch;
412}
413
414/*!
415 Puts the character \e ch back into the file and decrements the index if it
416 is not zero.
417
418 This function is normally called to "undo" a getch() operation.
419
420 Returns \e ch, or -1 if some error occurred.
421
422 \sa getch(), putch()
423*/
424
425int QFile::ungetch( int ch )
426{
427#if defined(CHECK_STATE)
428 if ( !isOpen() ) {// file not open
429qWarning( "QFile::ungetch: File not open" );
430return EOF;
431 }
432 if ( !isReadable() ) {// reading not permitted
433qWarning( "QFile::ungetch: Read operation not permitted" );
434return EOF;
435 }
436#endif
437 if ( ch == EOF )// cannot unget EOF
438return ch;
439
440 if ( isSequentialAccess() && !fh) {
441// pipe or similar => we cannot ungetch, so do it manually
442ungetchBuffer +=ch;
443return ch;
444 }
445
446 if ( isRaw() ) {// raw file (very inefficient)
447char buf[1];
448at( ioIndex-1 );
449buf[0] = ch;
450if ( writeBlock(buf, 1) == 1 )
451 at ( ioIndex-1 );
452else
453 ch = EOF;
454 } else {// buffered file
455if ( (ch = ungetc(ch, fh)) != EOF )
456 ioIndex--;
457else
458 setStatus( IO_ReadError );
459 }
460 return ch;
461}
462
463
464static QCString locale_encoder( const QString &fileName )
465{
466 return fileName.local8Bit();
467}
468
469
470static QFile::EncoderFn encoder = locale_encoder;
471
472/*!
473 When you use QFile, QFileInfo, and QDir to access the filesystem
474 with Qt, you can use Unicode filenames. On Unix, these filenames
475 are converted to an 8-bit encoding. If you want to do your own
476 file I/O on Unix, you should convert the filename using this
477 function. On Windows NT, Unicode filenames are supported directly
478 in the filesystem and this function should be avoided. On Windows 95,
479 non-Latin1 locales are not supported at this time.
480
481 By default, this function converts to the local 8-bit encoding
482 determined by the user's locale. This is sufficient for
483 filenames that the user chooses. Filenames hard-coded into the
484 application should only use 7-bit ASCII filename characters.
485
486 The conversion scheme can be changed using setEncodingFunction().
487 This might be useful if you wish to give the user an option to
488 store in filenames in UTF-8, etc., but beware that such filenames
489 would probably then be unrecognizable when seen by other programs.
490
491 \sa decodeName()
492*/
493
494QCString QFile::encodeName( const QString &fileName )
495{
496 return (*encoder)(fileName);
497}
498
499/*!
500 \enum QFile::EncoderFn
501
502 This is used by QFile::setEncodingFunction().
503*/
504
505/*!
506 Sets the function for encoding Unicode filenames.
507 The default encodes in the locale-specific 8-bit encoding.
508
509 \sa encodeName()
510*/
511void QFile::setEncodingFunction( EncoderFn f )
512{
513 encoder = f;
514}
515
516static
517QString locale_decoder( const QCString &localFileName )
518{
519 return QString::fromLocal8Bit(localFileName);
520}
521
522static QFile::DecoderFn decoder = locale_decoder;
523
524/*!
525 This does the reverse of QFile::encodeName().
526
527 \sa setDecodingFunction()
528*/
529QString QFile::decodeName( const QCString &localFileName )
530{
531 return (*decoder)(localFileName);
532}
533
534/*!
535 \enum QFile::DecoderFn
536
537 This is used by QFile::setDecodingFunction().
538*/
539
540/*!
541 Sets the function for decoding 8-bit filenames.
542 The default uses the locale-specific 8-bit encoding.
543
544 \sa encodeName(), decodeName()
545*/
546
547void QFile::setDecodingFunction( DecoderFn f )
548{
549 decoder = f;
550}
551

Archive Download this file

Revision: 1322