feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Mimetypes v3: Rename classes

Browse Source 
- fix includes
- use pragma once
- use namespace Utils
- rename QMime -> Mime
- fix exports
- don't use QFileSystemEntry
- don't use QT_REQUIRE_CONFIG
- disable QT_CONFIG(mimetype_database)

Change-Id: I3e27b7644a9db987ad213efada3b0d8c7199cfd9
Reviewed-by: Jarek Kobus <jaroslaw.kobus@qt.io>
This commit is contained in:
Eike Ziller
2022-02-18 11:00:57 +01:00
parent 88d892c13a
commit f112fd0572
16 changed files with 523 additions and 568 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
src/libs/utils/mimetypes2/mimedatabase.cpp
View File

@@ -40,13 +40,11 @@
#include <qplatformdefs.h> // always first #include <qplatformdefs.h> // always first
#include "qmimedatabase.h" #include "mimedatabase.h"
#include "qmimedatabase_p.h" #include "mimedatabase_p.h"
#include "qmimeprovider_p.h" #include "mimeprovider_p.h"
#include "qmimetype_p.h" #include "mimetype_p.h"
#include <private/qfilesystementry_p.h>
#include <QtCore/QFile> #include <QtCore/QFile>
#include <QtCore/QFileInfo> #include <QtCore/QFileInfo>
@@ -59,34 +57,34 @@
#include <functional> #include <functional>
#include <stack> #include <stack>
QT_BEGIN_NAMESPACE namespace Utils {
Q_GLOBAL_STATIC(QMimeDatabasePrivate, staticQMimeDatabase) Q_GLOBAL_STATIC(MimeDatabasePrivate, staticMimeDatabase)
QMimeDatabasePrivate *QMimeDatabasePrivate::instance() MimeDatabasePrivate *MimeDatabasePrivate::instance()
{ {
return staticQMimeDatabase(); return staticMimeDatabase();
} }
QMimeDatabasePrivate::QMimeDatabasePrivate() MimeDatabasePrivate::MimeDatabasePrivate()
: m_defaultMimeType(QLatin1String("application/octet-stream")) : m_defaultMimeType(QLatin1String("application/octet-stream"))
{ {
} }
QMimeDatabasePrivate::~QMimeDatabasePrivate() MimeDatabasePrivate::~MimeDatabasePrivate()
{ {
} }
#ifdef QT_BUILD_INTERNAL #if 0 //def QT_BUILD_INTERNAL
Q_CORE_EXPORT Q_CORE_EXPORT
#else #else
static const static const
#endif #endif
int qmime_secondsBetweenChecks = 5; int mime_secondsBetweenChecks = 5;
bool QMimeDatabasePrivate::shouldCheck() bool MimeDatabasePrivate::shouldCheck()
{ {
if (m_lastCheck.isValid() && m_lastCheck.elapsed() < qmime_secondsBetweenChecks * 1000) if (m_lastCheck.isValid() && m_lastCheck.elapsed() < mime_secondsBetweenChecks * 1000)
return false; return false;
m_lastCheck.start(); m_lastCheck.start();
return true; return true;
@@ -96,14 +94,14 @@ bool QMimeDatabasePrivate::shouldCheck()
# define QT_USE_MMAP # define QT_USE_MMAP
#endif #endif
void QMimeDatabasePrivate::loadProviders() void MimeDatabasePrivate::loadProviders()
{ {
// We use QStandardPaths every time to check if new files appeared // We use QStandardPaths every time to check if new files appeared
const QStringList mimeDirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QLatin1String("mime"), QStandardPaths::LocateDirectory); const QStringList mimeDirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QLatin1String("mime"), QStandardPaths::LocateDirectory);
const auto fdoIterator = std::find_if(mimeDirs.constBegin(), mimeDirs.constEnd(), [](const QString &mimeDir) -> bool { const auto fdoIterator = std::find_if(mimeDirs.constBegin(), mimeDirs.constEnd(), [](const QString &mimeDir) -> bool {
return QFileInfo::exists(mimeDir + QStringLiteral("/packages/freedesktop.org.xml")); } return QFileInfo::exists(mimeDir + QStringLiteral("/packages/freedesktop.org.xml")); }
); );
const bool needInternalDB = QMimeXMLProvider::InternalDatabaseAvailable && fdoIterator == mimeDirs.constEnd(); const bool needInternalDB = MimeXMLProvider::InternalDatabaseAvailable && fdoIterator == mimeDirs.constEnd();
//qDebug() << "mime dirs:" << mimeDirs; //qDebug() << "mime dirs:" << mimeDirs;
Providers currentProviders; Providers currentProviders;
@@ -114,16 +112,16 @@ void QMimeDatabasePrivate::loadProviders()
for (const QString &mimeDir : mimeDirs) { for (const QString &mimeDir : mimeDirs) {
const QString cacheFile = mimeDir + QStringLiteral("/mime.cache"); const QString cacheFile = mimeDir + QStringLiteral("/mime.cache");
// Check if we already have a provider for this dir // Check if we already have a provider for this dir
const auto predicate = [mimeDir](const std::unique_ptr<QMimeProviderBase> &prov) const auto predicate = [mimeDir](const std::unique_ptr<MimeProviderBase> &prov)
{ {
return prov && prov->directory() == mimeDir; return prov && prov->directory() == mimeDir;
}; };
const auto it = std::find_if(currentProviders.begin(), currentProviders.end(), predicate); const auto it = std::find_if(currentProviders.begin(), currentProviders.end(), predicate);
if (it == currentProviders.end()) { if (it == currentProviders.end()) {
std::unique_ptr<QMimeProviderBase> provider; std::unique_ptr<MimeProviderBase> provider;
#if defined(QT_USE_MMAP) #if defined(QT_USE_MMAP)
if (qEnvironmentVariableIsEmpty("QT_NO_MIME_CACHE") && QFileInfo::exists(cacheFile)) { if (qEnvironmentVariableIsEmpty("QT_NO_MIME_CACHE") && QFileInfo::exists(cacheFile)) {
provider.reset(new QMimeBinaryProvider(this, mimeDir)); provider.reset(new MimeBinaryProvider(this, mimeDir));
//qDebug() << "Created binary provider for" << mimeDir; //qDebug() << "Created binary provider for" << mimeDir;
if (!provider->isValid()) { if (!provider->isValid()) {
provider.reset(); provider.reset();
@@ -131,7 +129,7 @@ void QMimeDatabasePrivate::loadProviders()
} }
#endif #endif
if (!provider) { if (!provider) {
provider.reset(new QMimeXMLProvider(this, mimeDir)); provider.reset(new MimeXMLProvider(this, mimeDir));
//qDebug() << "Created XML provider for" << mimeDir; //qDebug() << "Created XML provider for" << mimeDir;
} }
m_providers.push_back(std::move(provider)); m_providers.push_back(std::move(provider));
@@ -139,7 +137,7 @@ void QMimeDatabasePrivate::loadProviders()
auto provider = std::move(*it); // take provider out of the vector auto provider = std::move(*it); // take provider out of the vector
provider->ensureLoaded(); provider->ensureLoaded();
if (!provider->isValid()) { if (!provider->isValid()) {
provider.reset(new QMimeXMLProvider(this, mimeDir)); provider.reset(new MimeXMLProvider(this, mimeDir));
//qDebug() << "Created XML provider to replace binary provider for" << mimeDir; //qDebug() << "Created XML provider to replace binary provider for" << mimeDir;
} }
m_providers.push_back(std::move(provider)); m_providers.push_back(std::move(provider));
@@ -149,20 +147,20 @@ void QMimeDatabasePrivate::loadProviders()
// so the internal XML DB goes at the end // so the internal XML DB goes at the end
if (needInternalDB) { if (needInternalDB) {
// Check if we already have a provider for the InternalDatabase // Check if we already have a provider for the InternalDatabase
const auto isInternal = [](const std::unique_ptr<QMimeProviderBase> &prov) const auto isInternal = [](const std::unique_ptr<MimeProviderBase> &prov)
{ {
return prov && prov->isInternalDatabase(); return prov && prov->isInternalDatabase();
}; };
const auto it = std::find_if(currentProviders.begin(), currentProviders.end(), isInternal); const auto it = std::find_if(currentProviders.begin(), currentProviders.end(), isInternal);
if (it == currentProviders.end()) { if (it == currentProviders.end()) {
m_providers.push_back(Providers::value_type(new QMimeXMLProvider(this, QMimeXMLProvider::InternalDatabase))); m_providers.push_back(Providers::value_type(new MimeXMLProvider(this, MimeXMLProvider::InternalDatabase)));
} else { } else {
m_providers.push_back(std::move(*it)); m_providers.push_back(std::move(*it));
} }
} }
} }
const QMimeDatabasePrivate::Providers &QMimeDatabasePrivate::providers() const MimeDatabasePrivate::Providers &MimeDatabasePrivate::providers()
{ {
#ifndef Q_OS_WASM // stub implementation always returns true #ifndef Q_OS_WASM // stub implementation always returns true
Q_ASSERT(!mutex.tryLock()); // caller should have locked mutex Q_ASSERT(!mutex.tryLock()); // caller should have locked mutex
@@ -177,7 +175,7 @@ const QMimeDatabasePrivate::Providers &QMimeDatabasePrivate::providers()
return m_providers; return m_providers;
} }
QString QMimeDatabasePrivate::resolveAlias(const QString &nameOrAlias) QString MimeDatabasePrivate::resolveAlias(const QString &nameOrAlias)
{ {
for (const auto &provider : providers()) { for (const auto &provider : providers()) {
const QString ret = provider->resolveAlias(nameOrAlias); const QString ret = provider->resolveAlias(nameOrAlias);
@@ -191,38 +189,38 @@ QString QMimeDatabasePrivate::resolveAlias(const QString &nameOrAlias)
\internal \internal
Returns a MIME type or an invalid one if none found Returns a MIME type or an invalid one if none found
*/ */
QMimeType QMimeDatabasePrivate::mimeTypeForName(const QString &nameOrAlias) MimeType MimeDatabasePrivate::mimeTypeForName(const QString &nameOrAlias)
{ {
const QString mimeName = resolveAlias(nameOrAlias); const QString mimeName = resolveAlias(nameOrAlias);
for (const auto &provider : providers()) { for (const auto &provider : providers()) {
const QMimeType mime = provider->mimeTypeForName(mimeName); const MimeType mime = provider->mimeTypeForName(mimeName);
if (mime.isValid()) if (mime.isValid())
return mime; return mime;
} }
return {}; return {};
} }
QStringList QMimeDatabasePrivate::mimeTypeForFileName(const QString &fileName) QStringList MimeDatabasePrivate::mimeTypeForFileName(const QString &fileName)
{ {
if (fileName.endsWith(QLatin1Char('/'))) if (fileName.endsWith(QLatin1Char('/')))
return QStringList() << QLatin1String("inode/directory"); return QStringList() << QLatin1String("inode/directory");
const QMimeGlobMatchResult result = findByFileName(fileName); const MimeGlobMatchResult result = findByFileName(fileName);
QStringList matchingMimeTypes = result.m_matchingMimeTypes; QStringList matchingMimeTypes = result.m_matchingMimeTypes;
matchingMimeTypes.sort(); // make it deterministic matchingMimeTypes.sort(); // make it deterministic
return matchingMimeTypes; return matchingMimeTypes;
} }
QMimeGlobMatchResult QMimeDatabasePrivate::findByFileName(const QString &fileName) MimeGlobMatchResult MimeDatabasePrivate::findByFileName(const QString &fileName)
{ {
QMimeGlobMatchResult result; MimeGlobMatchResult result;
const QString fileNameExcludingPath = QFileSystemEntry(fileName).fileName(); const QString fileNameExcludingPath = QFileInfo(fileName).fileName();
for (const auto &provider : providers()) for (const auto &provider : providers())
provider->addFileNameMatches(fileNameExcludingPath, result); provider->addFileNameMatches(fileNameExcludingPath, result);
return result; return result;
} }
void QMimeDatabasePrivate::loadMimeTypePrivate(QMimeTypePrivate &mimePrivate) void MimeDatabasePrivate::loadMimeTypePrivate(MimeTypePrivate &mimePrivate)
{ {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
if (mimePrivate.name.isEmpty()) if (mimePrivate.name.isEmpty())
@@ -246,7 +244,7 @@ void QMimeDatabasePrivate::loadMimeTypePrivate(QMimeTypePrivate &mimePrivate)
} }
} }
void QMimeDatabasePrivate::loadGenericIcon(QMimeTypePrivate &mimePrivate) void MimeDatabasePrivate::loadGenericIcon(MimeTypePrivate &mimePrivate)
{ {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
if (mimePrivate.fromCache) { if (mimePrivate.fromCache) {
@@ -259,7 +257,7 @@ void QMimeDatabasePrivate::loadGenericIcon(QMimeTypePrivate &mimePrivate)
} }
} }
void QMimeDatabasePrivate::loadIcon(QMimeTypePrivate &mimePrivate) void MimeDatabasePrivate::loadIcon(MimeTypePrivate &mimePrivate)
{ {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
if (mimePrivate.fromCache) { if (mimePrivate.fromCache) {
@@ -288,13 +286,13 @@ static QString fallbackParent(const QString &mimeTypeName)
return QString(); return QString();
} }
QStringList QMimeDatabasePrivate::mimeParents(const QString &mimeName) QStringList MimeDatabasePrivate::mimeParents(const QString &mimeName)
{ {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
return parents(mimeName); return parents(mimeName);
} }
QStringList QMimeDatabasePrivate::parents(const QString &mimeName) QStringList MimeDatabasePrivate::parents(const QString &mimeName)
{ {
Q_ASSERT(!mutex.tryLock()); Q_ASSERT(!mutex.tryLock());
QStringList result; QStringList result;
@@ -308,7 +306,7 @@ QStringList QMimeDatabasePrivate::parents(const QString &mimeName)
return result; return result;
} }
QStringList QMimeDatabasePrivate::listAliases(const QString &mimeName) QStringList MimeDatabasePrivate::listAliases(const QString &mimeName)
{ {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
QStringList result; QStringList result;
@@ -317,7 +315,7 @@ QStringList QMimeDatabasePrivate::listAliases(const QString &mimeName)
return result; return result;
} }
bool QMimeDatabasePrivate::mimeInherits(const QString &mime, const QString &parent) bool MimeDatabasePrivate::mimeInherits(const QString &mime, const QString &parent)
{ {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
return inherits(mime, parent); return inherits(mime, parent);
@@ -342,7 +340,7 @@ static inline bool isTextFile(const QByteArray &data)
return true; return true;
} }
QMimeType QMimeDatabasePrivate::findByData(const QByteArray &data, int *accuracyPtr) MimeType MimeDatabasePrivate::findByData(const QByteArray &data, int *accuracyPtr)
{ {
if (data.isEmpty()) { if (data.isEmpty()) {
*accuracyPtr = 100; *accuracyPtr = 100;
@@ -350,7 +348,7 @@ QMimeType QMimeDatabasePrivate::findByData(const QByteArray &data, int *accuracy
} }
*accuracyPtr = 0; *accuracyPtr = 0;
QMimeType candidate; MimeType candidate;
for (const auto &provider : providers()) for (const auto &provider : providers())
provider->findByMagic(data, accuracyPtr, candidate); provider->findByMagic(data, accuracyPtr, candidate);
@@ -365,7 +363,7 @@ QMimeType QMimeDatabasePrivate::findByData(const QByteArray &data, int *accuracy
return mimeTypeForName(defaultMimeType()); return mimeTypeForName(defaultMimeType());
} }
QMimeType QMimeDatabasePrivate::mimeTypeForFileNameAndData(const QString &fileName, QIODevice *device, int *accuracyPtr) MimeType MimeDatabasePrivate::mimeTypeForFileNameAndData(const QString &fileName, QIODevice *device, int *accuracyPtr)
{ {
// First, glob patterns are evaluated. If there is a match with max weight, // First, glob patterns are evaluated. If there is a match with max weight,
// this one is selected and we are done. Otherwise, the file contents are // this one is selected and we are done. Otherwise, the file contents are
@@ -375,10 +373,10 @@ QMimeType QMimeDatabasePrivate::mimeTypeForFileNameAndData(const QString &fileNa
*accuracyPtr = 0; *accuracyPtr = 0;
// Pass 1) Try to match on the file name // Pass 1) Try to match on the file name
QMimeGlobMatchResult candidatesByName = findByFileName(fileName); MimeGlobMatchResult candidatesByName = findByFileName(fileName);
if (candidatesByName.m_allMatchingMimeTypes.count() == 1) { if (candidatesByName.m_allMatchingMimeTypes.count() == 1) {
*accuracyPtr = 100; *accuracyPtr = 100;
const QMimeType mime = mimeTypeForName(candidatesByName.m_matchingMimeTypes.at(0)); const MimeType mime = mimeTypeForName(candidatesByName.m_matchingMimeTypes.at(0));
if (mime.isValid()) if (mime.isValid())
return mime; return mime;
candidatesByName = {}; candidatesByName = {};
@@ -393,7 +391,7 @@ QMimeType QMimeDatabasePrivate::mimeTypeForFileNameAndData(const QString &fileNa
const QByteArray data = device->peek(16384); const QByteArray data = device->peek(16384);
int magicAccuracy = 0; int magicAccuracy = 0;
QMimeType candidateByData(findByData(data, &magicAccuracy)); MimeType candidateByData(findByData(data, &magicAccuracy));
// Disambiguate conflicting extensions (if magic matching found something) // Disambiguate conflicting extensions (if magic matching found something)
if (candidateByData.isValid() && magicAccuracy > 0) { if (candidateByData.isValid() && magicAccuracy > 0) {
@@ -421,7 +419,7 @@ QMimeType QMimeDatabasePrivate::mimeTypeForFileNameAndData(const QString &fileNa
if (candidatesByName.m_allMatchingMimeTypes.count() > 1) { if (candidatesByName.m_allMatchingMimeTypes.count() > 1) {
candidatesByName.m_matchingMimeTypes.sort(); // make it deterministic candidatesByName.m_matchingMimeTypes.sort(); // make it deterministic
*accuracyPtr = 20; *accuracyPtr = 20;
const QMimeType mime = mimeTypeForName(candidatesByName.m_matchingMimeTypes.at(0)); const MimeType mime = mimeTypeForName(candidatesByName.m_matchingMimeTypes.at(0));
if (mime.isValid()) if (mime.isValid())
return mime; return mime;
} }
@@ -437,15 +435,15 @@ QMimeType QMimeDatabasePrivate::mimeTypeForFileNameAndData(const QString &fileNa
return matchOnContent(&fallbackFile); return matchOnContent(&fallbackFile);
} }
QList<QMimeType> QMimeDatabasePrivate::allMimeTypes() QList<MimeType> MimeDatabasePrivate::allMimeTypes()
{ {
QList<QMimeType> result; QList<MimeType> result;
for (const auto &provider : providers()) for (const auto &provider : providers())
provider->addAllMimeTypes(result); provider->addAllMimeTypes(result);
return result; return result;
} }
bool QMimeDatabasePrivate::inherits(const QString &mime, const QString &parent) bool MimeDatabasePrivate::inherits(const QString &mime, const QString &parent)
{ {
const QString resolvedParent = resolveAlias(parent); const QString resolvedParent = resolveAlias(parent);
std::stack<QString, QStringList> toCheck; std::stack<QString, QStringList> toCheck;
@@ -463,9 +461,9 @@ bool QMimeDatabasePrivate::inherits(const QString &mime, const QString &parent)
} }
/*! /*!
\class QMimeDatabase \class MimeDatabase
\inmodule QtCore \inmodule QtCore
\brief The QMimeDatabase class maintains a database of MIME types. \brief The MimeDatabase class maintains a database of MIME types.
\since 5.0 \since 5.0
@@ -476,14 +474,14 @@ bool QMimeDatabasePrivate::inherits(const QString &mime, const QString &parent)
Applications which want to define custom MIME types need to install an Applications which want to define custom MIME types need to install an
XML file into the locations searched for MIME definitions. XML file into the locations searched for MIME definitions.
These locations can be queried with These locations can be queried with
\snippet code/src_corelib_mimetype_qmimedatabase.cpp 1 \snippet code/src_corelib_mimetype_mimedatabase.cpp 1
On a typical Unix system, this will be /usr/share/mime/packages/, but it is also On a typical Unix system, this will be /usr/share/mime/packages/, but it is also
possible to extend the list of directories by setting the environment variable possible to extend the list of directories by setting the environment variable
\c XDG_DATA_DIRS. For instance adding /opt/myapp/share to \c XDG_DATA_DIRS will result \c XDG_DATA_DIRS. For instance adding /opt/myapp/share to \c XDG_DATA_DIRS will result
in /opt/myapp/share/mime/packages/ being searched for MIME definitions. in /opt/myapp/share/mime/packages/ being searched for MIME definitions.
Here is an example of MIME XML: Here is an example of MIME XML:
\snippet code/src_corelib_mimetype_qmimedatabase.cpp 2 \snippet code/src_corelib_mimetype_mimedatabase.cpp 2
For more details about the syntax of XML MIME definitions, including defining For more details about the syntax of XML MIME definitions, including defining
"magic" in order to detect MIME types based on data as well, read the "magic" in order to detect MIME types based on data as well, read the
@@ -497,39 +495,39 @@ bool QMimeDatabasePrivate::inherits(const QString &mime, const QString &parent)
\threadsafe \threadsafe
\snippet code/src_corelib_mimetype_qmimedatabase.cpp 0 \snippet code/src_corelib_mimetype_mimedatabase.cpp 0
\sa QMimeType, {MIME Type Browser Example} \sa MimeType, {MIME Type Browser Example}
*/ */
/*! /*!
\fn QMimeDatabase::QMimeDatabase(); \fn MimeDatabase::MimeDatabase();
Constructs a QMimeDatabase object. Constructs a MimeDatabase object.
It is perfectly OK to create an instance of QMimeDatabase every time you need to It is perfectly OK to create an instance of MimeDatabase every time you need to
perform a lookup. perform a lookup.
The parsing of mimetypes is done on demand (when shared-mime-info is installed) The parsing of mimetypes is done on demand (when shared-mime-info is installed)
or when the very first instance is constructed (when parsing XML files directly). or when the very first instance is constructed (when parsing XML files directly).
*/ */
QMimeDatabase::QMimeDatabase() : MimeDatabase::MimeDatabase() :
d(staticQMimeDatabase()) d(staticMimeDatabase())
{ {
} }
/*! /*!
\fn QMimeDatabase::~QMimeDatabase(); \fn MimeDatabase::~MimeDatabase();
Destroys the QMimeDatabase object. Destroys the MimeDatabase object.
*/ */
QMimeDatabase::~QMimeDatabase() MimeDatabase::~MimeDatabase()
{ {
d = nullptr; d = nullptr;
} }
/*! /*!
\fn QMimeType QMimeDatabase::mimeTypeForName(const QString &nameOrAlias) const; \fn MimeType MimeDatabase::mimeTypeForName(const QString &nameOrAlias) const;
Returns a MIME type for \a nameOrAlias or an invalid one if none found. Returns a MIME type for \a nameOrAlias or an invalid one if none found.
*/ */
QMimeType QMimeDatabase::mimeTypeForName(const QString &nameOrAlias) const MimeType MimeDatabase::mimeTypeForName(const QString &nameOrAlias) const
{ {
QMutexLocker locker(&d->mutex); QMutexLocker locker(&d->mutex);
@@ -562,9 +560,9 @@ QMimeType QMimeDatabase::mimeTypeForName(const QString &nameOrAlias) const
\a fileInfo may refer to an absolute or relative path. \a fileInfo may refer to an absolute or relative path.
\sa QMimeType::isDefault(), mimeTypeForData() \sa MimeType::isDefault(), mimeTypeForData()
*/ */
QMimeType QMimeDatabase::mimeTypeForFile(const QFileInfo &fileInfo, MatchMode mode) const MimeType MimeDatabase::mimeTypeForFile(const QFileInfo &fileInfo, MatchMode mode) const
{ {
QMutexLocker locker(&d->mutex); QMutexLocker locker(&d->mutex);
@@ -617,7 +615,7 @@ QMimeType QMimeDatabase::mimeTypeForFile(const QFileInfo &fileInfo, MatchMode mo
\overload \overload
*/ */
QMimeType QMimeDatabase::mimeTypeForFile(const QString &fileName, MatchMode mode) const MimeType MimeDatabase::mimeTypeForFile(const QString &fileName, MatchMode mode) const
{ {
if (mode == MatchExtension) { if (mode == MatchExtension) {
QMutexLocker locker(&d->mutex); QMutexLocker locker(&d->mutex);
@@ -650,12 +648,12 @@ QMimeType QMimeDatabase::mimeTypeForFile(const QString &fileName, MatchMode mode
\sa mimeTypeForFile() \sa mimeTypeForFile()
*/ */
QList<QMimeType> QMimeDatabase::mimeTypesForFileName(const QString &fileName) const QList<MimeType> MimeDatabase::mimeTypesForFileName(const QString &fileName) const
{ {
QMutexLocker locker(&d->mutex); QMutexLocker locker(&d->mutex);
const QStringList matches = d->mimeTypeForFileName(fileName); const QStringList matches = d->mimeTypeForFileName(fileName);
QList<QMimeType> mimes; QList<MimeType> mimes;
mimes.reserve(matches.count()); mimes.reserve(matches.count());
for (const QString &mime : matches) for (const QString &mime : matches)
mimes.append(d->mimeTypeForName(mime)); mimes.append(d->mimeTypeForName(mime));
@@ -667,7 +665,7 @@ QList<QMimeType> QMimeDatabase::mimeTypesForFileName(const QString &fileName) co
This allows to pre-select "tar.bz2" for foo.tar.bz2, but still only This allows to pre-select "tar.bz2" for foo.tar.bz2, but still only
"txt" for my.file.with.dots.txt. "txt" for my.file.with.dots.txt.
*/ */
QString QMimeDatabase::suffixForFileName(const QString &fileName) const QString MimeDatabase::suffixForFileName(const QString &fileName) const
{ {
QMutexLocker locker(&d->mutex); QMutexLocker locker(&d->mutex);
const int suffixLength = d->findByFileName(fileName).m_knownSuffixLength; const int suffixLength = d->findByFileName(fileName).m_knownSuffixLength;
@@ -681,7 +679,7 @@ QString QMimeDatabase::suffixForFileName(const QString &fileName) const
known MIME type data, the default MIME type (application/octet-stream) known MIME type data, the default MIME type (application/octet-stream)
is returned. is returned.
*/ */
QMimeType QMimeDatabase::mimeTypeForData(const QByteArray &data) const MimeType MimeDatabase::mimeTypeForData(const QByteArray &data) const
{ {
QMutexLocker locker(&d->mutex); QMutexLocker locker(&d->mutex);
@@ -696,7 +694,7 @@ QMimeType QMimeDatabase::mimeTypeForData(const QByteArray &data) const
known MIME type data, the default MIME type (application/octet-stream) known MIME type data, the default MIME type (application/octet-stream)
is returned. is returned.
*/ */
QMimeType QMimeDatabase::mimeTypeForData(QIODevice *device) const MimeType MimeDatabase::mimeTypeForData(QIODevice *device) const
{ {
QMutexLocker locker(&d->mutex); QMutexLocker locker(&d->mutex);
@@ -706,7 +704,7 @@ QMimeType QMimeDatabase::mimeTypeForData(QIODevice *device) const
// Read 16K in one go (QIODEVICE_BUFFERSIZE in qiodevice_p.h). // Read 16K in one go (QIODEVICE_BUFFERSIZE in qiodevice_p.h).
// This is much faster than seeking back and forth into QIODevice. // This is much faster than seeking back and forth into QIODevice.
const QByteArray data = device->peek(16384); const QByteArray data = device->peek(16384);
const QMimeType result = d->findByData(data, &accuracy); const MimeType result = d->findByData(data, &accuracy);
if (openedByUs) if (openedByUs)
device->close(); device->close();
return result; return result;
@@ -728,7 +726,7 @@ QMimeType QMimeDatabase::mimeTypeForData(QIODevice *device) const
known MIME type data, the default MIME type (application/octet-stream) known MIME type data, the default MIME type (application/octet-stream)
is returned. is returned.
*/ */
QMimeType QMimeDatabase::mimeTypeForUrl(const QUrl &url) const MimeType MimeDatabase::mimeTypeForUrl(const QUrl &url) const
{ {
if (url.isLocalFile()) if (url.isLocalFile())
return mimeTypeForFile(url.toLocalFile()); return mimeTypeForFile(url.toLocalFile());
@@ -759,7 +757,7 @@ QMimeType QMimeDatabase::mimeTypeForUrl(const QUrl &url) const
but the contents will be used if the file extension is unknown, or but the contents will be used if the file extension is unknown, or
matches multiple MIME types. matches multiple MIME types.
*/ */
QMimeType QMimeDatabase::mimeTypeForFileNameAndData(const QString &fileName, QIODevice *device) const MimeType MimeDatabase::mimeTypeForFileNameAndData(const QString &fileName, QIODevice *device) const
{ {
QMutexLocker locker(&d->mutex); QMutexLocker locker(&d->mutex);
@@ -768,7 +766,7 @@ QMimeType QMimeDatabase::mimeTypeForFileNameAndData(const QString &fileName, QIO
int accuracy = 0; int accuracy = 0;
const bool openedByUs = !device->isOpen() && device->open(QIODevice::ReadOnly); const bool openedByUs = !device->isOpen() && device->open(QIODevice::ReadOnly);
const QMimeType result = d->mimeTypeForFileNameAndData(fileName, device, &accuracy); const MimeType result = d->mimeTypeForFileNameAndData(fileName, device, &accuracy);
if (openedByUs) if (openedByUs)
device->close(); device->close();
return result; return result;
@@ -790,7 +788,7 @@ QMimeType QMimeDatabase::mimeTypeForFileNameAndData(const QString &fileName, QIO
but the contents will be used if the file extension is unknown, or but the contents will be used if the file extension is unknown, or
matches multiple MIME types. matches multiple MIME types.
*/ */
QMimeType QMimeDatabase::mimeTypeForFileNameAndData(const QString &fileName, const QByteArray &data) const MimeType MimeDatabase::mimeTypeForFileNameAndData(const QString &fileName, const QByteArray &data) const
{ {
QMutexLocker locker(&d->mutex); QMutexLocker locker(&d->mutex);
@@ -810,7 +808,7 @@ QMimeType QMimeDatabase::mimeTypeForFileNameAndData(const QString &fileName, con
in a MIME type editor. Do not use unless really necessary in other cases in a MIME type editor. Do not use unless really necessary in other cases
though, prefer using the \l {mimeTypeForData()}{mimeTypeForXxx()} methods for performance reasons. though, prefer using the \l {mimeTypeForData()}{mimeTypeForXxx()} methods for performance reasons.
*/ */
QList<QMimeType> QMimeDatabase::allMimeTypes() const QList<MimeType> MimeDatabase::allMimeTypes() const
{ {
QMutexLocker locker(&d->mutex); QMutexLocker locker(&d->mutex);
@@ -818,7 +816,7 @@ QList<QMimeType> QMimeDatabase::allMimeTypes() const
} }
/*! /*!
\enum QMimeDatabase::MatchMode \enum MimeDatabase::MatchMode
This enum specifies how matching a file to a MIME type is performed. This enum specifies how matching a file to a MIME type is performed.
@@ -829,4 +827,4 @@ QList<QMimeType> QMimeDatabase::allMimeTypes() const
\value MatchContent The file content is used to look for a match \value MatchContent The file content is used to look for a match
*/ */
QT_END_NAMESPACE } // namespace Utils

47
src/libs/utils/mimetypes2/mimedatabase.h
View File

@@ -38,32 +38,33 @@
** **
****************************************************************************/ ****************************************************************************/
#ifndef QMIMEDATABASE_H #pragma once
#define QMIMEDATABASE_H
#include <QtCore/qmimetype.h> #include "mimetype.h"
QT_REQUIRE_CONFIG(mimetype); #include <utils/utils_global.h>
#include <QtCore/qstringlist.h> #include <QtCore/qstringlist.h>
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
class QByteArray; class QByteArray;
class QFileInfo; class QFileInfo;
class QIODevice; class QIODevice;
class QUrl; class QUrl;
QT_END_NAMESPACE
class QMimeDatabasePrivate; namespace Utils {
class Q_CORE_EXPORT QMimeDatabase
class MimeDatabasePrivate;
class QTCREATOR_UTILS_EXPORT MimeDatabase
{ {
Q_DISABLE_COPY(QMimeDatabase) Q_DISABLE_COPY(MimeDatabase)
public: public:
QMimeDatabase(); MimeDatabase();
~QMimeDatabase(); ~MimeDatabase();
QMimeType mimeTypeForName(const QString &nameOrAlias) const; MimeType mimeTypeForName(const QString &nameOrAlias) const;
enum MatchMode { enum MatchMode {
MatchDefault = 0x0, MatchDefault = 0x0,
@@ -71,25 +72,23 @@ public:
MatchContent = 0x2 MatchContent = 0x2
}; };
QMimeType mimeTypeForFile(const QString &fileName, MatchMode mode = MatchDefault) const; MimeType mimeTypeForFile(const QString &fileName, MatchMode mode = MatchDefault) const;
QMimeType mimeTypeForFile(const QFileInfo &fileInfo, MatchMode mode = MatchDefault) const; MimeType mimeTypeForFile(const QFileInfo &fileInfo, MatchMode mode = MatchDefault) const;
QList<QMimeType> mimeTypesForFileName(const QString &fileName) const; QList<MimeType> mimeTypesForFileName(const QString &fileName) const;
QMimeType mimeTypeForData(const QByteArray &data) const; MimeType mimeTypeForData(const QByteArray &data) const;
QMimeType mimeTypeForData(QIODevice *device) const; MimeType mimeTypeForData(QIODevice *device) const;
QMimeType mimeTypeForUrl(const QUrl &url) const; MimeType mimeTypeForUrl(const QUrl &url) const;
QMimeType mimeTypeForFileNameAndData(const QString &fileName, QIODevice *device) const; MimeType mimeTypeForFileNameAndData(const QString &fileName, QIODevice *device) const;
QMimeType mimeTypeForFileNameAndData(const QString &fileName, const QByteArray &data) const; MimeType mimeTypeForFileNameAndData(const QString &fileName, const QByteArray &data) const;
QString suffixForFileName(const QString &fileName) const; QString suffixForFileName(const QString &fileName) const;
QList<QMimeType> allMimeTypes() const; QList<MimeType> allMimeTypes() const;
private: private:
QMimeDatabasePrivate *d; MimeDatabasePrivate *d;
}; };
QT_END_NAMESPACE } // namespace Utils
#endif // QMIMEDATABASE_H

54
src/libs/utils/mimetypes2/mimedatabase_p.h
View File

@@ -38,8 +38,7 @@
** **
****************************************************************************/ ****************************************************************************/
#ifndef QMIMEDATABASE_P_H #pragma once
#define QMIMEDATABASE_P_H
// //
// W A R N I N G // W A R N I N G
@@ -52,12 +51,10 @@
// We mean it. // We mean it.
// //
#include "qmimetype.h" #include "mimetype.h"
QT_REQUIRE_CONFIG(mimetype); #include "mimeglobpattern_p.h"
#include "mimetype_p.h"
#include "qmimetype_p.h"
#include "qmimeglobpattern_p.h"
#include <QtCore/qelapsedtimer.h> #include <QtCore/qelapsedtimer.h>
#include <QtCore/qlist.h> #include <QtCore/qlist.h>
@@ -67,45 +64,48 @@ QT_REQUIRE_CONFIG(mimetype);
#include <memory> #include <memory>
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
class QIODevice; class QIODevice;
class QMimeDatabase; QT_END_NAMESPACE
class QMimeProviderBase;
class QMimeDatabasePrivate namespace Utils {
class MimeDatabase;
class MimeProviderBase;
class MimeDatabasePrivate
{ {
public: public:
Q_DISABLE_COPY_MOVE(QMimeDatabasePrivate) Q_DISABLE_COPY_MOVE(MimeDatabasePrivate)
QMimeDatabasePrivate(); MimeDatabasePrivate();
~QMimeDatabasePrivate(); ~MimeDatabasePrivate();
static QMimeDatabasePrivate *instance(); static MimeDatabasePrivate *instance();
inline QString defaultMimeType() const { return m_defaultMimeType; } inline QString defaultMimeType() const { return m_defaultMimeType; }
bool inherits(const QString &mime, const QString &parent); bool inherits(const QString &mime, const QString &parent);
QList<QMimeType> allMimeTypes(); QList<MimeType> allMimeTypes();
QString resolveAlias(const QString &nameOrAlias); QString resolveAlias(const QString &nameOrAlias);
QStringList parents(const QString &mimeName); QStringList parents(const QString &mimeName);
QMimeType mimeTypeForName(const QString &nameOrAlias); MimeType mimeTypeForName(const QString &nameOrAlias);
QMimeType mimeTypeForFileNameAndData(const QString &fileName, QIODevice *device, int *priorityPtr); MimeType mimeTypeForFileNameAndData(const QString &fileName, QIODevice *device, int *priorityPtr);
QMimeType findByData(const QByteArray &data, int *priorityPtr); MimeType findByData(const QByteArray &data, int *priorityPtr);
QStringList mimeTypeForFileName(const QString &fileName); QStringList mimeTypeForFileName(const QString &fileName);
QMimeGlobMatchResult findByFileName(const QString &fileName); MimeGlobMatchResult findByFileName(const QString &fileName);
// API for QMimeType. Takes care of locking the mutex. // API for MimeType. Takes care of locking the mutex.
void loadMimeTypePrivate(QMimeTypePrivate &mimePrivate); void loadMimeTypePrivate(MimeTypePrivate &mimePrivate);
void loadGenericIcon(QMimeTypePrivate &mimePrivate); void loadGenericIcon(MimeTypePrivate &mimePrivate);
void loadIcon(QMimeTypePrivate &mimePrivate); void loadIcon(MimeTypePrivate &mimePrivate);
QStringList mimeParents(const QString &mimeName); QStringList mimeParents(const QString &mimeName);
QStringList listAliases(const QString &mimeName); QStringList listAliases(const QString &mimeName);
bool mimeInherits(const QString &mime, const QString &parent); bool mimeInherits(const QString &mime, const QString &parent);
private: private:
using Providers = std::vector<std::unique_ptr<QMimeProviderBase>>; using Providers = std::vector<std::unique_ptr<MimeProviderBase>>;
const Providers &providers(); const Providers &providers();
bool shouldCheck(); bool shouldCheck();
void loadProviders(); void loadProviders();
@@ -118,6 +118,4 @@ public:
QMutex mutex; QMutex mutex;
}; };
QT_END_NAMESPACE } // namespace Utils
#endif // QMIMEDATABASE_P_H

38
src/libs/utils/mimetypes2/mimeglobpattern.cpp
View File

@@ -37,7 +37,7 @@
** **
****************************************************************************/ ****************************************************************************/
#include "qmimeglobpattern_p.h" #include "mimeglobpattern_p.h"
#if QT_CONFIG(regularexpression) #if QT_CONFIG(regularexpression)
#include <QRegularExpression> #include <QRegularExpression>
@@ -45,18 +45,18 @@
#include <QStringList> #include <QStringList>
#include <QDebug> #include <QDebug>
QT_BEGIN_NAMESPACE namespace Utils {
/*! /*!
\internal \internal
\class QMimeGlobMatchResult \class MimeGlobMatchResult
\inmodule QtCore \inmodule QtCore
\brief The QMimeGlobMatchResult class accumulates results from glob matching. \brief The MimeGlobMatchResult class accumulates results from glob matching.
Handles glob weights, and preferring longer matches over shorter matches. Handles glob weights, and preferring longer matches over shorter matches.
*/ */
void QMimeGlobMatchResult::addMatch(const QString &mimeType, int weight, const QString &pattern, int knownSuffixLength) void MimeGlobMatchResult::addMatch(const QString &mimeType, int weight, const QString &pattern, int knownSuffixLength)
{ {
if (m_allMatchingMimeTypes.contains(mimeType)) if (m_allMatchingMimeTypes.contains(mimeType))
return; return;
@@ -91,7 +91,7 @@ void QMimeGlobMatchResult::addMatch(const QString &mimeType, int weight, const Q
} }
} }
QMimeGlobPattern::PatternType QMimeGlobPattern::detectPatternType(const QString &pattern) const MimeGlobPattern::PatternType MimeGlobPattern::detectPatternType(const QString &pattern) const
{ {
const int patternLength = pattern.length(); const int patternLength = pattern.length();
if (!patternLength) if (!patternLength)
@@ -127,14 +127,14 @@ QMimeGlobPattern::PatternType QMimeGlobPattern::detectPatternType(const QString
/*! /*!
\internal \internal
\class QMimeGlobPattern \class MimeGlobPattern
\inmodule QtCore \inmodule QtCore
\brief The QMimeGlobPattern class contains the glob pattern for file names for MIME type matching. \brief The MimeGlobPattern class contains the glob pattern for file names for MIME type matching.
\sa QMimeType, QMimeDatabase, QMimeMagicRuleMatcher, QMimeMagicRule \sa MimeType, MimeDatabase, MimeMagicRuleMatcher, MimeMagicRule
*/ */
bool QMimeGlobPattern::matchFileName(const QString &inputFileName) const bool MimeGlobPattern::matchFileName(const QString &inputFileName) const
{ {
// "Applications MUST match globs case-insensitively, except when the case-sensitive // "Applications MUST match globs case-insensitively, except when the case-sensitive
// attribute is set to true." // attribute is set to true."
@@ -219,7 +219,7 @@ static bool isFastPattern(const QString &pattern)
; ;
} }
void QMimeAllGlobPatterns::addGlob(const QMimeGlobPattern &glob) void MimeAllGlobPatterns::addGlob(const MimeGlobPattern &glob)
{ {
const QString &pattern = glob.pattern(); const QString &pattern = glob.pattern();
Q_ASSERT(!pattern.isEmpty()); Q_ASSERT(!pattern.isEmpty());
@@ -245,7 +245,7 @@ void QMimeAllGlobPatterns::addGlob(const QMimeGlobPattern &glob)
} }
} }
void QMimeAllGlobPatterns::removeMimeType(const QString &mimeType) void MimeAllGlobPatterns::removeMimeType(const QString &mimeType)
{ {
for (auto &x : m_fastPatterns) for (auto &x : m_fastPatterns)
x.removeAll(mimeType); x.removeAll(mimeType);
@@ -253,14 +253,14 @@ void QMimeAllGlobPatterns::removeMimeType(const QString &mimeType)
m_lowWeightGlobs.removeMimeType(mimeType); m_lowWeightGlobs.removeMimeType(mimeType);
} }
void QMimeGlobPatternList::match(QMimeGlobMatchResult &result, void MimeGlobPatternList::match(MimeGlobMatchResult &result,
const QString &fileName) const const QString &fileName) const
{ {
QMimeGlobPatternList::const_iterator it = this->constBegin(); MimeGlobPatternList::const_iterator it = this->constBegin();
const QMimeGlobPatternList::const_iterator endIt = this->constEnd(); const MimeGlobPatternList::const_iterator endIt = this->constEnd();
for (; it != endIt; ++it) { for (; it != endIt; ++it) {
const QMimeGlobPattern &glob = *it; const MimeGlobPattern &glob = *it;
if (glob.matchFileName(fileName)) { if (glob.matchFileName(fileName)) {
const QString pattern = glob.pattern(); const QString pattern = glob.pattern();
const int suffixLen = isSimplePattern(pattern) ? pattern.length() - 2 : 0; const int suffixLen = isSimplePattern(pattern) ? pattern.length() - 2 : 0;
@@ -269,7 +269,7 @@ void QMimeGlobPatternList::match(QMimeGlobMatchResult &result,
} }
} }
void QMimeAllGlobPatterns::matchingGlobs(const QString &fileName, QMimeGlobMatchResult &result) const void MimeAllGlobPatterns::matchingGlobs(const QString &fileName, MimeGlobMatchResult &result) const
{ {
// First try the high weight matches (>50), if any. // First try the high weight matches (>50), if any.
m_highWeightGlobs.match(result, fileName); m_highWeightGlobs.match(result, fileName);
@@ -294,11 +294,11 @@ void QMimeAllGlobPatterns::matchingGlobs(const QString &fileName, QMimeGlobMatch
m_lowWeightGlobs.match(result, fileName); m_lowWeightGlobs.match(result, fileName);
} }
void QMimeAllGlobPatterns::clear() void MimeAllGlobPatterns::clear()
{ {
m_fastPatterns.clear(); m_fastPatterns.clear();
m_highWeightGlobs.clear(); m_highWeightGlobs.clear();
m_lowWeightGlobs.clear(); m_lowWeightGlobs.clear();
} }
QT_END_NAMESPACE } // namespace Utils

38
src/libs/utils/mimetypes2/mimeglobpattern_p.h
View File

@@ -37,8 +37,7 @@
** **
****************************************************************************/ ****************************************************************************/
#ifndef QMIMEGLOBPATTERN_P_H #pragma once
#define QMIMEGLOBPATTERN_P_H
// //
// W A R N I N G // W A R N I N G
@@ -51,16 +50,12 @@
// We mean it. // We mean it.
// //
#include <QtCore/private/qglobal_p.h>
QT_REQUIRE_CONFIG(mimetype);
#include <QtCore/qstringlist.h> #include <QtCore/qstringlist.h>
#include <QtCore/qhash.h> #include <QtCore/qhash.h>
QT_BEGIN_NAMESPACE namespace Utils {
struct QMimeGlobMatchResult struct MimeGlobMatchResult
{ {
void addMatch(const QString &mimeType, int weight, const QString &pattern, int knownSuffixLength = 0); void addMatch(const QString &mimeType, int weight, const QString &pattern, int knownSuffixLength = 0);
@@ -71,14 +66,14 @@ struct QMimeGlobMatchResult
int m_knownSuffixLength = 0; int m_knownSuffixLength = 0;
}; };
class QMimeGlobPattern class MimeGlobPattern
{ {
public: public:
static const unsigned MaxWeight = 100; static const unsigned MaxWeight = 100;
static const unsigned DefaultWeight = 50; static const unsigned DefaultWeight = 50;
static const unsigned MinWeight = 1; static const unsigned MinWeight = 1;
explicit QMimeGlobPattern(const QString &thePattern, const QString &theMimeType, unsigned theWeight = DefaultWeight, Qt::CaseSensitivity s = Qt::CaseInsensitive) : explicit MimeGlobPattern(const QString &thePattern, const QString &theMimeType, unsigned theWeight = DefaultWeight, Qt::CaseSensitivity s = Qt::CaseInsensitive) :
m_pattern(s == Qt::CaseInsensitive ? thePattern.toLower() : thePattern), m_pattern(s == Qt::CaseInsensitive ? thePattern.toLower() : thePattern),
m_mimeType(theMimeType), m_mimeType(theMimeType),
m_weight(theWeight), m_weight(theWeight),
@@ -87,7 +82,7 @@ public:
{ {
} }
void swap(QMimeGlobPattern &other) noexcept void swap(MimeGlobPattern &other) noexcept
{ {
qSwap(m_pattern, other.m_pattern); qSwap(m_pattern, other.m_pattern);
qSwap(m_mimeType, other.m_mimeType); qSwap(m_mimeType, other.m_mimeType);
@@ -120,9 +115,8 @@ private:
Qt::CaseSensitivity m_caseSensitivity; Qt::CaseSensitivity m_caseSensitivity;
PatternType m_patternType; PatternType m_patternType;
}; };
Q_DECLARE_SHARED(QMimeGlobPattern)
class QMimeGlobPatternList : public QList<QMimeGlobPattern> class MimeGlobPatternList : public QList<MimeGlobPattern>
{ {
public: public:
bool hasPattern(const QString &mimeType, const QString &pattern) const bool hasPattern(const QString &mimeType, const QString &pattern) const
@@ -140,13 +134,13 @@ public:
*/ */
void removeMimeType(const QString &mimeType) void removeMimeType(const QString &mimeType)
{ {
auto isMimeTypeEqual = [&mimeType](const QMimeGlobPattern &pattern) { auto isMimeTypeEqual = [&mimeType](const MimeGlobPattern &pattern) {
return pattern.mimeType() == mimeType; return pattern.mimeType() == mimeType;
}; };
removeIf(isMimeTypeEqual); removeIf(isMimeTypeEqual);
} }
void match(QMimeGlobMatchResult &result, const QString &fileName) const; void match(MimeGlobMatchResult &result, const QString &fileName) const;
}; };
/*! /*!
@@ -156,21 +150,21 @@ public:
2) a linear list of high-weight globs 2) a linear list of high-weight globs
3) a linear list of low-weight globs 3) a linear list of low-weight globs
*/ */
class QMimeAllGlobPatterns class MimeAllGlobPatterns
{ {
public: public:
typedef QHash<QString, QStringList> PatternsMap; // MIME type -> patterns typedef QHash<QString, QStringList> PatternsMap; // MIME type -> patterns
void addGlob(const QMimeGlobPattern &glob); void addGlob(const MimeGlobPattern &glob);
void removeMimeType(const QString &mimeType); void removeMimeType(const QString &mimeType);
void matchingGlobs(const QString &fileName, QMimeGlobMatchResult &result) const; void matchingGlobs(const QString &fileName, MimeGlobMatchResult &result) const;
void clear(); void clear();
PatternsMap m_fastPatterns; // example: "doc" -> "application/msword", "text/plain" PatternsMap m_fastPatterns; // example: "doc" -> "application/msword", "text/plain"
QMimeGlobPatternList m_highWeightGlobs; MimeGlobPatternList m_highWeightGlobs;
QMimeGlobPatternList m_lowWeightGlobs; // <= 50, including the non-fast 50 patterns MimeGlobPatternList m_lowWeightGlobs; // <= 50, including the non-fast 50 patterns
}; };
QT_END_NAMESPACE } // namespace Utils
#endif // QMIMEGLOBPATTERN_P_H Q_DECLARE_SHARED(Utils::MimeGlobPattern)

47
src/libs/utils/mimetypes2/mimemagicrule.cpp
View File

@@ -37,17 +37,14 @@
** **
****************************************************************************/ ****************************************************************************/
#include "mimemagicrule_p.h"
#define QT_NO_CAST_FROM_ASCII #include "mimetypeparser_p.h"
#include "qmimemagicrule_p.h"
#include "qmimetypeparser_p.h"
#include <QtCore/QList> #include <QtCore/QList>
#include <QtCore/QDebug> #include <QtCore/QDebug>
#include <qendian.h> #include <qendian.h>
QT_BEGIN_NAMESPACE namespace Utils {
// in the same order as Type! // in the same order as Type!
static const char magicRuleTypes_string[] = static const char magicRuleTypes_string[] =
@@ -66,7 +63,7 @@ static const int magicRuleTypes_indices[] = {
0, 8, 15, 22, 29, 35, 41, 50, 59, 64, 0 0, 8, 15, 22, 29, 35, 41, 50, 59, 64, 0
}; };
QMimeMagicRule::Type QMimeMagicRule::type(const QByteArray &theTypeName) MimeMagicRule::Type MimeMagicRule::type(const QByteArray &theTypeName)
{ {
for (int i = String; i <= Byte; ++i) { for (int i = String; i <= Byte; ++i) {
if (theTypeName == magicRuleTypes_string + magicRuleTypes_indices[i]) if (theTypeName == magicRuleTypes_string + magicRuleTypes_indices[i])
@@ -75,12 +72,12 @@ QMimeMagicRule::Type QMimeMagicRule::type(const QByteArray &theTypeName)
return Invalid; return Invalid;
} }
QByteArray QMimeMagicRule::typeName(QMimeMagicRule::Type theType) QByteArray MimeMagicRule::typeName(MimeMagicRule::Type theType)
{ {
return magicRuleTypes_string + magicRuleTypes_indices[theType]; return magicRuleTypes_string + magicRuleTypes_indices[theType];
} }
bool QMimeMagicRule::operator==(const QMimeMagicRule &other) const bool MimeMagicRule::operator==(const MimeMagicRule &other) const
{ {
return m_type == other.m_type && return m_type == other.m_type &&
m_value == other.m_value && m_value == other.m_value &&
@@ -94,7 +91,7 @@ bool QMimeMagicRule::operator==(const QMimeMagicRule &other) const
} }
// Used by both providers // Used by both providers
bool QMimeMagicRule::matchSubstring(const char *dataPtr, int dataSize, int rangeStart, int rangeLength, bool MimeMagicRule::matchSubstring(const char *dataPtr, int dataSize, int rangeStart, int rangeLength,
int valueLength, const char *valueData, const char *mask) int valueLength, const char *valueData, const char *mask)
{ {
// Size of searched data. // Size of searched data.
@@ -143,14 +140,14 @@ bool QMimeMagicRule::matchSubstring(const char *dataPtr, int dataSize, int range
return true; return true;
} }
bool QMimeMagicRule::matchString(const QByteArray &data) const bool MimeMagicRule::matchString(const QByteArray &data) const
{ {
const int rangeLength = m_endPos - m_startPos + 1; const int rangeLength = m_endPos - m_startPos + 1;
return QMimeMagicRule::matchSubstring(data.constData(), data.size(), m_startPos, rangeLength, m_pattern.size(), m_pattern.constData(), m_mask.constData()); return MimeMagicRule::matchSubstring(data.constData(), data.size(), m_startPos, rangeLength, m_pattern.size(), m_pattern.constData(), m_mask.constData());
} }
template <typename T> template <typename T>
bool QMimeMagicRule::matchNumber(const QByteArray &data) const bool MimeMagicRule::matchNumber(const QByteArray &data) const
{ {
const T value(m_number); const T value(m_number);
const T mask(m_numberMask); const T mask(m_numberMask);
@@ -221,12 +218,12 @@ static inline QByteArray makePattern(const QByteArray &value)
// <match value="must be converted with BinHex" type="string" offset="11"/> // <match value="must be converted with BinHex" type="string" offset="11"/>
// <match value="0x9501" type="big16" offset="0:64"/> // <match value="0x9501" type="big16" offset="0:64"/>
QMimeMagicRule::QMimeMagicRule(const QString &type, MimeMagicRule::MimeMagicRule(const QString &type,
const QByteArray &value, const QByteArray &value,
const QString &offsets, const QString &offsets,
const QByteArray &mask, const QByteArray &mask,
QString *errorString) QString *errorString)
: m_type(QMimeMagicRule::type(type.toLatin1())), : m_type(MimeMagicRule::type(type.toLatin1())),
m_value(value), m_value(value),
m_mask(mask), m_mask(mask),
m_matchFunction(nullptr) m_matchFunction(nullptr)
@@ -238,8 +235,8 @@ QMimeMagicRule::QMimeMagicRule(const QString &type,
const int colonIndex = offsets.indexOf(QLatin1Char(':')); const int colonIndex = offsets.indexOf(QLatin1Char(':'));
const QStringView startPosStr = QStringView{offsets}.mid(0, colonIndex); // \ These decay to returning 'offsets' const QStringView startPosStr = QStringView{offsets}.mid(0, colonIndex); // \ These decay to returning 'offsets'
const QStringView endPosStr = QStringView{offsets}.mid(colonIndex + 1);// / unchanged when colonIndex == -1 const QStringView endPosStr = QStringView{offsets}.mid(colonIndex + 1);// / unchanged when colonIndex == -1
if (Q_UNLIKELY(!QMimeTypeParserBase::parseNumber(startPosStr, &m_startPos, errorString)) || if (Q_UNLIKELY(!MimeTypeParserBase::parseNumber(startPosStr, &m_startPos, errorString)) ||
Q_UNLIKELY(!QMimeTypeParserBase::parseNumber(endPosStr, &m_endPos, errorString))) { Q_UNLIKELY(!MimeTypeParserBase::parseNumber(endPosStr, &m_endPos, errorString))) {
m_type = Invalid; m_type = Invalid;
return; return;
} }
@@ -287,13 +284,13 @@ QMimeMagicRule::QMimeMagicRule(const QString &type,
m_mask.fill(char(-1), m_pattern.size()); m_mask.fill(char(-1), m_pattern.size());
} }
m_mask.squeeze(); m_mask.squeeze();
m_matchFunction = &QMimeMagicRule::matchString; m_matchFunction = &MimeMagicRule::matchString;
break; break;
case Byte: case Byte:
if (m_number <= quint8(-1)) { if (m_number <= quint8(-1)) {
if (m_numberMask == 0) if (m_numberMask == 0)
m_numberMask = quint8(-1); m_numberMask = quint8(-1);
m_matchFunction = &QMimeMagicRule::matchNumber<quint8>; m_matchFunction = &MimeMagicRule::matchNumber<quint8>;
} }
break; break;
case Big16: case Big16:
@@ -308,7 +305,7 @@ QMimeMagicRule::QMimeMagicRule(const QString &type,
if (m_number <= quint16(-1)) { if (m_number <= quint16(-1)) {
if (m_numberMask == 0) if (m_numberMask == 0)
m_numberMask = quint16(-1); m_numberMask = quint16(-1);
m_matchFunction = &QMimeMagicRule::matchNumber<quint16>; m_matchFunction = &MimeMagicRule::matchNumber<quint16>;
} }
break; break;
case Big32: case Big32:
@@ -320,14 +317,14 @@ QMimeMagicRule::QMimeMagicRule(const QString &type,
case Host32: case Host32:
if (m_numberMask == 0) if (m_numberMask == 0)
m_numberMask = quint32(-1); m_numberMask = quint32(-1);
m_matchFunction = &QMimeMagicRule::matchNumber<quint32>; m_matchFunction = &MimeMagicRule::matchNumber<quint32>;
break; break;
default: default:
break; break;
} }
} }
QByteArray QMimeMagicRule::mask() const QByteArray MimeMagicRule::mask() const
{ {
QByteArray result = m_mask; QByteArray result = m_mask;
if (m_type == String) { if (m_type == String) {
@@ -337,7 +334,7 @@ QByteArray QMimeMagicRule::mask() const
return result; return result;
} }
bool QMimeMagicRule::matches(const QByteArray &data) const bool MimeMagicRule::matches(const QByteArray &data) const
{ {
const bool ok = m_matchFunction && (this->*m_matchFunction)(data); const bool ok = m_matchFunction && (this->*m_matchFunction)(data);
if (!ok) if (!ok)
@@ -349,7 +346,7 @@ bool QMimeMagicRule::matches(const QByteArray &data) const
//qDebug() << "Checking" << m_subMatches.count() << "sub-rules"; //qDebug() << "Checking" << m_subMatches.count() << "sub-rules";
// Check that one of the submatches matches too // Check that one of the submatches matches too
for ( QList<QMimeMagicRule>::const_iterator it = m_subMatches.begin(), end = m_subMatches.end() ; for ( QList<MimeMagicRule>::const_iterator it = m_subMatches.begin(), end = m_subMatches.end() ;
it != end ; ++it ) { it != end ; ++it ) {
if ((*it).matches(data)) { if ((*it).matches(data)) {
// One of the hierarchies matched -> mimetype recognized. // One of the hierarchies matched -> mimetype recognized.
@@ -361,4 +358,4 @@ bool QMimeMagicRule::matches(const QByteArray &data) const
} }
QT_END_NAMESPACE } // namespace Utils

26
src/libs/utils/mimetypes2/mimemagicrule_p.h
View File

@@ -37,8 +37,7 @@
** **
****************************************************************************/ ****************************************************************************/
#ifndef QMIMEMAGICRULE_P_H #pragma once
#define QMIMEMAGICRULE_P_H
// //
// W A R N I N G // W A R N I N G
@@ -51,25 +50,21 @@
// We mean it. // We mean it.
// //
#include <QtCore/private/qglobal_p.h>
QT_REQUIRE_CONFIG(mimetype);
#include <QtCore/qbytearray.h> #include <QtCore/qbytearray.h>
#include <QtCore/qscopedpointer.h> #include <QtCore/qscopedpointer.h>
#include <QtCore/qlist.h> #include <QtCore/qlist.h>
QT_BEGIN_NAMESPACE namespace Utils {
class QMimeMagicRule class MimeMagicRule
{ {
public: public:
enum Type { Invalid = 0, String, Host16, Host32, Big16, Big32, Little16, Little32, Byte }; enum Type { Invalid = 0, String, Host16, Host32, Big16, Big32, Little16, Little32, Byte };
QMimeMagicRule(const QString &typeStr, const QByteArray &value, const QString &offsets, MimeMagicRule(const QString &typeStr, const QByteArray &value, const QString &offsets,
const QByteArray &mask, QString *errorString); const QByteArray &mask, QString *errorString);
void swap(QMimeMagicRule &other) noexcept void swap(MimeMagicRule &other) noexcept
{ {
qSwap(m_type, other.m_type); qSwap(m_type, other.m_type);
qSwap(m_value, other.m_value); qSwap(m_value, other.m_value);
@@ -82,7 +77,7 @@ public:
qSwap(m_matchFunction, other.m_matchFunction); qSwap(m_matchFunction, other.m_matchFunction);
} }
bool operator==(const QMimeMagicRule &other) const; bool operator==(const MimeMagicRule &other) const;
Type type() const { return m_type; } Type type() const { return m_type; }
QByteArray value() const { return m_value; } QByteArray value() const { return m_value; }
@@ -94,7 +89,7 @@ public:
bool matches(const QByteArray &data) const; bool matches(const QByteArray &data) const;
QList<QMimeMagicRule> m_subMatches; QList<MimeMagicRule> m_subMatches;
static Type type(const QByteArray &type); static Type type(const QByteArray &type);
static QByteArray typeName(Type type); static QByteArray typeName(Type type);
@@ -112,7 +107,7 @@ private:
quint32 m_number; quint32 m_number;
quint32 m_numberMask; quint32 m_numberMask;
typedef bool (QMimeMagicRule::*MatchFunction)(const QByteArray &data) const; typedef bool (MimeMagicRule::*MatchFunction)(const QByteArray &data) const;
MatchFunction m_matchFunction; MatchFunction m_matchFunction;
private: private:
@@ -121,8 +116,7 @@ private:
template <typename T> template <typename T>
bool matchNumber(const QByteArray &data) const; bool matchNumber(const QByteArray &data) const;
}; };
Q_DECLARE_SHARED(QMimeMagicRule)
QT_END_NAMESPACE } // namespace Utils
#endif // QMIMEMAGICRULE_H Q_DECLARE_SHARED(Utils::MimeMagicRule)

34
src/libs/utils/mimetypes2/mimemagicrulematcher.cpp
View File

@@ -37,59 +37,57 @@
** **
****************************************************************************/ ****************************************************************************/
#define QT_NO_CAST_FROM_ASCII #include "mimemagicrulematcher_p.h"
#include "qmimemagicrulematcher_p.h" #include "mimetype_p.h"
#include "qmimetype_p.h" namespace Utils {
QT_BEGIN_NAMESPACE
/*! /*!
\internal \internal
\class QMimeMagicRuleMatcher \class MimeMagicRuleMatcher
\inmodule QtCore \inmodule QtCore
\brief The QMimeMagicRuleMatcher class checks a number of rules based on operator "or". \brief The MimeMagicRuleMatcher class checks a number of rules based on operator "or".
It is used for rules parsed from XML files. It is used for rules parsed from XML files.
\sa QMimeType, QMimeDatabase, MagicRule, MagicStringRule, MagicByteRule, GlobPattern \sa MimeType, MimeDatabase, MagicRule, MagicStringRule, MagicByteRule, GlobPattern
\sa QMimeTypeParserBase, MimeTypeParser \sa MimeTypeParserBase, MimeTypeParser
*/ */
QMimeMagicRuleMatcher::QMimeMagicRuleMatcher(const QString &mime, unsigned thePriority) : MimeMagicRuleMatcher::MimeMagicRuleMatcher(const QString &mime, unsigned thePriority) :
m_list(), m_list(),
m_priority(thePriority), m_priority(thePriority),
m_mimetype(mime) m_mimetype(mime)
{ {
} }
bool QMimeMagicRuleMatcher::operator==(const QMimeMagicRuleMatcher &other) const bool MimeMagicRuleMatcher::operator==(const MimeMagicRuleMatcher &other) const
{ {
return m_list == other.m_list && return m_list == other.m_list &&
m_priority == other.m_priority; m_priority == other.m_priority;
} }
void QMimeMagicRuleMatcher::addRule(const QMimeMagicRule &rule) void MimeMagicRuleMatcher::addRule(const MimeMagicRule &rule)
{ {
m_list.append(rule); m_list.append(rule);
} }
void QMimeMagicRuleMatcher::addRules(const QList<QMimeMagicRule> &rules) void MimeMagicRuleMatcher::addRules(const QList<MimeMagicRule> &rules)
{ {
m_list.append(rules); m_list.append(rules);
} }
QList<QMimeMagicRule> QMimeMagicRuleMatcher::magicRules() const QList<MimeMagicRule> MimeMagicRuleMatcher::magicRules() const
{ {
return m_list; return m_list;
} }
// Check for a match on contents of a file // Check for a match on contents of a file
bool QMimeMagicRuleMatcher::matches(const QByteArray &data) const bool MimeMagicRuleMatcher::matches(const QByteArray &data) const
{ {
for (const QMimeMagicRule &magicRule : m_list) { for (const MimeMagicRule &magicRule : m_list) {
if (magicRule.matches(data)) if (magicRule.matches(data))
return true; return true;
} }
@@ -98,9 +96,9 @@ bool QMimeMagicRuleMatcher::matches(const QByteArray &data) const
} }
// Return a priority value from 1..100 // Return a priority value from 1..100
unsigned QMimeMagicRuleMatcher::priority() const unsigned MimeMagicRuleMatcher::priority() const
{ {
return m_priority; return m_priority;
} }
QT_END_NAMESPACE } // namespace Utils

30
src/libs/utils/mimetypes2/mimemagicrulematcher_p.h
View File

@@ -37,8 +37,7 @@
** **
****************************************************************************/ ****************************************************************************/
#ifndef QMIMEMAGICRULEMATCHER_P_H #pragma once
#define QMIMEMAGICRULEMATCHER_P_H
// //
// W A R N I N G // W A R N I N G
@@ -51,33 +50,31 @@
// We mean it. // We mean it.
// //
#include "qmimemagicrule_p.h" #include "mimemagicrule_p.h"
QT_REQUIRE_CONFIG(mimetype);
#include <QtCore/qbytearray.h> #include <QtCore/qbytearray.h>
#include <QtCore/qlist.h> #include <QtCore/qlist.h>
#include <QtCore/qstring.h> #include <QtCore/qstring.h>
QT_BEGIN_NAMESPACE namespace Utils {
class QMimeMagicRuleMatcher class MimeMagicRuleMatcher
{ {
public: public:
explicit QMimeMagicRuleMatcher(const QString &mime, unsigned priority = 65535); explicit MimeMagicRuleMatcher(const QString &mime, unsigned priority = 65535);
void swap(QMimeMagicRuleMatcher &other) noexcept void swap(MimeMagicRuleMatcher &other) noexcept
{ {
qSwap(m_list, other.m_list); qSwap(m_list, other.m_list);
qSwap(m_priority, other.m_priority); qSwap(m_priority, other.m_priority);
qSwap(m_mimetype, other.m_mimetype); qSwap(m_mimetype, other.m_mimetype);
} }
bool operator==(const QMimeMagicRuleMatcher &other) const; bool operator==(const MimeMagicRuleMatcher &other) const;
void addRule(const QMimeMagicRule &rule); void addRule(const MimeMagicRule &rule);
void addRules(const QList<QMimeMagicRule> &rules); void addRules(const QList<MimeMagicRule> &rules);
QList<QMimeMagicRule> magicRules() const; QList<MimeMagicRule> magicRules() const;
bool matches(const QByteArray &data) const; bool matches(const QByteArray &data) const;
@@ -86,12 +83,11 @@ public:
QString mimetype() const { return m_mimetype; } QString mimetype() const { return m_mimetype; }
private: private:
QList<QMimeMagicRule> m_list; QList<MimeMagicRule> m_list;
unsigned m_priority; unsigned m_priority;
QString m_mimetype; QString m_mimetype;
}; };
Q_DECLARE_SHARED(QMimeMagicRuleMatcher)
QT_END_NAMESPACE } // namespace Utils
#endif // QMIMEMAGICRULEMATCHER_P_H Q_DECLARE_SHARED(Utils::MimeMagicRuleMatcher)

152
src/libs/utils/mimetypes2/mimeprovider.cpp
View File

@@ -39,12 +39,12 @@
** **
****************************************************************************/ ****************************************************************************/
#include "qmimeprovider_p.h" #include "mimeprovider_p.h"
#include "mimetypeparser_p.h"
#include "mimemagicrulematcher_p.h"
#include "qmimetypeparser_p.h"
#include <qstandardpaths.h> #include <qstandardpaths.h>
#include "qmimemagicrulematcher_p.h"
#include <QXmlStreamReader> #include <QXmlStreamReader>
#include <QBuffer> #include <QBuffer>
#include <QDir> #include <QDir>
@@ -54,7 +54,7 @@
#include <QDateTime> #include <QDateTime>
#include <QtEndian> #include <QtEndian>
#if QT_CONFIG(mimetype_database) #if 0 // QT_CONFIG(mimetype_database)
# if defined(Q_CC_MSVC) # if defined(Q_CC_MSVC)
# pragma section(".qtmimedatabase", read, shared) # pragma section(".qtmimedatabase", read, shared)
__declspec(allocate(".qtmimedatabase")) __declspec(align(4096)) __declspec(allocate(".qtmimedatabase")) __declspec(align(4096))
@@ -82,21 +82,21 @@ __attribute__((section(".qtmimedatabase"), aligned(4096)))
# endif # endif
#endif #endif
QT_BEGIN_NAMESPACE namespace Utils {
QMimeProviderBase::QMimeProviderBase(QMimeDatabasePrivate *db, const QString &directory) MimeProviderBase::MimeProviderBase(MimeDatabasePrivate *db, const QString &directory)
: m_db(db), m_directory(directory) : m_db(db), m_directory(directory)
{ {
} }
QMimeBinaryProvider::QMimeBinaryProvider(QMimeDatabasePrivate *db, const QString &directory) MimeBinaryProvider::MimeBinaryProvider(MimeDatabasePrivate *db, const QString &directory)
: QMimeProviderBase(db, directory), m_mimetypeListLoaded(false) : MimeProviderBase(db, directory), m_mimetypeListLoaded(false)
{ {
ensureLoaded(); ensureLoaded();
} }
struct QMimeBinaryProvider::CacheFile struct MimeBinaryProvider::CacheFile
{ {
CacheFile(const QString &fileName); CacheFile(const QString &fileName);
~CacheFile(); ~CacheFile();
@@ -123,17 +123,17 @@ struct QMimeBinaryProvider::CacheFile
bool m_valid; bool m_valid;
}; };
QMimeBinaryProvider::CacheFile::CacheFile(const QString &fileName) MimeBinaryProvider::CacheFile::CacheFile(const QString &fileName)
: file(fileName), m_valid(false) : file(fileName), m_valid(false)
{ {
load(); load();
} }
QMimeBinaryProvider::CacheFile::~CacheFile() MimeBinaryProvider::CacheFile::~CacheFile()
{ {
} }
bool QMimeBinaryProvider::CacheFile::load() bool MimeBinaryProvider::CacheFile::load()
{ {
if (!file.open(QIODevice::ReadOnly)) if (!file.open(QIODevice::ReadOnly))
return false; return false;
@@ -147,7 +147,7 @@ bool QMimeBinaryProvider::CacheFile::load()
return m_valid; return m_valid;
} }
bool QMimeBinaryProvider::CacheFile::reload() bool MimeBinaryProvider::CacheFile::reload()
{ {
m_valid = false; m_valid = false;
if (file.isOpen()) { if (file.isOpen()) {
@@ -157,17 +157,17 @@ bool QMimeBinaryProvider::CacheFile::reload()
return load(); return load();
} }
QMimeBinaryProvider::~QMimeBinaryProvider() MimeBinaryProvider::~MimeBinaryProvider()
{ {
delete m_cacheFile; delete m_cacheFile;
} }
bool QMimeBinaryProvider::isValid() bool MimeBinaryProvider::isValid()
{ {
return m_cacheFile != nullptr; return m_cacheFile != nullptr;
} }
bool QMimeBinaryProvider::isInternalDatabase() const bool MimeBinaryProvider::isInternalDatabase() const
{ {
return false; return false;
} }
@@ -185,7 +185,7 @@ enum {
PosGenericIconsListOffset = 36 PosGenericIconsListOffset = 36
}; };
bool QMimeBinaryProvider::checkCacheChanged() bool MimeBinaryProvider::checkCacheChanged()
{ {
QFileInfo fileInfo(m_cacheFile->file); QFileInfo fileInfo(m_cacheFile->file);
if (fileInfo.lastModified() > m_cacheFile->m_mtime) { if (fileInfo.lastModified() > m_cacheFile->m_mtime) {
@@ -197,7 +197,7 @@ bool QMimeBinaryProvider::checkCacheChanged()
return false; return false;
} }
void QMimeBinaryProvider::ensureLoaded() void MimeBinaryProvider::ensureLoaded()
{ {
if (!m_cacheFile) { if (!m_cacheFile) {
const QString cacheFileName = m_directory + QLatin1String("/mime.cache"); const QString cacheFileName = m_directory + QLatin1String("/mime.cache");
@@ -218,28 +218,28 @@ void QMimeBinaryProvider::ensureLoaded()
} }
} }
static QMimeType mimeTypeForNameUnchecked(const QString &name) static MimeType mimeTypeForNameUnchecked(const QString &name)
{ {
QMimeTypePrivate data; MimeTypePrivate data;
data.name = name; data.name = name;
data.fromCache = true; data.fromCache = true;
// The rest is retrieved on demand. // The rest is retrieved on demand.
// comment and globPatterns: in loadMimeTypePrivate // comment and globPatterns: in loadMimeTypePrivate
// iconName: in loadIcon // iconName: in loadIcon
// genericIconName: in loadGenericIcon // genericIconName: in loadGenericIcon
return QMimeType(data); return MimeType(data);
} }
QMimeType QMimeBinaryProvider::mimeTypeForName(const QString &name) MimeType MimeBinaryProvider::mimeTypeForName(const QString &name)
{ {
if (!m_mimetypeListLoaded) if (!m_mimetypeListLoaded)
loadMimeTypeList(); loadMimeTypeList();
if (!m_mimetypeNames.contains(name)) if (!m_mimetypeNames.contains(name))
return QMimeType(); // unknown mimetype return MimeType(); // unknown mimetype
return mimeTypeForNameUnchecked(name); return mimeTypeForNameUnchecked(name);
} }
void QMimeBinaryProvider::addFileNameMatches(const QString &fileName, QMimeGlobMatchResult &result) void MimeBinaryProvider::addFileNameMatches(const QString &fileName, MimeGlobMatchResult &result)
{ {
if (fileName.isEmpty()) if (fileName.isEmpty())
return; return;
@@ -261,7 +261,7 @@ void QMimeBinaryProvider::addFileNameMatches(const QString &fileName, QMimeGlobM
matchGlobList(result, m_cacheFile, m_cacheFile->getUint32(PosGlobListOffset), fileName); matchGlobList(result, m_cacheFile, m_cacheFile->getUint32(PosGlobListOffset), fileName);
} }
void QMimeBinaryProvider::matchGlobList(QMimeGlobMatchResult &result, CacheFile *cacheFile, int off, const QString &fileName) void MimeBinaryProvider::matchGlobList(MimeGlobMatchResult &result, CacheFile *cacheFile, int off, const QString &fileName)
{ {
const int numGlobs = cacheFile->getUint32(off); const int numGlobs = cacheFile->getUint32(off);
//qDebug() << "Loading" << numGlobs << "globs from" << cacheFile->file.fileName() << "at offset" << cacheFile->globListOffset; //qDebug() << "Loading" << numGlobs << "globs from" << cacheFile->file.fileName() << "at offset" << cacheFile->globListOffset;
@@ -276,14 +276,14 @@ void QMimeBinaryProvider::matchGlobList(QMimeGlobMatchResult &result, CacheFile
const char *mimeType = cacheFile->getCharStar(mimeTypeOffset); const char *mimeType = cacheFile->getCharStar(mimeTypeOffset);
//qDebug() << pattern << mimeType << weight << caseSensitive; //qDebug() << pattern << mimeType << weight << caseSensitive;
QMimeGlobPattern glob(pattern, QString() /*unused*/, weight, qtCaseSensitive); MimeGlobPattern glob(pattern, QString() /*unused*/, weight, qtCaseSensitive);
if (glob.matchFileName(fileName)) if (glob.matchFileName(fileName))
result.addMatch(QLatin1String(mimeType), weight, pattern); result.addMatch(QLatin1String(mimeType), weight, pattern);
} }
} }
bool QMimeBinaryProvider::matchSuffixTree(QMimeGlobMatchResult &result, QMimeBinaryProvider::CacheFile *cacheFile, int numEntries, int firstOffset, const QString &fileName, int charPos, bool caseSensitiveCheck) bool MimeBinaryProvider::matchSuffixTree(MimeGlobMatchResult &result, MimeBinaryProvider::CacheFile *cacheFile, int numEntries, int firstOffset, const QString &fileName, int charPos, bool caseSensitiveCheck)
{ {
QChar fileChar = fileName[charPos]; QChar fileChar = fileName[charPos];
int min = 0; int min = 0;
@@ -327,7 +327,7 @@ bool QMimeBinaryProvider::matchSuffixTree(QMimeGlobMatchResult &result, QMimeBin
return false; return false;
} }
bool QMimeBinaryProvider::matchMagicRule(QMimeBinaryProvider::CacheFile *cacheFile, int numMatchlets, int firstOffset, const QByteArray &data) bool MimeBinaryProvider::matchMagicRule(MimeBinaryProvider::CacheFile *cacheFile, int numMatchlets, int firstOffset, const QByteArray &data)
{ {
const char *dataPtr = data.constData(); const char *dataPtr = data.constData();
const int dataSize = data.size(); const int dataSize = data.size();
@@ -341,7 +341,7 @@ bool QMimeBinaryProvider::matchMagicRule(QMimeBinaryProvider::CacheFile *cacheFi
const int maskOffset = cacheFile->getUint32(off + 20); const int maskOffset = cacheFile->getUint32(off + 20);
const char *mask = maskOffset ? cacheFile->getCharStar(maskOffset) : nullptr; const char *mask = maskOffset ? cacheFile->getCharStar(maskOffset) : nullptr;
if (!QMimeMagicRule::matchSubstring(dataPtr, dataSize, rangeStart, rangeLength, valueLength, cacheFile->getCharStar(valueOffset), mask)) if (!MimeMagicRule::matchSubstring(dataPtr, dataSize, rangeStart, rangeLength, valueLength, cacheFile->getCharStar(valueOffset), mask))
continue; continue;
const int numChildren = cacheFile->getUint32(off + 24); const int numChildren = cacheFile->getUint32(off + 24);
@@ -355,7 +355,7 @@ bool QMimeBinaryProvider::matchMagicRule(QMimeBinaryProvider::CacheFile *cacheFi
return false; return false;
} }
void QMimeBinaryProvider::findByMagic(const QByteArray &data, int *accuracyPtr, QMimeType &candidate) void MimeBinaryProvider::findByMagic(const QByteArray &data, int *accuracyPtr, MimeType &candidate)
{ {
const int magicListOffset = m_cacheFile->getUint32(PosMagicListOffset); const int magicListOffset = m_cacheFile->getUint32(PosMagicListOffset);
const int numMatches = m_cacheFile->getUint32(magicListOffset); const int numMatches = m_cacheFile->getUint32(magicListOffset);
@@ -378,7 +378,7 @@ void QMimeBinaryProvider::findByMagic(const QByteArray &data, int *accuracyPtr,
} }
} }
void QMimeBinaryProvider::addParents(const QString &mime, QStringList &result) void MimeBinaryProvider::addParents(const QString &mime, QStringList &result)
{ {
const QByteArray mimeStr = mime.toLatin1(); const QByteArray mimeStr = mime.toLatin1();
const int parentListOffset = m_cacheFile->getUint32(PosParentListOffset); const int parentListOffset = m_cacheFile->getUint32(PosParentListOffset);
@@ -411,7 +411,7 @@ void QMimeBinaryProvider::addParents(const QString &mime, QStringList &result)
} }
} }
QString QMimeBinaryProvider::resolveAlias(const QString &name) QString MimeBinaryProvider::resolveAlias(const QString &name)
{ {
const QByteArray input = name.toLatin1(); const QByteArray input = name.toLatin1();
const int aliasListOffset = m_cacheFile->getUint32(PosAliasListOffset); const int aliasListOffset = m_cacheFile->getUint32(PosAliasListOffset);
@@ -437,7 +437,7 @@ QString QMimeBinaryProvider::resolveAlias(const QString &name)
return QString(); return QString();
} }
void QMimeBinaryProvider::addAliases(const QString &name, QStringList &result) void MimeBinaryProvider::addAliases(const QString &name, QStringList &result)
{ {
const QByteArray input = name.toLatin1(); const QByteArray input = name.toLatin1();
const int aliasListOffset = m_cacheFile->getUint32(PosAliasListOffset); const int aliasListOffset = m_cacheFile->getUint32(PosAliasListOffset);
@@ -457,7 +457,7 @@ void QMimeBinaryProvider::addAliases(const QString &name, QStringList &result)
} }
} }
void QMimeBinaryProvider::loadMimeTypeList() void MimeBinaryProvider::loadMimeTypeList()
{ {
if (!m_mimetypeListLoaded) { if (!m_mimetypeListLoaded) {
m_mimetypeListLoaded = true; m_mimetypeListLoaded = true;
@@ -476,7 +476,7 @@ void QMimeBinaryProvider::loadMimeTypeList()
} }
} }
void QMimeBinaryProvider::addAllMimeTypes(QList<QMimeType> &result) void MimeBinaryProvider::addAllMimeTypes(QList<MimeType> &result)
{ {
loadMimeTypeList(); loadMimeTypeList();
if (result.isEmpty()) { if (result.isEmpty()) {
@@ -485,13 +485,13 @@ void QMimeBinaryProvider::addAllMimeTypes(QList<QMimeType> &result)
result.append(mimeTypeForNameUnchecked(name)); result.append(mimeTypeForNameUnchecked(name));
} else { } else {
for (const QString &name : qAsConst(m_mimetypeNames)) for (const QString &name : qAsConst(m_mimetypeNames))
if (std::find_if(result.constBegin(), result.constEnd(), [name](const QMimeType &mime) -> bool { return mime.name() == name; }) if (std::find_if(result.constBegin(), result.constEnd(), [name](const MimeType &mime) -> bool { return mime.name() == name; })
== result.constEnd()) == result.constEnd())
result.append(mimeTypeForNameUnchecked(name)); result.append(mimeTypeForNameUnchecked(name));
} }
} }
bool QMimeBinaryProvider::loadMimeTypePrivate(QMimeTypePrivate &data) bool MimeBinaryProvider::loadMimeTypePrivate(MimeTypePrivate &data)
{ {
#ifdef QT_NO_XMLSTREAMREADER #ifdef QT_NO_XMLSTREAMREADER
Q_UNUSED(data); Q_UNUSED(data);
@@ -573,7 +573,7 @@ bool QMimeBinaryProvider::loadMimeTypePrivate(QMimeTypePrivate &data)
} }
// Binary search in the icons or generic-icons list // Binary search in the icons or generic-icons list
QLatin1String QMimeBinaryProvider::iconForMime(CacheFile *cacheFile, int posListOffset, const QByteArray &inputMime) QLatin1String MimeBinaryProvider::iconForMime(CacheFile *cacheFile, int posListOffset, const QByteArray &inputMime)
{ {
const int iconsListOffset = cacheFile->getUint32(posListOffset); const int iconsListOffset = cacheFile->getUint32(posListOffset);
const int numIcons = cacheFile->getUint32(iconsListOffset); const int numIcons = cacheFile->getUint32(iconsListOffset);
@@ -597,7 +597,7 @@ QLatin1String QMimeBinaryProvider::iconForMime(CacheFile *cacheFile, int posList
return QLatin1String(); return QLatin1String();
} }
void QMimeBinaryProvider::loadIcon(QMimeTypePrivate &data) void MimeBinaryProvider::loadIcon(MimeTypePrivate &data)
{ {
const QByteArray inputMime = data.name.toLatin1(); const QByteArray inputMime = data.name.toLatin1();
const QLatin1String icon = iconForMime(m_cacheFile, PosIconsListOffset, inputMime); const QLatin1String icon = iconForMime(m_cacheFile, PosIconsListOffset, inputMime);
@@ -606,7 +606,7 @@ void QMimeBinaryProvider::loadIcon(QMimeTypePrivate &data)
} }
} }
void QMimeBinaryProvider::loadGenericIcon(QMimeTypePrivate &data) void MimeBinaryProvider::loadGenericIcon(MimeTypePrivate &data)
{ {
const QByteArray inputMime = data.name.toLatin1(); const QByteArray inputMime = data.name.toLatin1();
const QLatin1String icon = iconForMime(m_cacheFile, PosGenericIconsListOffset, inputMime); const QLatin1String icon = iconForMime(m_cacheFile, PosGenericIconsListOffset, inputMime);
@@ -617,7 +617,7 @@ void QMimeBinaryProvider::loadGenericIcon(QMimeTypePrivate &data)
//// ////
#if QT_CONFIG(mimetype_database) #if 0 //QT_CONFIG(mimetype_database)
static QString internalMimeFileName() static QString internalMimeFileName()
{ {
return QStringLiteral("<internal MIME data>"); return QStringLiteral("<internal MIME data>");
@@ -664,54 +664,54 @@ QMimeXMLProvider::QMimeXMLProvider(QMimeDatabasePrivate *db, InternalDatabaseEnu
#else // !QT_CONFIG(mimetype_database) #else // !QT_CONFIG(mimetype_database)
// never called in release mode, but some debug builds may need // never called in release mode, but some debug builds may need
// this to be defined. // this to be defined.
QMimeXMLProvider::QMimeXMLProvider(QMimeDatabasePrivate *db, InternalDatabaseEnum) MimeXMLProvider::MimeXMLProvider(MimeDatabasePrivate *db, InternalDatabaseEnum)
: QMimeProviderBase(db, QString()) : MimeProviderBase(db, QString())
{ {
Q_UNREACHABLE(); Q_UNREACHABLE();
} }
#endif // QT_CONFIG(mimetype_database) #endif // QT_CONFIG(mimetype_database)
QMimeXMLProvider::QMimeXMLProvider(QMimeDatabasePrivate *db, const QString &directory) MimeXMLProvider::MimeXMLProvider(MimeDatabasePrivate *db, const QString &directory)
: QMimeProviderBase(db, directory) : MimeProviderBase(db, directory)
{ {
ensureLoaded(); ensureLoaded();
} }
QMimeXMLProvider::~QMimeXMLProvider() MimeXMLProvider::~MimeXMLProvider()
{ {
} }
bool QMimeXMLProvider::isValid() bool MimeXMLProvider::isValid()
{ {
// If you change this method, adjust the logic in QMimeDatabasePrivate::loadProviders, // If you change this method, adjust the logic in MimeDatabasePrivate::loadProviders,
// which assumes isValid==false is only possible in QMimeBinaryProvider. // which assumes isValid==false is only possible in MimeBinaryProvider.
return true; return true;
} }
bool QMimeXMLProvider::isInternalDatabase() const bool MimeXMLProvider::isInternalDatabase() const
{ {
#if QT_CONFIG(mimetype_database) #if 0 //QT_CONFIG(mimetype_database)
return m_directory == internalMimeFileName(); return m_directory == internalMimeFileName();
#else #else
return false; return false;
#endif #endif
} }
QMimeType QMimeXMLProvider::mimeTypeForName(const QString &name) MimeType MimeXMLProvider::mimeTypeForName(const QString &name)
{ {
return m_nameMimeTypeMap.value(name); return m_nameMimeTypeMap.value(name);
} }
void QMimeXMLProvider::addFileNameMatches(const QString &fileName, QMimeGlobMatchResult &result) void MimeXMLProvider::addFileNameMatches(const QString &fileName, MimeGlobMatchResult &result)
{ {
m_mimeTypeGlobs.matchingGlobs(fileName, result); m_mimeTypeGlobs.matchingGlobs(fileName, result);
} }
void QMimeXMLProvider::findByMagic(const QByteArray &data, int *accuracyPtr, QMimeType &candidate) void MimeXMLProvider::findByMagic(const QByteArray &data, int *accuracyPtr, MimeType &candidate)
{ {
QString candidateName; QString candidateName;
bool foundOne = false; bool foundOne = false;
for (const QMimeMagicRuleMatcher &matcher : qAsConst(m_magicMatchers)) { for (const MimeMagicRuleMatcher &matcher : qAsConst(m_magicMatchers)) {
if (matcher.matches(data)) { if (matcher.matches(data)) {
const int priority = matcher.priority(); const int priority = matcher.priority();
if (priority > *accuracyPtr) { if (priority > *accuracyPtr) {
@@ -725,7 +725,7 @@ void QMimeXMLProvider::findByMagic(const QByteArray &data, int *accuracyPtr, QMi
candidate = mimeTypeForName(candidateName); candidate = mimeTypeForName(candidateName);
} }
void QMimeXMLProvider::ensureLoaded() void MimeXMLProvider::ensureLoaded()
{ {
QStringList allFiles; QStringList allFiles;
const QString packageDir = m_directory + QStringLiteral("/packages"); const QString packageDir = m_directory + QStringLiteral("/packages");
@@ -751,14 +751,14 @@ void QMimeXMLProvider::ensureLoaded()
load(file); load(file);
} }
void QMimeXMLProvider::load(const QString &fileName) void MimeXMLProvider::load(const QString &fileName)
{ {
QString errorMessage; QString errorMessage;
if (!load(fileName, &errorMessage)) if (!load(fileName, &errorMessage))
qWarning("QMimeDatabase: Error loading %ls\n%ls", qUtf16Printable(fileName), qUtf16Printable(errorMessage)); qWarning("MimeDatabase: Error loading %ls\n%ls", qUtf16Printable(fileName), qUtf16Printable(errorMessage));
} }
bool QMimeXMLProvider::load(const QString &fileName, QString *errorMessage) bool MimeXMLProvider::load(const QString &fileName, QString *errorMessage)
{ {
QFile file(fileName); QFile file(fileName);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) { if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
@@ -770,35 +770,35 @@ bool QMimeXMLProvider::load(const QString &fileName, QString *errorMessage)
if (errorMessage) if (errorMessage)
errorMessage->clear(); errorMessage->clear();
QMimeTypeParser parser(*this); MimeTypeParser parser(*this);
return parser.parse(&file, fileName, errorMessage); return parser.parse(&file, fileName, errorMessage);
} }
#if QT_CONFIG(mimetype_database) #if 0 //QT_CONFIG(mimetype_database)
void QMimeXMLProvider::load(const char *data, qsizetype len) void MimeXMLProvider::load(const char *data, qsizetype len)
{ {
QBuffer buffer; QBuffer buffer;
buffer.setData(QByteArray::fromRawData(data, len)); buffer.setData(QByteArray::fromRawData(data, len));
buffer.open(QIODevice::ReadOnly); buffer.open(QIODevice::ReadOnly);
QString errorMessage; QString errorMessage;
QMimeTypeParser parser(*this); MimeTypeParser parser(*this);
if (!parser.parse(&buffer, internalMimeFileName(), &errorMessage)) if (!parser.parse(&buffer, internalMimeFileName(), &errorMessage))
qWarning("QMimeDatabase: Error loading internal MIME data\n%s", qPrintable(errorMessage)); qWarning("MimeDatabase: Error loading internal MIME data\n%s", qPrintable(errorMessage));
} }
#endif #endif
void QMimeXMLProvider::addGlobPattern(const QMimeGlobPattern &glob) void MimeXMLProvider::addGlobPattern(const MimeGlobPattern &glob)
{ {
m_mimeTypeGlobs.addGlob(glob); m_mimeTypeGlobs.addGlob(glob);
} }
void QMimeXMLProvider::addMimeType(const QMimeType &mt) void MimeXMLProvider::addMimeType(const MimeType &mt)
{ {
Q_ASSERT(!mt.d.data()->fromCache); Q_ASSERT(!mt.d.data()->fromCache);
m_nameMimeTypeMap.insert(mt.name(), mt); m_nameMimeTypeMap.insert(mt.name(), mt);
} }
void QMimeXMLProvider::addParents(const QString &mime, QStringList &result) void MimeXMLProvider::addParents(const QString &mime, QStringList &result)
{ {
for (const QString &parent : m_parents.value(mime)) { for (const QString &parent : m_parents.value(mime)) {
if (!result.contains(parent)) if (!result.contains(parent))
@@ -806,12 +806,12 @@ void QMimeXMLProvider::addParents(const QString &mime, QStringList &result)
} }
} }
void QMimeXMLProvider::addParent(const QString &child, const QString &parent) void MimeXMLProvider::addParent(const QString &child, const QString &parent)
{ {
m_parents[child].append(parent); m_parents[child].append(parent);
} }
void QMimeXMLProvider::addAliases(const QString &name, QStringList &result) void MimeXMLProvider::addAliases(const QString &name, QStringList &result)
{ {
// Iterate through the whole hash. This method is rarely used. // Iterate through the whole hash. This method is rarely used.
for (auto it = m_aliases.constBegin(), end = m_aliases.constEnd() ; it != end ; ++it) { for (auto it = m_aliases.constBegin(), end = m_aliases.constEnd() ; it != end ; ++it) {
@@ -823,33 +823,33 @@ void QMimeXMLProvider::addAliases(const QString &name, QStringList &result)
} }
QString QMimeXMLProvider::resolveAlias(const QString &name) QString MimeXMLProvider::resolveAlias(const QString &name)
{ {
return m_aliases.value(name); return m_aliases.value(name);
} }
void QMimeXMLProvider::addAlias(const QString &alias, const QString &name) void MimeXMLProvider::addAlias(const QString &alias, const QString &name)
{ {
m_aliases.insert(alias, name); m_aliases.insert(alias, name);
} }
void QMimeXMLProvider::addAllMimeTypes(QList<QMimeType> &result) void MimeXMLProvider::addAllMimeTypes(QList<MimeType> &result)
{ {
if (result.isEmpty()) { // fast path if (result.isEmpty()) { // fast path
result = m_nameMimeTypeMap.values(); result = m_nameMimeTypeMap.values();
} else { } else {
for (auto it = m_nameMimeTypeMap.constBegin(), end = m_nameMimeTypeMap.constEnd() ; it != end ; ++it) { for (auto it = m_nameMimeTypeMap.constBegin(), end = m_nameMimeTypeMap.constEnd() ; it != end ; ++it) {
const QString newMime = it.key(); const QString newMime = it.key();
if (std::find_if(result.constBegin(), result.constEnd(), [newMime](const QMimeType &mime) -> bool { return mime.name() == newMime; }) if (std::find_if(result.constBegin(), result.constEnd(), [newMime](const MimeType &mime) -> bool { return mime.name() == newMime; })
== result.constEnd()) == result.constEnd())
result.append(it.value()); result.append(it.value());
} }
} }
} }
void QMimeXMLProvider::addMagicMatcher(const QMimeMagicRuleMatcher &matcher) void MimeXMLProvider::addMagicMatcher(const MimeMagicRuleMatcher &matcher)
{ {
m_magicMatchers.append(matcher); m_magicMatchers.append(matcher);
} }
QT_END_NAMESPACE } // namespace Utils

93
src/libs/utils/mimetypes2/mimeprovider_p.h
View File

@@ -38,8 +38,7 @@
** **
****************************************************************************/ ****************************************************************************/
#ifndef QMIMEPROVIDER_P_H #pragma once
#define QMIMEPROVIDER_P_H
// //
// W A R N I N G // W A R N I N G
@@ -52,72 +51,70 @@
// We mean it. // We mean it.
// //
#include "qmimedatabase_p.h" #include "mimedatabase_p.h"
QT_REQUIRE_CONFIG(mimetype); #include "mimeglobpattern_p.h"
#include "qmimeglobpattern_p.h"
#include <QtCore/qdatetime.h> #include <QtCore/qdatetime.h>
#include <QtCore/qset.h> #include <QtCore/qset.h>
QT_BEGIN_NAMESPACE namespace Utils {
class QMimeMagicRuleMatcher; class MimeMagicRuleMatcher;
class QMimeProviderBase class MimeProviderBase
{ {
public: public:
QMimeProviderBase(QMimeDatabasePrivate *db, const QString &directory); MimeProviderBase(MimeDatabasePrivate *db, const QString &directory);
virtual ~QMimeProviderBase() {} virtual ~MimeProviderBase() {}
virtual bool isValid() = 0; virtual bool isValid() = 0;
virtual bool isInternalDatabase() const = 0; virtual bool isInternalDatabase() const = 0;
virtual QMimeType mimeTypeForName(const QString &name) = 0; virtual MimeType mimeTypeForName(const QString &name) = 0;
virtual void addFileNameMatches(const QString &fileName, QMimeGlobMatchResult &result) = 0; virtual void addFileNameMatches(const QString &fileName, MimeGlobMatchResult &result) = 0;
virtual void addParents(const QString &mime, QStringList &result) = 0; virtual void addParents(const QString &mime, QStringList &result) = 0;
virtual QString resolveAlias(const QString &name) = 0; virtual QString resolveAlias(const QString &name) = 0;
virtual void addAliases(const QString &name, QStringList &result) = 0; virtual void addAliases(const QString &name, QStringList &result) = 0;
virtual void findByMagic(const QByteArray &data, int *accuracyPtr, QMimeType &candidate) = 0; virtual void findByMagic(const QByteArray &data, int *accuracyPtr, MimeType &candidate) = 0;
virtual void addAllMimeTypes(QList<QMimeType> &result) = 0; virtual void addAllMimeTypes(QList<MimeType> &result) = 0;
virtual bool loadMimeTypePrivate(QMimeTypePrivate &) { return false; } virtual bool loadMimeTypePrivate(MimeTypePrivate &) { return false; }
virtual void loadIcon(QMimeTypePrivate &) {} virtual void loadIcon(MimeTypePrivate &) {}
virtual void loadGenericIcon(QMimeTypePrivate &) {} virtual void loadGenericIcon(MimeTypePrivate &) {}
virtual void ensureLoaded() {} virtual void ensureLoaded() {}
QString directory() const { return m_directory; } QString directory() const { return m_directory; }
QMimeDatabasePrivate *m_db; MimeDatabasePrivate *m_db;
QString m_directory; QString m_directory;
}; };
/* /*
Parses the files 'mime.cache' and 'types' on demand Parses the files 'mime.cache' and 'types' on demand
*/ */
class QMimeBinaryProvider : public QMimeProviderBase class MimeBinaryProvider : public MimeProviderBase
{ {
public: public:
QMimeBinaryProvider(QMimeDatabasePrivate *db, const QString &directory); MimeBinaryProvider(MimeDatabasePrivate *db, const QString &directory);
virtual ~QMimeBinaryProvider(); virtual ~MimeBinaryProvider();
bool isValid() override; bool isValid() override;
bool isInternalDatabase() const override; bool isInternalDatabase() const override;
QMimeType mimeTypeForName(const QString &name) override; MimeType mimeTypeForName(const QString &name) override;
void addFileNameMatches(const QString &fileName, QMimeGlobMatchResult &result) override; void addFileNameMatches(const QString &fileName, MimeGlobMatchResult &result) override;
void addParents(const QString &mime, QStringList &result) override; void addParents(const QString &mime, QStringList &result) override;
QString resolveAlias(const QString &name) override; QString resolveAlias(const QString &name) override;
void addAliases(const QString &name, QStringList &result) override; void addAliases(const QString &name, QStringList &result) override;
void findByMagic(const QByteArray &data, int *accuracyPtr, QMimeType &candidate) override; void findByMagic(const QByteArray &data, int *accuracyPtr, MimeType &candidate) override;
void addAllMimeTypes(QList<QMimeType> &result) override; void addAllMimeTypes(QList<MimeType> &result) override;
bool loadMimeTypePrivate(QMimeTypePrivate &) override; bool loadMimeTypePrivate(MimeTypePrivate &) override;
void loadIcon(QMimeTypePrivate &) override; void loadIcon(MimeTypePrivate &) override;
void loadGenericIcon(QMimeTypePrivate &) override; void loadGenericIcon(MimeTypePrivate &) override;
void ensureLoaded() override; void ensureLoaded() override;
private: private:
struct CacheFile; struct CacheFile;
void matchGlobList(QMimeGlobMatchResult &result, CacheFile *cacheFile, int offset, const QString &fileName); void matchGlobList(MimeGlobMatchResult &result, CacheFile *cacheFile, int offset, const QString &fileName);
bool matchSuffixTree(QMimeGlobMatchResult &result, CacheFile *cacheFile, int numEntries, int firstOffset, const QString &fileName, int charPos, bool caseSensitiveCheck); bool matchSuffixTree(MimeGlobMatchResult &result, CacheFile *cacheFile, int numEntries, int firstOffset, const QString &fileName, int charPos, bool caseSensitiveCheck);
bool matchMagicRule(CacheFile *cacheFile, int numMatchlets, int firstOffset, const QByteArray &data); bool matchMagicRule(CacheFile *cacheFile, int numMatchlets, int firstOffset, const QByteArray &data);
QLatin1String iconForMime(CacheFile *cacheFile, int posListOffset, const QByteArray &inputMime); QLatin1String iconForMime(CacheFile *cacheFile, int posListOffset, const QByteArray &inputMime);
void loadMimeTypeList(); void loadMimeTypeList();
@@ -138,44 +135,44 @@ private:
/* /*
Parses the raw XML files (slower) Parses the raw XML files (slower)
*/ */
class QMimeXMLProvider : public QMimeProviderBase class MimeXMLProvider : public MimeProviderBase
{ {
public: public:
enum InternalDatabaseEnum { InternalDatabase }; enum InternalDatabaseEnum { InternalDatabase };
#if QT_CONFIG(mimetype_database) #if 0 // QT_CONFIG(mimetype_database)
enum : bool { InternalDatabaseAvailable = true }; enum : bool { InternalDatabaseAvailable = true };
#else #else
enum : bool { InternalDatabaseAvailable = false }; enum : bool { InternalDatabaseAvailable = false };
#endif #endif
QMimeXMLProvider(QMimeDatabasePrivate *db, InternalDatabaseEnum); MimeXMLProvider(MimeDatabasePrivate *db, InternalDatabaseEnum);
QMimeXMLProvider(QMimeDatabasePrivate *db, const QString &directory); MimeXMLProvider(MimeDatabasePrivate *db, const QString &directory);
~QMimeXMLProvider(); ~MimeXMLProvider();
bool isValid() override; bool isValid() override;
bool isInternalDatabase() const override; bool isInternalDatabase() const override;
QMimeType mimeTypeForName(const QString &name) override; MimeType mimeTypeForName(const QString &name) override;
void addFileNameMatches(const QString &fileName, QMimeGlobMatchResult &result) override; void addFileNameMatches(const QString &fileName, MimeGlobMatchResult &result) override;
void addParents(const QString &mime, QStringList &result) override; void addParents(const QString &mime, QStringList &result) override;
QString resolveAlias(const QString &name) override; QString resolveAlias(const QString &name) override;
void addAliases(const QString &name, QStringList &result) override; void addAliases(const QString &name, QStringList &result) override;
void findByMagic(const QByteArray &data, int *accuracyPtr, QMimeType &candidate) override; void findByMagic(const QByteArray &data, int *accuracyPtr, MimeType &candidate) override;
void addAllMimeTypes(QList<QMimeType> &result) override; void addAllMimeTypes(QList<MimeType> &result) override;
void ensureLoaded() override; void ensureLoaded() override;
bool load(const QString &fileName, QString *errorMessage); bool load(const QString &fileName, QString *errorMessage);
// Called by the mimetype xml parser // Called by the mimetype xml parser
void addMimeType(const QMimeType &mt); void addMimeType(const MimeType &mt);
void addGlobPattern(const QMimeGlobPattern &glob); void addGlobPattern(const MimeGlobPattern &glob);
void addParent(const QString &child, const QString &parent); void addParent(const QString &child, const QString &parent);
void addAlias(const QString &alias, const QString &name); void addAlias(const QString &alias, const QString &name);
void addMagicMatcher(const QMimeMagicRuleMatcher &matcher); void addMagicMatcher(const MimeMagicRuleMatcher &matcher);
private: private:
void load(const QString &fileName); void load(const QString &fileName);
void load(const char *data, qsizetype len); void load(const char *data, qsizetype len);
typedef QHash<QString, QMimeType> NameMimeTypeMap; typedef QHash<QString, MimeType> NameMimeTypeMap;
NameMimeTypeMap m_nameMimeTypeMap; NameMimeTypeMap m_nameMimeTypeMap;
typedef QHash<QString, QString> AliasHash; typedef QHash<QString, QString> AliasHash;
@@ -183,12 +180,10 @@ private:
typedef QHash<QString, QStringList> ParentsHash; typedef QHash<QString, QStringList> ParentsHash;
ParentsHash m_parents; ParentsHash m_parents;
QMimeAllGlobPatterns m_mimeTypeGlobs; MimeAllGlobPatterns m_mimeTypeGlobs;
QList<QMimeMagicRuleMatcher> m_magicMatchers; QList<MimeMagicRuleMatcher> m_magicMatchers;
QStringList m_allFiles; QStringList m_allFiles;
}; };
QT_END_NAMESPACE } // namespace Utils
#endif // QMIMEPROVIDER_P_H

182
src/libs/utils/mimetypes2/mimetype.cpp
View File

@@ -38,13 +38,13 @@
** **
****************************************************************************/ ****************************************************************************/
#include "qmimetype.h" #include "mimetype.h"
#include "qmimetype_p.h" #include "mimetype_p.h"
#include "qmimedatabase_p.h" #include "mimedatabase_p.h"
#include "qmimeprovider_p.h" #include "mimeprovider_p.h"
#include "qmimeglobpattern_p.h" #include "mimeglobpattern_p.h"
#include <QtCore/QDebug> #include <QtCore/QDebug>
#include <QtCore/QLocale> #include <QtCore/QLocale>
@@ -52,13 +52,13 @@
#include <memory> #include <memory>
QT_BEGIN_NAMESPACE namespace Utils {
QMimeTypePrivate::QMimeTypePrivate() MimeTypePrivate::MimeTypePrivate()
: loaded(false), fromCache(false) : loaded(false), fromCache(false)
{} {}
QMimeTypePrivate::QMimeTypePrivate(const QMimeType &other) MimeTypePrivate::MimeTypePrivate(const MimeType &other)
: loaded(other.d->loaded), : loaded(other.d->loaded),
name(other.d->name), name(other.d->name),
localeComments(other.d->localeComments), localeComments(other.d->localeComments),
@@ -67,7 +67,7 @@ QMimeTypePrivate::QMimeTypePrivate(const QMimeType &other)
globPatterns(other.d->globPatterns) globPatterns(other.d->globPatterns)
{} {}
void QMimeTypePrivate::clear() void MimeTypePrivate::clear()
{ {
name.clear(); name.clear();
localeComments.clear(); localeComments.clear();
@@ -76,16 +76,16 @@ void QMimeTypePrivate::clear()
globPatterns.clear(); globPatterns.clear();
} }
void QMimeTypePrivate::addGlobPattern(const QString &pattern) void MimeTypePrivate::addGlobPattern(const QString &pattern)
{ {
globPatterns.append(pattern); globPatterns.append(pattern);
} }
/*! /*!
\class QMimeType \class MimeType
\inmodule QtCore \inmodule QtCore
\ingroup shared \ingroup shared
\brief The QMimeType class describes types of file or data, represented by a MIME type string. \brief The MimeType class describes types of file or data, represented by a MIME type string.
\since 5.0 \since 5.0
@@ -96,48 +96,48 @@ void QMimeTypePrivate::addGlobPattern(const QString &pattern)
Determining the MIME type of a file can be useful to make sure your Determining the MIME type of a file can be useful to make sure your
application supports it. It is also useful in file-manager-like applications application supports it. It is also useful in file-manager-like applications
or widgets, in order to display an appropriate \l {QMimeType::iconName}{icon} for the file, or even or widgets, in order to display an appropriate \l {MimeType::iconName}{icon} for the file, or even
the descriptive \l {QMimeType::comment()}{comment} in detailed views. the descriptive \l {MimeType::comment()}{comment} in detailed views.
To check if a file has the expected MIME type, you should use inherits() To check if a file has the expected MIME type, you should use inherits()
rather than a simple string comparison based on the name(). This is because rather than a simple string comparison based on the name(). This is because
MIME types can inherit from each other: for instance a C source file is MIME types can inherit from each other: for instance a C source file is
a specific type of plain text file, so text/x-csrc inherits text/plain. a specific type of plain text file, so text/x-csrc inherits text/plain.
\sa QMimeDatabase, {MIME Type Browser Example} \sa MimeDatabase, {MIME Type Browser Example}
*/ */
/*! /*!
\fn QMimeType &QMimeType::operator=(QMimeType &&other) \fn MimeType &MimeType::operator=(MimeType &&other)
Move-assigns \a other to this QMimeType instance. Move-assigns \a other to this MimeType instance.
\since 5.2 \since 5.2
*/ */
/*! /*!
\fn QMimeType::QMimeType(); \fn MimeType::MimeType();
Constructs this QMimeType object initialized with default property values that indicate an invalid MIME type. Constructs this MimeType object initialized with default property values that indicate an invalid MIME type.
*/ */
QMimeType::QMimeType() : MimeType::MimeType() :
d(new QMimeTypePrivate()) d(new MimeTypePrivate())
{ {
} }
/*! /*!
\fn QMimeType::QMimeType(const QMimeType &other); \fn MimeType::MimeType(const MimeType &other);
Constructs this QMimeType object as a copy of \a other. Constructs this MimeType object as a copy of \a other.
*/ */
QMimeType::QMimeType(const QMimeType &other) : MimeType::MimeType(const MimeType &other) :
d(other.d) d(other.d)
{ {
} }
/*! /*!
\fn QMimeType &QMimeType::operator=(const QMimeType &other); \fn MimeType &MimeType::operator=(const MimeType &other);
Assigns the data of \a other to this QMimeType object, and returns a reference to this object. Assigns the data of \a other to this MimeType object, and returns a reference to this object.
*/ */
QMimeType &QMimeType::operator=(const QMimeType &other) MimeType &MimeType::operator=(const MimeType &other)
{ {
if (d != other.d) if (d != other.d)
d = other.d; d = other.d;
@@ -145,18 +145,18 @@ QMimeType &QMimeType::operator=(const QMimeType &other)
} }
/*! /*!
\fn QMimeType::QMimeType(const QMimeTypePrivate &dd); \fn MimeType::MimeType(const MimeTypePrivate &dd);
Assigns the data of the QMimeTypePrivate \a dd to this QMimeType object, and returns a reference to this object. Assigns the data of the MimeTypePrivate \a dd to this MimeType object, and returns a reference to this object.
\internal \internal
*/ */
QMimeType::QMimeType(const QMimeTypePrivate &dd) : MimeType::MimeType(const MimeTypePrivate &dd) :
d(new QMimeTypePrivate(dd)) d(new MimeTypePrivate(dd))
{ {
} }
/*! /*!
\fn void QMimeType::swap(QMimeType &other); \fn void MimeType::swap(MimeType &other);
Swaps QMimeType \a other with this QMimeType object. Swaps MimeType \a other with this MimeType object.
This operation is very fast and never fails. This operation is very fast and never fails.
@@ -167,83 +167,83 @@ QMimeType::QMimeType(const QMimeTypePrivate &dd) :
*/ */
/*! /*!
\fn QMimeType::~QMimeType(); \fn MimeType::~MimeType();
Destroys the QMimeType object, and releases the d pointer. Destroys the MimeType object, and releases the d pointer.
*/ */
QMimeType::~QMimeType() MimeType::~MimeType()
{ {
} }
/*! /*!
\fn bool QMimeType::operator==(const QMimeType &other) const; \fn bool MimeType::operator==(const MimeType &other) const;
Returns \c true if \a other equals this QMimeType object, otherwise returns \c false. Returns \c true if \a other equals this MimeType object, otherwise returns \c false.
The name is the unique identifier for a mimetype, so two mimetypes with The name is the unique identifier for a mimetype, so two mimetypes with
the same name, are equal. the same name, are equal.
*/ */
bool QMimeType::operator==(const QMimeType &other) const bool MimeType::operator==(const MimeType &other) const
{ {
return d == other.d || d->name == other.d->name; return d == other.d || d->name == other.d->name;
} }
/*! /*!
\since 5.6 \since 5.6
\relates QMimeType \relates MimeType
Returns the hash value for \a key, using Returns the hash value for \a key, using
\a seed to seed the calculation. \a seed to seed the calculation.
*/ */
size_t qHash(const QMimeType &key, size_t seed) noexcept size_t qHash(const MimeType &key, size_t seed) noexcept
{ {
return qHash(key.d->name, seed); return qHash(key.d->name, seed);
} }
/*! /*!
\fn bool QMimeType::operator!=(const QMimeType &other) const; \fn bool MimeType::operator!=(const MimeType &other) const;
Returns \c true if \a other does not equal this QMimeType object, otherwise returns \c false. Returns \c true if \a other does not equal this MimeType object, otherwise returns \c false.
*/ */
/*! /*!
\property QMimeType::valid \property MimeType::valid
\brief \c true if the QMimeType object contains valid data, \c false otherwise \brief \c true if the MimeType object contains valid data, \c false otherwise
A valid MIME type has a non-empty name(). A valid MIME type has a non-empty name().
The invalid MIME type is the default-constructed QMimeType. The invalid MIME type is the default-constructed MimeType.
While this property was introduced in 5.10, the While this property was introduced in 5.10, the
corresponding accessor method has always been there. corresponding accessor method has always been there.
*/ */
bool QMimeType::isValid() const bool MimeType::isValid() const
{ {
return !d->name.isEmpty(); return !d->name.isEmpty();
} }
/*! /*!
\property QMimeType::isDefault \property MimeType::isDefault
\brief \c true if this MIME type is the default MIME type which \brief \c true if this MIME type is the default MIME type which
applies to all files: application/octet-stream. applies to all files: application/octet-stream.
While this property was introduced in 5.10, the While this property was introduced in 5.10, the
corresponding accessor method has always been there. corresponding accessor method has always been there.
*/ */
bool QMimeType::isDefault() const bool MimeType::isDefault() const
{ {
return d->name == QMimeDatabasePrivate::instance()->defaultMimeType(); return d->name == MimeDatabasePrivate::instance()->defaultMimeType();
} }
/*! /*!
\property QMimeType::name \property MimeType::name
\brief the name of the MIME type \brief the name of the MIME type
While this property was introduced in 5.10, the While this property was introduced in 5.10, the
corresponding accessor method has always been there. corresponding accessor method has always been there.
*/ */
QString QMimeType::name() const QString MimeType::name() const
{ {
return d->name; return d->name;
} }
/*! /*!
\property QMimeType::comment \property MimeType::comment
\brief the description of the MIME type to be displayed on user interfaces \brief the description of the MIME type to be displayed on user interfaces
The default language (QLocale().name()) is used to select the appropriate translation. The default language (QLocale().name()) is used to select the appropriate translation.
@@ -251,9 +251,9 @@ QString QMimeType::name() const
While this property was introduced in 5.10, the While this property was introduced in 5.10, the
corresponding accessor method has always been there. corresponding accessor method has always been there.
*/ */
QString QMimeType::comment() const QString MimeType::comment() const
{ {
QMimeDatabasePrivate::instance()->loadMimeTypePrivate(const_cast<QMimeTypePrivate&>(*d)); MimeDatabasePrivate::instance()->loadMimeTypePrivate(const_cast<MimeTypePrivate&>(*d));
QStringList languageList; QStringList languageList;
languageList << QLocale().name(); languageList << QLocale().name();
@@ -279,7 +279,7 @@ QString QMimeType::comment() const
} }
/*! /*!
\property QMimeType::genericIconName \property MimeType::genericIconName
\brief the file name of a generic icon that represents the MIME type \brief the file name of a generic icon that represents the MIME type
This should be used if the icon returned by iconName() cannot be found on This should be used if the icon returned by iconName() cannot be found on
@@ -292,9 +292,9 @@ QString QMimeType::comment() const
While this property was introduced in 5.10, the While this property was introduced in 5.10, the
corresponding accessor method has always been there. corresponding accessor method has always been there.
*/ */
QString QMimeType::genericIconName() const QString MimeType::genericIconName() const
{ {
QMimeDatabasePrivate::instance()->loadGenericIcon(const_cast<QMimeTypePrivate&>(*d)); MimeDatabasePrivate::instance()->loadGenericIcon(const_cast<MimeTypePrivate&>(*d));
if (d->genericIconName.isEmpty()) { if (d->genericIconName.isEmpty()) {
// From the spec: // From the spec:
// If the generic icon name is empty (not specified by the mimetype definition) // If the generic icon name is empty (not specified by the mimetype definition)
@@ -320,7 +320,7 @@ static QString make_default_icon_name_from_mimetype_name(QString iconName)
} }
/*! /*!
\property QMimeType::iconName \property MimeType::iconName
\brief the file name of an icon image that represents the MIME type \brief the file name of an icon image that represents the MIME type
The icon name can be given to QIcon::fromTheme() in order to load the icon. The icon name can be given to QIcon::fromTheme() in order to load the icon.
@@ -328,9 +328,9 @@ static QString make_default_icon_name_from_mimetype_name(QString iconName)
While this property was introduced in 5.10, the While this property was introduced in 5.10, the
corresponding accessor method has always been there. corresponding accessor method has always been there.
*/ */
QString QMimeType::iconName() const QString MimeType::iconName() const
{ {
QMimeDatabasePrivate::instance()->loadIcon(const_cast<QMimeTypePrivate&>(*d)); MimeDatabasePrivate::instance()->loadIcon(const_cast<MimeTypePrivate&>(*d));
if (d->iconName.isEmpty()) { if (d->iconName.isEmpty()) {
return make_default_icon_name_from_mimetype_name(name()); return make_default_icon_name_from_mimetype_name(name());
} }
@@ -338,20 +338,20 @@ QString QMimeType::iconName() const
} }
/*! /*!
\property QMimeType::globPatterns \property MimeType::globPatterns
\brief the list of glob matching patterns \brief the list of glob matching patterns
While this property was introduced in 5.10, the While this property was introduced in 5.10, the
corresponding accessor method has always been there. corresponding accessor method has always been there.
*/ */
QStringList QMimeType::globPatterns() const QStringList MimeType::globPatterns() const
{ {
QMimeDatabasePrivate::instance()->loadMimeTypePrivate(const_cast<QMimeTypePrivate&>(*d)); MimeDatabasePrivate::instance()->loadMimeTypePrivate(const_cast<MimeTypePrivate&>(*d));
return d->globPatterns; return d->globPatterns;
} }
/*! /*!
\property QMimeType::parentMimeTypes \property MimeType::parentMimeTypes
\brief the names of parent MIME types \brief the names of parent MIME types
A type is a subclass of another type if any instance of the first type is A type is a subclass of another type if any instance of the first type is
@@ -368,14 +368,14 @@ QStringList QMimeType::globPatterns() const
While this property was introduced in 5.10, the While this property was introduced in 5.10, the
corresponding accessor method has always been there. corresponding accessor method has always been there.
*/ */
QStringList QMimeType::parentMimeTypes() const QStringList MimeType::parentMimeTypes() const
{ {
return QMimeDatabasePrivate::instance()->mimeParents(d->name); return MimeDatabasePrivate::instance()->mimeParents(d->name);
} }
static void collectParentMimeTypes(const QString &mime, QStringList &allParents) static void collectParentMimeTypes(const QString &mime, QStringList &allParents)
{ {
const QStringList parents = QMimeDatabasePrivate::instance()->mimeParents(mime); const QStringList parents = MimeDatabasePrivate::instance()->mimeParents(mime);
for (const QString &parent : parents) { for (const QString &parent : parents) {
// I would use QSet, but since order matters I better not // I would use QSet, but since order matters I better not
if (!allParents.contains(parent)) if (!allParents.contains(parent))
@@ -388,7 +388,7 @@ static void collectParentMimeTypes(const QString &mime, QStringList &allParents)
} }
/*! /*!
\property QMimeType::allAncestors \property MimeType::allAncestors
\brief the names of direct and indirect parent MIME types \brief the names of direct and indirect parent MIME types
Return all the parent mimetypes of this mimetype, direct and indirect. Return all the parent mimetypes of this mimetype, direct and indirect.
@@ -403,7 +403,7 @@ static void collectParentMimeTypes(const QString &mime, QStringList &allParents)
While this property was introduced in 5.10, the While this property was introduced in 5.10, the
corresponding accessor method has always been there. corresponding accessor method has always been there.
*/ */
QStringList QMimeType::allAncestors() const QStringList MimeType::allAncestors() const
{ {
QStringList allParents; QStringList allParents;
collectParentMimeTypes(d->name, allParents); collectParentMimeTypes(d->name, allParents);
@@ -411,13 +411,13 @@ QStringList QMimeType::allAncestors() const
} }
/*! /*!
\property QMimeType::aliases \property MimeType::aliases
\brief the list of aliases of this mimetype \brief the list of aliases of this mimetype
For instance, for text/csv, the returned list would be: For instance, for text/csv, the returned list would be:
text/x-csv, text/x-comma-separated-values. text/x-csv, text/x-comma-separated-values.
Note that all QMimeType instances refer to proper mimetypes, Note that all MimeType instances refer to proper mimetypes,
never to aliases directly. never to aliases directly.
The order of the aliases in the list is undefined. The order of the aliases in the list is undefined.
@@ -425,13 +425,13 @@ QStringList QMimeType::allAncestors() const
While this property was introduced in 5.10, the While this property was introduced in 5.10, the
corresponding accessor method has always been there. corresponding accessor method has always been there.
*/ */
QStringList QMimeType::aliases() const QStringList MimeType::aliases() const
{ {
return QMimeDatabasePrivate::instance()->listAliases(d->name); return MimeDatabasePrivate::instance()->listAliases(d->name);
} }
/*! /*!
\property QMimeType::suffixes \property MimeType::suffixes
\brief the known suffixes for the MIME type \brief the known suffixes for the MIME type
No leading dot is included, so for instance this would return "jpg", "jpeg" for image/jpeg. No leading dot is included, so for instance this would return "jpg", "jpeg" for image/jpeg.
@@ -439,9 +439,9 @@ QStringList QMimeType::aliases() const
While this property was introduced in 5.10, the While this property was introduced in 5.10, the
corresponding accessor method has always been there. corresponding accessor method has always been there.
*/ */
QStringList QMimeType::suffixes() const QStringList MimeType::suffixes() const
{ {
QMimeDatabasePrivate::instance()->loadMimeTypePrivate(const_cast<QMimeTypePrivate&>(*d)); MimeDatabasePrivate::instance()->loadMimeTypePrivate(const_cast<MimeTypePrivate&>(*d));
QStringList result; QStringList result;
for (const QString &pattern : qAsConst(d->globPatterns)) { for (const QString &pattern : qAsConst(d->globPatterns)) {
@@ -458,7 +458,7 @@ QStringList QMimeType::suffixes() const
} }
/*! /*!
\property QMimeType::preferredSuffix \property MimeType::preferredSuffix
\brief the preferred suffix for the MIME type \brief the preferred suffix for the MIME type
No leading dot is included, so for instance this would return "pdf" for application/pdf. No leading dot is included, so for instance this would return "pdf" for application/pdf.
@@ -467,7 +467,7 @@ QStringList QMimeType::suffixes() const
While this property was introduced in 5.10, the While this property was introduced in 5.10, the
corresponding accessor method has always been there. corresponding accessor method has always been there.
*/ */
QString QMimeType::preferredSuffix() const QString MimeType::preferredSuffix() const
{ {
if (isDefault()) // workaround for unwanted *.bin suffix for octet-stream, https://bugs.freedesktop.org/show_bug.cgi?id=101667, fixed upstream in 1.10 if (isDefault()) // workaround for unwanted *.bin suffix for octet-stream, https://bugs.freedesktop.org/show_bug.cgi?id=101667, fixed upstream in 1.10
return QString(); return QString();
@@ -476,15 +476,15 @@ QString QMimeType::preferredSuffix() const
} }
/*! /*!
\property QMimeType::filterString \property MimeType::filterString
\brief a filter string usable for a file dialog \brief a filter string usable for a file dialog
While this property was introduced in 5.10, the While this property was introduced in 5.10, the
corresponding accessor method has always been there. corresponding accessor method has always been there.
*/ */
QString QMimeType::filterString() const QString MimeType::filterString() const
{ {
QMimeDatabasePrivate::instance()->loadMimeTypePrivate(const_cast<QMimeTypePrivate&>(*d)); MimeDatabasePrivate::instance()->loadMimeTypePrivate(const_cast<MimeTypePrivate&>(*d));
QString filter; QString filter;
if (!d->globPatterns.empty()) { if (!d->globPatterns.empty()) {
@@ -501,33 +501,33 @@ QString QMimeType::filterString() const
} }
/*! /*!
\fn bool QMimeType::inherits(const QString &mimeTypeName) const; \fn bool MimeType::inherits(const QString &mimeTypeName) const;
Returns \c true if this mimetype is \a mimeTypeName, Returns \c true if this mimetype is \a mimeTypeName,
or inherits \a mimeTypeName (see parentMimeTypes()), or inherits \a mimeTypeName (see parentMimeTypes()),
or \a mimeTypeName is an alias for this mimetype. or \a mimeTypeName is an alias for this mimetype.
This method has been made invokable from QML since 5.10. This method has been made invokable from QML since 5.10.
*/ */
bool QMimeType::inherits(const QString &mimeTypeName) const bool MimeType::inherits(const QString &mimeTypeName) const
{ {
if (d->name == mimeTypeName) if (d->name == mimeTypeName)
return true; return true;
return QMimeDatabasePrivate::instance()->mimeInherits(d->name, mimeTypeName); return MimeDatabasePrivate::instance()->mimeInherits(d->name, mimeTypeName);
} }
} // namespace Utils
#ifndef QT_NO_DEBUG_STREAM #ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug debug, const QMimeType &mime) QDebug operator<<(QDebug debug, const Utils::MimeType &mime)
{ {
QDebugStateSaver saver(debug); QDebugStateSaver saver(debug);
if (!mime.isValid()) { if (!mime.isValid()) {
debug.nospace() << "QMimeType(invalid)"; debug.nospace() << "MimeType(invalid)";
} else { } else {
debug.nospace() << "QMimeType(" << mime.name() << ")"; debug.nospace() << "MimeType(" << mime.name() << ")";
} }
return debug; return debug;
} }
#endif #endif
QT_END_NAMESPACE #include "moc_mimetype.cpp"
#include "moc_qmimetype.cpp"

58
src/libs/utils/mimetypes2/mimetype.h
View File

@@ -38,26 +38,23 @@
** **
****************************************************************************/ ****************************************************************************/
#ifndef QMIMETYPE_H #pragma once
#define QMIMETYPE_H
#include <QtCore/qglobal.h> #include <utils/utils_global.h>
QT_REQUIRE_CONFIG(mimetype);
#include <QtCore/qobjectdefs.h> #include <QtCore/qobjectdefs.h>
#include <QtCore/qshareddata.h> #include <QtCore/qshareddata.h>
#include <QtCore/qstring.h> #include <QtCore/qstring.h>
#include <QtCore/qstringlist.h> #include <QtCore/qstringlist.h>
QT_BEGIN_NAMESPACE namespace Utils {
class QMimeTypePrivate; class MimeTypePrivate;
class QMimeType; class MimeType;
Q_CORE_EXPORT size_t qHash(const QMimeType &key, size_t seed = 0) noexcept; QTCREATOR_UTILS_EXPORT size_t qHash(const MimeType &key, size_t seed = 0) noexcept;
class Q_CORE_EXPORT QMimeType class QTCREATOR_UTILS_EXPORT MimeType
{ {
Q_GADGET Q_GADGET
Q_PROPERTY(bool valid READ isValid CONSTANT) Q_PROPERTY(bool valid READ isValid CONSTANT)
@@ -75,20 +72,20 @@ class Q_CORE_EXPORT QMimeType
Q_PROPERTY(QString filterString READ filterString CONSTANT) Q_PROPERTY(QString filterString READ filterString CONSTANT)
public: public:
QMimeType(); MimeType();
QMimeType(const QMimeType &other); MimeType(const MimeType &other);
QMimeType &operator=(const QMimeType &other); MimeType &operator=(const MimeType &other);
QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(QMimeType) QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(MimeType)
void swap(QMimeType &other) noexcept void swap(MimeType &other) noexcept
{ {
d.swap(other.d); d.swap(other.d);
} }
explicit QMimeType(const QMimeTypePrivate &dd); explicit MimeType(const MimeTypePrivate &dd);
~QMimeType(); ~MimeType();
bool operator==(const QMimeType &other) const; bool operator==(const MimeType &other) const;
inline bool operator!=(const QMimeType &other) const inline bool operator!=(const MimeType &other) const
{ {
return !operator==(other); return !operator==(other);
} }
@@ -113,24 +110,23 @@ public:
QString filterString() const; QString filterString() const;
protected: protected:
friend class QMimeTypeParserBase; friend class MimeTypeParserBase;
friend class MimeTypeMapEntry; friend class MimeTypeMapEntry;
friend class QMimeDatabasePrivate; friend class MimeDatabasePrivate;
friend class QMimeXMLProvider; friend class MimeXMLProvider;
friend class QMimeBinaryProvider; friend class MimeBinaryProvider;
friend class QMimeTypePrivate; friend class MimeTypePrivate;
friend Q_CORE_EXPORT size_t qHash(const QMimeType &key, size_t seed) noexcept; friend QTCREATOR_UTILS_EXPORT size_t qHash(const MimeType &key, size_t seed) noexcept;
QExplicitlySharedDataPointer<QMimeTypePrivate> d; QExplicitlySharedDataPointer<MimeTypePrivate> d;
}; };
Q_DECLARE_SHARED(QMimeType)
} // namespace Utils
#ifndef QT_NO_DEBUG_STREAM #ifndef QT_NO_DEBUG_STREAM
class QDebug; class QDebug;
Q_CORE_EXPORT QDebug operator<<(QDebug debug, const QMimeType &mime); QTCREATOR_UTILS_EXPORT QDebug operator<<(QDebug debug, const Utils::MimeType &mime);
#endif #endif
QT_END_NAMESPACE Q_DECLARE_SHARED(Utils::MimeType)
#endif // QMIMETYPE_H

22
src/libs/utils/mimetypes2/mimetype_p.h
View File

@@ -37,8 +37,7 @@
** **
****************************************************************************/ ****************************************************************************/
#ifndef QMIMETYPE_P_H #pragma once
#define QMIMETYPE_P_H
// //
// W A R N I N G // W A R N I N G
@@ -51,23 +50,20 @@
// We mean it. // We mean it.
// //
#include <QtCore/private/qglobal_p.h> #include "mimetype.h"
#include "qmimetype.h"
QT_REQUIRE_CONFIG(mimetype);
#include <QtCore/qhash.h> #include <QtCore/qhash.h>
#include <QtCore/qstringlist.h> #include <QtCore/qstringlist.h>
QT_BEGIN_NAMESPACE namespace Utils {
class Q_AUTOTEST_EXPORT QMimeTypePrivate : public QSharedData class MimeTypePrivate : public QSharedData
{ {
public: public:
typedef QHash<QString, QString> LocaleHash; typedef QHash<QString, QString> LocaleHash;
QMimeTypePrivate(); MimeTypePrivate();
explicit QMimeTypePrivate(const QMimeType &other); explicit MimeTypePrivate(const MimeType &other);
void clear(); void clear();
@@ -82,8 +78,9 @@ public:
QStringList globPatterns; QStringList globPatterns;
}; };
QT_END_NAMESPACE } // namespace Utils
#if 0
#define QMIMETYPE_BUILDER_FROM_RVALUE_REFS \ #define QMIMETYPE_BUILDER_FROM_RVALUE_REFS \
QT_BEGIN_NAMESPACE \ QT_BEGIN_NAMESPACE \
static QMimeType buildQMimeType ( \ static QMimeType buildQMimeType ( \
@@ -102,5 +99,4 @@ QT_END_NAMESPACE
return QMimeType(qMimeTypeData); \ return QMimeType(qMimeTypeData); \
} \ } \
QT_END_NAMESPACE QT_END_NAMESPACE
#endif
#endif // QMIMETYPE_P_H

62
src/libs/utils/mimetypes2/mimetypeparser.cpp
View File

@@ -37,12 +37,10 @@
** **
****************************************************************************/ ****************************************************************************/
#define QT_NO_CAST_FROM_ASCII #include "mimetypeparser_p.h"
#include "qmimetypeparser_p.h" #include "mimetype_p.h"
#include "mimemagicrulematcher_p.h"
#include "qmimetype_p.h"
#include "qmimemagicrulematcher_p.h"
#include <QtCore/QCoreApplication> #include <QtCore/QCoreApplication>
#include <QtCore/QDebug> #include <QtCore/QDebug>
@@ -51,7 +49,7 @@
#include <QtCore/QXmlStreamWriter> #include <QtCore/QXmlStreamWriter>
#include <QtCore/QStack> #include <QtCore/QStack>
QT_BEGIN_NAMESPACE namespace Utils {
// XML tags in MIME files // XML tags in MIME files
static const char mimeInfoTagC[] = "mime-info"; static const char mimeInfoTagC[] = "mime-info";
@@ -80,35 +78,35 @@ static const char matchOffsetAttributeC[] = "offset";
static const char matchMaskAttributeC[] = "mask"; static const char matchMaskAttributeC[] = "mask";
/*! /*!
\class QMimeTypeParser \class MimeTypeParser
\inmodule QtCore \inmodule QtCore
\internal \internal
\brief The QMimeTypeParser class parses MIME types, and builds a MIME database hierarchy by adding to QMimeDatabase. \brief The MimeTypeParser class parses MIME types, and builds a MIME database hierarchy by adding to MimeDatabase.
Populates QMimeDataBase Populates MimeDataBase
\sa QMimeDatabase, QMimeMagicRuleMatcher, MagicRule, MagicStringRule, MagicByteRule, GlobPattern \sa MimeDatabase, MimeMagicRuleMatcher, MagicRule, MagicStringRule, MagicByteRule, GlobPattern
\sa QMimeTypeParser \sa MimeTypeParser
*/ */
/*! /*!
\class QMimeTypeParserBase \class MimeTypeParserBase
\inmodule QtCore \inmodule QtCore
\internal \internal
\brief The QMimeTypeParserBase class parses for a sequence of <mime-type> in a generic way. \brief The MimeTypeParserBase class parses for a sequence of <mime-type> in a generic way.
Calls abstract handler function process for QMimeType it finds. Calls abstract handler function process for MimeType it finds.
\sa QMimeDatabase, QMimeMagicRuleMatcher, MagicRule, MagicStringRule, MagicByteRule, GlobPattern \sa MimeDatabase, MimeMagicRuleMatcher, MagicRule, MagicStringRule, MagicByteRule, GlobPattern
\sa QMimeTypeParser \sa MimeTypeParser
*/ */
/*! /*!
\fn virtual bool QMimeTypeParserBase::process(const QMimeType &t, QString *errorMessage) = 0; \fn virtual bool MimeTypeParserBase::process(const MimeType &t, QString *errorMessage) = 0;
Overwrite to process the sequence of parsed data Overwrite to process the sequence of parsed data
*/ */
QMimeTypeParserBase::ParseState QMimeTypeParserBase::nextState(ParseState currentState, QStringView startElement) MimeTypeParserBase::ParseState MimeTypeParserBase::nextState(ParseState currentState, QStringView startElement)
{ {
switch (currentState) { switch (currentState) {
case ParseBeginning: case ParseBeginning:
@@ -161,7 +159,7 @@ QMimeTypeParserBase::ParseState QMimeTypeParserBase::nextState(ParseState curren
} }
// Parse int number from an (attribute) string // Parse int number from an (attribute) string
bool QMimeTypeParserBase::parseNumber(QStringView n, int *target, QString *errorMessage) bool MimeTypeParserBase::parseNumber(QStringView n, int *target, QString *errorMessage)
{ {
bool ok; bool ok;
*target = n.toInt(&ok); *target = n.toInt(&ok);
@@ -177,7 +175,7 @@ bool QMimeTypeParserBase::parseNumber(QStringView n, int *target, QString *error
struct CreateMagicMatchRuleResult struct CreateMagicMatchRuleResult
{ {
QString errorMessage; // must be first QString errorMessage; // must be first
QMimeMagicRule rule; MimeMagicRule rule;
CreateMagicMatchRuleResult(QStringView type, QStringView value, QStringView offsets, QStringView mask) CreateMagicMatchRuleResult(QStringView type, QStringView value, QStringView offsets, QStringView mask)
: errorMessage(), rule(type.toString(), value.toUtf8(), offsets.toString(), mask.toLatin1(), &errorMessage) : errorMessage(), rule(type.toString(), value.toUtf8(), offsets.toString(), mask.toLatin1(), &errorMessage)
@@ -196,7 +194,7 @@ static CreateMagicMatchRuleResult createMagicMatchRule(const QXmlStreamAttribute
} }
#endif #endif
bool QMimeTypeParserBase::parse(QIODevice *dev, const QString &fileName, QString *errorMessage) bool MimeTypeParserBase::parse(QIODevice *dev, const QString &fileName, QString *errorMessage)
{ {
#ifdef QT_NO_XMLSTREAMREADER #ifdef QT_NO_XMLSTREAMREADER
Q_UNUSED(dev); Q_UNUSED(dev);
@@ -204,11 +202,11 @@ bool QMimeTypeParserBase::parse(QIODevice *dev, const QString &fileName, QString
*errorMessage = QString::fromLatin1("QXmlStreamReader is not available, cannot parse '%1'.").arg(fileName); *errorMessage = QString::fromLatin1("QXmlStreamReader is not available, cannot parse '%1'.").arg(fileName);
return false; return false;
#else #else
QMimeTypePrivate data; MimeTypePrivate data;
data.loaded = true; data.loaded = true;
int priority = 50; int priority = 50;
QStack<QMimeMagicRule *> currentRules; // stack for the nesting of rules QStack<MimeMagicRule *> currentRules; // stack for the nesting of rules
QList<QMimeMagicRule> rules; // toplevel rules QList<MimeMagicRule> rules; // toplevel rules
QXmlStreamReader reader(dev); QXmlStreamReader reader(dev);
ParseState ps = ParseBeginning; ParseState ps = ParseBeginning;
while (!reader.atEnd()) { while (!reader.atEnd()) {
@@ -238,13 +236,13 @@ bool QMimeTypeParserBase::parse(QIODevice *dev, const QString &fileName, QString
const bool caseSensitive = atts.value(QLatin1String(caseSensitiveAttributeC)) == QLatin1String("true"); const bool caseSensitive = atts.value(QLatin1String(caseSensitiveAttributeC)) == QLatin1String("true");
if (weight == 0) if (weight == 0)
weight = QMimeGlobPattern::DefaultWeight; weight = MimeGlobPattern::DefaultWeight;
Q_ASSERT(!data.name.isEmpty()); Q_ASSERT(!data.name.isEmpty());
const QMimeGlobPattern glob(pattern, data.name, weight, caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive); const MimeGlobPattern glob(pattern, data.name, weight, caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive);
if (!process(glob, errorMessage)) // for actual glob matching if (!process(glob, errorMessage)) // for actual glob matching
return false; return false;
data.addGlobPattern(pattern); // just for QMimeType::globPatterns() data.addGlobPattern(pattern); // just for MimeType::globPatterns()
} }
break; break;
case ParseGlobDeleteAll: case ParseGlobDeleteAll:
@@ -286,9 +284,9 @@ bool QMimeTypeParserBase::parse(QIODevice *dev, const QString &fileName, QString
case ParseMagicMatchRule: { case ParseMagicMatchRule: {
auto result = createMagicMatchRule(atts); auto result = createMagicMatchRule(atts);
if (Q_UNLIKELY(!result.rule.isValid())) if (Q_UNLIKELY(!result.rule.isValid()))
qWarning("QMimeDatabase: Error parsing %ls\n%ls", qWarning("MimeDatabase: Error parsing %ls\n%ls",
qUtf16Printable(fileName), qUtf16Printable(result.errorMessage)); qUtf16Printable(fileName), qUtf16Printable(result.errorMessage));
QList<QMimeMagicRule> *ruleList; QList<MimeMagicRule> *ruleList;
if (currentRules.isEmpty()) if (currentRules.isEmpty())
ruleList = &rules; ruleList = &rules;
else // nest this rule into the proper parent else // nest this rule into the proper parent
@@ -311,7 +309,7 @@ bool QMimeTypeParserBase::parse(QIODevice *dev, const QString &fileName, QString
{ {
const auto elementName = reader.name(); const auto elementName = reader.name();
if (elementName == QLatin1String(mimeTypeTagC)) { if (elementName == QLatin1String(mimeTypeTagC)) {
if (!process(QMimeType(data), errorMessage)) if (!process(MimeType(data), errorMessage))
return false; return false;
data.clear(); data.clear();
} else if (elementName == QLatin1String(matchTagC)) { } else if (elementName == QLatin1String(matchTagC)) {
@@ -321,7 +319,7 @@ bool QMimeTypeParserBase::parse(QIODevice *dev, const QString &fileName, QString
} else if (elementName == QLatin1String(magicTagC)) { } else if (elementName == QLatin1String(magicTagC)) {
//qDebug() << "MAGIC ended, we got" << rules.count() << "rules, with prio" << priority; //qDebug() << "MAGIC ended, we got" << rules.count() << "rules, with prio" << priority;
// Finished a <magic> sequence // Finished a <magic> sequence
QMimeMagicRuleMatcher ruleMatcher(data.name, priority); MimeMagicRuleMatcher ruleMatcher(data.name, priority);
ruleMatcher.addRules(rules); ruleMatcher.addRules(rules);
processMagicMatcher(ruleMatcher); processMagicMatcher(ruleMatcher);
rules.clear(); rules.clear();
@@ -347,4 +345,4 @@ bool QMimeTypeParserBase::parse(QIODevice *dev, const QString &fileName, QString
#endif //QT_NO_XMLSTREAMREADER #endif //QT_NO_XMLSTREAMREADER
} }
QT_END_NAMESPACE } // namespace Utils

44
src/libs/utils/mimetypes2/mimetypeparser_p.h
View File

@@ -37,9 +37,7 @@
** **
****************************************************************************/ ****************************************************************************/
#pragma once
#ifndef QMIMETYPEPARSER_P_H
#define QMIMETYPEPARSER_P_H
// //
// W A R N I N G // W A R N I N G
@@ -52,34 +50,34 @@
// We mean it. // We mean it.
// //
#include "qmimedatabase_p.h" #include "mimedatabase_p.h"
QT_REQUIRE_CONFIG(mimetype); #include "mimeprovider_p.h"
#include "qmimeprovider_p.h"
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
class QIODevice; class QIODevice;
QT_END_NAMESPACE
class QMimeTypeParserBase namespace Utils {
class MimeTypeParserBase
{ {
Q_DISABLE_COPY_MOVE(QMimeTypeParserBase) Q_DISABLE_COPY_MOVE(MimeTypeParserBase)
public: public:
QMimeTypeParserBase() {} MimeTypeParserBase() {}
virtual ~QMimeTypeParserBase() {} virtual ~MimeTypeParserBase() {}
bool parse(QIODevice *dev, const QString &fileName, QString *errorMessage); bool parse(QIODevice *dev, const QString &fileName, QString *errorMessage);
static bool parseNumber(QStringView n, int *target, QString *errorMessage); static bool parseNumber(QStringView n, int *target, QString *errorMessage);
protected: protected:
virtual bool process(const QMimeType &t, QString *errorMessage) = 0; virtual bool process(const MimeType &t, QString *errorMessage) = 0;
virtual bool process(const QMimeGlobPattern &t, QString *errorMessage) = 0; virtual bool process(const MimeGlobPattern &t, QString *errorMessage) = 0;
virtual void processParent(const QString &child, const QString &parent) = 0; virtual void processParent(const QString &child, const QString &parent) = 0;
virtual void processAlias(const QString &alias, const QString &name) = 0; virtual void processAlias(const QString &alias, const QString &name) = 0;
virtual void processMagicMatcher(const QMimeMagicRuleMatcher &matcher) = 0; virtual void processMagicMatcher(const MimeMagicRuleMatcher &matcher) = 0;
private: private:
enum ParseState { enum ParseState {
@@ -103,16 +101,16 @@ private:
}; };
class QMimeTypeParser : public QMimeTypeParserBase class MimeTypeParser : public MimeTypeParserBase
{ {
public: public:
explicit QMimeTypeParser(QMimeXMLProvider &provider) : m_provider(provider) {} explicit MimeTypeParser(MimeXMLProvider &provider) : m_provider(provider) {}
protected: protected:
inline bool process(const QMimeType &t, QString *) override inline bool process(const MimeType &t, QString *) override
{ m_provider.addMimeType(t); return true; } { m_provider.addMimeType(t); return true; }
inline bool process(const QMimeGlobPattern &glob, QString *) override inline bool process(const MimeGlobPattern &glob, QString *) override
{ m_provider.addGlobPattern(glob); return true; } { m_provider.addGlobPattern(glob); return true; }
inline void processParent(const QString &child, const QString &parent) override inline void processParent(const QString &child, const QString &parent) override
@@ -121,13 +119,11 @@ protected:
inline void processAlias(const QString &alias, const QString &name) override inline void processAlias(const QString &alias, const QString &name) override
{ m_provider.addAlias(alias, name); } { m_provider.addAlias(alias, name); }
inline void processMagicMatcher(const QMimeMagicRuleMatcher &matcher) override inline void processMagicMatcher(const MimeMagicRuleMatcher &matcher) override
{ m_provider.addMagicMatcher(matcher); } { m_provider.addMagicMatcher(matcher); }
private: private:
QMimeXMLProvider &m_provider; MimeXMLProvider &m_provider;
}; };
QT_END_NAMESPACE } // namespace Utils
#endif // MIMETYPEPARSER_P_H