Use pointer instead of reference to QgsVectorLayer

m-kuhn · m-kuhn · commit ec21166e58fd · 2018-09-10T15:51:16.000+02:00
diff --git a/src/analysis/vector/geometry_checker/qgsgeometrycheck.cpp b/src/analysis/vector/geometry_checker/qgsgeometrycheck.cpp
@@ -50,7 +50,7 @@ QgsGeometryCheckError::QgsGeometryCheckError( const QgsGeometryCheck *check,
     const QgsPointXY &errorLocation, QgsVertexId vidx,
     const QVariant &value, ValueType valueType )
   : mCheck( check )
-  , mLayerId( layerFeature.layer().id() )
+  , mLayerId( layerFeature.layer()->id() )
   , mFeatureId( layerFeature.feature().id() )
   , mErrorLocation( errorLocation )
   , mVidx( vidx )
diff --git a/src/analysis/vector/geometry_checker/qgsgeometrycheckerutils.cpp b/src/analysis/vector/geometry_checker/qgsgeometrycheckerutils.cpp
@@ -43,23 +43,28 @@ namespace QgsGeometryCheckerUtils
   {
     delete mGeometry;
   }
-  const QgsVectorLayer &LayerFeature::layer() const { return *mFeaturePool->layer(); }
+
+  QgsVectorLayer *LayerFeature::layer() const
+  {
+    return mFeaturePool->layer();
+  }
+
   double LayerFeature::layerToMapUnits() const { return mFeaturePool->getLayerToMapUnits(); }
   const QgsCoordinateTransform &LayerFeature::layerToMapTransform() const { return mFeaturePool->getLayerToMapTransform(); }
 
   QString LayerFeature::id() const
   {
-    return QString( "%1:%2" ).arg( layer().name() ).arg( mFeature.id() );
+    return QString( "%1:%2" ).arg( layer()->name() ).arg( mFeature.id() );
   }
 
   bool LayerFeature::operator==( const LayerFeature &other ) const
   {
-    return layer().id() == other.layer().id() && feature().id() == other.feature().id();
+    return layer()->id() == other.layer()->id() && feature().id() == other.feature().id();
   }
 
   bool LayerFeature::operator!=( const LayerFeature &other ) const
   {
-    return layer().id() != other.layer().id() || feature().id() != other.feature().id();
+    return layer()->id() != other.layer()->id() || feature().id() != other.feature().id();
   }
 
   /////////////////////////////////////////////////////////////////////////////
diff --git a/src/analysis/vector/geometry_checker/qgsgeometrycheckerutils.h b/src/analysis/vector/geometry_checker/qgsgeometrycheckerutils.h
@@ -35,7 +35,7 @@ namespace QgsGeometryCheckerUtils
       LayerFeature( const QgsFeaturePool *pool, const QgsFeature &feature, bool useMapCrs );
       ~LayerFeature();
       const QgsFeature &feature() const { return mFeature; }
-      const QgsVectorLayer &layer() const;
+      QgsVectorLayer *layer() const;
       double layerToMapUnits() const;
       const QgsCoordinateTransform &layerToMapTransform() const;
       const QgsAbstractGeometry *geometry() const { return mGeometry; }
diff --git a/src/analysis/vector/geometry_checker/qgsgeometrycontainedcheck.h b/src/analysis/vector/geometry_checker/qgsgeometrycontainedcheck.h
@@ -30,7 +30,7 @@ class ANALYSIS_EXPORT QgsGeometryContainedCheckError : public QgsGeometryCheckEr
                                     const QgsGeometryCheckerUtils::LayerFeature &containingFeature
                                   )
       : QgsGeometryCheckError( check, layerFeature, errorLocation, QgsVertexId(), containingFeature.id(), ValueOther )
-      , mContainingFeature( qMakePair( containingFeature.layer().id(), containingFeature.feature().id() ) )
+      , mContainingFeature( qMakePair( containingFeature.layer()->id(), containingFeature.feature().id() ) )
     { }
     const QPair<QString, QgsFeatureId> &containingFeature() const { return mContainingFeature; }
 
diff --git a/src/analysis/vector/geometry_checker/qgsgeometrydanglecheck.cpp b/src/analysis/vector/geometry_checker/qgsgeometrydanglecheck.cpp
@@ -47,7 +47,7 @@ void QgsGeometryDangleCheck::collectErrors( QList<QgsGeometryCheckError *> &erro
       }
 
       // Check whether endpoints line on another line in the layer
-      QgsGeometryCheckerUtils::LayerFeatures checkFeatures( mContext->featurePools, QList<QString>() << layerFeature.layer().id(), line->boundingBox(), {QgsWkbTypes::LineGeometry} );
+      QgsGeometryCheckerUtils::LayerFeatures checkFeatures( mContext->featurePools, QList<QString>() << layerFeature.layer()->id(), line->boundingBox(), {QgsWkbTypes::LineGeometry} );
       for ( const QgsGeometryCheckerUtils::LayerFeature &checkFeature : checkFeatures )
       {
         const QgsAbstractGeometry *testGeom = checkFeature.geometry();
diff --git a/src/analysis/vector/geometry_checker/qgsgeometryduplicatecheck.cpp b/src/analysis/vector/geometry_checker/qgsgeometryduplicatecheck.cpp
@@ -45,7 +45,7 @@ void QgsGeometryDuplicateCheck::collectErrors( QList<QgsGeometryCheckError *> &e
   for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureA : layerFeaturesA )
   {
     // Ensure each pair of layers only gets compared once: remove the current layer from the layerIds, but add it to the layerList for layerFeaturesB
-    layerIds.removeOne( layerFeatureA.layer().id() );
+    layerIds.removeOne( layerFeatureA.layer()->id() );
 
     QgsRectangle bboxA = layerFeatureA.geometry()->boundingBox();
     std::unique_ptr< QgsGeometryEngine > geomEngineA = QgsGeometryCheckerUtils::createGeomEngine( layerFeatureA.geometry(), mContext->tolerance );
@@ -57,19 +57,19 @@ void QgsGeometryDuplicateCheck::collectErrors( QList<QgsGeometryCheckError *> &e
     QMap<QString, QList<QgsFeatureId>> duplicates;
 
     QgsWkbTypes::GeometryType geomType = layerFeatureA.feature().geometry().type();
-    QgsGeometryCheckerUtils::LayerFeatures layerFeaturesB( mContext->featurePools, QList<QString>() << layerFeatureA.layer().id() << layerIds, bboxA, {geomType} );
+    QgsGeometryCheckerUtils::LayerFeatures layerFeaturesB( mContext->featurePools, QList<QString>() << layerFeatureA.layer()->id() << layerIds, bboxA, {geomType} );
     for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureB : layerFeaturesB )
     {
       // > : only report overlaps within same layer once
-      if ( layerFeatureA.layer().id() == layerFeatureB.layer().id() && layerFeatureB.feature().id() >= layerFeatureA.feature().id() )
+      if ( layerFeatureA.layer()->id() == layerFeatureB.layer()->id() && layerFeatureB.feature().id() >= layerFeatureA.feature().id() )
       {
         continue;
       }
       QString errMsg;
       QgsAbstractGeometry *diffGeom = geomEngineA->symDifference( layerFeatureB.geometry(), &errMsg );
       if ( errMsg.isEmpty() && diffGeom && diffGeom->isEmpty() )
       {
-        duplicates[layerFeatureB.layer().id()].append( layerFeatureB.feature().id() );
+        duplicates[layerFeatureB.layer()->id()].append( layerFeatureB.feature().id() );
       }
       else if ( !errMsg.isEmpty() )
       {
diff --git a/src/analysis/vector/geometry_checker/qgsgeometryfollowboundariescheck.cpp b/src/analysis/vector/geometry_checker/qgsgeometryfollowboundariescheck.cpp
@@ -49,7 +49,7 @@ void QgsGeometryFollowBoundariesCheck::collectErrors( QList<QgsGeometryCheckErro
     const QgsAbstractGeometry *geom = layerFeature.geometry();
 
     // The geometry to crs of the check layer
-    QgsCoordinateTransform crst( layerFeature.layer().crs(), mCheckLayer->crs(), QgsProject::instance() );
+    QgsCoordinateTransform crst( layerFeature.layer()->crs(), mCheckLayer->crs(), QgsProject::instance() );
     QgsGeometry geomt( geom->clone() );
     geomt.transform( crst );
 
diff --git a/src/analysis/vector/geometry_checker/qgsgeometrygapcheck.cpp b/src/analysis/vector/geometry_checker/qgsgeometrygapcheck.cpp
@@ -100,7 +100,7 @@ void QgsGeometryGapCheck::collectErrors( QList<QgsGeometryCheckError *> &errors,
     {
       if ( QgsGeometryCheckerUtils::sharedEdgeLength( gapGeom.get(), layerFeature.geometry(), mContext->reducedTolerance ) > 0 )
       {
-        neighboringIds[layerFeature.layer().id()].insert( layerFeature.feature().id() );
+        neighboringIds[layerFeature.layer()->id()].insert( layerFeature.feature().id() );
         gapAreaBBox.combineExtentWith( layerFeature.geometry()->boundingBox() );
       }
     }
diff --git a/src/analysis/vector/geometry_checker/qgsgeometrylineintersectioncheck.cpp b/src/analysis/vector/geometry_checker/qgsgeometrylineintersectioncheck.cpp
@@ -25,7 +25,7 @@ void QgsGeometryLineIntersectionCheck::collectErrors( QList<QgsGeometryCheckErro
   for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureA : layerFeaturesA )
   {
     // Ensure each pair of layers only gets compared once: remove the current layer from the layerIds, but add it to the layerList for layerFeaturesB
-    layerIds.removeOne( layerFeatureA.layer().id() );
+    layerIds.removeOne( layerFeatureA.layer()->id() );
 
     const QgsAbstractGeometry *geom = layerFeatureA.geometry();
     for ( int iPart = 0, nParts = geom->partCount(); iPart < nParts; ++iPart )
@@ -38,11 +38,11 @@ void QgsGeometryLineIntersectionCheck::collectErrors( QList<QgsGeometryCheckErro
       }
 
       // Check whether the line intersects with any other lines
-      QgsGeometryCheckerUtils::LayerFeatures layerFeaturesB( mContext->featurePools, QList<QString>() << layerFeatureA.layer().id() << layerIds, line->boundingBox(), {QgsWkbTypes::LineGeometry} );
+      QgsGeometryCheckerUtils::LayerFeatures layerFeaturesB( mContext->featurePools, QList<QString>() << layerFeatureA.layer()->id() << layerIds, line->boundingBox(), {QgsWkbTypes::LineGeometry} );
       for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureB : layerFeaturesB )
       {
         // > : only report intersections within same layer once
-        if ( layerFeatureA.layer().id() == layerFeatureB.layer().id() && layerFeatureB.feature().id() > layerFeatureA.feature().id() )
+        if ( layerFeatureA.layer()->id() == layerFeatureB.layer()->id() && layerFeatureB.feature().id() > layerFeatureA.feature().id() )
         {
           continue;
         }
diff --git a/src/analysis/vector/geometry_checker/qgsgeometryoverlapcheck.cpp b/src/analysis/vector/geometry_checker/qgsgeometryoverlapcheck.cpp
@@ -27,7 +27,7 @@ void QgsGeometryOverlapCheck::collectErrors( QList<QgsGeometryCheckError *> &err
   for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureA : layerFeaturesA )
   {
     // Ensure each pair of layers only gets compared once: remove the current layer from the layerIds, but add it to the layerList for layerFeaturesB
-    layerIds.removeOne( layerFeatureA.layer().id() );
+    layerIds.removeOne( layerFeatureA.layer()->id() );
 
     QgsRectangle bboxA = layerFeatureA.geometry()->boundingBox();
     std::unique_ptr< QgsGeometryEngine > geomEngineA = QgsGeometryCheckerUtils::createGeomEngine( layerFeatureA.geometry(), mContext->tolerance );
@@ -37,11 +37,11 @@ void QgsGeometryOverlapCheck::collectErrors( QList<QgsGeometryCheckError *> &err
       continue;
     }
 
-    const QgsGeometryCheckerUtils::LayerFeatures layerFeaturesB( mContext->featurePools, QList<QString>() << layerFeatureA.layer().id() << layerIds, bboxA, mCompatibleGeometryTypes );
+    const QgsGeometryCheckerUtils::LayerFeatures layerFeaturesB( mContext->featurePools, QList<QString>() << layerFeatureA.layer()->id() << layerIds, bboxA, mCompatibleGeometryTypes );
     for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureB : layerFeaturesB )
     {
       // > : only report overlaps within same layer once
-      if ( layerFeatureA.layer().id() == layerFeatureB.layer().id() && layerFeatureB.feature().id() >= layerFeatureA.feature().id() )
+      if ( layerFeatureA.layer()->id() == layerFeatureB.layer()->id() && layerFeatureB.feature().id() >= layerFeatureA.feature().id() )
       {
         continue;
       }
diff --git a/src/analysis/vector/geometry_checker/qgsgeometryoverlapcheck.h b/src/analysis/vector/geometry_checker/qgsgeometryoverlapcheck.h
@@ -30,8 +30,8 @@ class ANALYSIS_EXPORT QgsGeometryOverlapCheckError : public QgsGeometryCheckErro
                                   const QgsPointXY &errorLocation,
                                   const QVariant &value,
                                   const QgsGeometryCheckerUtils::LayerFeature &overlappedFeature )
-      : QgsGeometryCheckError( check, layerFeature.layer().id(), layerFeature.feature().id(), geometry, errorLocation, QgsVertexId(), value, ValueArea )
-      , mOverlappedFeature( qMakePair( overlappedFeature.layer().id(), overlappedFeature.feature().id() ) )
+      : QgsGeometryCheckError( check, layerFeature.layer()->id(), layerFeature.feature().id(), geometry, errorLocation, QgsVertexId(), value, ValueArea )
+      , mOverlappedFeature( qMakePair( overlappedFeature.layer()->id(), overlappedFeature.feature().id() ) )
     { }
     const QPair<QString, QgsFeatureId> &overlappedFeature() const { return mOverlappedFeature; }
 

Original file line number	Diff line number	Diff line change
`@@ -43,23 +43,28 @@ namespace QgsGeometryCheckerUtils`
`43`	`43`	`{`
`44`	`44`	`delete mGeometry;`
`45`	`45`	`}`
`46`		`- const QgsVectorLayer &LayerFeature::layer() const { return *mFeaturePool->layer(); }`
	`46`	`+`
	`47`	`+ QgsVectorLayer *LayerFeature::layer() const`
	`48`	`+ {`
	`49`	`+ return mFeaturePool->layer();`
	`50`	`+ }`
	`51`	`+`
`47`	`52`	`double LayerFeature::layerToMapUnits() const { return mFeaturePool->getLayerToMapUnits(); }`
`48`	`53`	`const QgsCoordinateTransform &LayerFeature::layerToMapTransform() const { return mFeaturePool->getLayerToMapTransform(); }`
`49`	`54`
`50`	`55`	`QString LayerFeature::id() const`
`51`	`56`	`{`
`52`		`- return QString( "%1:%2" ).arg( layer().name() ).arg( mFeature.id() );`
	`57`	`+ return QString( "%1:%2" ).arg( layer()->name() ).arg( mFeature.id() );`
`53`	`58`	`}`
`54`	`59`
`55`	`60`	`bool LayerFeature::operator==( const LayerFeature &other ) const`
`56`	`61`	`{`
`57`		`- return layer().id() == other.layer().id() && feature().id() == other.feature().id();`
	`62`	`+ return layer()->id() == other.layer()->id() && feature().id() == other.feature().id();`
`58`	`63`	`}`
`59`	`64`
`60`	`65`	`bool LayerFeature::operator!=( const LayerFeature &other ) const`
`61`	`66`	`{`
`62`		`- return layer().id() != other.layer().id() \|\| feature().id() != other.feature().id();`
	`67`	`+ return layer()->id() != other.layer()->id() \|\| feature().id() != other.feature().id();`
`63`	`68`	`}`
`64`	`69`
`65`	`70`	`/////////////////////////////////////////////////////////////////////////////`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ class ANALYSIS_EXPORT QgsGeometryContainedCheckError : public QgsGeometryCheckEr`
`30`	`30`	`const QgsGeometryCheckerUtils::LayerFeature &containingFeature`
`31`	`31`	`)`
`32`	`32`	`: QgsGeometryCheckError( check, layerFeature, errorLocation, QgsVertexId(), containingFeature.id(), ValueOther )`
`33`		`- , mContainingFeature( qMakePair( containingFeature.layer().id(), containingFeature.feature().id() ) )`
	`33`	`+ , mContainingFeature( qMakePair( containingFeature.layer()->id(), containingFeature.feature().id() ) )`
`34`	`34`	`{ }`
`35`	`35`	`const QPair<QString, QgsFeatureId> &containingFeature() const { return mContainingFeature; }`
`36`	`36`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ void QgsGeometryDangleCheck::collectErrors( QList<QgsGeometryCheckError *> &erro`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`// Check whether endpoints line on another line in the layer`
`50`		`- QgsGeometryCheckerUtils::LayerFeatures checkFeatures( mContext->featurePools, QList<QString>() << layerFeature.layer().id(), line->boundingBox(), {QgsWkbTypes::LineGeometry} );`
	`50`	`+ QgsGeometryCheckerUtils::LayerFeatures checkFeatures( mContext->featurePools, QList<QString>() << layerFeature.layer()->id(), line->boundingBox(), {QgsWkbTypes::LineGeometry} );`
`51`	`51`	`for ( const QgsGeometryCheckerUtils::LayerFeature &checkFeature : checkFeatures )`
`52`	`52`	`{`
`53`	`53`	`const QgsAbstractGeometry *testGeom = checkFeature.geometry();`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ void QgsGeometryDuplicateCheck::collectErrors( QList<QgsGeometryCheckError *> &e`
`45`	`45`	`for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureA : layerFeaturesA )`
`46`	`46`	`{`
`47`	`47`	`// Ensure each pair of layers only gets compared once: remove the current layer from the layerIds, but add it to the layerList for layerFeaturesB`
`48`		`- layerIds.removeOne( layerFeatureA.layer().id() );`
	`48`	`+ layerIds.removeOne( layerFeatureA.layer()->id() );`
`49`	`49`
`50`	`50`	`QgsRectangle bboxA = layerFeatureA.geometry()->boundingBox();`
`51`	`51`	`std::unique_ptr< QgsGeometryEngine > geomEngineA = QgsGeometryCheckerUtils::createGeomEngine( layerFeatureA.geometry(), mContext->tolerance );`
`@@ -57,19 +57,19 @@ void QgsGeometryDuplicateCheck::collectErrors( QList<QgsGeometryCheckError *> &e`
`57`	`57`	`QMap<QString, QList<QgsFeatureId>> duplicates;`
`58`	`58`
`59`	`59`	`QgsWkbTypes::GeometryType geomType = layerFeatureA.feature().geometry().type();`
`60`		`- QgsGeometryCheckerUtils::LayerFeatures layerFeaturesB( mContext->featurePools, QList<QString>() << layerFeatureA.layer().id() << layerIds, bboxA, {geomType} );`
	`60`	`+ QgsGeometryCheckerUtils::LayerFeatures layerFeaturesB( mContext->featurePools, QList<QString>() << layerFeatureA.layer()->id() << layerIds, bboxA, {geomType} );`
`61`	`61`	`for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureB : layerFeaturesB )`
`62`	`62`	`{`
`63`	`63`	`// > : only report overlaps within same layer once`
`64`		`- if ( layerFeatureA.layer().id() == layerFeatureB.layer().id() && layerFeatureB.feature().id() >= layerFeatureA.feature().id() )`
	`64`	`+ if ( layerFeatureA.layer()->id() == layerFeatureB.layer()->id() && layerFeatureB.feature().id() >= layerFeatureA.feature().id() )`
`65`	`65`	`{`
`66`	`66`	`continue;`
`67`	`67`	`}`
`68`	`68`	`QString errMsg;`
`69`	`69`	`QgsAbstractGeometry *diffGeom = geomEngineA->symDifference( layerFeatureB.geometry(), &errMsg );`
`70`	`70`	`if ( errMsg.isEmpty() && diffGeom && diffGeom->isEmpty() )`
`71`	`71`	`{`
`72`		`- duplicates[layerFeatureB.layer().id()].append( layerFeatureB.feature().id() );`
	`72`	`+ duplicates[layerFeatureB.layer()->id()].append( layerFeatureB.feature().id() );`
`73`	`73`	`}`
`74`	`74`	`else if ( !errMsg.isEmpty() )`
`75`	`75`	`{`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ void QgsGeometryGapCheck::collectErrors( QList<QgsGeometryCheckError *> &errors,`
`100`	`100`	`{`
`101`	`101`	`if ( QgsGeometryCheckerUtils::sharedEdgeLength( gapGeom.get(), layerFeature.geometry(), mContext->reducedTolerance ) > 0 )`
`102`	`102`	`{`
`103`		`- neighboringIds[layerFeature.layer().id()].insert( layerFeature.feature().id() );`
	`103`	`+ neighboringIds[layerFeature.layer()->id()].insert( layerFeature.feature().id() );`
`104`	`104`	`gapAreaBBox.combineExtentWith( layerFeature.geometry()->boundingBox() );`
`105`	`105`	`}`
`106`	`106`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ void QgsGeometryLineIntersectionCheck::collectErrors( QList<QgsGeometryCheckErro`
`25`	`25`	`for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureA : layerFeaturesA )`
`26`	`26`	`{`
`27`	`27`	`// Ensure each pair of layers only gets compared once: remove the current layer from the layerIds, but add it to the layerList for layerFeaturesB`
`28`		`- layerIds.removeOne( layerFeatureA.layer().id() );`
	`28`	`+ layerIds.removeOne( layerFeatureA.layer()->id() );`
`29`	`29`
`30`	`30`	`const QgsAbstractGeometry *geom = layerFeatureA.geometry();`
`31`	`31`	`for ( int iPart = 0, nParts = geom->partCount(); iPart < nParts; ++iPart )`
`@@ -38,11 +38,11 @@ void QgsGeometryLineIntersectionCheck::collectErrors( QList<QgsGeometryCheckErro`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`// Check whether the line intersects with any other lines`
`41`		`- QgsGeometryCheckerUtils::LayerFeatures layerFeaturesB( mContext->featurePools, QList<QString>() << layerFeatureA.layer().id() << layerIds, line->boundingBox(), {QgsWkbTypes::LineGeometry} );`
	`41`	`+ QgsGeometryCheckerUtils::LayerFeatures layerFeaturesB( mContext->featurePools, QList<QString>() << layerFeatureA.layer()->id() << layerIds, line->boundingBox(), {QgsWkbTypes::LineGeometry} );`
`42`	`42`	`for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureB : layerFeaturesB )`
`43`	`43`	`{`
`44`	`44`	`// > : only report intersections within same layer once`
`45`		`- if ( layerFeatureA.layer().id() == layerFeatureB.layer().id() && layerFeatureB.feature().id() > layerFeatureA.feature().id() )`
	`45`	`+ if ( layerFeatureA.layer()->id() == layerFeatureB.layer()->id() && layerFeatureB.feature().id() > layerFeatureA.feature().id() )`
`46`	`46`	`{`
`47`	`47`	`continue;`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ void QgsGeometryOverlapCheck::collectErrors( QList<QgsGeometryCheckError *> &err`
`27`	`27`	`for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureA : layerFeaturesA )`
`28`	`28`	`{`
`29`	`29`	`// Ensure each pair of layers only gets compared once: remove the current layer from the layerIds, but add it to the layerList for layerFeaturesB`
`30`		`- layerIds.removeOne( layerFeatureA.layer().id() );`
	`30`	`+ layerIds.removeOne( layerFeatureA.layer()->id() );`
`31`	`31`
`32`	`32`	`QgsRectangle bboxA = layerFeatureA.geometry()->boundingBox();`
`33`	`33`	`std::unique_ptr< QgsGeometryEngine > geomEngineA = QgsGeometryCheckerUtils::createGeomEngine( layerFeatureA.geometry(), mContext->tolerance );`
`@@ -37,11 +37,11 @@ void QgsGeometryOverlapCheck::collectErrors( QList<QgsGeometryCheckError *> &err`
`37`	`37`	`continue;`
`38`	`38`	`}`
`39`	`39`
`40`		`- const QgsGeometryCheckerUtils::LayerFeatures layerFeaturesB( mContext->featurePools, QList<QString>() << layerFeatureA.layer().id() << layerIds, bboxA, mCompatibleGeometryTypes );`
	`40`	`+ const QgsGeometryCheckerUtils::LayerFeatures layerFeaturesB( mContext->featurePools, QList<QString>() << layerFeatureA.layer()->id() << layerIds, bboxA, mCompatibleGeometryTypes );`
`41`	`41`	`for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureB : layerFeaturesB )`
`42`	`42`	`{`
`43`	`43`	`// > : only report overlaps within same layer once`
`44`		`- if ( layerFeatureA.layer().id() == layerFeatureB.layer().id() && layerFeatureB.feature().id() >= layerFeatureA.feature().id() )`
	`44`	`+ if ( layerFeatureA.layer()->id() == layerFeatureB.layer()->id() && layerFeatureB.feature().id() >= layerFeatureA.feature().id() )`
`45`	`45`	`{`
`46`	`46`	`continue;`
`47`	`47`	`}`