#include <qfileinfo_p.h>

Inheritance diagram for QFileInfoPrivate:

Public Types
enum	{ CachedFileFlags =0x01, CachedLinkTypeFlag =0x02, CachedBundleTypeFlag =0x04, CachedMTime =0x10, CachedCTime =0x20, CachedATime =0x40, CachedSize =0x08, CachedPerms =0x80 }

Public Functions
void	clear ()

void	clearFlags () const

bool	getCachedFlag (uint c) const

uint	getFileFlags (QAbstractFileEngine::FileFlags) const

QString	getFileName (QAbstractFileEngine::FileName) const

QString	getFileOwner (QAbstractFileEngine::FileOwner own) const

QDateTime &	getFileTime (QAbstractFileEngine::FileTime) const

	QFileInfoPrivate ()

	QFileInfoPrivate (const QFileInfoPrivate &copy)

	QFileInfoPrivate (const QString &file)

	QFileInfoPrivate (const QFileSystemEntry &file, const QFileSystemMetaData &data)

void	setCachedFlag (uint c) const

Public Functions inherited from QSharedData
	QSharedData ()
	Constructs a QSharedData object with a reference count of 0. More...

	QSharedData (const QSharedData &)
	Constructs a QSharedData object with reference count 0. More...

Public Variables
bool	cache_enabled: 1

uint	cachedFlags: 30

QScopedPointer< QAbstractFileEngine > const	fileEngine

QFileSystemEntry	fileEntry

uint	fileFlags

QString	fileNames [QAbstractFileEngine::NFileNames]

QString	fileOwners [2]

qint64	fileSize

QDateTime	fileTimes [3]

bool const	isDefaultConstructed: 1

QFileSystemMetaData	metaData

Public Variables inherited from QSharedData
QAtomicInt	ref

Detailed Description

Definition at line 68 of file qfileinfo_p.h.

Enumerations

◆ anonymous enum

anonymous enum

Enumerator
CachedFileFlags
CachedLinkTypeFlag
CachedBundleTypeFlag
CachedMTime
CachedCTime
CachedATime
CachedSize
CachedPerms

Definition at line 71 of file qfileinfo_p.h.

          { CachedFileFlags=0x01, CachedLinkTypeFlag=0x02, CachedBundleTypeFlag=0x04,
            CachedMTime=0x10, CachedCTime=0x20, CachedATime=0x40,
            CachedSize =0x08, CachedPerms=0x80 };

Constructors and Destructors

◆ QFileInfoPrivate() [1/4]

QFileInfoPrivate::QFileInfoPrivate ( )

inline

Definition at line 75 of file qfileinfo_p.h.

         : QSharedData(), fileEngine(0),
         cachedFlags(0),
         isDefaultConstructed(true),
         cache_enabled(true), fileFlags(0), fileSize(0)
     {}

◆ QFileInfoPrivate() [2/4]

QFileInfoPrivate::QFileInfoPrivate ( const QFileInfoPrivate & copy )

inline

Definition at line 81 of file qfileinfo_p.h.

         : QSharedData(copy),
         fileEntry(copy.fileEntry),
         metaData(copy.metaData),
         fileEngine(QFileSystemEngine::resolveEntryAndCreateLegacyEngine(fileEntry, metaData)),
         cachedFlags(0),
 #ifndef QT_NO_FSFILEENGINE
         isDefaultConstructed(false),
 #else
         isDefaultConstructed(!fileEngine),
 #endif
         cache_enabled(copy.cache_enabled), fileFlags(0), fileSize(0)
     {}

◆ QFileInfoPrivate() [3/4]

QFileInfoPrivate::QFileInfoPrivate ( const QString & file )

inline

Definition at line 94 of file qfileinfo_p.h.

         : fileEntry(QDir::fromNativeSeparators(file)),
         fileEngine(QFileSystemEngine::resolveEntryAndCreateLegacyEngine(fileEntry, metaData)),
         cachedFlags(0),
 #ifndef QT_NO_FSFILEENGINE
         isDefaultConstructed(false),
 #else
         isDefaultConstructed(!fileEngine),
 #endif
         cache_enabled(true), fileFlags(0), fileSize(0)
     {
     }

◆ QFileInfoPrivate() [4/4]

QFileInfoPrivate::QFileInfoPrivate	(	const QFileSystemEntry &	file,
		const QFileSystemMetaData &	data
	)

inline

Definition at line 107 of file qfileinfo_p.h.

         : QSharedData(),
         fileEntry(file),
         metaData(data),
         fileEngine(QFileSystemEngine::resolveEntryAndCreateLegacyEngine(fileEntry, metaData)),
         cachedFlags(0),
         isDefaultConstructed(false),
         cache_enabled(true), fileFlags(0), fileSize(0)
     {
         //If the file engine is not null, this maybe a "mount point" for a custom file engine
         //in which case we can't trust the metadata
         if (fileEngine)
             metaData = QFileSystemMetaData();
     }

Functions

◆ clear()

void QFileInfoPrivate::clear ( )

inline

Definition at line 128 of file qfileinfo_p.h.

                         {
         metaData.clear();
         clearFlags();
         for (int i = QAbstractFileEngine::NFileNames - 1 ; i >= 0 ; --i)
             fileNames[i].clear();
         fileOwners[1].clear();
         fileOwners[0].clear();
     }

◆ clearFlags()

void QFileInfoPrivate::clearFlags ( ) const

inline

Definition at line 122 of file qfileinfo_p.h.

Referenced by clear(), and getFileTime().

                                    {
         fileFlags = 0;
         cachedFlags = 0;
         if (fileEngine)
             (void)fileEngine->fileFlags(QAbstractFileEngine::Refresh);
     }

◆ getCachedFlag()

bool QFileInfoPrivate::getCachedFlag ( uint c ) const

inline

Definition at line 156 of file qfileinfo_p.h.

Referenced by getFileFlags(), and getFileTime().

157 { return cache_enabled ? (cachedFlags & c) : 0; }

c

unsigned char c[8]

Definition: qnumeric_p.h:62

QFileInfoPrivate::cache_enabled

bool cache_enabled

Definition: qfileinfo_p.h:152

QFileInfoPrivate::cachedFlags

uint cachedFlags

Definition: qfileinfo_p.h:150

◆ getFileFlags()

uint QFileInfoPrivate::getFileFlags ( QAbstractFileEngine::FileFlags request ) const

Definition at line 126 of file qfileinfo.cpp.

Referenced by clear().

 {
     Q_ASSERT(fileEngine); // should never be called when using the native FS
     // We split the testing into tests for for LinkType, BundleType, PermsMask
     // and the rest.
     // Tests for file permissions on Windows can be slow, expecially on network
     // paths and NTFS drives.
     // In order to determine if a file is a symlink or not, we have to lstat().
     // If we're not interested in that information, we might as well avoid one
     // extra syscall. Bundle detecton on Mac can be slow, expecially on network
     // paths, so we separate out that as well.
 
     QAbstractFileEngine::FileFlags req = 0;
     uint cachedFlags = 0;
 
     if (request & (QAbstractFileEngine::FlagsMask | QAbstractFileEngine::TypesMask)) {
         if (!getCachedFlag(CachedFileFlags)) {
             req |= QAbstractFileEngine::FlagsMask;
             req |= QAbstractFileEngine::TypesMask;
             req &= (~QAbstractFileEngine::LinkType);
             req &= (~QAbstractFileEngine::BundleType);
 
             cachedFlags |= CachedFileFlags;
         }
 
         if (request & QAbstractFileEngine::LinkType) {
             if (!getCachedFlag(CachedLinkTypeFlag)) {
                 req |= QAbstractFileEngine::LinkType;
                 cachedFlags |= CachedLinkTypeFlag;
             }
         }
 
         if (request & QAbstractFileEngine::BundleType) {
             if (!getCachedFlag(CachedBundleTypeFlag)) {
                 req |= QAbstractFileEngine::BundleType;
                 cachedFlags |= CachedBundleTypeFlag;
             }
         }
     }
 
     if (request & QAbstractFileEngine::PermsMask) {
         if (!getCachedFlag(CachedPerms)) {
             req |= QAbstractFileEngine::PermsMask;
             cachedFlags |= CachedPerms;
         }
     }
 
     if (req) {
         if (cache_enabled)
             req &= (~QAbstractFileEngine::Refresh);
         else
             req |= QAbstractFileEngine::Refresh;
 
         QAbstractFileEngine::FileFlags flags = fileEngine->fileFlags(req);
         fileFlags |= uint(flags);
         setCachedFlag(cachedFlags);
     }
 
     return fileFlags & request;
 }

◆ getFileName()

QString QFileInfoPrivate::getFileName ( QAbstractFileEngine::FileName name ) const

Definition at line 50 of file qfileinfo.cpp.

Referenced by clear().

 {
     if (cache_enabled && !fileNames[(int)name].isNull())
         return fileNames[(int)name];
 
     QString ret;
     if (fileEngine == 0) { // local file; use the QFileSystemEngine directly
         switch (name) {
             case QAbstractFileEngine::CanonicalName:
             case QAbstractFileEngine::CanonicalPathName: {
                 QFileSystemEntry entry = QFileSystemEngine::canonicalName(fileEntry, metaData);
                 if (cache_enabled) { // be smart and store both
                     fileNames[QAbstractFileEngine::CanonicalName] = entry.filePath();
                     fileNames[QAbstractFileEngine::CanonicalPathName] = entry.path();
                 }
                 if (name == QAbstractFileEngine::CanonicalName)
                     ret = entry.filePath();
                 else
                     ret = entry.path();
                 break;
             }
             case QAbstractFileEngine::LinkName:
                 ret = QFileSystemEngine::getLinkTarget(fileEntry, metaData).filePath();
                 break;
             case QAbstractFileEngine::BundleName:
                 ret = QFileSystemEngine::bundleName(fileEntry);
                 break;
             case QAbstractFileEngine::AbsoluteName:
             case QAbstractFileEngine::AbsolutePathName: {
                 QFileSystemEntry entry = QFileSystemEngine::absoluteName(fileEntry);
                 if (cache_enabled) { // be smart and store both
                     fileNames[QAbstractFileEngine::AbsoluteName] = entry.filePath();
                     fileNames[QAbstractFileEngine::AbsolutePathName] = entry.path();
                 }
                 if (name == QAbstractFileEngine::AbsoluteName)
                     ret = entry.filePath();
                 else
                     ret = entry.path();
                 break;
             }
             default: break;
         }
     } else {
         ret = fileEngine->fileName(name);
     }
     if (ret.isNull())
         ret = QLatin1String("");
     if (cache_enabled)
         fileNames[(int)name] = ret;
     return ret;
 }

◆ getFileOwner()

QString QFileInfoPrivate::getFileOwner ( QAbstractFileEngine::FileOwner own ) const

Definition at line 102 of file qfileinfo.cpp.

Referenced by clear().

 {
     if (cache_enabled && !fileOwners[(int)own].isNull())
         return fileOwners[(int)own];
     QString ret;
     if (fileEngine == 0) {
         switch (own) {
         case QAbstractFileEngine::OwnerUser:
             ret = QFileSystemEngine::resolveUserName(fileEntry, metaData);
             break;
         case QAbstractFileEngine::OwnerGroup:
             ret = QFileSystemEngine::resolveGroupName(fileEntry, metaData);
             break;
         }
      } else {
         ret = fileEngine->owner(own);
     }
     if (ret.isNull())
         ret = QLatin1String("");
     if (cache_enabled)
         fileOwners[(int)own] = ret;
     return ret;
 }

◆ getFileTime()

QDateTime & QFileInfoPrivate::getFileTime ( QAbstractFileEngine::FileTime request ) const

Definition at line 187 of file qfileinfo.cpp.

Referenced by clear().

 {
     Q_ASSERT(fileEngine); // should never be called when using the native FS
     if (!cache_enabled)
         clearFlags();
     uint cf;
     if (request == QAbstractFileEngine::CreationTime)
         cf = CachedCTime;
     else if (request == QAbstractFileEngine::ModificationTime)
         cf = CachedMTime;
     else
         cf = CachedATime;
     if (!getCachedFlag(cf)) {
         fileTimes[request] = fileEngine->fileTime(request);
         setCachedFlag(cf);
     }
     return fileTimes[request];
 }