QDeclarativeImportsPrivate Class Reference

Public Functions
bool	add (const QDeclarativeDirComponents &qmldircomponentsnetwork, const QString &uri_arg, const QString &prefix, int vmaj, int vmin, QDeclarativeScriptParser::Import::Type importType, QDeclarativeImportDatabase *database, QString *errorString)
bool	find (const QByteArray &type, int *vmajor, int *vminor, QDeclarativeType **type_return, QUrl *url_return, QString *errorString)
QDeclarativeImportedNamespace *	findNamespace (const QString &type)
bool	importExtension (const QString &absoluteFilePath, const QString &uri, QDeclarativeImportDatabase *database, QDeclarativeDirComponents *components, QString *errorString)
	QDeclarativeImportsPrivate (QDeclarativeTypeLoader *loader)
QString	resolvedUri (const QString &dir_arg, QDeclarativeImportDatabase *database)
	~QDeclarativeImportsPrivate ()

Public Variables
QUrl	base
QSet< QString >	qmlDirFilesForWhichPluginsHaveBeenLoaded
int	ref
QHash< QString, QDeclarativeImportedNamespace *>	set
QDeclarativeTypeLoader *	typeLoader
QDeclarativeImportedNamespace	unqualifiedset

Detailed Description

Definition at line 90 of file qdeclarativeimport.cpp.

Constructors and Destructors

QDeclarativeImportsPrivate()

QDeclarativeImportsPrivate::QDeclarativeImportsPrivate

(

QDeclarativeTypeLoader *

loader

)

Definition at line 357 of file qdeclarativeimport.cpp.

    : ref(1), typeLoader(loader){
}

~QDeclarativeImportsPrivate()

QDeclarativeImportsPrivate::~QDeclarativeImportsPrivate

(

)

Definition at line 361 of file qdeclarativeimport.cpp.

{
    foreach (QDeclarativeImportedNamespace* s, set.values())
        delete s;
}

Functions

add()

bool QDeclarativeImportsPrivate::add	(	const QDeclarativeDirComponents &	qmldircomponentsnetwork,
		const QString &	uri_arg,
		const QString &	prefix,
		int	vmaj,
		int	vmin,
		QDeclarativeScriptParser::Import::Type	importType,
		QDeclarativeImportDatabase *	database,
		QString *	errorString
	)

Definition at line 447 of file qdeclarativeimport.cpp.

{
    Q_ASSERT(typeLoader);
    QDeclarativeDirComponents qmldircomponents = qmldircomponentsnetwork;
    QString uri = uri_arg;
    QDeclarativeImportedNamespace *s;
    if (prefix.isEmpty()) {
        s = &unqualifiedset;
    } else {
        s = set.value(prefix);
        if (!s)
            set.insert(prefix,(s=new QDeclarativeImportedNamespace));
    }

    bool appendInstead = false;
    if (importType == QDeclarativeScriptParser::Import::Implicit) {
        //Treat same as a File import, but lower precedence
        appendInstead = true;
        importType = QDeclarativeScriptParser::Import::File;
    }

    QString url = uri;
    bool versionFound = false;
    if (importType == QDeclarativeScriptParser::Import::Library) {
        url.replace(QLatin1Char('.'), QLatin1Char('/'));
        bool found = false;
        QString dir;
        QString qmldir;

        // step 1: search for extension with fully encoded version number
        if (vmaj >= 0 && vmin >= 0) {
            foreach (const QString &p, database->fileImportPath) {
                dir = p+QLatin1Char('/')+url;
                qmldir = dir+QString(QLatin1String(".%1.%2")).arg(vmaj).arg(vmin)+QLatin1String("/qmldir");

                QString absoluteFilePath = typeLoader->absoluteFilePath(qmldir);
                if (!absoluteFilePath.isEmpty()) {
                    found = true;

                    QString absolutePath = absoluteFilePath.left(absoluteFilePath.lastIndexOf(QLatin1Char('/')));
                    url = QUrl::fromLocalFile(absolutePath).toString();
                    uri = resolvedUri(dir, database);
                    if (!importExtension(absoluteFilePath, uri, database, &qmldircomponents, errorString))
                        return false;
                    break;
                }
            }
        }
        // step 2: search for extension with encoded version major
        if (vmaj >= 0 && vmin >= 0) {
            foreach (const QString &p, database->fileImportPath) {
                dir = p+QLatin1Char('/')+url;
                qmldir = dir+QString(QLatin1String(".%1")).arg(vmaj)+QLatin1String("/qmldir");

                QString absoluteFilePath = typeLoader->absoluteFilePath(qmldir);
                if (!absoluteFilePath.isEmpty()) {
                    found = true;

                    QString absolutePath = absoluteFilePath.left(absoluteFilePath.lastIndexOf(QLatin1Char('/')));
                    url = QUrl::fromLocalFile(absolutePath).toString();
                    uri = resolvedUri(dir, database);
                    if (!importExtension(absoluteFilePath, uri, database, &qmldircomponents, errorString))
                        return false;
                    break;
                }
            }
        }
        if (!found) {
            // step 3: search for extension without version number

            foreach (const QString &p, database->fileImportPath) {
                dir = p+QLatin1Char('/')+url;
                qmldir = dir+QLatin1String("/qmldir");

                QString absoluteFilePath = typeLoader->absoluteFilePath(qmldir);
                if (!absoluteFilePath.isEmpty()) {
                    found = true;

                    QString absolutePath = absoluteFilePath.left(absoluteFilePath.lastIndexOf(QLatin1Char('/')));
                    url = QUrl::fromLocalFile(absolutePath).toString();
                    uri = resolvedUri(dir, database);
                    if (!importExtension(absoluteFilePath, uri, database, &qmldircomponents, errorString))
                        return false;
                    break;
                }
            }
        }

        if (QDeclarativeMetaType::isModule(uri.toUtf8(), vmaj, vmin))
            versionFound = true;

        //Load any type->file mappings registered for this uri
        qmldircomponents << QDeclarativeMetaType::qmlComponents(uri.toUtf8(), vmaj, vmin);

        if (!versionFound && qmldircomponents.isEmpty()) {
            if (errorString) {
                bool anyversion = QDeclarativeMetaType::isModule(uri.toUtf8(), -1, -1);
                if (anyversion)
                    *errorString = QDeclarativeImportDatabase::tr("module \"%1\" version %2.%3 is not installed").arg(uri_arg).arg(vmaj).arg(vmin);
                else
                    *errorString = QDeclarativeImportDatabase::tr("module \"%1\" is not installed").arg(uri_arg);
            }
            return false;
        }
    } else {

        if (importType == QDeclarativeScriptParser::Import::File && qmldircomponents.isEmpty()) {
            QUrl importUrl = base.resolved(QUrl(uri + QLatin1String("/qmldir")));
            QString localFileOrQrc = QDeclarativeEnginePrivate::urlToLocalFileOrQrc(importUrl);
            if (!localFileOrQrc.isEmpty()) {
                QString dir = QDeclarativeEnginePrivate::urlToLocalFileOrQrc(base.resolved(QUrl(uri)));
                QFileInfo dirinfo(dir);
                if (dir.isEmpty() || !dirinfo.exists() || !dirinfo.isDir()) {
                    if (errorString)
                        *errorString = QDeclarativeImportDatabase::tr("\"%1\": no such directory").arg(uri_arg);
                    return false; // local import dirs must exist
                }
                uri = resolvedUri(QDeclarativeEnginePrivate::urlToLocalFileOrQrc(base.resolved(QUrl(uri))), database);
                if (uri.endsWith(QLatin1Char('/')))
                    uri.chop(1);
                if (!typeLoader->absoluteFilePath(localFileOrQrc).isEmpty()) {
                    if (!importExtension(localFileOrQrc,uri,database,&qmldircomponents,errorString))
                        return false;
                }
            } else {
                if (prefix.isEmpty()) {
                    // directory must at least exist for valid import
                    QString localFileOrQrc = QDeclarativeEnginePrivate::urlToLocalFileOrQrc(base.resolved(QUrl(uri)));
                    QFileInfo dirinfo(localFileOrQrc);
                    if (localFileOrQrc.isEmpty() || !dirinfo.exists() || !dirinfo.isDir()) {
                        if (errorString) {
                            if (localFileOrQrc.isEmpty())
                                *errorString = QDeclarativeImportDatabase::tr("import \"%1\" has no qmldir and no namespace").arg(uri);
                            else
                                *errorString = QDeclarativeImportDatabase::tr("\"%1\": no such directory").arg(uri);
                        }
                        return false;
                    }
                }
            }
        }

        url = base.resolved(QUrl(url)).toString();
        if (url.endsWith(QLatin1Char('/')))
            url.chop(1);
    }

    if (!versionFound && vmaj > -1 && vmin > -1 && !qmldircomponents.isEmpty()) {
        QList<QDeclarativeDirParser::Component>::ConstIterator it = qmldircomponents.begin();
        int lowest_maj = INT_MAX;
        int lowest_min = INT_MAX;
        int highest_maj = INT_MIN;
        int highest_min = INT_MIN;
        for (; it != qmldircomponents.end(); ++it) {
            if (it->majorVersion > highest_maj || (it->majorVersion == highest_maj && it->minorVersion > highest_min)) {
                highest_maj = it->majorVersion;
                highest_min = it->minorVersion;
            }
            if (it->majorVersion < lowest_maj || (it->majorVersion == lowest_maj && it->minorVersion < lowest_min)) {
                lowest_maj = it->majorVersion;
                lowest_min = it->minorVersion;
            }
        }
        if (lowest_maj > vmaj || (lowest_maj == vmaj && lowest_min > vmin)
            || highest_maj < vmaj || (highest_maj == vmaj && highest_min < vmin))
        {
            *errorString = QDeclarativeImportDatabase::tr("module \"%1\" version %2.%3 is not installed").arg(uri_arg).arg(vmaj).arg(vmin);
            return false;
        }
    }

    if (appendInstead) {
        s->uris.append(uri);
        s->urls.append(url);
        s->majversions.append(vmaj);
        s->minversions.append(vmin);
        s->isLibrary.append(importType == QDeclarativeScriptParser::Import::Library);
        s->qmlDirComponents.append(qmldircomponents);
    } else {
        s->uris.prepend(uri);
        s->urls.prepend(url);
        s->majversions.prepend(vmaj);
        s->minversions.prepend(vmin);
        s->isLibrary.prepend(importType == QDeclarativeScriptParser::Import::Library);
        s->qmlDirComponents.prepend(qmldircomponents);
    }
    return true;
}

find()

bool QDeclarativeImportsPrivate::find	(	const QByteArray &	type,
		int *	vmajor,
		int *	vminor,
		QDeclarativeType **	type_return,
		QUrl *	url_return,
		QString *	errorString
	)

Definition at line 639 of file qdeclarativeimport.cpp.

Referenced by QDeclarativeImports::resolveType().

{
    Q_ASSERT(typeLoader);
    QDeclarativeImportedNamespace *s = 0;
    int slash = type.indexOf('/');
    if (slash >= 0) {
        QString namespaceName = QString::fromUtf8(type.left(slash));
        s = set.value(namespaceName);
        if (!s) {
            if (errorString)
                *errorString = QDeclarativeImportDatabase::tr("- %1 is not a namespace").arg(namespaceName);
            return false;
        }
        int nslash = type.indexOf('/',slash+1);
        if (nslash > 0) {
            if (errorString)
                *errorString = QDeclarativeImportDatabase::tr("- nested namespaces not allowed");
            return false;
        }
    } else {
        s = &unqualifiedset;
    }
    QByteArray unqualifiedtype = slash < 0 ? type : type.mid(slash+1); // common-case opt (QString::mid works fine, but slower)
    if (s) {
        if (s->find(typeLoader, unqualifiedtype,vmajor,vminor,type_return,url_return, &base, errorString))
            return true;
        if (s->urls.count() == 1 && !s->isLibrary[0] && url_return && s != &unqualifiedset) {
            // qualified, and only 1 url
            *url_return = QUrl(s->urls[0]+QLatin1Char('/')).resolved(QUrl(QString::fromUtf8(unqualifiedtype) + QLatin1String(".qml")));
            return true;
        }
    }

    return false;
}

findNamespace()

QDeclarativeImportedNamespace * QDeclarativeImportsPrivate::findNamespace

(

const QString &

type

)

Definition at line 676 of file qdeclarativeimport.cpp.

Referenced by QDeclarativeImports::resolveType().

{
    return set.value(type);
}

importExtension()

bool QDeclarativeImportsPrivate::importExtension	(	const QString &	absoluteFilePath,
		const QString &	uri,
		QDeclarativeImportDatabase *	database,
		QDeclarativeDirComponents *	components,
		QString *	errorString
	)

Definition at line 367 of file qdeclarativeimport.cpp.

Referenced by add().

{
    Q_ASSERT(typeLoader);
    const QDeclarativeDirParser *qmldirParser = typeLoader->qmlDirParser(absoluteFilePath);
    if (qmldirParser->hasError()) {
        if (errorString) {
            const QList<QDeclarativeError> qmldirErrors = qmldirParser->errors(uri);
            for (int i = 0; i < qmldirErrors.size(); ++i)
                *errorString += qmldirErrors.at(i).description();
        }
        return false;
    }

    if (! qmlDirFilesForWhichPluginsHaveBeenLoaded.contains(absoluteFilePath)) {
        qmlDirFilesForWhichPluginsHaveBeenLoaded.insert(absoluteFilePath);

        QDir dir = QFileInfo(absoluteFilePath).dir();
        foreach (const QDeclarativeDirParser::Plugin &plugin, qmldirParser->plugins()) {

            QString resolvedFilePath = database->resolvePlugin(dir, plugin.path, plugin.name);
#if defined(QT_LIBINFIX) && defined(Q_OS_SYMBIAN)
            if (resolvedFilePath.isEmpty()) {
                // In case of libinfixed build, attempt to load libinfixed version, too.
                QString infixedPluginName = plugin.name + QLatin1String(QT_LIBINFIX);
                resolvedFilePath = database->resolvePlugin(dir, plugin.path, infixedPluginName);
            }
#endif
            if (!resolvedFilePath.isEmpty()) {
                if (!database->importPlugin(resolvedFilePath, uri, errorString)) {
                    if (errorString)
                        *errorString = QDeclarativeImportDatabase::tr("plugin cannot be loaded for module \"%1\": %2").arg(uri).arg(*errorString);
                    return false;
                }
            } else {
                if (errorString)
                    *errorString = QDeclarativeImportDatabase::tr("module \"%1\" plugin \"%2\" not found").arg(uri).arg(plugin.name);
                return false;
            }
        }
    }

    if (components)
        *components = qmldirParser->components();

    return true;
}

resolvedUri()

QString QDeclarativeImportsPrivate::resolvedUri	(	const QString &	dir_arg,
		QDeclarativeImportDatabase *	database
	)

Definition at line 416 of file qdeclarativeimport.cpp.

Referenced by add().

{
    QString dir = dir_arg;
    if (dir.endsWith(QLatin1Char('/')) || dir.endsWith(QLatin1Char('\\')))
        dir.chop(1);

    QStringList paths = database->fileImportPath;
    qSort(paths.begin(), paths.end(), greaterThan); // Ensure subdirs preceed their parents.

    QString stableRelativePath = dir;
    foreach(const QString &path, paths) {
        if (dir.startsWith(path)) {
            stableRelativePath = dir.mid(path.length()+1);
            break;
        }
    }

    stableRelativePath.replace(QLatin1Char('\\'), QLatin1Char('/'));

    // remove optional versioning in dot notation from uri
    int lastSlash = stableRelativePath.lastIndexOf(QLatin1Char('/'));
    if (lastSlash >= 0) {
        int versionDot = stableRelativePath.indexOf(QLatin1Char('.'), lastSlash);
        if (versionDot >= 0)
            stableRelativePath = stableRelativePath.left(versionDot);
    }

    stableRelativePath.replace(QLatin1Char('/'), QLatin1Char('.'));
    return stableRelativePath;
}

Properties

base

QUrl QDeclarativeImportsPrivate::base

Definition at line 109 of file qdeclarativeimport.cpp.

Referenced by add(), QDeclarativeImports::baseUrl(), find(), and QDeclarativeImports::setBaseUrl().

qmlDirFilesForWhichPluginsHaveBeenLoaded

QSet<QString> QDeclarativeImportsPrivate::qmlDirFilesForWhichPluginsHaveBeenLoaded

Definition at line 112 of file qdeclarativeimport.cpp.

Referenced by importExtension().

ref

int QDeclarativeImportsPrivate::ref

Definition at line 110 of file qdeclarativeimport.cpp.

Referenced by QDeclarativeImports::operator=(), QDeclarativeImports::QDeclarativeImports(), and QDeclarativeImports::~QDeclarativeImports().

set

QHash<QString,QDeclarativeImportedNamespace* > QDeclarativeImportsPrivate::set

Definition at line 114 of file qdeclarativeimport.cpp.

Referenced by QDeclarativeImports::populateCache().

typeLoader

QDeclarativeTypeLoader* QDeclarativeImportsPrivate::typeLoader

Definition at line 115 of file qdeclarativeimport.cpp.

Referenced by add(), find(), importExtension(), and QDeclarativeImports::resolveType().

unqualifiedset

QDeclarativeImportedNamespace QDeclarativeImportsPrivate::unqualifiedset

Definition at line 113 of file qdeclarativeimport.cpp.

Referenced by add(), find(), and QDeclarativeImports::populateCache().

---

The documentation for this class was generated from the following file:

• /src/declarative/qml/qdeclarativeimport.cpp