1 /****************************************************************************

     2 ** 

     3 **

     4 ** Implementation of QFileInfo class

     5 **

     6 ** Created : 950628

     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 

    40 #include "qfileinfo.h"

    41 #include "qfiledefs_p.h"

    42 #include "qdatetime.h"

    43 #include "qdir.h"

    44 

    45 extern bool qt_file_access( const QString& fn, int t );

    46 

    47 // NOT REVISED

    48 /*!

    49   \class QFileInfo qfileinfo.h

    50   \brief The QFileInfo class provides system-independent file information.

    51 

    52   \ingroup io

    53 

    54   QFileInfo provides information about a file's name and position (path) in

    55   the file system, its access rights and whether it is a directory or a

    56   symbolic link.  Its size and last modified/read times are also available.

    57 

    58   To speed up performance QFileInfo caches information about the file. Since

    59   files can be changed by other users or programs, or even by other parts of

    60   the same program there is a function that refreshes the file information;

    61   refresh(). If you would rather like a QFileInfo to access the file system

    62   every time you request information from it, you can call the function

    63   setCaching( FALSE ).

    64 

    65   A QFileInfo can point to a file using either a relative or an absolute

    66   file path. Absolute file paths begin with the directory separator

    67   ('/') or a drive specification (not applicable to UNIX).

    68   Relative file names begin with a directory name or a file name and specify

    69   a path relative to the current directory. An example of

    70   an absolute path is the string "/tmp/quartz". A relative path might look like

    71   "src/fatlib". You can use the function isRelative() to check if a QFileInfo

    72   is using a relative or an absolute file path. You can call the function

    73   convertToAbs() to convert a relative QFileInfo to an absolute one.

    74 

    75   If you need to read and traverse directories, see the QDir class.

    76 */

    77 

    78 

    79 /*!

    80   Constructs a new empty QFileInfo.

    81 */

    82 

    83 QFileInfo::QFileInfo()

    84 {

    85     fic	  = 0;

    86     cache = TRUE;

    87 }

    88 

    89 /*!

    90   Constructs a new QFileInfo that gives information about the given file.

    91   The string given can be an absolute or a relative file path.

    92 

    93   \sa bool setFile(QString ), isRelative(), QDir::setCurrent(),

    94   QDir::isRelativePath()

    95 */

    96 

    97 QFileInfo::QFileInfo( const QString &file )

    98 {

    99     fn	  = file;

   100     slashify( fn );

   101     fic	  = 0;

   102     cache = TRUE;

   103 }

   104 

   105 /*!

   106   Constructs a new QFileInfo that gives information about \e file.

   107 

   108   If the file has a relative path, the QFileInfo will also have one.

   109 

   110   \sa isRelative()

   111 */

   112 

   113 QFileInfo::QFileInfo( const QFile &file )

   114 {

   115     fn	  = file.name();

   116     slashify( fn );

   117     fic	  = 0;

   118     cache = TRUE;

   119 }

   120 

   121 /*!

   122   Constructs a new QFileInfo that gives information about the file

   123   named \e fileName in the directory \e d.

   124 

   125   If the directory has a relative path, the QFileInfo will also have one.

   126 

   127   \sa isRelative()

   128 */

   129 #ifndef QT_NO_DIR

   130 QFileInfo::QFileInfo( const QDir &d, const QString &fileName )

   131 {

   132     fn	  = d.filePath( fileName );

   133     slashify( fn );

   134     fic	  = 0;

   135     cache = TRUE;

   136 }

   137 #endif

   138 /*!

   139   Constructs a new QFileInfo that is a copy of \e fi.

   140 */

   141 

   142 QFileInfo::QFileInfo( const QFileInfo &fi )

   143 {

   144     fn = fi.fn;

   145     if ( fi.fic ) {

   146 	fic = new QFileInfoCache;

   147 	*fic = *fi.fic;

   148     } else {

   149 	fic = 0;

   150     }

   151     cache = fi.cache;

   152 }

   153 

   154 /*!

   155   Destructs the QFileInfo.

   156 */

   157 

   158 QFileInfo::~QFileInfo()

   159 {

   160     delete fic;

   161 }

   162 

   163 

   164 /*!

   165   Makes a copy of \e fi and assigns it to this QFileInfo.

   166 */

   167 

   168 QFileInfo &QFileInfo::operator=( const QFileInfo &fi )

   169 {

   170     fn = fi.fn;

   171     if ( !fi.fic ) {

   172 	delete fic;

   173 	fic = 0;

   174     } else {

   175 	if ( !fic ) {

   176 	    fic = new QFileInfoCache;

   177 	    CHECK_PTR( fic );

   178 	}

   179 	*fic = *fi.fic;

   180     }

   181     cache = fi.cache;

   182     return *this;

   183 }

   184 

   185 

   186 /*!

   187   Sets the file to obtain information about.

   188 

   189   The string given can be an absolute or a relative file path. Absolute file

   190   paths begin with the directory separator (e.g. '/' under UNIX) or a drive

   191   specification (not applicable to UNIX). Relative file names begin with a

   192   directory name or a file name and specify a path relative to the current

   193   directory.

   194 

   195   Example:

   196   \code

   197     #include <qfileinfo.h>

   198     #include <qdir.h>

   199 

   200     void test()

   201     {

   202 	QString absolute = "/liver/aorta";

   203 	QString relative = "liver/aorta";

   204 	QFileInfo fi1( absolute );

   205 	QFileInfo fi2( relative );

   206 

   207 	QDir::setCurrent( QDir::rootDirPath() );

   208 				// fi1 and fi2 now point to the same file

   209 

   210 	QDir::setCurrent( "/tmp" );

   211 				// fi1 now points to "/liver/aorta",

   212 				// while fi2 points to "/tmp/liver/aorta"

   213     }

   214   \endcode

   215 

   216   \sa isRelative(), QDir::setCurrent(), QDir::isRelativePath()

   217 */

   218 

   219 void QFileInfo::setFile( const QString &file )

   220 {

   221     fn = file;

   222     slashify( fn );

   223     delete fic;

   224     fic = 0;

   225 }

   226 

   227 /*!

   228   Sets the file to obtain information about.

   229 

   230   If the file has a relative path, the QFileInfo will also have one.

   231 

   232   \sa isRelative()

   233 */

   234 

   235 void QFileInfo::setFile( const QFile &file )

   236 {

   237     fn	= file.name();

   238     slashify( fn );

   239     delete fic;

   240     fic = 0;

   241 }

   242 

   243 /*!

   244   Sets the file to obtains information about to \e fileName in the

   245   directory \e d.

   246 

   247   If the directory has a relative path, the QFileInfo will also have one.

   248 

   249   \sa isRelative()

   250 */

   251 #ifndef QT_NO_DIR

   252 void QFileInfo::setFile( const QDir &d, const QString &fileName )

   253 {

   254     fn	= d.filePath( fileName );

   255     slashify( fn );

   256     delete fic;

   257     fic = 0;

   258 }

   259 #endif

   260 

   261 /*!

   262   Returns TRUE if the file pointed to exists, otherwise FALSE.

   263 */

   264 

   265 bool QFileInfo::exists() const

   266 {

   267     return qt_file_access( fn, F_OK );

   268 }

   269 

   270 /*!

   271   Refresh the information about the file, i.e. read in information from the

   272   file system the next time a cached property is fetched.

   273 

   274   \sa setCaching()

   275 */

   276 

   277 void QFileInfo::refresh() const

   278 {

   279     QFileInfo *that = (QFileInfo*)this;		// Mutable function

   280     delete that->fic;

   281     that->fic = 0;

   282 }

   283 

   284 /*!

   285   \fn bool QFileInfo::caching() const

   286   Returns TRUE if caching is enabled.

   287   \sa setCaching(), refresh()

   288 */

   289 

   290 /*!

   291   Enables caching of file information if \e enable is TRUE, or disables it

   292   if \e enable is FALSE.

   293 

   294   When caching is enabled, QFileInfo reads the file information the first

   295   time

   296 

   297   Caching is enabled by default.

   298 

   299   \sa refresh(), caching()

   300 */

   301 

   302 void QFileInfo::setCaching( bool enable )

   303 {

   304     if ( cache == enable )

   305 	return;

   306     cache = enable;

   307     if ( cache ) {

   308 	delete fic;

   309 	fic = 0;

   310     }

   311 }

   312 

   313 

   314 /*!

   315   Returns the name, i.e. the file name including the path (which can be

   316   absolute or relative).

   317 

   318   \sa isRelative(), absFilePath()

   319 */

   320 

   321 QString QFileInfo::filePath() const

   322 {

   323     return fn;

   324 }

   325 

   326 /*!

   327   Returns the base name of the file.

   328 

   329   The base name consists of all characters in the file name up to (but not

   330   including) the first '.' character.  The path is not included.

   331 

   332   Example:

   333   \code

   334      QFileInfo fi( "/tmp/abdomen.lower" );

   335      QString base = fi.baseName();		// base = "abdomen"

   336   \endcode

   337 

   338   \sa fileName(), extension()

   339 */

   340 

   341 QString QFileInfo::baseName() const

   342 {

   343     QString tmp = fileName();

   344     int pos = tmp.find( '.' );

   345     if ( pos == -1 )

   346 	return tmp;

   347     else

   348 	return tmp.left( pos );

   349 }

   350 

   351 /*!

   352   Returns the extension name of the file.

   353 

   354   If \a complete is TRUE (the default), extension() returns the string

   355   of all characters in the file name after (but not including) the

   356   first '.'  character.  For a file named "archive.tar.gz" this

   357   returns "tar.gz".

   358 

   359   If \a complete is FALSE, extension() returns the string of all

   360   characters in the file name after (but not including) the last '.'

   361   character.  For a file named "archive.tar.gz" this returns "gz".

   362 

   363   Example:

   364   \code

   365      QFileInfo fi( "lex.yy.c" );

   366      QString ext = fi.extension();		// ext = "yy.c"

   367      QString ext = fi.extension( FALSE );	// ext = "c"

   368   \endcode

   369 

   370   \sa fileName(), baseName()

   371 

   372 */

   373 

   374 QString QFileInfo::extension( bool complete ) const

   375 {

   376     QString s = fileName();

   377     int pos = complete ? s.find( '.' ) : s.findRev( '.' );

   378     if ( pos < 0 )

   379 	return QString::fromLatin1( "" );

   380     else

   381 	return s.right( s.length() - pos - 1 );

   382 }

   383 

   384 /*!

   385   Returns the directory path of the file.

   386 

   387   If the QFileInfo is relative and \e absPath is FALSE, the QDir will be

   388   relative, otherwise it will be absolute.

   389 

   390   \sa dirPath(), filePath(), fileName(), isRelative()

   391 */

   392 #ifndef QT_NO_DIR

   393 QDir QFileInfo::dir( bool absPath ) const

   394 {

   395     return QDir( dirPath(absPath) );

   396 }

   397 #endif

   398 

   399 

   400 /*!

   401   Returns TRUE if the file is readable.

   402   \sa isWritable(), isExecutable(), permission()

   403 */

   404 

   405 bool QFileInfo::isReadable() const

   406 {

   407     return qt_file_access( fn, R_OK );

   408 }

   409 

   410 /*!

   411   Returns TRUE if the file is writable.

   412   \sa isReadable(), isExecutable(), permission()

   413 */

   414 

   415 bool QFileInfo::isWritable() const

   416 {

   417     return qt_file_access( fn, W_OK );

   418 }

   419 

   420 /*!

   421   Returns TRUE if the file is executable.

   422   \sa isReadable(), isWritable(), permission()

   423 */

   424 

   425 bool QFileInfo::isExecutable() const

   426 {

   427     return qt_file_access( fn, X_OK );

   428 }

   429 

   430 

   431 /*!

   432   Returns TRUE if the file path name is relative to the current directory,

   433   FALSE if the path is absolute (e.g. under UNIX a path is relative if it

   434   does not start with a '/').

   435 

   436   According to Einstein this function should always return TRUE.

   437 */

   438 #ifndef QT_NO_DIR

   439 bool QFileInfo::isRelative() const

   440 {

   441     return QDir::isRelativePath( fn );

   442 }

   443 

   444 /*!

   445   Converts the file path name to an absolute path.

   446 

   447   If it is already absolute nothing is done.

   448 

   449   \sa filePath(), isRelative()

   450 */

   451 

   452 bool QFileInfo::convertToAbs()

   453 {

   454     if ( isRelative() )

   455 	fn = absFilePath();

   456     return QDir::isRelativePath( fn );

   457 }

   458 #endif