Flip a couple of Q_FOREACHs to c++11 for loops

nyalldawson · nyalldawson · commit 9ac511dc8375 · 2017-08-29T14:43:59.000+10:00
... just to check how bad the Q_FOREACH deprecation will be. And yep,
it's horrendous. Each one takes around 10 seconds or so to port, and
we've got some 2500+ remaining uses.
diff --git a/src/core/annotations/qgsannotationmanager.cpp b/src/core/annotations/qgsannotationmanager.cpp
@@ -62,7 +62,7 @@ bool QgsAnnotationManager::removeAnnotation( QgsAnnotation *annotation )
 
 void QgsAnnotationManager::clear()
 {
-  Q_FOREACH ( QgsAnnotation *a, mAnnotations )
+  for ( auto *a : qgsAsConst( mAnnotations ) )
   {
     removeAnnotation( a );
   }
@@ -76,7 +76,7 @@ QList<QgsAnnotation *> QgsAnnotationManager::annotations() const
 QList<QgsAnnotation *> QgsAnnotationManager::cloneAnnotations() const
 {
   QList<QgsAnnotation *> results;
-  Q_FOREACH ( const QgsAnnotation *a, mAnnotations )
+  for ( const auto *a : qgsAsConst( mAnnotations ) )
   {
     results << a->clone();
   }
diff --git a/src/core/auth/qgsauthcertutils.cpp b/src/core/auth/qgsauthcertutils.cpp
@@ -48,7 +48,7 @@ QString QgsAuthCertUtils::getSslProtocolName( QSsl::SslProtocol protocol )
 QMap<QString, QSslCertificate> QgsAuthCertUtils::mapDigestToCerts( const QList<QSslCertificate> &certs )
 {
   QMap<QString, QSslCertificate> digestmap;
-  Q_FOREACH ( const QSslCertificate &cert, certs )
+  for ( const auto &cert : certs )
   {
     digestmap.insert( shaHexForCert( cert ), cert );
   }
@@ -58,7 +58,7 @@ QMap<QString, QSslCertificate> QgsAuthCertUtils::mapDigestToCerts( const QList<Q
 QMap<QString, QList<QSslCertificate> > QgsAuthCertUtils::certsGroupedByOrg( const QList<QSslCertificate> &certs )
 {
   QMap< QString, QList<QSslCertificate> > orgcerts;
-  Q_FOREACH ( const QSslCertificate &cert, certs )
+  for ( const auto &cert : certs )
   {
     QString org( SSL_SUBJECT_INFO( cert, QSslCertificate::Organization ) );
     if ( org.isEmpty() )
@@ -72,7 +72,7 @@ QMap<QString, QList<QSslCertificate> > QgsAuthCertUtils::certsGroupedByOrg( cons
 QMap<QString, QgsAuthConfigSslServer> QgsAuthCertUtils::mapDigestToSslConfigs( const QList<QgsAuthConfigSslServer> &configs )
 {
   QMap<QString, QgsAuthConfigSslServer> digestmap;
-  Q_FOREACH ( const QgsAuthConfigSslServer &config, configs )
+  for ( const auto &config : configs )
   {
     digestmap.insert( shaHexForCert( config.sslCertificate() ), config );
   }
@@ -82,7 +82,7 @@ QMap<QString, QgsAuthConfigSslServer> QgsAuthCertUtils::mapDigestToSslConfigs( c
 QMap<QString, QList<QgsAuthConfigSslServer> > QgsAuthCertUtils::sslConfigsGroupedByOrg( const QList<QgsAuthConfigSslServer> &configs )
 {
   QMap< QString, QList<QgsAuthConfigSslServer> > orgconfigs;
-  Q_FOREACH ( const QgsAuthConfigSslServer &config, configs )
+  for ( const auto &config : configs )
   {
     QString org( SSL_SUBJECT_INFO( config.sslCertificate(), QSslCertificate::Organization ) );
 
@@ -439,7 +439,7 @@ QCA::CertificateCollection QgsAuthCertUtils::qtCertsToQcaCollection( const QList
   if ( QgsAuthManager::instance()->isDisabled() )
     return qcacoll;
 
-  Q_FOREACH ( const QSslCertificate &cert, certs )
+  for ( const auto &cert : certs )
   {
     QCA::Certificate qcacert( qtCertToQcaCert( cert ) );
     if ( !qcacert.isNull() )
@@ -622,8 +622,8 @@ QList<QgsAuthCertUtils::CertUsageType> QgsAuthCertUtils::certificateUsageTypes(
     usages << QgsAuthCertUtils::CertAuthorityUsage;
   }
 
-  QList<QCA::ConstraintType> certconsts = qcacert.constraints();
-  Q_FOREACH ( const QCA::ConstraintType &certconst, certconsts )
+  const QList<QCA::ConstraintType> certconsts = qcacert.constraints();
+  for ( const auto &certconst : certconsts )
   {
     if ( certconst.known() == QCA::KeyCertificateSign )
     {
@@ -722,8 +722,8 @@ bool QgsAuthCertUtils::certificateIsSslServer( const QSslCertificate &cert )
     return false;
   }
 
-  QList<QCA::ConstraintType> certconsts = qcacert.constraints();
-  Q_FOREACH ( QCA::ConstraintType certconst, certconsts )
+  const QList<QCA::ConstraintType> certconsts = qcacert.constraints();
+  for ( const auto & certconst, certconsts )
   {
     if ( certconst.known() == QCA::KeyCertificateSign )
     {
@@ -737,7 +737,7 @@ bool QgsAuthCertUtils::certificateIsSslServer( const QSslCertificate &cert )
   bool serverauth = false;
   bool dsignature = false;
   bool keyencrypt = false;
-  Q_FOREACH ( QCA::ConstraintType certconst, certconsts )
+  for ( const auto &certconst : certconsts )
   {
     if ( certconst.known() == QCA::DigitalSignature )
     {
@@ -791,7 +791,7 @@ bool QgsAuthCertUtils::certificateIsSslServer( const QSslCertificate &cert )
     {
       return false;
     }
-    Q_FOREACH ( QCA::ConstraintType certconst, certconsts )
+    for ( const auto &certconst : certconsts )
     {
       if ( certconst.known() == QCA::EncipherOnly )
       {
diff --git a/src/core/auth/qgsauthconfig.cpp b/src/core/auth/qgsauthconfig.cpp
@@ -91,9 +91,9 @@ void QgsAuthMethodConfig::loadConfigString( const QString &configstr )
     return;
   }
 
-  QStringList confs( configstr.split( CONFIG_SEP ) );
+  const QStringList confs( configstr.split( CONFIG_SEP ) );
 
-  Q_FOREACH ( const QString &conf, confs )
+  for ( const auto &conf : confs )
   {
     if ( conf.contains( CONFIG_KEY_SEP ) )
     {
@@ -255,7 +255,7 @@ const QgsPkiBundle QgsPkiBundle::fromPkcs12Paths( const QString &bundlepath,
     QCA::KeyBundle bundle( QCA::KeyBundle::fromFile( bundlepath, passarray, &res, QStringLiteral( "qca-ossl" ) ) );
     if ( res == QCA::ConvertGood && !bundle.isNull() )
     {
-      QCA::CertificateChain cert_chain( bundle.certificateChain() );
+      const QCA::CertificateChain cert_chain( bundle.certificateChain() );
       QSslCertificate cert( cert_chain.primary().toPEM().toLatin1() );
       if ( !cert.isNull() )
       {
@@ -270,7 +270,7 @@ const QgsPkiBundle QgsPkiBundle::fromPkcs12Paths( const QString &bundlepath,
       if ( cert_chain.size() > 1 )
       {
         QList<QSslCertificate> ca_chain;
-        Q_FOREACH ( const QCA::Certificate &ca_cert, cert_chain )
+        for ( const auto &ca_cert : cert_chain )
         {
           if ( ca_cert != cert_chain.primary() )
           {
@@ -366,7 +366,8 @@ QgsAuthConfigSslServer::QgsAuthConfigSslServer()
 const QList<QSslError> QgsAuthConfigSslServer::sslIgnoredErrors() const
 {
   QList<QSslError> errors;
-  Q_FOREACH ( QSslError::SslError errenum, sslIgnoredErrorEnums() )
+  const QList<QSslError::SslError> ignoredErrors = sslIgnoredErrorEnums();
+  for ( QSslError::SslError errenum : ignoredErrors )
   {
     errors << QSslError( errenum );
   }
@@ -381,7 +382,7 @@ const QString QgsAuthConfigSslServer::configString() const
   configlist << QString::number( static_cast< int >( mSslProtocol ) );
 
   QStringList errs;
-  Q_FOREACH ( const QSslError::SslError &err, mSslIgnoredErrors )
+  for ( auto err : mSslIgnoredErrors )
   {
     errs << QString::number( static_cast< int >( err ) );
   }
@@ -408,8 +409,8 @@ void QgsAuthConfigSslServer::loadConfigString( const QString &config )
   mSslProtocol = static_cast< QSsl::SslProtocol >( configlist.at( 2 ).toInt() );
 
   mSslIgnoredErrors.clear();
-  QStringList errs( configlist.at( 3 ).split( QStringLiteral( "~~" ) ) );
-  Q_FOREACH ( const QString &err, errs )
+  const QStringList errs( configlist.at( 3 ).split( QStringLiteral( "~~" ) ) );
+  for ( const auto &err : errs )
   {
     mSslIgnoredErrors.append( static_cast< QSslError::SslError >( err.toInt() ) );
   }
diff --git a/src/core/auth/qgsauthmanager.cpp b/src/core/auth/qgsauthmanager.cpp
@@ -148,9 +148,9 @@ bool QgsAuthManager::init( const QString &pluginPath )
   }
 
   QgsDebugMsg( "Prioritizing qca-ossl over all other QCA providers..." );
-  QCA::ProviderList provds = QCA::providers();
+  const QCA::ProviderList provds = QCA::providers();
   QStringList prlist;
-  Q_FOREACH ( QCA::Provider *p, provds )
+  for ( QCA::Provider *p : provds )
   {
     QString pn = p->name();
     int pr = 0;
@@ -780,7 +780,8 @@ bool QgsAuthManager::registerCoreAuthMethods()
 
   qDeleteAll( mAuthMethods );
   mAuthMethods.clear();
-  Q_FOREACH ( const QString &authMethodKey, QgsAuthMethodRegistry::instance()->authMethodList() )
+  const QStringList methods = QgsAuthMethodRegistry::instance()->authMethodList();
+  for ( const auto &authMethodKey : methods )
   {
     mAuthMethods.insert( authMethodKey, QgsAuthMethodRegistry::instance()->authMethod( authMethodKey ).release() );
   }
@@ -2086,7 +2087,7 @@ void QgsAuthManager::dumpIgnoredSslErrorsCache_()
     while ( i != mIgnoredSslErrorsCache.constEnd() )
     {
       QStringList errs;
-      Q_FOREACH ( QSslError::SslError err, i.value() )
+      for ( auto err : i.value() )
       {
         errs << QgsAuthCertUtils::sslErrorEnumString( err );
       }
@@ -2150,7 +2151,7 @@ bool QgsAuthManager::updateIgnoredSslErrorsCache( const QString &shahostport, co
   }
 
   QSet<QSslError::SslError> errs;
-  Q_FOREACH ( const QSslError &error, errors )
+  for ( const auto &error : errors )
   {
     if ( error.error() == QSslError::NoError )
       continue;
@@ -2240,7 +2241,7 @@ bool QgsAuthManager::storeCertAuthorities( const QList<QSslCertificate> &certs )
     return false;
   }
 
-  Q_FOREACH ( const QSslCertificate &cert, certs )
+  for ( const auto &cert : certs )
   {
     if ( !storeCertAuthority( cert ) )
       return false;
@@ -2410,7 +2411,7 @@ const QList<QSslCertificate> QgsAuthManager::getExtraFileCAs()
     filecerts = QgsAuthCertUtils::certsFromFile( cafile );
   }
   // only CAs or certs capable of signing other certs are allowed
-  Q_FOREACH ( const QSslCertificate &cert, filecerts )
+  for ( const auto &cert : qgsAsConst( filecerts ) )
   {
     if ( !allowinvalid.toBool() && !cert.isValid() )
     {
@@ -2547,7 +2548,7 @@ bool QgsAuthManager::removeCertTrustPolicies( const QList<QSslCertificate> &cert
     return false;
   }
 
-  Q_FOREACH ( const QSslCertificate &cert, certs )
+  for ( const auto &cert : certs )
   {
     if ( !removeCertTrustPolicy( cert ) )
       return false;
@@ -2730,11 +2731,11 @@ bool QgsAuthManager::rebuildTrustedCaCertsCache()
 const QByteArray QgsAuthManager::getTrustedCaCertsPemText()
 {
   QByteArray capem;
-  QList<QSslCertificate> certs( getTrustedCaCertsCache() );
+  const QList<QSslCertificate> certs( getTrustedCaCertsCache() );
   if ( !certs.isEmpty() )
   {
     QStringList certslist;
-    Q_FOREACH ( const QSslCertificate &cert, certs )
+    for ( const auto &cert : certs )
     {
       certslist << cert.toPem();
     }
@@ -2762,7 +2763,8 @@ void QgsAuthManager::clearAllCachedConfigs()
   if ( isDisabled() )
     return;
 
-  Q_FOREACH ( QString authcfg, configIds() )
+  const QStringList ids = configIds();
+  for ( const auto &authcfg : ids )
   {
     clearCachedConfig( authcfg );
   }
@@ -3307,7 +3309,8 @@ bool QgsAuthManager::reencryptAllAuthenticationConfigs( const QString &prevpass,
     return false;
 
   bool res = true;
-  Q_FOREACH ( QString configid, configIds() )
+  const QStringList ids = configIds();
+  for ( const auto &configid : ids )
   {
     res = res && reencryptAuthenticationConfig( configid, prevpass, prevciv );
   }
@@ -3395,7 +3398,7 @@ bool QgsAuthManager::reencryptAllAuthenticationSettings( const QString &prevpass
   QStringList encryptedsettings;
   encryptedsettings << "";
 
-  Q_FOREACH ( const QString &sett, encryptedsettings )
+  for ( const auto & sett, qgsAsConst( encryptedsettings ) )
   {
     if ( sett.isEmpty() || !existsAuthSetting( sett ) )
       continue;
@@ -3468,7 +3471,8 @@ bool QgsAuthManager::reencryptAllAuthenticationIdentities( const QString &prevpa
     return false;
 
   bool res = true;
-  Q_FOREACH ( const QString &identid, getCertIdentityIds() )
+  const QStringList ids = getCertIdentityIds();
+  for ( const auto &identid : ids )
   {
     res = res && reencryptAuthenticationIdentity( identid, prevpass, prevciv );
   }
@@ -3649,7 +3653,7 @@ bool QgsAuthManager::authDbTransactionQuery( QSqlQuery *query ) const
 
 void QgsAuthManager::insertCaCertInCache( QgsAuthCertUtils::CaCertSource source, const QList<QSslCertificate> &certs )
 {
-  Q_FOREACH ( const QSslCertificate &cert, certs )
+  for ( const auto &cert : certs )
   {
     mCaCertsCache.insert( QgsAuthCertUtils::shaHexForCert( cert ),
                           QPair<QgsAuthCertUtils::CaCertSource, QSslCertificate>( source, cert ) );

Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ bool QgsAnnotationManager::removeAnnotation( QgsAnnotation *annotation )`
`62`	`62`
`63`	`63`	`void QgsAnnotationManager::clear()`
`64`	`64`	`{`
`65`		`- Q_FOREACH ( QgsAnnotation *a, mAnnotations )`
	`65`	`+ for ( auto *a : qgsAsConst( mAnnotations ) )`
`66`	`66`	`{`
`67`	`67`	`removeAnnotation( a );`
`68`	`68`	`}`
`@@ -76,7 +76,7 @@ QList<QgsAnnotation *> QgsAnnotationManager::annotations() const`
`76`	`76`	`QList<QgsAnnotation *> QgsAnnotationManager::cloneAnnotations() const`
`77`	`77`	`{`
`78`	`78`	`QList<QgsAnnotation *> results;`
`79`		`- Q_FOREACH ( const QgsAnnotation *a, mAnnotations )`
	`79`	`+ for ( const auto *a : qgsAsConst( mAnnotations ) )`
`80`	`80`	`{`
`81`	`81`	`results << a->clone();`
`82`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ QString QgsAuthCertUtils::getSslProtocolName( QSsl::SslProtocol protocol )`
`48`	`48`	`QMap<QString, QSslCertificate> QgsAuthCertUtils::mapDigestToCerts( const QList<QSslCertificate> &certs )`
`49`	`49`	`{`
`50`	`50`	`QMap<QString, QSslCertificate> digestmap;`
`51`		`- Q_FOREACH ( const QSslCertificate &cert, certs )`
	`51`	`+ for ( const auto &cert : certs )`
`52`	`52`	`{`
`53`	`53`	`digestmap.insert( shaHexForCert( cert ), cert );`
`54`	`54`	`}`
`@@ -58,7 +58,7 @@ QMap<QString, QSslCertificate> QgsAuthCertUtils::mapDigestToCerts( const QList<Q`
`58`	`58`	`QMap<QString, QList<QSslCertificate> > QgsAuthCertUtils::certsGroupedByOrg( const QList<QSslCertificate> &certs )`
`59`	`59`	`{`
`60`	`60`	`QMap< QString, QList<QSslCertificate> > orgcerts;`
`61`		`- Q_FOREACH ( const QSslCertificate &cert, certs )`
	`61`	`+ for ( const auto &cert : certs )`
`62`	`62`	`{`
`63`	`63`	`QString org( SSL_SUBJECT_INFO( cert, QSslCertificate::Organization ) );`
`64`	`64`	`if ( org.isEmpty() )`
`@@ -72,7 +72,7 @@ QMap<QString, QList<QSslCertificate> > QgsAuthCertUtils::certsGroupedByOrg( cons`
`72`	`72`	`QMap<QString, QgsAuthConfigSslServer> QgsAuthCertUtils::mapDigestToSslConfigs( const QList<QgsAuthConfigSslServer> &configs )`
`73`	`73`	`{`
`74`	`74`	`QMap<QString, QgsAuthConfigSslServer> digestmap;`
`75`		`- Q_FOREACH ( const QgsAuthConfigSslServer &config, configs )`
	`75`	`+ for ( const auto &config : configs )`
`76`	`76`	`{`
`77`	`77`	`digestmap.insert( shaHexForCert( config.sslCertificate() ), config );`
`78`	`78`	`}`
`@@ -82,7 +82,7 @@ QMap<QString, QgsAuthConfigSslServer> QgsAuthCertUtils::mapDigestToSslConfigs( c`
`82`	`82`	`QMap<QString, QList<QgsAuthConfigSslServer> > QgsAuthCertUtils::sslConfigsGroupedByOrg( const QList<QgsAuthConfigSslServer> &configs )`
`83`	`83`	`{`
`84`	`84`	`QMap< QString, QList<QgsAuthConfigSslServer> > orgconfigs;`
`85`		`- Q_FOREACH ( const QgsAuthConfigSslServer &config, configs )`
	`85`	`+ for ( const auto &config : configs )`
`86`	`86`	`{`
`87`	`87`	`QString org( SSL_SUBJECT_INFO( config.sslCertificate(), QSslCertificate::Organization ) );`
`88`	`88`
`@@ -439,7 +439,7 @@ QCA::CertificateCollection QgsAuthCertUtils::qtCertsToQcaCollection( const QList`
`439`	`439`	`if ( QgsAuthManager::instance()->isDisabled() )`
`440`	`440`	`return qcacoll;`
`441`	`441`
`442`		`- Q_FOREACH ( const QSslCertificate &cert, certs )`
	`442`	`+ for ( const auto &cert : certs )`
`443`	`443`	`{`
`444`	`444`	`QCA::Certificate qcacert( qtCertToQcaCert( cert ) );`
`445`	`445`	`if ( !qcacert.isNull() )`
`@@ -622,8 +622,8 @@ QList<QgsAuthCertUtils::CertUsageType> QgsAuthCertUtils::certificateUsageTypes(`
`622`	`622`	`usages << QgsAuthCertUtils::CertAuthorityUsage;`
`623`	`623`	`}`
`624`	`624`
`625`		`- QList<QCA::ConstraintType> certconsts = qcacert.constraints();`
`626`		`- Q_FOREACH ( const QCA::ConstraintType &certconst, certconsts )`
	`625`	`+ const QList<QCA::ConstraintType> certconsts = qcacert.constraints();`
	`626`	`+ for ( const auto &certconst : certconsts )`
`627`	`627`	`{`
`628`	`628`	`if ( certconst.known() == QCA::KeyCertificateSign )`
`629`	`629`	`{`
`@@ -722,8 +722,8 @@ bool QgsAuthCertUtils::certificateIsSslServer( const QSslCertificate &cert )`
`722`	`722`	`return false;`
`723`	`723`	`}`
`724`	`724`
`725`		`- QList<QCA::ConstraintType> certconsts = qcacert.constraints();`
`726`		`- Q_FOREACH ( QCA::ConstraintType certconst, certconsts )`
	`725`	`+ const QList<QCA::ConstraintType> certconsts = qcacert.constraints();`
	`726`	`+ for ( const auto & certconst, certconsts )`
`727`	`727`	`{`
`728`	`728`	`if ( certconst.known() == QCA::KeyCertificateSign )`
`729`	`729`	`{`
`@@ -737,7 +737,7 @@ bool QgsAuthCertUtils::certificateIsSslServer( const QSslCertificate &cert )`
`737`	`737`	`bool serverauth = false;`
`738`	`738`	`bool dsignature = false;`
`739`	`739`	`bool keyencrypt = false;`
`740`		`- Q_FOREACH ( QCA::ConstraintType certconst, certconsts )`
	`740`	`+ for ( const auto &certconst : certconsts )`
`741`	`741`	`{`
`742`	`742`	`if ( certconst.known() == QCA::DigitalSignature )`
`743`	`743`	`{`
`@@ -791,7 +791,7 @@ bool QgsAuthCertUtils::certificateIsSslServer( const QSslCertificate &cert )`
`791`	`791`	`{`
`792`	`792`	`return false;`
`793`	`793`	`}`
`794`		`- Q_FOREACH ( QCA::ConstraintType certconst, certconsts )`
	`794`	`+ for ( const auto &certconst : certconsts )`
`795`	`795`	`{`
`796`	`796`	`if ( certconst.known() == QCA::EncipherOnly )`
`797`	`797`	`{`
Original file line number	Diff line number	Diff line change
`@@ -91,9 +91,9 @@ void QgsAuthMethodConfig::loadConfigString( const QString &configstr )`
`91`	`91`	`return;`
`92`	`92`	`}`
`93`	`93`
`94`		`- QStringList confs( configstr.split( CONFIG_SEP ) );`
	`94`	`+ const QStringList confs( configstr.split( CONFIG_SEP ) );`
`95`	`95`
`96`		`- Q_FOREACH ( const QString &conf, confs )`
	`96`	`+ for ( const auto &conf : confs )`
`97`	`97`	`{`
`98`	`98`	`if ( conf.contains( CONFIG_KEY_SEP ) )`
`99`	`99`	`{`
`@@ -255,7 +255,7 @@ const QgsPkiBundle QgsPkiBundle::fromPkcs12Paths( const QString &bundlepath,`
`255`	`255`	`QCA::KeyBundle bundle( QCA::KeyBundle::fromFile( bundlepath, passarray, &res, QStringLiteral( "qca-ossl" ) ) );`
`256`	`256`	`if ( res == QCA::ConvertGood && !bundle.isNull() )`
`257`	`257`	`{`
`258`		`- QCA::CertificateChain cert_chain( bundle.certificateChain() );`
	`258`	`+ const QCA::CertificateChain cert_chain( bundle.certificateChain() );`
`259`	`259`	`QSslCertificate cert( cert_chain.primary().toPEM().toLatin1() );`
`260`	`260`	`if ( !cert.isNull() )`
`261`	`261`	`{`
`@@ -270,7 +270,7 @@ const QgsPkiBundle QgsPkiBundle::fromPkcs12Paths( const QString &bundlepath,`
`270`	`270`	`if ( cert_chain.size() > 1 )`
`271`	`271`	`{`
`272`	`272`	`QList<QSslCertificate> ca_chain;`
`273`		`- Q_FOREACH ( const QCA::Certificate &ca_cert, cert_chain )`
	`273`	`+ for ( const auto &ca_cert : cert_chain )`
`274`	`274`	`{`
`275`	`275`	`if ( ca_cert != cert_chain.primary() )`
`276`	`276`	`{`
`@@ -366,7 +366,8 @@ QgsAuthConfigSslServer::QgsAuthConfigSslServer()`
`366`	`366`	`const QList<QSslError> QgsAuthConfigSslServer::sslIgnoredErrors() const`
`367`	`367`	`{`
`368`	`368`	`QList<QSslError> errors;`
`369`		`- Q_FOREACH ( QSslError::SslError errenum, sslIgnoredErrorEnums() )`
	`369`	`+ const QList<QSslError::SslError> ignoredErrors = sslIgnoredErrorEnums();`
	`370`	`+ for ( QSslError::SslError errenum : ignoredErrors )`
`370`	`371`	`{`
`371`	`372`	`errors << QSslError( errenum );`
`372`	`373`	`}`
`@@ -381,7 +382,7 @@ const QString QgsAuthConfigSslServer::configString() const`
`381`	`382`	`configlist << QString::number( static_cast< int >( mSslProtocol ) );`
`382`	`383`
`383`	`384`	`QStringList errs;`
`384`		`- Q_FOREACH ( const QSslError::SslError &err, mSslIgnoredErrors )`
	`385`	`+ for ( auto err : mSslIgnoredErrors )`
`385`	`386`	`{`
`386`	`387`	`errs << QString::number( static_cast< int >( err ) );`
`387`	`388`	`}`
`@@ -408,8 +409,8 @@ void QgsAuthConfigSslServer::loadConfigString( const QString &config )`
`408`	`409`	`mSslProtocol = static_cast< QSsl::SslProtocol >( configlist.at( 2 ).toInt() );`
`409`	`410`
`410`	`411`	`mSslIgnoredErrors.clear();`
`411`		`- QStringList errs( configlist.at( 3 ).split( QStringLiteral( "~~" ) ) );`
`412`		`- Q_FOREACH ( const QString &err, errs )`
	`412`	`+ const QStringList errs( configlist.at( 3 ).split( QStringLiteral( "~~" ) ) );`
	`413`	`+ for ( const auto &err : errs )`
`413`	`414`	`{`
`414`	`415`	`mSslIgnoredErrors.append( static_cast< QSslError::SslError >( err.toInt() ) );`
`415`	`416`	`}`
Original file line number	Diff line number	Diff line change
`@@ -148,9 +148,9 @@ bool QgsAuthManager::init( const QString &pluginPath )`
`148`	`148`	`}`
`149`	`149`
`150`	`150`	`QgsDebugMsg( "Prioritizing qca-ossl over all other QCA providers..." );`
`151`		`- QCA::ProviderList provds = QCA::providers();`
	`151`	`+ const QCA::ProviderList provds = QCA::providers();`
`152`	`152`	`QStringList prlist;`
`153`		`- Q_FOREACH ( QCA::Provider *p, provds )`
	`153`	`+ for ( QCA::Provider *p : provds )`
`154`	`154`	`{`
`155`	`155`	`QString pn = p->name();`
`156`	`156`	`int pr = 0;`
`@@ -780,7 +780,8 @@ bool QgsAuthManager::registerCoreAuthMethods()`
`780`	`780`
`781`	`781`	`qDeleteAll( mAuthMethods );`
`782`	`782`	`mAuthMethods.clear();`
`783`		`- Q_FOREACH ( const QString &authMethodKey, QgsAuthMethodRegistry::instance()->authMethodList() )`
	`783`	`+ const QStringList methods = QgsAuthMethodRegistry::instance()->authMethodList();`
	`784`	`+ for ( const auto &authMethodKey : methods )`
`784`	`785`	`{`
`785`	`786`	`mAuthMethods.insert( authMethodKey, QgsAuthMethodRegistry::instance()->authMethod( authMethodKey ).release() );`
`786`	`787`	`}`
`@@ -2086,7 +2087,7 @@ void QgsAuthManager::dumpIgnoredSslErrorsCache_()`
`2086`	`2087`	`while ( i != mIgnoredSslErrorsCache.constEnd() )`
`2087`	`2088`	`{`
`2088`	`2089`	`QStringList errs;`
`2089`		`- Q_FOREACH ( QSslError::SslError err, i.value() )`
	`2090`	`+ for ( auto err : i.value() )`
`2090`	`2091`	`{`
`2091`	`2092`	`errs << QgsAuthCertUtils::sslErrorEnumString( err );`
`2092`	`2093`	`}`
`@@ -2150,7 +2151,7 @@ bool QgsAuthManager::updateIgnoredSslErrorsCache( const QString &shahostport, co`
`2150`	`2151`	`}`
`2151`	`2152`
`2152`	`2153`	`QSet<QSslError::SslError> errs;`
`2153`		`- Q_FOREACH ( const QSslError &error, errors )`
	`2154`	`+ for ( const auto &error : errors )`
`2154`	`2155`	`{`
`2155`	`2156`	`if ( error.error() == QSslError::NoError )`
`2156`	`2157`	`continue;`
`@@ -2240,7 +2241,7 @@ bool QgsAuthManager::storeCertAuthorities( const QList<QSslCertificate> &certs )`
`2240`	`2241`	`return false;`
`2241`	`2242`	`}`
`2242`	`2243`
`2243`		`- Q_FOREACH ( const QSslCertificate &cert, certs )`
	`2244`	`+ for ( const auto &cert : certs )`
`2244`	`2245`	`{`
`2245`	`2246`	`if ( !storeCertAuthority( cert ) )`
`2246`	`2247`	`return false;`
`@@ -2410,7 +2411,7 @@ const QList<QSslCertificate> QgsAuthManager::getExtraFileCAs()`
`2410`	`2411`	`filecerts = QgsAuthCertUtils::certsFromFile( cafile );`
`2411`	`2412`	`}`
`2412`	`2413`	`// only CAs or certs capable of signing other certs are allowed`
`2413`		`- Q_FOREACH ( const QSslCertificate &cert, filecerts )`
	`2414`	`+ for ( const auto &cert : qgsAsConst( filecerts ) )`
`2414`	`2415`	`{`
`2415`	`2416`	`if ( !allowinvalid.toBool() && !cert.isValid() )`
`2416`	`2417`	`{`
`@@ -2547,7 +2548,7 @@ bool QgsAuthManager::removeCertTrustPolicies( const QList<QSslCertificate> &cert`
`2547`	`2548`	`return false;`
`2548`	`2549`	`}`
`2549`	`2550`
`2550`		`- Q_FOREACH ( const QSslCertificate &cert, certs )`
	`2551`	`+ for ( const auto &cert : certs )`
`2551`	`2552`	`{`
`2552`	`2553`	`if ( !removeCertTrustPolicy( cert ) )`
`2553`	`2554`	`return false;`
`@@ -2730,11 +2731,11 @@ bool QgsAuthManager::rebuildTrustedCaCertsCache()`
`2730`	`2731`	`const QByteArray QgsAuthManager::getTrustedCaCertsPemText()`
`2731`	`2732`	`{`
`2732`	`2733`	`QByteArray capem;`
`2733`		`- QList<QSslCertificate> certs( getTrustedCaCertsCache() );`
	`2734`	`+ const QList<QSslCertificate> certs( getTrustedCaCertsCache() );`
`2734`	`2735`	`if ( !certs.isEmpty() )`
`2735`	`2736`	`{`
`2736`	`2737`	`QStringList certslist;`
`2737`		`- Q_FOREACH ( const QSslCertificate &cert, certs )`
	`2738`	`+ for ( const auto &cert : certs )`
`2738`	`2739`	`{`
`2739`	`2740`	`certslist << cert.toPem();`
`2740`	`2741`	`}`
`@@ -2762,7 +2763,8 @@ void QgsAuthManager::clearAllCachedConfigs()`
`2762`	`2763`	`if ( isDisabled() )`
`2763`	`2764`	`return;`
`2764`	`2765`
`2765`		`- Q_FOREACH ( QString authcfg, configIds() )`
	`2766`	`+ const QStringList ids = configIds();`
	`2767`	`+ for ( const auto &authcfg : ids )`
`2766`	`2768`	`{`
`2767`	`2769`	`clearCachedConfig( authcfg );`
`2768`	`2770`	`}`
`@@ -3307,7 +3309,8 @@ bool QgsAuthManager::reencryptAllAuthenticationConfigs( const QString &prevpass,`
`3307`	`3309`	`return false;`
`3308`	`3310`
`3309`	`3311`	`bool res = true;`
`3310`		`- Q_FOREACH ( QString configid, configIds() )`
	`3312`	`+ const QStringList ids = configIds();`
	`3313`	`+ for ( const auto &configid : ids )`
`3311`	`3314`	`{`
`3312`	`3315`	`res = res && reencryptAuthenticationConfig( configid, prevpass, prevciv );`
`3313`	`3316`	`}`
`@@ -3395,7 +3398,7 @@ bool QgsAuthManager::reencryptAllAuthenticationSettings( const QString &prevpass`
`3395`	`3398`	`QStringList encryptedsettings;`
`3396`	`3399`	`encryptedsettings << "";`
`3397`	`3400`
`3398`		`- Q_FOREACH ( const QString &sett, encryptedsettings )`
	`3401`	`+ for ( const auto & sett, qgsAsConst( encryptedsettings ) )`
`3399`	`3402`	`{`
`3400`	`3403`	`if ( sett.isEmpty() \|\| !existsAuthSetting( sett ) )`
`3401`	`3404`	`continue;`
`@@ -3468,7 +3471,8 @@ bool QgsAuthManager::reencryptAllAuthenticationIdentities( const QString &prevpa`
`3468`	`3471`	`return false;`
`3469`	`3472`
`3470`	`3473`	`bool res = true;`
`3471`		`- Q_FOREACH ( const QString &identid, getCertIdentityIds() )`
	`3474`	`+ const QStringList ids = getCertIdentityIds();`
	`3475`	`+ for ( const auto &identid : ids )`
`3472`	`3476`	`{`
`3473`	`3477`	`res = res && reencryptAuthenticationIdentity( identid, prevpass, prevciv );`
`3474`	`3478`	`}`
`@@ -3649,7 +3653,7 @@ bool QgsAuthManager::authDbTransactionQuery( QSqlQuery *query ) const`
`3649`	`3653`
`3650`	`3654`	`void QgsAuthManager::insertCaCertInCache( QgsAuthCertUtils::CaCertSource source, const QList<QSslCertificate> &certs )`
`3651`	`3655`	`{`
`3652`		`- Q_FOREACH ( const QSslCertificate &cert, certs )`
	`3656`	`+ for ( const auto &cert : certs )`
`3653`	`3657`	`{`
`3654`	`3658`	`mCaCertsCache.insert( QgsAuthCertUtils::shaHexForCert( cert ),`
`3655`	`3659`	`QPair<QgsAuthCertUtils::CaCertSource, QSslCertificate>( source, cert ) );`