Public Functions
bool	find (QDeclarativeTypeLoader typeLoader, const QByteArray &type, int vmajor, int vminor, QDeclarativeType type_return, QUrl url_return, QUrl base=0, QString errorString=0)

bool	find_helper (QDeclarativeTypeLoader typeLoader, int i, const QByteArray &type, int vmajor, int vminor, QDeclarativeType type_return, QUrl url_return, QUrl base=0, bool typeRecursionDetected=0)

Public Variables
QList< bool >	isLibrary

QList< int >	majversions

QList< int >	minversions

QList< QDeclarativeDirComponents >	qmlDirComponents

QStringList	uris

QStringList	urls

Detailed Description

Definition at line 72 of file qdeclarativeimport.cpp.

Functions

◆ find()

bool QDeclarativeImportedNamespace::find	(	QDeclarativeTypeLoader *	typeLoader,
		const QByteArray &	type,
		int *	vmajor,
		int *	vminor,
		QDeclarativeType **	type_return,
		QUrl *	url_return,
		QUrl *	base = `0`,
		QString *	errorString = `0`
	)

Definition at line 681 of file qdeclarativeimport.cpp.

Referenced by QDeclarativeImportsPrivate::find(), and QDeclarativeImports::resolveType().

 {
     bool typeRecursionDetected = false;
     for (int i=0; i<urls.count(); ++i) {
         if (find_helper(typeLoader, i, type, vmajor, vminor, type_return, url_return, base, &typeRecursionDetected)) {
             if (qmlCheckTypes()) {
                 // check for type clashes
                 for (int j = i+1; j<urls.count(); ++j) {
                     if (find_helper(typeLoader, j, type, vmajor, vminor, 0, 0, base)) {
                         if (errorString) {
                             QString u1 = urls.at(i);
                             QString u2 = urls.at(j);
                             if (base) {
                                 QString b = base->toString();
                                 int slash = b.lastIndexOf(QLatin1Char('/'));
                                 if (slash >= 0) {
                                     b = b.left(slash+1);
                                     QString l = b.left(slash);
                                     if (u1.startsWith(b))
                                         u1 = u1.mid(b.count());
                                     else if (u1 == l)
                                         u1 = QDeclarativeImportDatabase::tr("local directory");
                                     if (u2.startsWith(b))
                                         u2 = u2.mid(b.count());
                                     else if (u2 == l)
                                         u2 = QDeclarativeImportDatabase::tr("local directory");
                                 }
                             }
 
                             if (u1 != u2)
                                 *errorString
                                         = QDeclarativeImportDatabase::tr("is ambiguous. Found in %1 and in %2")
                                 .arg(u1).arg(u2);
                             else
                                 *errorString
                                         = QDeclarativeImportDatabase::tr("is ambiguous. Found in %1 in version %2.%3 and %4.%5")
                                           .arg(u1)
                                           .arg(majversions.at(i)).arg(minversions.at(i))
                                           .arg(majversions.at(j)).arg(minversions.at(j));
                         }
                         return false;
                     }
                 }
             }
             return true;
         }
     }
     if (errorString) {
         if (typeRecursionDetected)
             *errorString = QDeclarativeImportDatabase::tr("is instantiated recursively");
         else
             *errorString = QDeclarativeImportDatabase::tr("is not a type");
     }
     return false;
 }

◆ find_helper()

bool QDeclarativeImportedNamespace::find_helper	(	QDeclarativeTypeLoader *	typeLoader,
		int	i,
		const QByteArray &	type,
		int *	vmajor,
		int *	vminor,
		QDeclarativeType **	type_return,
		QUrl *	url_return,
		QUrl *	base = `0`,
		bool *	typeRecursionDetected = `0`
	)

Definition at line 289 of file qdeclarativeimport.cpp.

 {
     int vmaj = majversions.at(i);
     int vmin = minversions.at(i);
 
     QByteArray qt = uris.at(i).toUtf8();
     qt += '/';
     qt += type;
 
     QDeclarativeType *t = QDeclarativeMetaType::qmlType(qt,vmaj,vmin);
     if (t) {
         if (vmajor) *vmajor = vmaj;
         if (vminor) *vminor = vmin;
         if (type_return)
             *type_return = t;
         return true;
     }
 
     QDeclarativeDirComponents qmldircomponents = qmlDirComponents.at(i);
 
     bool typeWasDeclaredInQmldir = false;
     if (!qmldircomponents.isEmpty()) {
         const QString typeName = QString::fromUtf8(type);
         foreach (const QDeclarativeDirParser::Component &c, qmldircomponents) {
             if (c.typeName == typeName) {
                 typeWasDeclaredInQmldir = true;
 
                 // importing version -1 means import ALL versions
                 if ((vmaj == -1) || (c.majorVersion < vmaj || (c.majorVersion == vmaj && vmin >= c.minorVersion))) {
                     QUrl url = QUrl(urls.at(i) + QLatin1Char('/') + QString::fromUtf8(type) + QLatin1String(".qml"));
                     QUrl candidate = url.resolved(QUrl(c.fileName));
                     if (c.internal && base) {
                         if (base->resolved(QUrl(c.fileName)) != candidate)
                             continue; // failed attempt to access an internal type
                     }
                     if (base && *base == candidate) {
                         if (typeRecursionDetected)
                             *typeRecursionDetected = true;
                         continue; // no recursion
                     }
                     if (url_return)
                         *url_return = candidate;
                     return true;
                 }
             }
         }
     }
 
     if (!typeWasDeclaredInQmldir  && !isLibrary.at(i)) {
         // XXX search non-files too! (eg. zip files, see QT-524)
         QUrl url = QUrl(urls.at(i) + QLatin1Char('/') + QString::fromUtf8(type) + QLatin1String(".qml"));
         QString file = QDeclarativeEnginePrivate::urlToLocalFileOrQrc(url);
         if (!typeLoader->absoluteFilePath(file).isEmpty()) {
             if (base && *base == url) { // no recursion
                 if (typeRecursionDetected)
                     *typeRecursionDetected = true;
             } else {
                 if (url_return)
                     *url_return = url;
                 return true;
             }
         }
     }
     return false;
 }