C++ QRegularExpression::match方法代码示例

bool CRegularExpressionRule::match(const QList<QString>& lQuery, const QString& sContent) const
{
	Q_ASSERT( m_nType == RuleType::RegularExpression );

	if ( m_sContent.isEmpty() )
		return false;

	if ( m_bSpecialElements )
	{
		// Build a regular expression filter from the search query words.
		// Returns an empty string if not applied or if the filter was invalid.
		//
		// Substitutes:
		// <_> - inserts all query keywords;
		// <0>..<9> - inserts query keyword number 0..9;
		// <> - inserts next query keyword.
		//
		// For example regular expression:
		//	.*(<2><1>)|(<_>).*
		// for "music mp3" query will be converted to:
		//	.*(mp3\s*music\s*)|(music\s*mp3\s*).*
		//
		// Note: \s* - matches any number of white-space symbols (including zero).

		QString sFilter, sBaseFilter = m_sContent;

		int pos = sBaseFilter.indexOf( '<' );
		if ( pos != -1 )
		{
			quint8 nArg = 0;

			// replace all relevant occurrences of <*something*
			while ( pos != -1 );
			{
				sFilter += sBaseFilter.left( pos );
				sBaseFilter.remove( 0, pos );
				bool bSuccess = replace( sBaseFilter, lQuery, nArg );

				pos = sBaseFilter.indexOf( '<', bSuccess ? 0 : 1 );
			}
			// add whats left of the base filter string to the newly generated filter
			sFilter += sBaseFilter;

			QRegularExpression oRegExpFilter = QRegularExpression( sFilter );
			return oRegExpFilter.match( sContent ).hasMatch();
		}
		else
		{
			// This shouldn't happen, but it's covered anyway...
			Q_ASSERT( false );

			QRegularExpression oRegExpFilter = QRegularExpression( m_sContent );
			return oRegExpFilter.match( sContent ).hasMatch();
		}
	}
	else
	{
		return m_regularExpressionContent.match( sContent ).hasMatch();
	}
}

int Walltime::toInt( QString const& string )
{
    int h,m;
    int s = -1;
    QRegularExpression re;
    QRegularExpressionMatch rem;
 // "h+:mm:ss"
    re.setPattern("^(\\d+):(\\d+):(\\d+)");
    rem = re.match(string);
    if( rem.hasMatch() ) {
        try {
            h = rem.captured(1).toInt();
            m = rem.captured(2).toInt();
            s = rem.captured(3).toInt();
            s+= h*3600 + m*60;
        } catch(...) {
            s = -1;
        }
        return s;
    }
 // "<integer>unit" where unit is d|h|m|s (case insensitive)
    re.setPattern("^\\s*(\\d+)\\s*([dhmsDHMS]?)\\s*$");
    rem = re.match( string );
    if( rem.hasMatch() ) {
        QString number = rem.captured(1);
        QString unit   = rem.captured(2);
        try {
            s = number.toInt();
            if( s<0 ) s = -1;
            else if( unit=="d" ) s*=24*3600;
            else if( unit=="h" ) s*=3600;
            else if( unit=="m" ) s*=60;
            else if( unit=="s" ) s*=1;
            else s = -1;
        } catch(...) {
            s = -1;
        }
        return s;
    }
 // "h+:mm"
    re.setPattern("^\\s*(\\d+):(\\d+)\\s*$");
    rem = re.match( string );
    if( rem.hasMatch() ) {
        try {
            h = rem.captured(1).toInt();
            m = rem.captured(2).toInt();
            s = h*3600 + m*60;
        } catch(...) {
            s = -1;
        }
        return s;
    }
    return -1; //keep the compiler happy
}

QStringList CaViewerScanner::getImageSeries(QString sFullName, QString &sRetPath, QString &sRetBaseName)
{
    //  creates list components based on sFilename (eg. .../foo_t0001.tif)
    QStringList slImageSeries;
    //  checks whether the filename matches the format or not
    const QString sFormatPrefix("^(?<path>.*/)(?<name>[^/]+)");
    const QString sFormatNumber("_t(?<num>\\d{4})");
    const QString sFormatSuffix("(?<dotext>\\..{1,3})$");
    const QRegularExpression regexpSeries(sFormatPrefix + sFormatNumber + sFormatSuffix);
    const QRegularExpressionMatch matchSeries = regexpSeries.match(sFullName);
    if(matchSeries.hasMatch())
    {   //  match found (i.e. there are related files in the same folder)
        sRetBaseName = matchSeries.captured("name");
        sRetPath = matchSeries.captured("path");
        const QString sExtension = matchSeries.captured("dotext");

        const QDir dir(sRetPath);
        const QStringList slAllFiles = dir.entryList(QDir::Files, QDir::Name);

        QRegularExpression regexpFileName(QRegularExpression::escape(sRetBaseName) + sFormatNumber
                                          + QRegularExpression::escape(sExtension));
        int nSequence = 0;
        for(int count = 0; count < slAllFiles.size(); ++count)
        {
            QRegularExpressionMatch match = regexpFileName.match(slAllFiles.at(count));
            if(match.hasMatch())
            {
                int fileNum = match.captured("num").toInt();
                if(fileNum != nSequence)
                    return slImageSeries;
                else
                {
                    slImageSeries << slAllFiles.at(count);
                    ++nSequence;
                }
            }
        }
    }
    else
    {   //  no match found
        const QRegularExpression regexpSingle(sFormatPrefix + sFormatSuffix);
        const QRegularExpressionMatch matchSingle = regexpSingle.match(sFullName);
        if(matchSingle.hasMatch())
        {
            sRetBaseName = matchSingle.captured("name");
            sRetPath = matchSingle.captured("path");
            slImageSeries << sRetBaseName + matchSingle.captured("dotext");
        }
    }

    return slImageSeries;
}

bool CliPlugin::readExtractLine(const QString &line)
{
    const QRegularExpression rxCRC(QStringLiteral("CRC failed"));
    if (rxCRC.match(line).hasMatch()) {
        emit error(i18n("One or more wrong checksums"));
        return false;
    }

    const QRegularExpression rxVolume(QStringLiteral("Cannot find volume "));
    if (rxVolume.match(line).hasMatch()) {
        emit error(i18n("Failed to find all archive volumes."));
        return false;
    }

    return true;
}

QList<LocatorFilterEntry> OpenDocumentsFilter::matchesFor(QFutureInterface<LocatorFilterEntry> &future,
                                                          const QString &entry)
{
    QList<LocatorFilterEntry> goodEntries;
    QList<LocatorFilterEntry> betterEntries;
    const EditorManager::FilePathInfo fp = EditorManager::splitLineAndColumnNumber(entry);

    const QRegularExpression regexp = createRegExp(fp.filePath);
    if (!regexp.isValid())
        return goodEntries;

    const QList<Entry> editorEntries = editors();
    for (const Entry &editorEntry : editorEntries) {
        if (future.isCanceled())
            break;
        QString fileName = editorEntry.fileName.toString();
        if (fileName.isEmpty())
            continue;
        QString displayName = editorEntry.displayName;
        const QRegularExpressionMatch match = regexp.match(displayName);
        if (match.hasMatch()) {
            LocatorFilterEntry filterEntry(this, displayName, QString(fileName + fp.postfix));
            filterEntry.extraInfo = FileUtils::shortNativePath(FileName::fromString(fileName));
            filterEntry.fileName = fileName;
            filterEntry.highlightInfo = highlightInfo(match);
            if (match.capturedStart() == 0)
                betterEntries.append(filterEntry);
            else
                goodEntries.append(filterEntry);
        }
    }
    betterEntries.append(goodEntries);
    return betterEntries;
}

void PremiumizeMeDownloadHandler::generateLinkReplyFinished()
{
    auto reply = static_cast< QNetworkReply *>(sender());

    QString data(QString::fromLatin1(reply->readAll()));
    reply->deleteLater();

    QRegularExpressionMatch match = LOCATION_REGEXP.match(data);
    if(!match.hasMatch()) {
        m_download->setMessage("No download url found: "+data);
        m_download->setEnabled(false);
        return;
    }

    QString downloadUrl = match.captured(1);
    downloadUrl.replace(QLatin1String("\\/"), QLatin1String("/"));

    m_download->setRedirectedUrl(QUrl(downloadUrl));
    m_download->setMessage("Getting file information...");
    Controller::downloadsDao()->update(m_download);

    m_downloader->setUrl(m_download->redirectedUrl());
    m_downloader->getMetaData();

    QObject::connect(m_downloader, &Downloader::metaDataChanged, [&]() {
        m_download->setRedirectedUrl(m_downloader->redirectedUrl());
        m_download->setFileName(m_downloader->fileName());
        m_download->setFileSize(m_downloader->fileSize());
        m_download->setMessage("");
        Controller::downloadsDao()->update(m_download);

        emit downloadInformationReady();
    });
}

  ImageOutputFormat parseImageFormat( const QString &format )
  {
    if ( format.compare( QLatin1String( "png" ), Qt::CaseInsensitive ) == 0 ||
         format.compare( QLatin1String( "image/png" ), Qt::CaseInsensitive ) == 0 )
    {
      return PNG;
    }
    else if ( format.compare( QLatin1String( "jpg " ), Qt::CaseInsensitive ) == 0  ||
              format.compare( QLatin1String( "image/jpeg" ), Qt::CaseInsensitive ) == 0 )
    {
      return JPEG;
    }
    else
    {
      // lookup for png with mode
      QRegularExpression modeExpr = QRegularExpression( QStringLiteral( "image/png\\s*;\\s*mode=([^;]+)" ),
                                    QRegularExpression::CaseInsensitiveOption );

      QRegularExpressionMatch match = modeExpr.match( format );
      QString mode = match.captured();
      if ( mode.compare( QLatin1String( "16bit" ), Qt::CaseInsensitive ) == 0 )
        return PNG16;
      if ( mode.compare( QLatin1String( "8bit" ), Qt::CaseInsensitive ) == 0 )
        return PNG8;
      if ( mode.compare( QLatin1String( "1bit" ), Qt::CaseInsensitive ) == 0 )
        return PNG1;
    }

    return UNKN;
  }

// Delete all temporary directories for an application
int PathUtils::removeTemporaryApplicationDirs(QString appName) {
    if (appName.isNull()) {
        appName = qApp->applicationName();
    }

    auto dirName = TEMP_DIR_FORMAT.arg(appName).arg("*").arg("*");

    QDir rootTempDir = QDir::tempPath();
    auto dirs = rootTempDir.entryInfoList({ dirName }, QDir::Dirs);
    int removed = 0;
    for (auto& dir : dirs) {
        auto dirName = dir.fileName();
        auto absoluteDirPath = QDir(dir.absoluteFilePath());
        QRegularExpression re { "^" + QRegularExpression::escape(appName) + "\\-(?<pid>\\d+)\\-(?<timestamp>\\d+)$" };

        auto match = re.match(dirName);
        if (match.hasMatch()) {
            auto pid = match.capturedRef("pid").toLongLong();
            auto timestamp = match.capturedRef("timestamp");
            if (!processIsRunning(pid)) {
                qDebug() << "  Removing old temporary directory: " << dir.absoluteFilePath();
                absoluteDirPath.removeRecursively();
                removed++;
            } else {
                qDebug() << "  Not removing (process is running): " << dir.absoluteFilePath();
            }
        }
    }

    return removed;
}

bool Utils::Misc::isUrl(const QString &s)
{
    static const QRegularExpression reURLScheme(
                "http[s]?|ftp", QRegularExpression::CaseInsensitiveOption);

    return reURLScheme.match(QUrl(s).scheme()).hasMatch();
}

NimLexer::Token NimLexer::readIdentifierOrKeyword(SourceCodeStream* stream)
{
    static QRegularExpression isLetter {"[a-zA-Z\x80-\xFF]"};
    static QSet<QString> keywords {"template", "include", // 7
                                   "method", "string", "import" // 6
                                   "while", "cbool", "tuple", "defer", // 5
                                   "cint", "case", "bool", "proc", "type",
                                   "else", "from", "enum", "when", // 4
                                   "int", "var", "for", "ref", // 3
                                   "in", "of", "if" }; // 2
    stream->setAnchor();
    stream->move();

    while (!stream->isEnd()) {
        const QChar& c = stream->peek();
        if (!(c == '_' || c.isDigit() || isLetter.match(c).hasMatch()))
            break;
        stream->move();
    }

    QString value = stream->value();
    bool isKeyword = keywords.contains(value);

    return Token (stream->anchor(),
                  stream->length(),
                  isKeyword ? TokenType::Keyword : TokenType::Identifier );
}

QByteArray ViewJson::render(Context *c) const
{
    Q_D(const ViewJson);

    QByteArray ret;
    QJsonObject obj;

    const QVariantHash stash = c->stash();

    switch (d->exposeMode) {
    case All:
        obj = QJsonObject::fromVariantHash(stash);
        break;
    case String:
    {
        auto it = stash.constFind(d->exposeKey);
        if (it != stash.constEnd()) {
            obj.insert(d->exposeKey, QJsonValue::fromVariant(it.value()));
        }
        break;
    }
    case StringList:
    {
        QVariantHash exposedStash;

        auto it = stash.constBegin();
        while (it != stash.constEnd()) {
            const QString key = it.key();
            if (d->exposeKeys.contains(key)) {
                exposedStash.insertMulti(it.key(), it.value());
            }
            ++it;
        }
        obj = QJsonObject::fromVariantHash(exposedStash);
        break;
    }
    case RegularExpression:
    {
        QVariantHash exposedStash;
        QRegularExpression re = d->exposeRE; // thread safety

        auto it = stash.constBegin();
        while (it != stash.constEnd()) {
            const QString key = it.key();
            if (re.match(key).hasMatch()) {
                exposedStash.insertMulti(key, it.value());
            }
            ++it;
        }
        obj = QJsonObject::fromVariantHash(exposedStash);
        break;
    }
    }

    c->response()->setContentType(QStringLiteral("application/json"));

    ret = QJsonDocument(obj).toJson(d->format);
    return ret;
}

/** Redefined to disable search in the table and trigger jumpToWidget's action. */
void TableView::keyboardSearch(const QString &search)
{
	// If one has assigned a simple key like 'N' to 'Skip Forward' we don't actually want to skip the track
	// IMHO, it's better to trigger the JumpTo widget to 'N' section
	static QRegularExpression az("[a-z]", QRegularExpression::CaseInsensitiveOption | QRegularExpression::OptimizeOnFirstUsageOption);
	if (az.match(search).hasMatch()) {
		this->jumpTo(search);
	}
}

/**
 * Returns encrypted note text if it is encrypted
 */
QString Note::getEncryptedNoteText() {
    QString noteText = this->noteText;

    // get regular expression for the encrypted string
    QRegularExpression re = getEncryptedNoteTextRegularExpression();

    // check if we have an encrypted note text and return it if so
    QRegularExpressionMatch match = re.match(noteText);
    return match.hasMatch() ? match.captured(1) : "";
}

void RevDesc::on_anchorClicked(const QUrl& link) {
    static QRegularExpression anchorRE("^#(.+)$");
    qDebug() << "clicked on " << link.toDisplayString() << "\n";
    QWebFrame* frame = this->page()->mainFrame();

    QRegularExpressionMatch anchorMatch = anchorRE.match(link.toDisplayString());
    if(anchorMatch.hasMatch()) {
        frame->scrollToAnchor(anchorMatch.captured(1));
    }
}

static void applyPermissionsFromName(FileInfo &info) {
    static QRegularExpression rx("_PERM_([^_]*)_[^/]*$");
    auto m = rx.match(info.name);
    if (m.hasMatch()) {
        info.permissions = RemotePermissions::fromServerString(m.captured(1));
    }

    for (FileInfo &sub : info.children)
        applyPermissionsFromName(sub);
}