Merge pull request OSGeo#11958 from dbaston/geometry-create-from-wkt-usages

rouault · web-flow · commit 4738ce8f321f · 2025-03-13T20:15:06.000+01:00
OGRGeometryFactory: Update createFromWkt usages to unique_ptr overload
diff --git a/apps/gdal_grid_lib.cpp b/apps/gdal_grid_lib.cpp
@@ -1342,10 +1342,9 @@ GDALGridOptionsNew(char **papszArgv,
                       STARTS_WITH_CI(osVal.c_str(), "MULTIPOLYGON")) &&
                      VSIStatL(osVal.c_str(), &sStat) != 0)
             {
-                OGRGeometry *poGeom = nullptr;
-                OGRGeometryFactory::createFromWkt(osVal.c_str(), nullptr,
-                                                  &poGeom);
-                psOptions->poClipSrc.reset(poGeom);
+                psOptions->poClipSrc =
+                    OGRGeometryFactory::createFromWkt(osVal.c_str(), nullptr)
+                        .first;
                 if (psOptions->poClipSrc == nullptr)
                 {
                     CPLError(CE_Failure, CPLE_IllegalArg,
diff --git a/apps/gdalwarp_lib.cpp b/apps/gdalwarp_lib.cpp
@@ -3358,10 +3358,10 @@ static CPLErr LoadCutline(const std::string &osCutlineDSNameOrWKT,
             poSRS->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
             poSRS->SetFromUserInput(osSRS.c_str());
         }
-        OGRGeometry *poGeom = nullptr;
-        OGRGeometryFactory::createFromWkt(osCutlineDSNameOrWKT.c_str(),
-                                          poSRS.get(), &poGeom);
-        *phCutlineRet = OGRGeometry::ToHandle(poGeom);
+
+        auto [poGeom, _] = OGRGeometryFactory::createFromWkt(
+            osCutlineDSNameOrWKT.c_str(), poSRS.get());
+        *phCutlineRet = OGRGeometry::ToHandle(poGeom.release());
         return *phCutlineRet ? CE_None : CE_Failure;
     }
 
diff --git a/apps/ogr2ogr_lib.cpp b/apps/ogr2ogr_lib.cpp
@@ -8378,10 +8378,8 @@ GDALVectorTranslateOptions *GDALVectorTranslateOptionsNew(
                       STARTS_WITH_CI(osVal.c_str(), "MULTIPOLYGON")) &&
                      VSIStatL(osVal.c_str(), &sStat) != 0)
             {
-                OGRGeometry *poGeom = nullptr;
-                OGRGeometryFactory::createFromWkt(osVal.c_str(), nullptr,
-                                                  &poGeom);
-                psOptions->poClipSrc.reset(poGeom);
+                psOptions->poClipSrc =
+                    OGRGeometryFactory::createFromWkt(osVal.c_str()).first;
                 if (psOptions->poClipSrc == nullptr)
                 {
                     CPLError(
@@ -8433,10 +8431,8 @@ GDALVectorTranslateOptions *GDALVectorTranslateOptionsNew(
                       STARTS_WITH_CI(osVal.c_str(), "MULTIPOLYGON")) &&
                      VSIStatL(osVal.c_str(), &sStat) != 0)
             {
-                OGRGeometry *poGeom = nullptr;
-                OGRGeometryFactory::createFromWkt(osVal.c_str(), nullptr,
-                                                  &poGeom);
-                psOptions->poClipDst.reset(poGeom);
+                psOptions->poClipDst =
+                    OGRGeometryFactory::createFromWkt(osVal.c_str()).first;
                 if (psOptions->poClipDst == nullptr)
                 {
                     CPLError(
diff --git a/apps/test_ogrsf.cpp b/apps/test_ogrsf.cpp
@@ -822,9 +822,8 @@ static int TestCreateLayer(GDALDriver *poDriver, OGRwkbGeometryType eGeomType)
         const char *pszWKT = GetWKT(eGeomType);
         if (pszWKT != nullptr)
         {
-            OGRGeometry *poGeom = nullptr;
-            OGRGeometryFactory::createFromWkt(pszWKT, nullptr, &poGeom);
-            poFeature->SetGeometryDirectly(poGeom);
+            auto [poGeom, _] = OGRGeometryFactory::createFromWkt(pszWKT);
+            poFeature->SetGeometry(std::move(poGeom));
         }
 
         CPLErrorReset();
@@ -864,9 +863,8 @@ static int TestCreateLayer(GDALDriver *poDriver, OGRwkbGeometryType eGeomType)
         pszWKT = GetWKT(eOtherGeomType);
         if (pszWKT != nullptr)
         {
-            OGRGeometry *poGeom = nullptr;
-            OGRGeometryFactory::createFromWkt(pszWKT, nullptr, &poGeom);
-            poFeature->SetGeometryDirectly(poGeom);
+            auto [poGeom, _] = OGRGeometryFactory::createFromWkt(pszWKT);
+            poFeature->SetGeometry(std::move(poGeom));
         }
 
         CPLErrorReset();
@@ -915,9 +913,8 @@ static int TestCreateLayer(GDALDriver *poDriver, OGRwkbGeometryType eGeomType)
             pszWKT = GetWKT(eGeomType);
             if (pszWKT != nullptr)
             {
-                OGRGeometry *poGeom = nullptr;
-                OGRGeometryFactory::createFromWkt(pszWKT, nullptr, &poGeom);
-                poFeature->SetGeometryDirectly(poGeom);
+                auto [poGeom, _] = OGRGeometryFactory::createFromWkt(pszWKT);
+                poFeature->SetGeometry(std::move(poGeom));
             }
             CPLErrorReset();
             CPLPushErrorHandler(CPLQuietErrorHandler);
diff --git a/frmts/netcdf/netcdflayer.cpp b/frmts/netcdf/netcdflayer.cpp
@@ -1311,13 +1311,11 @@ bool netCDFLayer::FillFeatureFromVar(OGRFeature *poFeature, int nMainDimId,
         }
         if (pszWKT != nullptr)
         {
-            OGRGeometry *poGeom = nullptr;
-            CPL_IGNORE_RET_VAL(
-                OGRGeometryFactory::createFromWkt(pszWKT, nullptr, &poGeom));
+            auto [poGeom, _] = OGRGeometryFactory::createFromWkt(pszWKT);
             if (poGeom != nullptr)
             {
                 poGeom->assignSpatialReference(GetSpatialRef());
-                poFeature->SetGeometryDirectly(poGeom);
+                poFeature->SetGeometry(std::move(poGeom));
             }
             CPLFree(pszWKT);
         }
diff --git a/frmts/pdf/pdfcreatecopy.cpp b/frmts/pdf/pdfcreatecopy.cpp
@@ -690,8 +690,7 @@ GDALPDFObjectNum GDALPDFBaseWriter::WriteSRS_ISO32000(GDALDataset *poSrcDS,
         pszNEATLINE = poSrcDS->GetMetadataItem("NEATLINE");
     if (bHasGT && pszNEATLINE != nullptr && pszNEATLINE[0] != '\0')
     {
-        OGRGeometry *poGeom = nullptr;
-        OGRGeometryFactory::createFromWkt(pszNEATLINE, nullptr, &poGeom);
+        auto [poGeom, _] = OGRGeometryFactory::createFromWkt(pszNEATLINE);
         if (poGeom != nullptr &&
             wkbFlatten(poGeom->getGeometryType()) == wkbPolygon)
         {
@@ -748,7 +747,6 @@ GDALPDFObjectNum GDALPDFBaseWriter::WriteSRS_ISO32000(GDALDataset *poSrcDS,
                 }
             }
         }
-        delete poGeom;
     }
 
     if (pasGCPList)
diff --git a/frmts/pdf/pdfcreatefromcomposition.cpp b/frmts/pdf/pdfcreatefromcomposition.cpp
@@ -683,8 +683,8 @@ bool GDALPDFComposerWriter::GenerateGeoreferencing(
     std::vector<xyPair> aBoundingPolygon;
     if (pszBoundingPolygon)
     {
-        OGRGeometry *poGeom = nullptr;
-        OGRGeometryFactory::createFromWkt(pszBoundingPolygon, nullptr, &poGeom);
+        auto [poGeom, _] =
+            OGRGeometryFactory::createFromWkt(pszBoundingPolygon);
         if (poGeom && poGeom->getGeometryType() == wkbPolygon)
         {
             auto poPoly = poGeom->toPolygon();
@@ -707,7 +707,6 @@ bool GDALPDFComposerWriter::GenerateGeoreferencing(
                 }
             }
         }
-        delete poGeom;
     }
 
     const auto pszSRS = CPLGetXMLValue(psGeoreferencing, "SRS", nullptr);
diff --git a/ogr/ogr_wkb.cpp b/ogr/ogr_wkb.cpp
@@ -1618,7 +1618,7 @@ size_t OGRWKTToWKBTranslator::TranslateWKT(void *pabyWKTStart, size_t nLength,
     }
 
     // General case going through a OGRGeometry
-    OGRGeometry *poGeometry = nullptr;
+    std::unique_ptr<OGRGeometry> poGeometry = nullptr;
     if (bCanAlterByteAfter)
     {
         // Slight optimization for all geometries but the final one, to
@@ -1628,15 +1628,15 @@ size_t OGRWKTToWKBTranslator::TranslateWKT(void *pabyWKTStart, size_t nLength,
         char *pszEnd = static_cast<char *>(pabyWKTStart) + nLength;
         const char chBackup = *pszEnd;
         *pszEnd = 0;
-        OGRGeometryFactory::createFromWkt(pszPtrStart, nullptr, &poGeometry);
+        poGeometry = OGRGeometryFactory::createFromWkt(pszPtrStart).first;
         // cppcheck-suppress selfAssignment
         *pszEnd = chBackup;
     }
     else
     {
         std::string osTmp;
         osTmp.assign(pszPtrStart, nLength);
-        OGRGeometryFactory::createFromWkt(osTmp.c_str(), nullptr, &poGeometry);
+        poGeometry = OGRGeometryFactory::createFromWkt(osTmp.c_str()).first;
     }
     if (!poGeometry)
     {
@@ -1651,6 +1651,5 @@ size_t OGRWKTToWKBTranslator::TranslateWKT(void *pabyWKTStart, size_t nLength,
         return static_cast<size_t>(-1);
     }
     poGeometry->exportToWkb(wkbNDR, pabyWKB, wkbVariantIso);
-    delete poGeometry;
     return nWKBSize;
 }
diff --git a/ogr/ogrsf_frmts/csv/ogrcsvlayer.cpp b/ogr/ogrsf_frmts/csv/ogrcsvlayer.cpp
@@ -1401,48 +1401,45 @@ OGRFeature *OGRCSVLayer::GetNextUnfilteredFeature()
                 const char *pszStr = papszTokens[iAttr];
                 while (*pszStr == ' ')
                     pszStr++;
-                OGRGeometry *poGeom = nullptr;
+                std::unique_ptr<OGRGeometry> poGeom = nullptr;
+                OGRErr eErr;
 
                 if (EQUAL(poGeomFieldDefn->GetNameRef(), ""))
                 {
-                    if (OGRGeometryFactory::createFromWkt(
-                            pszStr, nullptr, &poGeom) != OGRERR_NONE)
+                    std::tie(poGeom, eErr) =
+                        OGRGeometryFactory::createFromWkt(pszStr);
+                    if (eErr != OGRERR_NONE)
                     {
                         CPLError(CE_Warning, CPLE_AppDefined,
                                  "Ignoring invalid WKT: %s", pszStr);
-                        delete poGeom;
-                        poGeom = nullptr;
                     }
                 }
                 else
                 {
                     CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
 
-                    if (OGRGeometryFactory::createFromWkt(
-                            pszStr, nullptr, &poGeom) != OGRERR_NONE)
-                    {
-                        delete poGeom;
-                        poGeom = nullptr;
-                    }
+                    std::tie(poGeom, eErr) =
+                        OGRGeometryFactory::createFromWkt(pszStr);
 
                     if (!poGeom && *pszStr == '{')
                     {
-                        poGeom = OGRGeometry::FromHandle(
-                            OGR_G_CreateGeometryFromJson(pszStr));
+                        poGeom.reset(OGRGeometry::FromHandle(
+                            OGR_G_CreateGeometryFromJson(pszStr)));
                     }
                     else if (!poGeom && ((*pszStr >= '0' && *pszStr <= '9') ||
                                          (*pszStr >= 'a' && *pszStr <= 'z') ||
                                          (*pszStr >= 'A' && *pszStr <= 'Z')))
                     {
-                        poGeom = OGRGeometryFromHexEWKB(pszStr, nullptr, FALSE);
+                        poGeom.reset(
+                            OGRGeometryFromHexEWKB(pszStr, nullptr, FALSE));
                     }
                 }
 
                 if (poGeom)
                 {
                     poGeom->assignSpatialReference(
                         poGeomFieldDefn->GetSpatialRef());
-                    poFeature->SetGeomFieldDirectly(iGeom, poGeom);
+                    poFeature->SetGeomField(iGeom, std::move(poGeom));
                 }
             }
 
diff --git a/ogr/ogrsf_frmts/sqlite/ogrsqlitelayer.cpp b/ogr/ogrsf_frmts/sqlite/ogrsqlitelayer.cpp
@@ -565,9 +565,10 @@ void OGRSQLiteLayer::BuildFeatureDefn(const char *pszLayerName, bool bIsSelect,
                 {
                     OGRSQLiteGeomFormat eGeomFormat = OSGF_None;
                     CPLPushErrorHandler(CPLQuietErrorHandler);
-                    OGRGeometry *poGeometry = nullptr;
-                    if (OGRGeometryFactory::createFromWkt(
-                            pszText, nullptr, &poGeometry) == OGRERR_NONE)
+
+                    auto [poGeometry, eErr] =
+                        OGRGeometryFactory::createFromWkt(pszText);
+                    if (eErr == OGRERR_NONE)
                     {
                         eGeomFormat = OSGF_WKT;
                         auto poGeomFieldDefn =
@@ -579,7 +580,6 @@ void OGRSQLiteLayer::BuildFeatureDefn(const char *pszLayerName, bool bIsSelect,
                     }
                     CPLPopErrorHandler();
                     CPLErrorReset();
-                    delete poGeometry;
                     if (eGeomFormat != OSGF_None)
                         continue;
                 }
diff --git a/ogr/ogrsf_frmts/vrt/ogr_vrt.h b/ogr/ogrsf_frmts/vrt/ogr_vrt.h
@@ -46,7 +46,7 @@ class OGRVRTGeomFieldProps
     const OGRSpatialReference *poSRS;
 
     bool bSrcClip;
-    OGRGeometry *poSrcRegion;
+    std::unique_ptr<OGRGeometry> poSrcRegion;
 
     // Geometry interpretation related.
     OGRVRTGeometryStyle eGeometryStyle;
diff --git a/ogr/ogrsf_frmts/vrt/ogrvrtlayer.cpp b/ogr/ogrsf_frmts/vrt/ogrvrtlayer.cpp
@@ -75,8 +75,6 @@ OGRVRTGeomFieldProps::~OGRVRTGeomFieldProps()
 {
     if (poSRS != nullptr)
         const_cast<OGRSpatialReference *>(poSRS)->Release();
-    if (poSrcRegion != nullptr)
-        delete poSrcRegion;
 }
 
 /************************************************************************/
@@ -467,8 +465,9 @@ bool OGRVRTLayer::ParseGeometryField(CPLXMLNode *psNode,
     const char *pszSrcRegion = CPLGetXMLValue(psSrcRegionNode, "", nullptr);
     if (pszSrcRegion != nullptr)
     {
-        OGRGeometryFactory::createFromWkt(pszSrcRegion, nullptr,
-                                          &poProps->poSrcRegion);
+        poProps->poSrcRegion =
+            OGRGeometryFactory::createFromWkt(pszSrcRegion).first;
+
         if (poProps->poSrcRegion == nullptr)
         {
             CPLError(CE_Warning, CPLE_AppDefined,
@@ -1325,7 +1324,7 @@ bool OGRVRTLayer::ResetSourceReading()
     {
         OGRGeometry *poNewSpatialGeom = nullptr;
         OGRGeometry *poSrcRegion =
-            apoGeomFieldProps[m_iGeomFieldFilter]->poSrcRegion;
+            apoGeomFieldProps[m_iGeomFieldFilter]->poSrcRegion.get();
         std::unique_ptr<OGRGeometry> poIntersection;
 
         if (poSrcRegion == nullptr)
@@ -1442,7 +1441,8 @@ void OGRVRTLayer::ClipAndAssignSRS(OGRFeature *poFeature)
         if (apoGeomFieldProps[i]->poSrcRegion != nullptr &&
             apoGeomFieldProps[i]->bSrcClip && poGeom != nullptr)
         {
-            poGeom = poGeom->Intersection(apoGeomFieldProps[i]->poSrcRegion);
+            poGeom =
+                poGeom->Intersection(apoGeomFieldProps[i]->poSrcRegion.get());
             if (poGeom != nullptr)
                 poGeom->assignSpatialReference(
                     GetLayerDefn()->GetGeomFieldDefn(i)->GetSpatialRef());
@@ -1507,13 +1507,11 @@ OGRFeature *OGRVRTLayer::TranslateFeature(OGRFeature *&poSrcFeat,
 
             if (pszWKT != nullptr)
             {
-                OGRGeometry *poGeom = nullptr;
-
-                OGRGeometryFactory::createFromWkt(pszWKT, nullptr, &poGeom);
+                auto [poGeom, _] = OGRGeometryFactory::createFromWkt(pszWKT);
                 if (poGeom == nullptr)
                     CPLDebug("OGR_VRT", "Did not get geometry from %s", pszWKT);
 
-                poDstFeat->SetGeomFieldDirectly(i, poGeom);
+                poDstFeat->SetGeomField(i, std::move(poGeom));
             }
         }
         else if (eGeometryStyle == VGS_WKB && iGeomField != -1)
@@ -1619,7 +1617,7 @@ OGRFeature *OGRVRTLayer::TranslateFeature(OGRFeature *&poSrcFeat,
         {
             OGRGeometry *poGeom = poDstFeat->GetGeomFieldRef(i);
             if (poGeom != nullptr &&
-                !poGeom->Intersects(apoGeomFieldProps[i]->poSrcRegion))
+                !poGeom->Intersects(apoGeomFieldProps[i]->poSrcRegion.get()))
             {
                 delete poSrcFeat;
                 delete poDstFeat;

Original file line number	Diff line number	Diff line change
`@@ -1342,10 +1342,9 @@ GDALGridOptionsNew(char **papszArgv,`
`1342`	`1342`	`STARTS_WITH_CI(osVal.c_str(), "MULTIPOLYGON")) &&`
`1343`	`1343`	`VSIStatL(osVal.c_str(), &sStat) != 0)`
`1344`	`1344`	`{`
`1345`		`- OGRGeometry *poGeom = nullptr;`
`1346`		`- OGRGeometryFactory::createFromWkt(osVal.c_str(), nullptr,`
`1347`		`- &poGeom);`
`1348`		`- psOptions->poClipSrc.reset(poGeom);`
	`1345`	`+ psOptions->poClipSrc =`
	`1346`	`+ OGRGeometryFactory::createFromWkt(osVal.c_str(), nullptr)`
	`1347`	`+ .first;`
`1349`	`1348`	`if (psOptions->poClipSrc == nullptr)`
`1350`	`1349`	`{`
`1351`	`1350`	`CPLError(CE_Failure, CPLE_IllegalArg,`
Original file line number	Diff line number	Diff line change
`@@ -3358,10 +3358,10 @@ static CPLErr LoadCutline(const std::string &osCutlineDSNameOrWKT,`
`3358`	`3358`	`poSRS->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);`
`3359`	`3359`	`poSRS->SetFromUserInput(osSRS.c_str());`
`3360`	`3360`	`}`
`3361`		`- OGRGeometry *poGeom = nullptr;`
`3362`		`- OGRGeometryFactory::createFromWkt(osCutlineDSNameOrWKT.c_str(),`
`3363`		`- poSRS.get(), &poGeom);`
`3364`		`- *phCutlineRet = OGRGeometry::ToHandle(poGeom);`
	`3361`	`+`
	`3362`	`+ auto [poGeom, _] = OGRGeometryFactory::createFromWkt(`
	`3363`	`+ osCutlineDSNameOrWKT.c_str(), poSRS.get());`
	`3364`	`+ *phCutlineRet = OGRGeometry::ToHandle(poGeom.release());`
`3365`	`3365`	`return *phCutlineRet ? CE_None : CE_Failure;`
`3366`	`3366`	`}`
`3367`	`3367`
Original file line number	Diff line number	Diff line change
`@@ -822,9 +822,8 @@ static int TestCreateLayer(GDALDriver *poDriver, OGRwkbGeometryType eGeomType)`
`822`	`822`	`const char *pszWKT = GetWKT(eGeomType);`
`823`	`823`	`if (pszWKT != nullptr)`
`824`	`824`	`{`
`825`		`- OGRGeometry *poGeom = nullptr;`
`826`		`- OGRGeometryFactory::createFromWkt(pszWKT, nullptr, &poGeom);`
`827`		`- poFeature->SetGeometryDirectly(poGeom);`
	`825`	`+ auto [poGeom, _] = OGRGeometryFactory::createFromWkt(pszWKT);`
	`826`	`+ poFeature->SetGeometry(std::move(poGeom));`
`828`	`827`	`}`
`829`	`828`
`830`	`829`	`CPLErrorReset();`
`@@ -864,9 +863,8 @@ static int TestCreateLayer(GDALDriver *poDriver, OGRwkbGeometryType eGeomType)`
`864`	`863`	`pszWKT = GetWKT(eOtherGeomType);`
`865`	`864`	`if (pszWKT != nullptr)`
`866`	`865`	`{`
`867`		`- OGRGeometry *poGeom = nullptr;`
`868`		`- OGRGeometryFactory::createFromWkt(pszWKT, nullptr, &poGeom);`
`869`		`- poFeature->SetGeometryDirectly(poGeom);`
	`866`	`+ auto [poGeom, _] = OGRGeometryFactory::createFromWkt(pszWKT);`
	`867`	`+ poFeature->SetGeometry(std::move(poGeom));`
`870`	`868`	`}`
`871`	`869`
`872`	`870`	`CPLErrorReset();`
`@@ -915,9 +913,8 @@ static int TestCreateLayer(GDALDriver *poDriver, OGRwkbGeometryType eGeomType)`
`915`	`913`	`pszWKT = GetWKT(eGeomType);`
`916`	`914`	`if (pszWKT != nullptr)`
`917`	`915`	`{`
`918`		`- OGRGeometry *poGeom = nullptr;`
`919`		`- OGRGeometryFactory::createFromWkt(pszWKT, nullptr, &poGeom);`
`920`		`- poFeature->SetGeometryDirectly(poGeom);`
	`916`	`+ auto [poGeom, _] = OGRGeometryFactory::createFromWkt(pszWKT);`
	`917`	`+ poFeature->SetGeometry(std::move(poGeom));`
`921`	`918`	`}`
`922`	`919`	`CPLErrorReset();`
`923`	`920`	`CPLPushErrorHandler(CPLQuietErrorHandler);`
Original file line number	Diff line number	Diff line change
`@@ -1311,13 +1311,11 @@ bool netCDFLayer::FillFeatureFromVar(OGRFeature *poFeature, int nMainDimId,`
`1311`	`1311`	`}`
`1312`	`1312`	`if (pszWKT != nullptr)`
`1313`	`1313`	`{`
`1314`		`- OGRGeometry *poGeom = nullptr;`
`1315`		`- CPL_IGNORE_RET_VAL(`
`1316`		`- OGRGeometryFactory::createFromWkt(pszWKT, nullptr, &poGeom));`
	`1314`	`+ auto [poGeom, _] = OGRGeometryFactory::createFromWkt(pszWKT);`
`1317`	`1315`	`if (poGeom != nullptr)`
`1318`	`1316`	`{`
`1319`	`1317`	`poGeom->assignSpatialReference(GetSpatialRef());`
`1320`		`- poFeature->SetGeometryDirectly(poGeom);`
	`1318`	`+ poFeature->SetGeometry(std::move(poGeom));`
`1321`	`1319`	`}`
`1322`	`1320`	`CPLFree(pszWKT);`
`1323`	`1321`	`}`
Original file line number	Diff line number	Diff line change
`@@ -690,8 +690,7 @@ GDALPDFObjectNum GDALPDFBaseWriter::WriteSRS_ISO32000(GDALDataset *poSrcDS,`
`690`	`690`	`pszNEATLINE = poSrcDS->GetMetadataItem("NEATLINE");`
`691`	`691`	`if (bHasGT && pszNEATLINE != nullptr && pszNEATLINE[0] != '\0')`
`692`	`692`	`{`
`693`		`- OGRGeometry *poGeom = nullptr;`
`694`		`- OGRGeometryFactory::createFromWkt(pszNEATLINE, nullptr, &poGeom);`
	`693`	`+ auto [poGeom, _] = OGRGeometryFactory::createFromWkt(pszNEATLINE);`
`695`	`694`	`if (poGeom != nullptr &&`
`696`	`695`	`wkbFlatten(poGeom->getGeometryType()) == wkbPolygon)`
`697`	`696`	`{`
`@@ -748,7 +747,6 @@ GDALPDFObjectNum GDALPDFBaseWriter::WriteSRS_ISO32000(GDALDataset *poSrcDS,`
`748`	`747`	`}`
`749`	`748`	`}`
`750`	`749`	`}`
`751`		`- delete poGeom;`
`752`	`750`	`}`
`753`	`751`
`754`	`752`	`if (pasGCPList)`
Original file line number	Diff line number	Diff line change
`@@ -683,8 +683,8 @@ bool GDALPDFComposerWriter::GenerateGeoreferencing(`
`683`	`683`	`std::vector<xyPair> aBoundingPolygon;`
`684`	`684`	`if (pszBoundingPolygon)`
`685`	`685`	`{`
`686`		`- OGRGeometry *poGeom = nullptr;`
`687`		`- OGRGeometryFactory::createFromWkt(pszBoundingPolygon, nullptr, &poGeom);`
	`686`	`+ auto [poGeom, _] =`
	`687`	`+ OGRGeometryFactory::createFromWkt(pszBoundingPolygon);`
`688`	`688`	`if (poGeom && poGeom->getGeometryType() == wkbPolygon)`
`689`	`689`	`{`
`690`	`690`	`auto poPoly = poGeom->toPolygon();`
`@@ -707,7 +707,6 @@ bool GDALPDFComposerWriter::GenerateGeoreferencing(`
`707`	`707`	`}`
`708`	`708`	`}`
`709`	`709`	`}`
`710`		`- delete poGeom;`
`711`	`710`	`}`
`712`	`711`
`713`	`712`	`const auto pszSRS = CPLGetXMLValue(psGeoreferencing, "SRS", nullptr);`
Original file line number	Diff line number	Diff line change
`@@ -1618,7 +1618,7 @@ size_t OGRWKTToWKBTranslator::TranslateWKT(void *pabyWKTStart, size_t nLength,`
`1618`	`1618`	`}`
`1619`	`1619`
`1620`	`1620`	`// General case going through a OGRGeometry`
`1621`		`- OGRGeometry *poGeometry = nullptr;`
	`1621`	`+ std::unique_ptr<OGRGeometry> poGeometry = nullptr;`
`1622`	`1622`	`if (bCanAlterByteAfter)`
`1623`	`1623`	`{`
`1624`	`1624`	`// Slight optimization for all geometries but the final one, to`
`@@ -1628,15 +1628,15 @@ size_t OGRWKTToWKBTranslator::TranslateWKT(void *pabyWKTStart, size_t nLength,`
`1628`	`1628`	`char pszEnd = static_cast<char >(pabyWKTStart) + nLength;`
`1629`	`1629`	`const char chBackup = *pszEnd;`
`1630`	`1630`	`*pszEnd = 0;`
`1631`		`- OGRGeometryFactory::createFromWkt(pszPtrStart, nullptr, &poGeometry);`
	`1631`	`+ poGeometry = OGRGeometryFactory::createFromWkt(pszPtrStart).first;`
`1632`	`1632`	`// cppcheck-suppress selfAssignment`
`1633`	`1633`	`*pszEnd = chBackup;`
`1634`	`1634`	`}`
`1635`	`1635`	`else`
`1636`	`1636`	`{`
`1637`	`1637`	`std::string osTmp;`
`1638`	`1638`	`osTmp.assign(pszPtrStart, nLength);`
`1639`		`- OGRGeometryFactory::createFromWkt(osTmp.c_str(), nullptr, &poGeometry);`
	`1639`	`+ poGeometry = OGRGeometryFactory::createFromWkt(osTmp.c_str()).first;`
`1640`	`1640`	`}`
`1641`	`1641`	`if (!poGeometry)`
`1642`	`1642`	`{`
`@@ -1651,6 +1651,5 @@ size_t OGRWKTToWKBTranslator::TranslateWKT(void *pabyWKTStart, size_t nLength,`
`1651`	`1651`	`return static_cast<size_t>(-1);`
`1652`	`1652`	`}`
`1653`	`1653`	`poGeometry->exportToWkb(wkbNDR, pabyWKB, wkbVariantIso);`
`1654`		`- delete poGeometry;`
`1655`	`1654`	`return nWKBSize;`
`1656`	`1655`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1401,48 +1401,45 @@ OGRFeature *OGRCSVLayer::GetNextUnfilteredFeature()`
`1401`	`1401`	`const char *pszStr = papszTokens[iAttr];`
`1402`	`1402`	`while (*pszStr == ' ')`
`1403`	`1403`	`pszStr++;`
`1404`		`- OGRGeometry *poGeom = nullptr;`
	`1404`	`+ std::unique_ptr<OGRGeometry> poGeom = nullptr;`
	`1405`	`+ OGRErr eErr;`
`1405`	`1406`
`1406`	`1407`	`if (EQUAL(poGeomFieldDefn->GetNameRef(), ""))`
`1407`	`1408`	`{`
`1408`		`- if (OGRGeometryFactory::createFromWkt(`
`1409`		`- pszStr, nullptr, &poGeom) != OGRERR_NONE)`
	`1409`	`+ std::tie(poGeom, eErr) =`
	`1410`	`+ OGRGeometryFactory::createFromWkt(pszStr);`
	`1411`	`+ if (eErr != OGRERR_NONE)`
`1410`	`1412`	`{`
`1411`	`1413`	`CPLError(CE_Warning, CPLE_AppDefined,`
`1412`	`1414`	`"Ignoring invalid WKT: %s", pszStr);`
`1413`		`- delete poGeom;`
`1414`		`- poGeom = nullptr;`
`1415`	`1415`	`}`
`1416`	`1416`	`}`
`1417`	`1417`	`else`
`1418`	`1418`	`{`
`1419`	`1419`	`CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);`
`1420`	`1420`
`1421`		`- if (OGRGeometryFactory::createFromWkt(`
`1422`		`- pszStr, nullptr, &poGeom) != OGRERR_NONE)`
`1423`		`- {`
`1424`		`- delete poGeom;`
`1425`		`- poGeom = nullptr;`
`1426`		`- }`
	`1421`	`+ std::tie(poGeom, eErr) =`
	`1422`	`+ OGRGeometryFactory::createFromWkt(pszStr);`
`1427`	`1423`
`1428`	`1424`	`if (!poGeom && *pszStr == '{')`
`1429`	`1425`	`{`
`1430`		`- poGeom = OGRGeometry::FromHandle(`
`1431`		`- OGR_G_CreateGeometryFromJson(pszStr));`
	`1426`	`+ poGeom.reset(OGRGeometry::FromHandle(`
	`1427`	`+ OGR_G_CreateGeometryFromJson(pszStr)));`
`1432`	`1428`	`}`
`1433`	`1429`	`else if (!poGeom && ((pszStr >= '0' && pszStr <= '9') \|\|`
`1434`	`1430`	`(pszStr >= 'a' && pszStr <= 'z') \|\|`
`1435`	`1431`	`(pszStr >= 'A' && pszStr <= 'Z')))`
`1436`	`1432`	`{`
`1437`		`- poGeom = OGRGeometryFromHexEWKB(pszStr, nullptr, FALSE);`
	`1433`	`+ poGeom.reset(`
	`1434`	`+ OGRGeometryFromHexEWKB(pszStr, nullptr, FALSE));`
`1438`	`1435`	`}`
`1439`	`1436`	`}`
`1440`	`1437`
`1441`	`1438`	`if (poGeom)`
`1442`	`1439`	`{`
`1443`	`1440`	`poGeom->assignSpatialReference(`
`1444`	`1441`	`poGeomFieldDefn->GetSpatialRef());`
`1445`		`- poFeature->SetGeomFieldDirectly(iGeom, poGeom);`
	`1442`	`+ poFeature->SetGeomField(iGeom, std::move(poGeom));`
`1446`	`1443`	`}`
`1447`	`1444`	`}`
`1448`	`1445`
Original file line number	Diff line number	Diff line change
`@@ -565,9 +565,10 @@ void OGRSQLiteLayer::BuildFeatureDefn(const char *pszLayerName, bool bIsSelect,`
`565`	`565`	`{`
`566`	`566`	`OGRSQLiteGeomFormat eGeomFormat = OSGF_None;`
`567`	`567`	`CPLPushErrorHandler(CPLQuietErrorHandler);`
`568`		`- OGRGeometry *poGeometry = nullptr;`
`569`		`- if (OGRGeometryFactory::createFromWkt(`
`570`		`- pszText, nullptr, &poGeometry) == OGRERR_NONE)`
	`568`	`+`
	`569`	`+ auto [poGeometry, eErr] =`
	`570`	`+ OGRGeometryFactory::createFromWkt(pszText);`
	`571`	`+ if (eErr == OGRERR_NONE)`
`571`	`572`	`{`
`572`	`573`	`eGeomFormat = OSGF_WKT;`
`573`	`574`	`auto poGeomFieldDefn =`
`@@ -579,7 +580,6 @@ void OGRSQLiteLayer::BuildFeatureDefn(const char *pszLayerName, bool bIsSelect,`
`579`	`580`	`}`
`580`	`581`	`CPLPopErrorHandler();`
`581`	`582`	`CPLErrorReset();`
`582`		`- delete poGeometry;`
`583`	`583`	`if (eGeomFormat != OSGF_None)`
`584`	`584`	`continue;`
`585`	`585`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,8 +75,6 @@ OGRVRTGeomFieldProps::~OGRVRTGeomFieldProps()`
`75`	`75`	`{`
`76`	`76`	`if (poSRS != nullptr)`
`77`	`77`	`const_cast<OGRSpatialReference *>(poSRS)->Release();`
`78`		`- if (poSrcRegion != nullptr)`
`79`		`- delete poSrcRegion;`
`80`	`78`	`}`
`81`	`79`
`82`	`80`	`/************************************************************************/`
`@@ -467,8 +465,9 @@ bool OGRVRTLayer::ParseGeometryField(CPLXMLNode *psNode,`
`467`	`465`	`const char *pszSrcRegion = CPLGetXMLValue(psSrcRegionNode, "", nullptr);`
`468`	`466`	`if (pszSrcRegion != nullptr)`
`469`	`467`	`{`
`470`		`- OGRGeometryFactory::createFromWkt(pszSrcRegion, nullptr,`
`471`		`- &poProps->poSrcRegion);`
	`468`	`+ poProps->poSrcRegion =`
	`469`	`+ OGRGeometryFactory::createFromWkt(pszSrcRegion).first;`
	`470`	`+`
`472`	`471`	`if (poProps->poSrcRegion == nullptr)`
`473`	`472`	`{`
`474`	`473`	`CPLError(CE_Warning, CPLE_AppDefined,`
`@@ -1325,7 +1324,7 @@ bool OGRVRTLayer::ResetSourceReading()`
`1325`	`1324`	`{`
`1326`	`1325`	`OGRGeometry *poNewSpatialGeom = nullptr;`
`1327`	`1326`	`OGRGeometry *poSrcRegion =`
`1328`		`- apoGeomFieldProps[m_iGeomFieldFilter]->poSrcRegion;`
	`1327`	`+ apoGeomFieldProps[m_iGeomFieldFilter]->poSrcRegion.get();`
`1329`	`1328`	`std::unique_ptr<OGRGeometry> poIntersection;`
`1330`	`1329`
`1331`	`1330`	`if (poSrcRegion == nullptr)`
`@@ -1442,7 +1441,8 @@ void OGRVRTLayer::ClipAndAssignSRS(OGRFeature *poFeature)`
`1442`	`1441`	`if (apoGeomFieldProps[i]->poSrcRegion != nullptr &&`
`1443`	`1442`	`apoGeomFieldProps[i]->bSrcClip && poGeom != nullptr)`
`1444`	`1443`	`{`
`1445`		`- poGeom = poGeom->Intersection(apoGeomFieldProps[i]->poSrcRegion);`
	`1444`	`+ poGeom =`
	`1445`	`+ poGeom->Intersection(apoGeomFieldProps[i]->poSrcRegion.get());`
`1446`	`1446`	`if (poGeom != nullptr)`
`1447`	`1447`	`poGeom->assignSpatialReference(`
`1448`	`1448`	`GetLayerDefn()->GetGeomFieldDefn(i)->GetSpatialRef());`
`@@ -1507,13 +1507,11 @@ OGRFeature OGRVRTLayer::TranslateFeature(OGRFeature &poSrcFeat,`
`1507`	`1507`
`1508`	`1508`	`if (pszWKT != nullptr)`
`1509`	`1509`	`{`
`1510`		`- OGRGeometry *poGeom = nullptr;`
`1511`		`-`
`1512`		`- OGRGeometryFactory::createFromWkt(pszWKT, nullptr, &poGeom);`
	`1510`	`+ auto [poGeom, _] = OGRGeometryFactory::createFromWkt(pszWKT);`
`1513`	`1511`	`if (poGeom == nullptr)`
`1514`	`1512`	`CPLDebug("OGR_VRT", "Did not get geometry from %s", pszWKT);`
`1515`	`1513`
`1516`		`- poDstFeat->SetGeomFieldDirectly(i, poGeom);`
	`1514`	`+ poDstFeat->SetGeomField(i, std::move(poGeom));`
`1517`	`1515`	`}`
`1518`	`1516`	`}`
`1519`	`1517`	`else if (eGeometryStyle == VGS_WKB && iGeomField != -1)`
`@@ -1619,7 +1617,7 @@ OGRFeature OGRVRTLayer::TranslateFeature(OGRFeature &poSrcFeat,`
`1619`	`1617`	`{`
`1620`	`1618`	`OGRGeometry *poGeom = poDstFeat->GetGeomFieldRef(i);`
`1621`	`1619`	`if (poGeom != nullptr &&`
`1622`		`- !poGeom->Intersects(apoGeomFieldProps[i]->poSrcRegion))`
	`1620`	`+ !poGeom->Intersects(apoGeomFieldProps[i]->poSrcRegion.get()))`
`1623`	`1621`	`{`
`1624`	`1622`	`delete poSrcFeat;`
`1625`	`1623`	`delete poDstFeat;`