LCOV - code coverage report
Current view: top level - gcore - gdaldriver.cpp (source / functions) Hit Total Coverage
Test: gdal_filtered.info Lines: 1042 1205 86.5 %
Date: 2025-10-21 22:35:35 Functions: 47 51 92.2 %

          Line data    Source code
       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  GDAL Core
       4             :  * Purpose:  Implementation of GDALDriver class (and C wrappers)
       5             :  * Author:   Frank Warmerdam, warmerdam@pobox.com
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 1998, 2000, Frank Warmerdam
       9             :  * Copyright (c) 2007-2014, Even Rouault <even dot rouault at spatialys.com>
      10             :  *
      11             :  * SPDX-License-Identifier: MIT
      12             :  ****************************************************************************/
      13             : 
      14             : #include "cpl_port.h"
      15             : #include "gdal.h"
      16             : #include "gdal_priv.h"
      17             : #include "gdal_rat.h"
      18             : #include "gdalalgorithm.h"
      19             : #include "gdal_known_connection_prefixes.h"
      20             : 
      21             : #include <algorithm>
      22             : #include <cerrno>
      23             : #include <cstdlib>
      24             : #include <cstring>
      25             : #include <set>
      26             : #include <sys/stat.h>
      27             : 
      28             : #include "cpl_conv.h"
      29             : #include "cpl_error.h"
      30             : #include "cpl_minixml.h"
      31             : #include "cpl_multiproc.h"
      32             : #include "cpl_progress.h"
      33             : #include "cpl_string.h"
      34             : #include "cpl_vsi.h"
      35             : #include "ograpispy.h"
      36             : #include "ogr_core.h"
      37             : #include "ogrsf_frmts.h"
      38             : 
      39             : /************************************************************************/
      40             : /*                             GDALDriver()                             */
      41             : /************************************************************************/
      42             : 
      43             : GDALDriver::GDALDriver() = default;
      44             : 
      45             : /************************************************************************/
      46             : /*                            ~GDALDriver()                             */
      47             : /************************************************************************/
      48             : 
      49      456530 : GDALDriver::~GDALDriver()
      50             : 
      51             : {
      52      257489 :     if (pfnUnloadDriver != nullptr)
      53        9397 :         pfnUnloadDriver(this);
      54      456530 : }
      55             : 
      56             : /************************************************************************/
      57             : /*                         GDALCreateDriver()                           */
      58             : /************************************************************************/
      59             : 
      60             : /**
      61             :  * \brief Create a GDALDriver.
      62             :  *
      63             :  * Creates a driver in the GDAL heap.
      64             :  */
      65             : 
      66         225 : GDALDriverH CPL_STDCALL GDALCreateDriver()
      67             : {
      68         225 :     return new GDALDriver();
      69             : }
      70             : 
      71             : /************************************************************************/
      72             : /*                         GDALDestroyDriver()                          */
      73             : /************************************************************************/
      74             : 
      75             : /**
      76             :  * \brief Destroy a GDALDriver.
      77             :  *
      78             :  * This is roughly equivalent to deleting the driver, but is guaranteed
      79             :  * to take place in the GDAL heap.  It is important this that function
      80             :  * not be called on a driver that is registered with the GDALDriverManager.
      81             :  *
      82             :  * @param hDriver the driver to destroy.
      83             :  */
      84             : 
      85           0 : void CPL_STDCALL GDALDestroyDriver(GDALDriverH hDriver)
      86             : 
      87             : {
      88           0 :     if (hDriver != nullptr)
      89           0 :         delete GDALDriver::FromHandle(hDriver);
      90           0 : }
      91             : 
      92             : /************************************************************************/
      93             : /*                               Open()                                 */
      94             : /************************************************************************/
      95             : 
      96             : //! @cond Doxygen_Suppress
      97             : 
      98      453829 : GDALDataset *GDALDriver::Open(GDALOpenInfo *poOpenInfo, bool bSetOpenOptions)
      99             : {
     100             : 
     101      453829 :     GDALDataset *poDS = nullptr;
     102      453829 :     pfnOpen = GetOpenCallback();
     103      453513 :     if (pfnOpen != nullptr)
     104             :     {
     105      453706 :         poDS = pfnOpen(poOpenInfo);
     106             :     }
     107           0 :     else if (pfnOpenWithDriverArg != nullptr)
     108             :     {
     109           3 :         poDS = pfnOpenWithDriverArg(this, poOpenInfo);
     110             :     }
     111             : 
     112      454281 :     if (poDS)
     113             :     {
     114             :         // Only set GDAL_OF_THREAD_SAFE if the driver itself has set it in
     115             :         // poDS->nOpenFlags
     116       56582 :         int nOpenFlags = poOpenInfo->nOpenFlags &
     117             :                          ~(GDAL_OF_FROM_GDALOPEN | GDAL_OF_THREAD_SAFE);
     118       56582 :         if (poDS->nOpenFlags & GDAL_OF_THREAD_SAFE)
     119         911 :             nOpenFlags |= GDAL_OF_THREAD_SAFE;
     120       56582 :         poDS->nOpenFlags = nOpenFlags;
     121             : 
     122       56582 :         if (strlen(poDS->GetDescription()) == 0)
     123       11832 :             poDS->SetDescription(poOpenInfo->pszFilename);
     124             : 
     125       56549 :         if (poDS->poDriver == nullptr)
     126       52624 :             poDS->poDriver = this;
     127             : 
     128       56549 :         if (poDS->papszOpenOptions == nullptr && bSetOpenOptions)
     129             :         {
     130          29 :             poDS->papszOpenOptions = CSLDuplicate(poOpenInfo->papszOpenOptions);
     131             :         }
     132             : 
     133       56549 :         if (!(poOpenInfo->nOpenFlags & GDAL_OF_INTERNAL))
     134             :         {
     135       46302 :             if (CPLGetPID() != GDALGetResponsiblePIDForCurrentThread())
     136           6 :                 CPLDebug(
     137             :                     "GDAL",
     138             :                     "GDALOpen(%s, this=%p) succeeds as "
     139             :                     "%s (pid=%d, responsiblePID=%d).",
     140           6 :                     poOpenInfo->pszFilename, poDS, GetDescription(),
     141           6 :                     static_cast<int>(CPLGetPID()),
     142           6 :                     static_cast<int>(GDALGetResponsiblePIDForCurrentThread()));
     143             :             else
     144       46299 :                 CPLDebug("GDAL", "GDALOpen(%s, this=%p) succeeds as %s.",
     145       46291 :                          poOpenInfo->pszFilename, poDS, GetDescription());
     146             : 
     147       46468 :             poDS->AddToDatasetOpenList();
     148             :         }
     149             :     }
     150             : 
     151      454607 :     return poDS;
     152             : }
     153             : 
     154             : //! @endcond
     155             : 
     156             : /************************************************************************/
     157             : /*                               Create()                               */
     158             : /************************************************************************/
     159             : 
     160             : /**
     161             :  * \brief Create a new dataset with this driver.
     162             :  *
     163             :  * What argument values are legal for particular drivers is driver specific,
     164             :  * and there is no way to query in advance to establish legal values.
     165             :  *
     166             :  * That function will try to validate the creation option list passed to the
     167             :  * driver with the GDALValidateCreationOptions() method. This check can be
     168             :  * disabled by defining the configuration option
     169             :  * GDAL_VALIDATE_CREATION_OPTIONS=NO.
     170             :  *
     171             :  * After you have finished working with the returned dataset, it is
     172             :  * <b>required</b> to close it with GDALClose(). This does not only close the
     173             :  * file handle, but also ensures that all the data and metadata has been written
     174             :  * to the dataset (GDALFlushCache() is not sufficient for that purpose).
     175             :  *
     176             :  * The arguments nXSize, nYSize and nBands can be passed to 0 when
     177             :  * creating a vector-only dataset for a compatible driver.
     178             :  *
     179             :  * Equivalent of the C function GDALCreate().
     180             :  *
     181             :  * @param pszFilename the name of the dataset to create.  UTF-8 encoded.
     182             :  * @param nXSize width of created raster in pixels.
     183             :  * @param nYSize height of created raster in pixels.
     184             :  * @param nBands number of bands.
     185             :  * @param eType type of raster.
     186             :  * @param papszOptions list of driver specific control parameters.
     187             :  * The APPEND_SUBDATASET=YES option can be
     188             :  * specified to avoid prior destruction of existing dataset.
     189             :  *
     190             :  * @return NULL on failure, or a new GDALDataset.
     191             :  */
     192             : 
     193       23851 : GDALDataset *GDALDriver::Create(const char *pszFilename, int nXSize, int nYSize,
     194             :                                 int nBands, GDALDataType eType,
     195             :                                 CSLConstList papszOptions)
     196             : 
     197             : {
     198             :     /* -------------------------------------------------------------------- */
     199             :     /*      Does this format support creation.                              */
     200             :     /* -------------------------------------------------------------------- */
     201       23851 :     pfnCreate = GetCreateCallback();
     202       23851 :     if (CPL_UNLIKELY(pfnCreate == nullptr && pfnCreateEx == nullptr &&
     203             :                      pfnCreateVectorOnly == nullptr))
     204             :     {
     205           1 :         CPLError(CE_Failure, CPLE_NotSupported,
     206             :                  "GDALDriver::Create() ... no create method implemented"
     207             :                  " for this format.");
     208             : 
     209           1 :         return nullptr;
     210             :     }
     211             :     /* -------------------------------------------------------------------- */
     212             :     /*      Do some rudimentary argument checking.                          */
     213             :     /* -------------------------------------------------------------------- */
     214       23850 :     if (CPL_UNLIKELY(nBands < 0))
     215             :     {
     216           1 :         CPLError(CE_Failure, CPLE_AppDefined,
     217             :                  "Attempt to create dataset with %d bands is illegal,"
     218             :                  "Must be >= 0.",
     219             :                  nBands);
     220           1 :         return nullptr;
     221             :     }
     222             : 
     223       23849 :     if (CPL_UNLIKELY(GetMetadataItem(GDAL_DCAP_RASTER) != nullptr &&
     224             :                      GetMetadataItem(GDAL_DCAP_VECTOR) == nullptr &&
     225       23849 :                      (nXSize < 1 || nYSize < 1)))
     226             :     {
     227           1 :         CPLError(CE_Failure, CPLE_AppDefined,
     228             :                  "Attempt to create %dx%d dataset is illegal,"
     229             :                  "sizes must be larger than zero.",
     230             :                  nXSize, nYSize);
     231           1 :         return nullptr;
     232             :     }
     233             : 
     234       23848 :     if (CPL_UNLIKELY(nBands != 0 &&
     235             :                      (eType == GDT_Unknown || eType == GDT_TypeCount)))
     236             :     {
     237           1 :         CPLError(CE_Failure, CPLE_IllegalArg,
     238             :                  "Illegal GDT_Unknown/GDT_TypeCount argument");
     239           1 :         return nullptr;
     240             :     }
     241             : 
     242             :     /* -------------------------------------------------------------------- */
     243             :     /*      Make sure we cleanup if there is an existing dataset of this    */
     244             :     /*      name.  But even if that seems to fail we will continue since    */
     245             :     /*      it might just be a corrupt file or something.                   */
     246             :     /* -------------------------------------------------------------------- */
     247       23847 :     if (!CPLFetchBool(papszOptions, "APPEND_SUBDATASET", false))
     248             :     {
     249             :         // Someone issuing Create("foo.tif") on a
     250             :         // memory driver doesn't expect files with those names to be deleted
     251             :         // on a file system...
     252             :         // This is somewhat messy. Ideally there should be a way for the
     253             :         // driver to overload the default behavior
     254       23828 :         if (!EQUAL(GetDescription(), "MEM") &&
     255       36895 :             !EQUAL(GetDescription(), "Memory") &&
     256             :             // ogr2ogr -f PostgreSQL might reach the Delete method of the
     257             :             // PostgisRaster driver which is undesirable
     258       13067 :             !EQUAL(GetDescription(), "PostgreSQL"))
     259             :         {
     260       13065 :             QuietDelete(pszFilename);
     261             :         }
     262             :     }
     263             : 
     264             :     /* -------------------------------------------------------------------- */
     265             :     /*      Validate creation options.                                      */
     266             :     /* -------------------------------------------------------------------- */
     267       23847 :     if (CPLTestBool(
     268             :             CPLGetConfigOption("GDAL_VALIDATE_CREATION_OPTIONS", "YES")))
     269       23847 :         GDALValidateCreationOptions(this, papszOptions);
     270             : 
     271             :     /* -------------------------------------------------------------------- */
     272             :     /*      Proceed with creation.                                          */
     273             :     /* -------------------------------------------------------------------- */
     274       47694 :     CPLDebug("GDAL", "GDALDriver::Create(%s,%s,%d,%d,%d,%s,%p)",
     275       23847 :              GetDescription(), pszFilename, nXSize, nYSize, nBands,
     276             :              GDALGetDataTypeName(eType), papszOptions);
     277             : 
     278       23847 :     GDALDataset *poDS = nullptr;
     279       23847 :     if (pfnCreateEx != nullptr)
     280             :     {
     281           0 :         poDS = pfnCreateEx(this, pszFilename, nXSize, nYSize, nBands, eType,
     282             :                            const_cast<char **>(papszOptions));
     283             :     }
     284       23847 :     else if (pfnCreate != nullptr)
     285             :     {
     286       23847 :         poDS = pfnCreate(pszFilename, nXSize, nYSize, nBands, eType,
     287             :                          const_cast<char **>(papszOptions));
     288             :     }
     289           0 :     else if (nBands < 1)
     290             :     {
     291           0 :         poDS = pfnCreateVectorOnly(this, pszFilename,
     292             :                                    const_cast<char **>(papszOptions));
     293             :     }
     294             : 
     295       23847 :     if (poDS != nullptr)
     296             :     {
     297       45100 :         if (poDS->GetDescription() == nullptr ||
     298       22550 :             strlen(poDS->GetDescription()) == 0)
     299       19892 :             poDS->SetDescription(pszFilename);
     300             : 
     301       22550 :         if (poDS->poDriver == nullptr)
     302       21886 :             poDS->poDriver = this;
     303             : 
     304       22550 :         poDS->AddToDatasetOpenList();
     305             :     }
     306             : 
     307       23847 :     return poDS;
     308             : }
     309             : 
     310             : /************************************************************************/
     311             : /*                             GDALCreate()                             */
     312             : /************************************************************************/
     313             : 
     314             : /**
     315             :  * \brief Create a new dataset with this driver.
     316             :  *
     317             :  * @see GDALDriver::Create()
     318             :  */
     319             : 
     320       19725 : GDALDatasetH CPL_DLL CPL_STDCALL GDALCreate(GDALDriverH hDriver,
     321             :                                             const char *pszFilename, int nXSize,
     322             :                                             int nYSize, int nBands,
     323             :                                             GDALDataType eBandType,
     324             :                                             CSLConstList papszOptions)
     325             : 
     326             : {
     327       19725 :     VALIDATE_POINTER1(hDriver, "GDALCreate", nullptr);
     328             : 
     329       19725 :     GDALDatasetH hDS = GDALDriver::FromHandle(hDriver)->Create(
     330             :         pszFilename, nXSize, nYSize, nBands, eBandType, papszOptions);
     331             : 
     332             : #ifdef OGRAPISPY_ENABLED
     333       19725 :     if (nBands < 1)
     334             :     {
     335        3593 :         OGRAPISpyCreateDataSource(hDriver, pszFilename,
     336             :                                   const_cast<char **>(papszOptions), hDS);
     337             :     }
     338             : #endif
     339             : 
     340       19725 :     return hDS;
     341             : }
     342             : 
     343             : /************************************************************************/
     344             : /*                       CreateMultiDimensional()                       */
     345             : /************************************************************************/
     346             : 
     347             : /**
     348             :  * \brief Create a new multidimensional dataset with this driver.
     349             :  *
     350             :  * Only drivers that advertise the GDAL_DCAP_MULTIDIM_RASTER capability and
     351             :  * implement the pfnCreateMultiDimensional method might return a non nullptr
     352             :  * GDALDataset.
     353             :  *
     354             :  * This is the same as the C function GDALCreateMultiDimensional().
     355             :  *
     356             :  * @param pszFilename  the name of the dataset to create.  UTF-8 encoded.
     357             :  * @param papszRootGroupOptions driver specific options regarding the creation
     358             :  *                              of the root group. Might be nullptr.
     359             :  * @param papszOptions driver specific options regarding the creation
     360             :  *                     of the dataset. Might be nullptr.
     361             :  * @return a new dataset, or nullptr in case of failure.
     362             :  *
     363             :  * @since GDAL 3.1
     364             :  */
     365             : 
     366             : GDALDataset *
     367         523 : GDALDriver::CreateMultiDimensional(const char *pszFilename,
     368             :                                    CSLConstList papszRootGroupOptions,
     369             :                                    CSLConstList papszOptions)
     370             : 
     371             : {
     372             :     /* -------------------------------------------------------------------- */
     373             :     /*      Does this format support creation.                              */
     374             :     /* -------------------------------------------------------------------- */
     375         523 :     pfnCreateMultiDimensional = GetCreateMultiDimensionalCallback();
     376         523 :     if (pfnCreateMultiDimensional == nullptr)
     377             :     {
     378           0 :         CPLError(CE_Failure, CPLE_NotSupported,
     379             :                  "GDALDriver::CreateMultiDimensional() ... "
     380             :                  "no CreateMultiDimensional method implemented "
     381             :                  "for this format.");
     382             : 
     383           0 :         return nullptr;
     384             :     }
     385             : 
     386             :     /* -------------------------------------------------------------------- */
     387             :     /*      Validate creation options.                                      */
     388             :     /* -------------------------------------------------------------------- */
     389         523 :     if (CPLTestBool(
     390             :             CPLGetConfigOption("GDAL_VALIDATE_CREATION_OPTIONS", "YES")))
     391             :     {
     392             :         const char *pszOptionList =
     393         523 :             GetMetadataItem(GDAL_DMD_MULTIDIM_DATASET_CREATIONOPTIONLIST);
     394        1046 :         CPLString osDriver;
     395         523 :         osDriver.Printf("driver %s", GetDescription());
     396         523 :         GDALValidateOptions(pszOptionList, papszOptions, "creation option",
     397             :                             osDriver);
     398             :     }
     399             : 
     400         523 :     auto poDstDS = pfnCreateMultiDimensional(pszFilename, papszRootGroupOptions,
     401             :                                              papszOptions);
     402             : 
     403         523 :     if (poDstDS != nullptr)
     404             :     {
     405        1042 :         if (poDstDS->GetDescription() == nullptr ||
     406         521 :             strlen(poDstDS->GetDescription()) == 0)
     407         144 :             poDstDS->SetDescription(pszFilename);
     408             : 
     409         521 :         if (poDstDS->poDriver == nullptr)
     410         519 :             poDstDS->poDriver = this;
     411             :     }
     412             : 
     413         523 :     return poDstDS;
     414             : }
     415             : 
     416             : /************************************************************************/
     417             : /*                       GDALCreateMultiDimensional()                   */
     418             : /************************************************************************/
     419             : 
     420             : /** \brief Create a new multidimensional dataset with this driver.
     421             :  *
     422             :  * This is the same as the C++ method GDALDriver::CreateMultiDimensional().
     423             :  */
     424         474 : GDALDatasetH GDALCreateMultiDimensional(GDALDriverH hDriver,
     425             :                                         const char *pszName,
     426             :                                         CSLConstList papszRootGroupOptions,
     427             :                                         CSLConstList papszOptions)
     428             : {
     429         474 :     VALIDATE_POINTER1(hDriver, __func__, nullptr);
     430         474 :     VALIDATE_POINTER1(pszName, __func__, nullptr);
     431         474 :     return GDALDataset::ToHandle(
     432             :         GDALDriver::FromHandle(hDriver)->CreateMultiDimensional(
     433         474 :             pszName, papszRootGroupOptions, papszOptions));
     434             : }
     435             : 
     436             : /************************************************************************/
     437             : /*                  DefaultCreateCopyMultiDimensional()                 */
     438             : /************************************************************************/
     439             : 
     440             : //! @cond Doxygen_Suppress
     441             : 
     442          26 : CPLErr GDALDriver::DefaultCreateCopyMultiDimensional(
     443             :     GDALDataset *poSrcDS, GDALDataset *poDstDS, bool bStrict,
     444             :     CSLConstList papszOptions, GDALProgressFunc pfnProgress,
     445             :     void *pProgressData)
     446             : {
     447          26 :     if (pfnProgress == nullptr)
     448           2 :         pfnProgress = GDALDummyProgress;
     449             : 
     450          52 :     auto poSrcRG = poSrcDS->GetRootGroup();
     451          26 :     if (!poSrcRG)
     452           0 :         return CE_Failure;
     453          52 :     auto poDstRG = poDstDS->GetRootGroup();
     454          26 :     if (!poDstRG)
     455           0 :         return CE_Failure;
     456          26 :     GUInt64 nCurCost = 0;
     457          52 :     return poDstRG->CopyFrom(poDstRG, poSrcDS, poSrcRG, bStrict, nCurCost,
     458             :                              poSrcRG->GetTotalCopyCost(), pfnProgress,
     459          26 :                              pProgressData, papszOptions)
     460          26 :                ? CE_None
     461          26 :                : CE_Failure;
     462             : }
     463             : 
     464             : //! @endcond
     465             : 
     466             : /************************************************************************/
     467             : /*                          DefaultCopyMasks()                          */
     468             : /************************************************************************/
     469             : 
     470             : //! @cond Doxygen_Suppress
     471        6166 : CPLErr GDALDriver::DefaultCopyMasks(GDALDataset *poSrcDS, GDALDataset *poDstDS,
     472             :                                     int bStrict)
     473             : 
     474             : {
     475        6166 :     return DefaultCopyMasks(poSrcDS, poDstDS, bStrict, nullptr, nullptr,
     476        6166 :                             nullptr);
     477             : }
     478             : 
     479        8151 : CPLErr GDALDriver::DefaultCopyMasks(GDALDataset *poSrcDS, GDALDataset *poDstDS,
     480             :                                     int bStrict, CSLConstList /*papszOptions*/,
     481             :                                     GDALProgressFunc pfnProgress,
     482             :                                     void *pProgressData)
     483             : 
     484             : {
     485        8151 :     if (pfnProgress == nullptr)
     486        6166 :         pfnProgress = GDALDummyProgress;
     487             : 
     488        8151 :     int nBands = poSrcDS->GetRasterCount();
     489        8151 :     if (nBands == 0)
     490           0 :         return CE_None;
     491             : 
     492             :     /* -------------------------------------------------------------------- */
     493             :     /*      Try to copy mask if it seems appropriate.                       */
     494             :     /* -------------------------------------------------------------------- */
     495        8151 :     const char *papszOptions[2] = {"COMPRESSED=YES", nullptr};
     496        8151 :     CPLErr eErr = CE_None;
     497             : 
     498        8151 :     int nTotalBandsWithMask = 0;
     499       28302 :     for (int iBand = 0; iBand < nBands; ++iBand)
     500             :     {
     501       20151 :         GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand(iBand + 1);
     502             : 
     503       20151 :         int nMaskFlags = poSrcBand->GetMaskFlags();
     504       20151 :         if (!(nMaskFlags &
     505             :               (GMF_ALL_VALID | GMF_PER_DATASET | GMF_ALPHA | GMF_NODATA)))
     506             :         {
     507           8 :             nTotalBandsWithMask++;
     508             :         }
     509             :     }
     510             : 
     511        8151 :     int iBandWithMask = 0;
     512       28302 :     for (int iBand = 0; eErr == CE_None && iBand < nBands; ++iBand)
     513             :     {
     514       20151 :         GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand(iBand + 1);
     515             : 
     516       20151 :         int nMaskFlags = poSrcBand->GetMaskFlags();
     517       20151 :         if (eErr == CE_None && !(nMaskFlags & (GMF_ALL_VALID | GMF_PER_DATASET |
     518             :                                                GMF_ALPHA | GMF_NODATA)))
     519             :         {
     520           8 :             GDALRasterBand *poDstBand = poDstDS->GetRasterBand(iBand + 1);
     521           8 :             if (poDstBand != nullptr)
     522             :             {
     523           8 :                 eErr = poDstBand->CreateMaskBand(nMaskFlags);
     524           8 :                 if (eErr == CE_None)
     525             :                 {
     526          24 :                     void *pScaledData = GDALCreateScaledProgress(
     527           8 :                         double(iBandWithMask) /
     528           8 :                             std::max(1, nTotalBandsWithMask),
     529           8 :                         double(iBandWithMask + 1) /
     530           8 :                             std::max(1, nTotalBandsWithMask),
     531             :                         pfnProgress, pProgressData);
     532          16 :                     eErr = GDALRasterBandCopyWholeRaster(
     533           8 :                         poSrcBand->GetMaskBand(), poDstBand->GetMaskBand(),
     534             :                         papszOptions, GDALScaledProgress, pScaledData);
     535           8 :                     GDALDestroyScaledProgress(pScaledData);
     536             :                 }
     537           0 :                 else if (!bStrict)
     538             :                 {
     539           0 :                     eErr = CE_None;
     540             :                 }
     541             :             }
     542             :         }
     543             :     }
     544             : 
     545             :     /* -------------------------------------------------------------------- */
     546             :     /*      Try to copy a per-dataset mask if we have one.                  */
     547             :     /* -------------------------------------------------------------------- */
     548        8151 :     const int nMaskFlags = poSrcDS->GetRasterBand(1)->GetMaskFlags();
     549        8151 :     if (eErr == CE_None &&
     550        8151 :         !(nMaskFlags & (GMF_ALL_VALID | GMF_ALPHA | GMF_NODATA)) &&
     551          13 :         (nMaskFlags & GMF_PER_DATASET))
     552             :     {
     553           8 :         eErr = poDstDS->CreateMaskBand(nMaskFlags);
     554           8 :         if (eErr == CE_None)
     555             :         {
     556           8 :             eErr = GDALRasterBandCopyWholeRaster(
     557           8 :                 poSrcDS->GetRasterBand(1)->GetMaskBand(),
     558           8 :                 poDstDS->GetRasterBand(1)->GetMaskBand(), papszOptions,
     559             :                 pfnProgress, pProgressData);
     560             :         }
     561           0 :         else if (!bStrict)
     562             :         {
     563           0 :             eErr = CE_None;
     564             :         }
     565             :     }
     566             : 
     567        8151 :     return eErr;
     568             : }
     569             : 
     570             : /************************************************************************/
     571             : /*                         DefaultCreateCopy()                          */
     572             : /************************************************************************/
     573             : 
     574        1423 : GDALDataset *GDALDriver::DefaultCreateCopy(const char *pszFilename,
     575             :                                            GDALDataset *poSrcDS, int bStrict,
     576             :                                            CSLConstList papszOptions,
     577             :                                            GDALProgressFunc pfnProgress,
     578             :                                            void *pProgressData)
     579             : 
     580             : {
     581        1423 :     if (pfnProgress == nullptr)
     582           0 :         pfnProgress = GDALDummyProgress;
     583             : 
     584        1423 :     CPLErrorReset();
     585             : 
     586             :     /* -------------------------------------------------------------------- */
     587             :     /*      Use multidimensional raster API if available.                   */
     588             :     /* -------------------------------------------------------------------- */
     589        2846 :     auto poSrcGroup = poSrcDS->GetRootGroup();
     590        1423 :     if (poSrcGroup != nullptr && GetMetadataItem(GDAL_DCAP_MULTIDIM_RASTER))
     591             :     {
     592          48 :         CPLStringList aosDatasetCO;
     593          31 :         for (const char *pszOption : cpl::Iterate(papszOptions))
     594             :         {
     595           7 :             if (!STARTS_WITH_CI(pszOption, "ARRAY:"))
     596           0 :                 aosDatasetCO.AddString(pszOption);
     597             :         }
     598             :         auto poDstDS = std::unique_ptr<GDALDataset>(
     599          48 :             CreateMultiDimensional(pszFilename, nullptr, aosDatasetCO.List()));
     600          24 :         if (!poDstDS)
     601           0 :             return nullptr;
     602          48 :         auto poDstGroup = poDstDS->GetRootGroup();
     603          24 :         if (!poDstGroup)
     604           0 :             return nullptr;
     605          24 :         if (DefaultCreateCopyMultiDimensional(
     606          24 :                 poSrcDS, poDstDS.get(), CPL_TO_BOOL(bStrict), papszOptions,
     607          24 :                 pfnProgress, pProgressData) != CE_None)
     608           0 :             return nullptr;
     609          24 :         return poDstDS.release();
     610             :     }
     611             : 
     612             :     /* -------------------------------------------------------------------- */
     613             :     /*      Validate that we can create the output as requested.            */
     614             :     /* -------------------------------------------------------------------- */
     615        1399 :     const int nXSize = poSrcDS->GetRasterXSize();
     616        1399 :     const int nYSize = poSrcDS->GetRasterYSize();
     617        1399 :     const int nBands = poSrcDS->GetRasterCount();
     618             : 
     619        1399 :     CPLDebug("GDAL", "Using default GDALDriver::CreateCopy implementation.");
     620             : 
     621        1399 :     const int nLayerCount = poSrcDS->GetLayerCount();
     622        1423 :     if (nBands == 0 && nLayerCount == 0 &&
     623          24 :         GetMetadataItem(GDAL_DCAP_VECTOR) == nullptr)
     624             :     {
     625          17 :         CPLError(CE_Failure, CPLE_NotSupported,
     626             :                  "GDALDriver::DefaultCreateCopy does not support zero band");
     627          17 :         return nullptr;
     628             :     }
     629        1382 :     if (poSrcDS->GetDriver() != nullptr &&
     630        1352 :         poSrcDS->GetDriver()->GetMetadataItem(GDAL_DCAP_RASTER) != nullptr &&
     631        1345 :         poSrcDS->GetDriver()->GetMetadataItem(GDAL_DCAP_VECTOR) == nullptr &&
     632        2737 :         GetMetadataItem(GDAL_DCAP_RASTER) == nullptr &&
     633           3 :         GetMetadataItem(GDAL_DCAP_VECTOR) != nullptr)
     634             :     {
     635           3 :         CPLError(CE_Failure, CPLE_NotSupported,
     636             :                  "Source driver is raster-only whereas output driver is "
     637             :                  "vector-only");
     638           3 :         return nullptr;
     639             :     }
     640        1379 :     else if (poSrcDS->GetDriver() != nullptr &&
     641        1349 :              poSrcDS->GetDriver()->GetMetadataItem(GDAL_DCAP_RASTER) ==
     642           7 :                  nullptr &&
     643           7 :              poSrcDS->GetDriver()->GetMetadataItem(GDAL_DCAP_VECTOR) !=
     644           7 :                  nullptr &&
     645        2728 :              GetMetadataItem(GDAL_DCAP_RASTER) != nullptr &&
     646           0 :              GetMetadataItem(GDAL_DCAP_VECTOR) == nullptr)
     647             :     {
     648           0 :         CPLError(CE_Failure, CPLE_NotSupported,
     649             :                  "Source driver is vector-only whereas output driver is "
     650             :                  "raster-only");
     651           0 :         return nullptr;
     652             :     }
     653             : 
     654        1379 :     if (!pfnProgress(0.0, nullptr, pProgressData))
     655             :     {
     656           2 :         CPLError(CE_Failure, CPLE_UserInterrupt, "User terminated");
     657           2 :         return nullptr;
     658             :     }
     659             : 
     660             :     /* -------------------------------------------------------------------- */
     661             :     /*      Propagate some specific structural metadata as options if it    */
     662             :     /*      appears to be supported by the target driver and the caller     */
     663             :     /*      didn't provide values.                                          */
     664             :     /* -------------------------------------------------------------------- */
     665        1377 :     char **papszCreateOptions = CSLDuplicate(papszOptions);
     666        1377 :     const char *const apszOptItems[] = {"NBITS", "IMAGE_STRUCTURE", "PIXELTYPE",
     667             :                                         "IMAGE_STRUCTURE", nullptr};
     668             : 
     669        4099 :     for (int iOptItem = 0; nBands > 0 && apszOptItems[iOptItem] != nullptr;
     670        2722 :          iOptItem += 2)
     671             :     {
     672             :         // does the source have this metadata item on the first band?
     673        2722 :         auto poBand = poSrcDS->GetRasterBand(1);
     674        2722 :         poBand->EnablePixelTypeSignedByteWarning(false);
     675        5444 :         const char *pszValue = poBand->GetMetadataItem(
     676        2722 :             apszOptItems[iOptItem], apszOptItems[iOptItem + 1]);
     677        2722 :         poBand->EnablePixelTypeSignedByteWarning(true);
     678             : 
     679        2722 :         if (pszValue == nullptr)
     680        2721 :             continue;
     681             : 
     682             :         // Do not override provided value.
     683           1 :         if (CSLFetchNameValue(papszCreateOptions, pszValue) != nullptr)
     684           0 :             continue;
     685             : 
     686             :         // Does this appear to be a supported creation option on this driver?
     687             :         const char *pszOptionList =
     688           1 :             GetMetadataItem(GDAL_DMD_CREATIONOPTIONLIST);
     689             : 
     690           1 :         if (pszOptionList == nullptr ||
     691           1 :             strstr(pszOptionList, apszOptItems[iOptItem]) == nullptr)
     692           0 :             continue;
     693             : 
     694           1 :         papszCreateOptions = CSLSetNameValue(papszCreateOptions,
     695           1 :                                              apszOptItems[iOptItem], pszValue);
     696             :     }
     697             : 
     698             :     /* -------------------------------------------------------------------- */
     699             :     /*      Create destination dataset.                                     */
     700             :     /* -------------------------------------------------------------------- */
     701        1377 :     GDALDataType eType = GDT_Unknown;
     702             : 
     703        1377 :     if (nBands > 0)
     704        1361 :         eType = poSrcDS->GetRasterBand(1)->GetRasterDataType();
     705             :     GDALDataset *poDstDS =
     706        1377 :         Create(pszFilename, nXSize, nYSize, nBands, eType, papszCreateOptions);
     707             : 
     708        1377 :     CSLDestroy(papszCreateOptions);
     709             : 
     710        1377 :     if (poDstDS == nullptr)
     711         326 :         return nullptr;
     712             : 
     713        1051 :     int nDstBands = poDstDS->GetRasterCount();
     714        1051 :     CPLErr eErr = CE_None;
     715        1051 :     if (nDstBands != nBands)
     716             :     {
     717           0 :         if (GetMetadataItem(GDAL_DCAP_RASTER) != nullptr)
     718             :         {
     719             :             // Should not happen for a well-behaved driver.
     720           0 :             CPLError(
     721             :                 CE_Failure, CPLE_AppDefined,
     722             :                 "Output driver created only %d bands whereas %d were expected",
     723             :                 nDstBands, nBands);
     724           0 :             eErr = CE_Failure;
     725             :         }
     726           0 :         nDstBands = 0;
     727             :     }
     728             : 
     729             :     /* -------------------------------------------------------------------- */
     730             :     /*      Try setting the projection and geotransform if it seems         */
     731             :     /*      suitable.                                                       */
     732             :     /* -------------------------------------------------------------------- */
     733        1051 :     if (nDstBands == 0 && !bStrict)
     734           4 :         CPLTurnFailureIntoWarning(true);
     735             : 
     736        1051 :     GDALGeoTransform gt;
     737        1974 :     if (eErr == CE_None && poSrcDS->GetGeoTransform(gt) == CE_None &&
     738        1974 :         gt != GDALGeoTransform())
     739             :     {
     740         919 :         eErr = poDstDS->SetGeoTransform(gt);
     741         919 :         if (!bStrict)
     742         569 :             eErr = CE_None;
     743             :     }
     744             : 
     745        1051 :     if (eErr == CE_None)
     746             :     {
     747        1042 :         const auto poSrcSRS = poSrcDS->GetSpatialRefRasterOnly();
     748        1042 :         if (poSrcSRS && !poSrcSRS->IsEmpty())
     749             :         {
     750         858 :             eErr = poDstDS->SetSpatialRef(poSrcSRS);
     751         858 :             if (!bStrict)
     752         540 :                 eErr = CE_None;
     753             :         }
     754             :     }
     755             : 
     756             :     /* -------------------------------------------------------------------- */
     757             :     /*      Copy GCPs.                                                      */
     758             :     /* -------------------------------------------------------------------- */
     759        1051 :     if (poSrcDS->GetGCPCount() > 0 && eErr == CE_None)
     760             :     {
     761           2 :         eErr = poDstDS->SetGCPs(poSrcDS->GetGCPCount(), poSrcDS->GetGCPs(),
     762             :                                 poSrcDS->GetGCPProjection());
     763           2 :         if (!bStrict)
     764           1 :             eErr = CE_None;
     765             :     }
     766             : 
     767        1051 :     if (nDstBands == 0 && !bStrict)
     768           4 :         CPLTurnFailureIntoWarning(false);
     769             : 
     770             :     /* -------------------------------------------------------------------- */
     771             :     /*      Copy metadata.                                                  */
     772             :     /* -------------------------------------------------------------------- */
     773        1051 :     DefaultCopyMetadata(poSrcDS, poDstDS, papszOptions, nullptr);
     774             : 
     775             :     /* -------------------------------------------------------------------- */
     776             :     /*      Loop copying bands.                                             */
     777             :     /* -------------------------------------------------------------------- */
     778        2671 :     for (int iBand = 0; eErr == CE_None && iBand < nDstBands; ++iBand)
     779             :     {
     780        1620 :         GDALRasterBand *const poSrcBand = poSrcDS->GetRasterBand(iBand + 1);
     781        1620 :         GDALRasterBand *const poDstBand = poDstDS->GetRasterBand(iBand + 1);
     782             : 
     783             :         /* --------------------------------------------------------------------
     784             :          */
     785             :         /*      Do we need to copy a colortable. */
     786             :         /* --------------------------------------------------------------------
     787             :          */
     788        1620 :         GDALColorTable *const poCT = poSrcBand->GetColorTable();
     789        1620 :         if (poCT != nullptr)
     790          29 :             poDstBand->SetColorTable(poCT);
     791             : 
     792             :         /* --------------------------------------------------------------------
     793             :          */
     794             :         /*      Do we need to copy other metadata?  Most of this is */
     795             :         /*      non-critical, so lets not bother folks if it fails are we */
     796             :         /*      are not in strict mode. */
     797             :         /* --------------------------------------------------------------------
     798             :          */
     799        1620 :         if (!bStrict)
     800        1003 :             CPLTurnFailureIntoWarning(true);
     801             : 
     802        1620 :         if (strlen(poSrcBand->GetDescription()) > 0)
     803          52 :             poDstBand->SetDescription(poSrcBand->GetDescription());
     804             : 
     805        1620 :         if (CSLCount(poSrcBand->GetMetadata()) > 0)
     806         114 :             poDstBand->SetMetadata(poSrcBand->GetMetadata());
     807             : 
     808        1620 :         int bSuccess = FALSE;
     809        1620 :         double dfValue = poSrcBand->GetOffset(&bSuccess);
     810        1620 :         if (bSuccess && dfValue != 0.0)
     811           5 :             poDstBand->SetOffset(dfValue);
     812             : 
     813        1620 :         dfValue = poSrcBand->GetScale(&bSuccess);
     814        1620 :         if (bSuccess && dfValue != 1.0)
     815           4 :             poDstBand->SetScale(dfValue);
     816             : 
     817        1620 :         GDALCopyNoDataValue(poDstBand, poSrcBand);
     818             : 
     819        2652 :         if (poSrcBand->GetColorInterpretation() != GCI_Undefined &&
     820        1032 :             poSrcBand->GetColorInterpretation() !=
     821        1032 :                 poDstBand->GetColorInterpretation())
     822         815 :             poDstBand->SetColorInterpretation(
     823         815 :                 poSrcBand->GetColorInterpretation());
     824             : 
     825        1620 :         char **papszCatNames = poSrcBand->GetCategoryNames();
     826        1620 :         if (nullptr != papszCatNames)
     827           1 :             poDstBand->SetCategoryNames(papszCatNames);
     828             : 
     829             :         // Only copy RAT if it is of reasonable size to fit in memory
     830        1620 :         GDALRasterAttributeTable *poRAT = poSrcBand->GetDefaultRAT();
     831        1622 :         if (poRAT != nullptr && static_cast<GIntBig>(poRAT->GetColumnCount()) *
     832           2 :                                         poRAT->GetRowCount() <
     833             :                                     1024 * 1024)
     834             :         {
     835           2 :             poDstBand->SetDefaultRAT(poRAT);
     836             :         }
     837             : 
     838        1620 :         if (!bStrict)
     839             :         {
     840        1003 :             CPLTurnFailureIntoWarning(false);
     841             :         }
     842             :         else
     843             :         {
     844         617 :             eErr = CPLGetLastErrorType();
     845             :         }
     846             :     }
     847             : 
     848             :     /* -------------------------------------------------------------------- */
     849             :     /*      Copy image data.                                                */
     850             :     /* -------------------------------------------------------------------- */
     851        1051 :     if (eErr == CE_None && nDstBands > 0)
     852             :     {
     853        1006 :         const char *const apszCopyRasterOptionsSkipHoles[] = {"SKIP_HOLES=YES",
     854             :                                                               nullptr};
     855        1006 :         const bool bSkipHoles = CPLTestBool(
     856             :             CSLFetchNameValueDef(papszOptions, "SKIP_HOLES", "FALSE"));
     857        1006 :         eErr = GDALDatasetCopyWholeRaster(
     858             :             poSrcDS, poDstDS,
     859             :             bSkipHoles ? apszCopyRasterOptionsSkipHoles : nullptr, pfnProgress,
     860             :             pProgressData);
     861             :     }
     862             : 
     863             :     /* -------------------------------------------------------------------- */
     864             :     /*      Should we copy some masks over?                                 */
     865             :     /* -------------------------------------------------------------------- */
     866        1051 :     if (eErr == CE_None && nDstBands > 0)
     867         989 :         eErr = DefaultCopyMasks(poSrcDS, poDstDS, eErr);
     868             : 
     869             :     /* -------------------------------------------------------------------- */
     870             :     /*      Copy vector layers                                              */
     871             :     /* -------------------------------------------------------------------- */
     872        1051 :     if (eErr == CE_None)
     873             :     {
     874        1002 :         if (nLayerCount > 0 && poDstDS->TestCapability(ODsCCreateLayer))
     875             :         {
     876          20 :             for (int iLayer = 0; iLayer < nLayerCount; ++iLayer)
     877             :             {
     878          10 :                 OGRLayer *poLayer = poSrcDS->GetLayer(iLayer);
     879             : 
     880          10 :                 if (poLayer == nullptr)
     881           0 :                     continue;
     882             : 
     883          10 :                 poDstDS->CopyLayer(poLayer, poLayer->GetName(), nullptr);
     884             :             }
     885             :         }
     886             :     }
     887             : 
     888             :     /* -------------------------------------------------------------------- */
     889             :     /*      Try to cleanup the output dataset if the translation failed.    */
     890             :     /* -------------------------------------------------------------------- */
     891        1051 :     if (eErr != CE_None)
     892             :     {
     893          49 :         delete poDstDS;
     894          49 :         if (!CPLFetchBool(papszOptions, "APPEND_SUBDATASET", false))
     895             :         {
     896             :             // Only delete if creating a new file
     897          49 :             Delete(pszFilename);
     898             :         }
     899          49 :         return nullptr;
     900             :     }
     901             :     else
     902             :     {
     903        1002 :         CPLErrorReset();
     904             :     }
     905             : 
     906        1002 :     return poDstDS;
     907             : }
     908             : 
     909             : /************************************************************************/
     910             : /*                       DefaultCopyMetadata()                          */
     911             : /************************************************************************/
     912             : 
     913        5413 : void GDALDriver::DefaultCopyMetadata(GDALDataset *poSrcDS, GDALDataset *poDstDS,
     914             :                                      CSLConstList papszOptions,
     915             :                                      CSLConstList papszExcludedDomains)
     916             : {
     917             :     const char *pszCopySrcMDD =
     918        5413 :         CSLFetchNameValueDef(papszOptions, "COPY_SRC_MDD", "AUTO");
     919        5413 :     char **papszSrcMDD = CSLFetchNameValueMultiple(papszOptions, "SRC_MDD");
     920        5413 :     if (EQUAL(pszCopySrcMDD, "AUTO") || CPLTestBool(pszCopySrcMDD) ||
     921             :         papszSrcMDD)
     922             :     {
     923           4 :         if ((!papszSrcMDD || CSLFindString(papszSrcMDD, "") >= 0 ||
     924           2 :              CSLFindString(papszSrcMDD, "_DEFAULT_") >= 0) &&
     925       10668 :             CSLFindString(papszExcludedDomains, "") < 0 &&
     926        5253 :             CSLFindString(papszExcludedDomains, "_DEFAULT_") < 0)
     927             :         {
     928        5253 :             if (poSrcDS->GetMetadata() != nullptr)
     929         826 :                 poDstDS->SetMetadata(poSrcDS->GetMetadata());
     930             :         }
     931             : 
     932             :         /* -------------------------------------------------------------------- */
     933             :         /*      Copy transportable special domain metadata.                     */
     934             :         /*      It would be nice to copy geolocation, but it is pretty fragile. */
     935             :         /* -------------------------------------------------------------------- */
     936        5411 :         constexpr const char *apszDefaultDomains[] = {
     937             :             "RPC", "xml:XMP", "json:ISIS3", "json:VICAR"};
     938       27055 :         for (const char *pszDomain : apszDefaultDomains)
     939             :         {
     940       43272 :             if ((!papszSrcMDD || CSLFindString(papszSrcMDD, pszDomain) >= 0) &&
     941       21628 :                 CSLFindString(papszExcludedDomains, pszDomain) < 0)
     942             :             {
     943       21628 :                 char **papszMD = poSrcDS->GetMetadata(pszDomain);
     944       21628 :                 if (papszMD)
     945           5 :                     poDstDS->SetMetadata(papszMD, pszDomain);
     946             :             }
     947             :         }
     948             : 
     949        5411 :         if ((!EQUAL(pszCopySrcMDD, "AUTO") && CPLTestBool(pszCopySrcMDD)) ||
     950             :             papszSrcMDD)
     951             :         {
     952          24 :             for (const char *pszDomain :
     953          30 :                  CPLStringList(poSrcDS->GetMetadataDomainList()))
     954             :             {
     955          36 :                 if (pszDomain[0] != 0 &&
     956          12 :                     (!papszSrcMDD ||
     957          12 :                      CSLFindString(papszSrcMDD, pszDomain) >= 0))
     958             :                 {
     959          10 :                     bool bCanCopy = true;
     960          10 :                     if (CSLFindString(papszExcludedDomains, pszDomain) >= 0)
     961             :                     {
     962           0 :                         bCanCopy = false;
     963             :                     }
     964             :                     else
     965             :                     {
     966          50 :                         for (const char *pszOtherDomain : apszDefaultDomains)
     967             :                         {
     968          40 :                             if (EQUAL(pszDomain, pszOtherDomain))
     969             :                             {
     970           0 :                                 bCanCopy = false;
     971           0 :                                 break;
     972             :                             }
     973             :                         }
     974          10 :                         if (!papszSrcMDD)
     975             :                         {
     976           6 :                             constexpr const char *const apszReservedDomains[] =
     977             :                                 {"IMAGE_STRUCTURE", "DERIVED_SUBDATASETS"};
     978           6 :                             for (const char *pszOtherDomain :
     979          12 :                                  apszReservedDomains)
     980             :                             {
     981          10 :                                 if (EQUAL(pszDomain, pszOtherDomain))
     982             :                                 {
     983           4 :                                     bCanCopy = false;
     984           4 :                                     break;
     985             :                                 }
     986             :                             }
     987             :                         }
     988             :                     }
     989          10 :                     if (bCanCopy)
     990             :                     {
     991           6 :                         poDstDS->SetMetadata(poSrcDS->GetMetadata(pszDomain),
     992           6 :                                              pszDomain);
     993             :                     }
     994             :                 }
     995             :             }
     996             :         }
     997             :     }
     998        5413 :     CSLDestroy(papszSrcMDD);
     999        5413 : }
    1000             : 
    1001             : /************************************************************************/
    1002             : /*                      QuietDeleteForCreateCopy()                      */
    1003             : /************************************************************************/
    1004             : 
    1005       11656 : CPLErr GDALDriver::QuietDeleteForCreateCopy(const char *pszFilename,
    1006             :                                             GDALDataset *poSrcDS)
    1007             : {
    1008             :     // Someone issuing CreateCopy("foo.tif") on a
    1009             :     // memory driver doesn't expect files with those names to be deleted
    1010             :     // on a file system...
    1011             :     // This is somewhat messy. Ideally there should be a way for the
    1012             :     // driver to overload the default behavior
    1013       22727 :     if (!EQUAL(GetDescription(), "MEM") && !EQUAL(GetDescription(), "Memory") &&
    1014             :         // Also exclude database formats for which there's no file list
    1015             :         // and whose opening might be slow (GeoRaster in particular)
    1016       33798 :         !EQUAL(GetDescription(), "GeoRaster") &&
    1017       11071 :         !EQUAL(GetDescription(), "PostGISRaster"))
    1018             :     {
    1019             :         /* --------------------------------------------------------------------
    1020             :          */
    1021             :         /*      Establish list of files of output dataset if it already
    1022             :          * exists. */
    1023             :         /* --------------------------------------------------------------------
    1024             :          */
    1025       22106 :         std::set<std::string> oSetExistingDestFiles;
    1026             :         {
    1027       22106 :             CPLErrorStateBackuper oErrorStateBackuper(CPLQuietErrorHandler);
    1028       11053 :             const char *const apszAllowedDrivers[] = {GetDescription(),
    1029       11053 :                                                       nullptr};
    1030             :             auto poExistingOutputDS =
    1031             :                 std::unique_ptr<GDALDataset>(GDALDataset::Open(
    1032       22106 :                     pszFilename, GDAL_OF_RASTER, apszAllowedDrivers));
    1033       11053 :             if (poExistingOutputDS)
    1034             :             {
    1035         674 :                 for (const char *pszFileInList :
    1036         640 :                      CPLStringList(poExistingOutputDS->GetFileList()))
    1037             :                 {
    1038             :                     oSetExistingDestFiles.insert(
    1039         337 :                         CPLString(pszFileInList).replaceAll('\\', '/'));
    1040             :                 }
    1041             :             }
    1042             :         }
    1043             : 
    1044             :         /* --------------------------------------------------------------------
    1045             :          */
    1046             :         /*      Check if the source dataset shares some files with the dest
    1047             :          * one.*/
    1048             :         /* --------------------------------------------------------------------
    1049             :          */
    1050       22106 :         std::set<std::string> oSetExistingDestFilesFoundInSource;
    1051       11053 :         if (!oSetExistingDestFiles.empty())
    1052             :         {
    1053         606 :             CPLErrorStateBackuper oErrorStateBackuper(CPLQuietErrorHandler);
    1054             :             // We need to reopen in a temporary dataset for the particular
    1055             :             // case of overwritten a .tif.ovr file from a .tif
    1056             :             // If we probe the file list of the .tif, it will then open the
    1057             :             // .tif.ovr !
    1058         303 :             const char *const apszAllowedDrivers[] = {
    1059         303 :                 poSrcDS->GetDriver() ? poSrcDS->GetDriver()->GetDescription()
    1060             :                                      : nullptr,
    1061         303 :                 nullptr};
    1062             :             auto poSrcDSTmp = std::unique_ptr<GDALDataset>(GDALDataset::Open(
    1063         303 :                 poSrcDS->GetDescription(), GDAL_OF_RASTER, apszAllowedDrivers,
    1064         606 :                 poSrcDS->papszOpenOptions));
    1065         303 :             if (poSrcDSTmp)
    1066             :             {
    1067         206 :                 for (const char *pszFileInList :
    1068         400 :                      CPLStringList(poSrcDSTmp->GetFileList()))
    1069             :                 {
    1070         412 :                     CPLString osFilename(pszFileInList);
    1071         206 :                     osFilename.replaceAll('\\', '/');
    1072         206 :                     if (cpl::contains(oSetExistingDestFiles, osFilename))
    1073             :                     {
    1074             :                         oSetExistingDestFilesFoundInSource.insert(
    1075          16 :                             std::move(osFilename));
    1076             :                     }
    1077             :                 }
    1078             :             }
    1079             :         }
    1080             : 
    1081             :         // If the source file(s) and the dest one share some files in
    1082             :         // common, only remove the files that are *not* in common
    1083       11053 :         if (!oSetExistingDestFilesFoundInSource.empty())
    1084             :         {
    1085          36 :             for (const std::string &osFilename : oSetExistingDestFiles)
    1086             :             {
    1087          21 :                 if (!cpl::contains(oSetExistingDestFilesFoundInSource,
    1088             :                                    osFilename))
    1089             :                 {
    1090           5 :                     VSIUnlink(osFilename.c_str());
    1091             :                 }
    1092             :             }
    1093             :         }
    1094             : 
    1095       11053 :         QuietDelete(pszFilename);
    1096             :     }
    1097             : 
    1098       11656 :     return CE_None;
    1099             : }
    1100             : 
    1101             : //! @endcond
    1102             : 
    1103             : /************************************************************************/
    1104             : /*                             CreateCopy()                             */
    1105             : /************************************************************************/
    1106             : 
    1107             : /**
    1108             :  * \brief Create a copy of a dataset.
    1109             :  *
    1110             :  * This method will attempt to create a copy of a raster dataset with the
    1111             :  * indicated filename, and in this drivers format.  Band number, size,
    1112             :  * type, projection, geotransform and so forth are all to be copied from
    1113             :  * the provided template dataset.
    1114             :  *
    1115             :  * Note that many sequential write once formats (such as JPEG and PNG) don't
    1116             :  * implement the Create() method but do implement this CreateCopy() method.
    1117             :  * If the driver doesn't implement CreateCopy(), but does implement Create()
    1118             :  * then the default CreateCopy() mechanism built on calling Create() will
    1119             :  * be used.
    1120             :  * So to test if CreateCopy() is available, you can test if GDAL_DCAP_CREATECOPY
    1121             :  * or GDAL_DCAP_CREATE is set in the GDAL metadata.
    1122             :  *
    1123             :  * It is intended that CreateCopy() will often be used with a source dataset
    1124             :  * which is a virtual dataset allowing configuration of band types, and other
    1125             :  * information without actually duplicating raster data (see the VRT driver).
    1126             :  * This is what is done by the gdal_translate utility for example.
    1127             :  *
    1128             :  * That function will try to validate the creation option list passed to the
    1129             :  * driver with the GDALValidateCreationOptions() method. This check can be
    1130             :  * disabled by defining the configuration option
    1131             :  * GDAL_VALIDATE_CREATION_OPTIONS=NO.
    1132             :  *
    1133             :  * This function copy all metadata from the default domain ("")
    1134             :  *
    1135             :  * Even is bStrict is TRUE, only the <b>value</b> of the data is equivalent,
    1136             :  * but the data layout (INTERLEAVE as PIXEL/LINE/BAND) of the dst dataset is
    1137             :  * controlled by the papszOptions creation options, and may differ from the
    1138             :  * poSrcDS src dataset.
    1139             :  * Starting from GDAL 3.5, if no INTERLEAVE and COMPRESS creation option has
    1140             :  * been specified in papszOptions, and if the driver supports equivalent
    1141             :  * interleaving as the src dataset, the CreateCopy() will internally add the
    1142             :  * proper creation option to get the same data interleaving.
    1143             :  *
    1144             :  * After you have finished working with the returned dataset, it is
    1145             :  * <b>required</b> to close it with GDALClose(). This does not only close the
    1146             :  * file handle, but also ensures that all the data and metadata has been written
    1147             :  * to the dataset (GDALFlushCache() is not sufficient for that purpose).
    1148             :  *
    1149             :  * For multidimensional datasets, papszOptions can contain array creation
    1150             :  * options, if they are prefixed with "ARRAY:". \see GDALGroup::CopyFrom()
    1151             :  * documentation for further details regarding such options.
    1152             :  *
    1153             :  * @param pszFilename the name for the new dataset.  UTF-8 encoded.
    1154             :  * @param poSrcDS the dataset being duplicated.
    1155             :  * @param bStrict TRUE if the copy must be strictly equivalent, or more
    1156             :  * normally FALSE indicating that the copy may adapt as needed for the
    1157             :  * output format.
    1158             :  * @param papszOptions additional format dependent options controlling
    1159             :  * creation of the output file.
    1160             :  * The APPEND_SUBDATASET=YES option can be specified to avoid prior destruction
    1161             :  * of existing dataset.
    1162             :  * Starting with GDAL 3.8.0, the following options are recognized by the
    1163             :  * GTiff, COG, VRT, PNG au JPEG drivers:
    1164             :  * <ul>
    1165             :  * <li>COPY_SRC_MDD=AUTO/YES/NO: whether metadata domains of the source dataset
    1166             :  * should be copied to the destination dataset. In the default AUTO mode, only
    1167             :  * "safe" domains will be copied, which include the default metadata domain
    1168             :  * (some drivers may include other domains such as IMD, RPC, GEOLOCATION). When
    1169             :  * setting YES, all domains will be copied (but a few reserved ones like
    1170             :  * IMAGE_STRUCTURE or DERIVED_SUBDATASETS). When setting NO, no source metadata
    1171             :  * will be copied.
    1172             :  * </li>
    1173             :  *<li>SRC_MDD=domain_name: which source metadata domain should be copied.
    1174             :  * This option restricts the list of source metadata domains to be copied
    1175             :  * (it implies COPY_SRC_MDD=YES if it is not set). This option may be specified
    1176             :  * as many times as they are source domains. The default metadata domain is the
    1177             :  * empty string "" ("_DEFAULT_") may also be used when empty string is not practical)
    1178             :  * </li>
    1179             :  * </ul>
    1180             :  * @param pfnProgress a function to be used to report progress of the copy.
    1181             :  * @param pProgressData application data passed into progress function.
    1182             :  *
    1183             :  * @return a pointer to the newly created dataset (may be read-only access).
    1184             :  */
    1185             : 
    1186       11135 : GDALDataset *GDALDriver::CreateCopy(const char *pszFilename,
    1187             :                                     GDALDataset *poSrcDS, int bStrict,
    1188             :                                     CSLConstList papszOptions,
    1189             :                                     GDALProgressFunc pfnProgress,
    1190             :                                     void *pProgressData)
    1191             : 
    1192             : {
    1193       11135 :     if (pfnProgress == nullptr)
    1194        8575 :         pfnProgress = GDALDummyProgress;
    1195             : 
    1196       11135 :     const int nBandCount = poSrcDS->GetRasterCount();
    1197             : 
    1198             :     /* -------------------------------------------------------------------- */
    1199             :     /*      If no INTERLEAVE creation option is given, we will try to add   */
    1200             :     /*      one that matches the current srcDS interleaving                 */
    1201             :     /* -------------------------------------------------------------------- */
    1202       11135 :     char **papszOptionsToDelete = nullptr;
    1203             :     const char *srcInterleave =
    1204       11135 :         poSrcDS->GetMetadataItem("INTERLEAVE", "IMAGE_STRUCTURE");
    1205        6692 :     if (nBandCount > 1 && srcInterleave != nullptr &&
    1206       24144 :         CSLFetchNameValue(papszOptions, "INTERLEAVE") == nullptr &&
    1207        6317 :         EQUAL(CSLFetchNameValueDef(papszOptions, "COMPRESS", "NONE"), "NONE"))
    1208             :     {
    1209             : 
    1210             :         // look for INTERLEAVE values of the driver
    1211        6163 :         char **interleavesCSL = nullptr;
    1212             :         const char *pszOptionList =
    1213        6163 :             this->GetMetadataItem(GDAL_DMD_CREATIONOPTIONLIST);
    1214             :         CPLXMLNode *xmlNode =
    1215        6163 :             !pszOptionList ? nullptr : CPLParseXMLString(pszOptionList);
    1216        6163 :         for (CPLXMLNode *child = !xmlNode ? nullptr : xmlNode->psChild;
    1217      125679 :              child != nullptr; child = child->psNext)
    1218             :         {
    1219      119516 :             if ((child->eType == CXT_Element) &&
    1220      119516 :                 EQUAL(child->pszValue, "Option"))
    1221             :             {
    1222             :                 const char *nameAttribute =
    1223      119516 :                     CPLGetXMLValue(child, "name", nullptr);
    1224      119516 :                 const bool isInterleaveAttribute =
    1225      119516 :                     nameAttribute && EQUAL(nameAttribute, "INTERLEAVE");
    1226      119516 :                 if (isInterleaveAttribute)
    1227             :                 {
    1228        1153 :                     for (CPLXMLNode *optionChild = child->psChild;
    1229        6986 :                          optionChild != nullptr;
    1230        5833 :                          optionChild = optionChild->psNext)
    1231             :                     {
    1232        5833 :                         if ((optionChild->eType == CXT_Element) &&
    1233        2359 :                             EQUAL(optionChild->pszValue, "Value"))
    1234             :                         {
    1235        2359 :                             CPLXMLNode *optionChildValue = optionChild->psChild;
    1236        2359 :                             if (optionChildValue &&
    1237        2359 :                                 (optionChildValue->eType == CXT_Text))
    1238             :                             {
    1239        2359 :                                 interleavesCSL = CSLAddString(
    1240        2359 :                                     interleavesCSL, optionChildValue->pszValue);
    1241             :                             }
    1242             :                         }
    1243             :                     }
    1244             :                 }
    1245             :             }
    1246             :         }
    1247        6163 :         CPLDestroyXMLNode(xmlNode);
    1248             : 
    1249             :         const char *dstInterleaveBand =
    1250       11197 :             (CSLFindString(interleavesCSL, "BAND") >= 0)  ? "BAND"
    1251        5034 :             : (CSLFindString(interleavesCSL, "BSQ") >= 0) ? "BSQ"
    1252        6163 :                                                           : nullptr;
    1253             :         const char *dstInterleaveLine =
    1254       12326 :             (CSLFindString(interleavesCSL, "LINE") >= 0)  ? "LINE"
    1255        6163 :             : (CSLFindString(interleavesCSL, "BIL") >= 0) ? "BIL"
    1256        6163 :                                                           : nullptr;
    1257             :         const char *dstInterleavePixel =
    1258       11197 :             (CSLFindString(interleavesCSL, "PIXEL") >= 0) ? "PIXEL"
    1259        5034 :             : (CSLFindString(interleavesCSL, "BIP") >= 0) ? "BIP"
    1260        6163 :                                                           : nullptr;
    1261        6163 :         const char *dstInterleave =
    1262        6446 :             EQUAL(srcInterleave, "BAND")    ? dstInterleaveBand
    1263         564 :             : EQUAL(srcInterleave, "LINE")  ? dstInterleaveLine
    1264         281 :             : EQUAL(srcInterleave, "PIXEL") ? dstInterleavePixel
    1265             :                                             : nullptr;
    1266        6163 :         CSLDestroy(interleavesCSL);
    1267             : 
    1268        6163 :         if (dstInterleave != nullptr)
    1269             :         {
    1270        1153 :             papszOptionsToDelete = CSLDuplicate(papszOptions);
    1271        1153 :             papszOptionsToDelete = CSLSetNameValue(papszOptionsToDelete,
    1272             :                                                    "INTERLEAVE", dstInterleave);
    1273        1153 :             papszOptionsToDelete = CSLSetNameValue(
    1274             :                 papszOptionsToDelete, "@INTERLEAVE_ADDED_AUTOMATICALLY", "YES");
    1275        1153 :             papszOptions = papszOptionsToDelete;
    1276             :         }
    1277             :     }
    1278             : 
    1279             :     /* -------------------------------------------------------------------- */
    1280             :     /*      Make sure we cleanup if there is an existing dataset of this    */
    1281             :     /*      name.  But even if that seems to fail we will continue since    */
    1282             :     /*      it might just be a corrupt file or something.                   */
    1283             :     /* -------------------------------------------------------------------- */
    1284             :     const bool bAppendSubdataset =
    1285       11135 :         CPLFetchBool(papszOptions, "APPEND_SUBDATASET", false);
    1286             :     // Note: @QUIET_DELETE_ON_CREATE_COPY is set to NO by the KMLSuperOverlay
    1287             :     // driver when writing a .kmz file. Also by GDALTranslate() if it has
    1288             :     // already done a similar job.
    1289       22250 :     if (!bAppendSubdataset &&
    1290       11115 :         CPLFetchBool(papszOptions, "@QUIET_DELETE_ON_CREATE_COPY", true))
    1291             :     {
    1292        8718 :         QuietDeleteForCreateCopy(pszFilename, poSrcDS);
    1293             :     }
    1294             : 
    1295             :     int iIdxQuietDeleteOnCreateCopy =
    1296       11135 :         CSLPartialFindString(papszOptions, "@QUIET_DELETE_ON_CREATE_COPY=");
    1297       11135 :     if (iIdxQuietDeleteOnCreateCopy >= 0)
    1298             :     {
    1299        2397 :         if (papszOptionsToDelete == nullptr)
    1300        1381 :             papszOptionsToDelete = CSLDuplicate(papszOptions);
    1301        2397 :         papszOptionsToDelete = CSLRemoveStrings(
    1302             :             papszOptionsToDelete, iIdxQuietDeleteOnCreateCopy, 1, nullptr);
    1303        2397 :         papszOptions = papszOptionsToDelete;
    1304             :     }
    1305             : 
    1306             :     /* -------------------------------------------------------------------- */
    1307             :     /*      If _INTERNAL_DATASET=YES, the returned dataset will not be      */
    1308             :     /*      registered in the global list of open datasets.                 */
    1309             :     /* -------------------------------------------------------------------- */
    1310             :     const int iIdxInternalDataset =
    1311       11135 :         CSLPartialFindString(papszOptions, "_INTERNAL_DATASET=");
    1312       11135 :     bool bInternalDataset = false;
    1313       11135 :     if (iIdxInternalDataset >= 0)
    1314             :     {
    1315             :         bInternalDataset =
    1316        4165 :             CPLFetchBool(papszOptions, "_INTERNAL_DATASET", false);
    1317        4165 :         if (papszOptionsToDelete == nullptr)
    1318        4165 :             papszOptionsToDelete = CSLDuplicate(papszOptions);
    1319        4165 :         papszOptionsToDelete = CSLRemoveStrings(
    1320             :             papszOptionsToDelete, iIdxInternalDataset, 1, nullptr);
    1321        4165 :         papszOptions = papszOptionsToDelete;
    1322             :     }
    1323             : 
    1324             :     /* -------------------------------------------------------------------- */
    1325             :     /*      Validate creation options.                                      */
    1326             :     /* -------------------------------------------------------------------- */
    1327       11135 :     if (CPLTestBool(
    1328             :             CPLGetConfigOption("GDAL_VALIDATE_CREATION_OPTIONS", "YES")))
    1329             :     {
    1330       22270 :         auto poSrcGroup = poSrcDS->GetRootGroup();
    1331       11135 :         if (poSrcGroup != nullptr && GetMetadataItem(GDAL_DCAP_MULTIDIM_RASTER))
    1332             :         {
    1333         218 :             CPLStringList aosDatasetCO;
    1334         116 :             for (const char *pszOption : cpl::Iterate(papszOptions))
    1335             :             {
    1336           7 :                 if (!STARTS_WITH_CI(pszOption, "ARRAY:"))
    1337           0 :                     aosDatasetCO.AddString(pszOption);
    1338             :             }
    1339         109 :             GDALValidateCreationOptions(this, aosDatasetCO.List());
    1340             :         }
    1341             :         else
    1342             :         {
    1343       11026 :             GDALValidateCreationOptions(this, papszOptions);
    1344             :         }
    1345             :     }
    1346             : 
    1347             :     /* -------------------------------------------------------------------- */
    1348             :     /*      Advise the source raster that we are going to read it completely */
    1349             :     /* -------------------------------------------------------------------- */
    1350             : 
    1351       11135 :     const int nXSize = poSrcDS->GetRasterXSize();
    1352       11135 :     const int nYSize = poSrcDS->GetRasterYSize();
    1353       11135 :     GDALDataType eDT = GDT_Unknown;
    1354       11135 :     if (nBandCount > 0)
    1355             :     {
    1356       10911 :         GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand(1);
    1357       10911 :         if (poSrcBand)
    1358       10911 :             eDT = poSrcBand->GetRasterDataType();
    1359             :     }
    1360       11135 :     poSrcDS->AdviseRead(0, 0, nXSize, nYSize, nXSize, nYSize, eDT, nBandCount,
    1361       11135 :                         nullptr, nullptr);
    1362             : 
    1363             :     /* -------------------------------------------------------------------- */
    1364             :     /*      If the format provides a CreateCopy() method use that,          */
    1365             :     /*      otherwise fallback to the internal implementation using the     */
    1366             :     /*      Create() method.                                                */
    1367             :     /* -------------------------------------------------------------------- */
    1368       11135 :     GDALDataset *poDstDS = nullptr;
    1369       11135 :     auto l_pfnCreateCopy = GetCreateCopyCallback();
    1370       21149 :     if (l_pfnCreateCopy != nullptr &&
    1371       10014 :         !CPLTestBool(CPLGetConfigOption("GDAL_DEFAULT_CREATE_COPY", "NO")))
    1372             :     {
    1373       10014 :         poDstDS = l_pfnCreateCopy(pszFilename, poSrcDS, bStrict,
    1374             :                                   const_cast<char **>(papszOptions),
    1375             :                                   pfnProgress, pProgressData);
    1376       10014 :         if (poDstDS != nullptr)
    1377             :         {
    1378       17808 :             if (poDstDS->GetDescription() == nullptr ||
    1379        8904 :                 strlen(poDstDS->GetDescription()) == 0)
    1380         385 :                 poDstDS->SetDescription(pszFilename);
    1381             : 
    1382        8904 :             if (poDstDS->poDriver == nullptr)
    1383        7852 :                 poDstDS->poDriver = this;
    1384             : 
    1385        8904 :             if (!bInternalDataset)
    1386        4739 :                 poDstDS->AddToDatasetOpenList();
    1387             :         }
    1388             :     }
    1389             :     else
    1390             :     {
    1391        1121 :         poDstDS = DefaultCreateCopy(pszFilename, poSrcDS, bStrict, papszOptions,
    1392             :                                     pfnProgress, pProgressData);
    1393             :     }
    1394             : 
    1395       11135 :     CSLDestroy(papszOptionsToDelete);
    1396       11135 :     return poDstDS;
    1397             : }
    1398             : 
    1399             : /************************************************************************/
    1400             : /*                           GDALCreateCopy()                           */
    1401             : /************************************************************************/
    1402             : 
    1403             : /**
    1404             :  * \brief Create a copy of a dataset.
    1405             :  *
    1406             :  * @see GDALDriver::CreateCopy()
    1407             :  */
    1408             : 
    1409        6369 : GDALDatasetH CPL_STDCALL GDALCreateCopy(GDALDriverH hDriver,
    1410             :                                         const char *pszFilename,
    1411             :                                         GDALDatasetH hSrcDS, int bStrict,
    1412             :                                         CSLConstList papszOptions,
    1413             :                                         GDALProgressFunc pfnProgress,
    1414             :                                         void *pProgressData)
    1415             : 
    1416             : {
    1417        6369 :     VALIDATE_POINTER1(hDriver, "GDALCreateCopy", nullptr);
    1418        6369 :     VALIDATE_POINTER1(hSrcDS, "GDALCreateCopy", nullptr);
    1419             : 
    1420        6369 :     return GDALDriver::FromHandle(hDriver)->CreateCopy(
    1421             :         pszFilename, GDALDataset::FromHandle(hSrcDS), bStrict, papszOptions,
    1422        6369 :         pfnProgress, pProgressData);
    1423             : }
    1424             : 
    1425             : /************************************************************************/
    1426             : /*                      CanVectorTranslateFrom()                        */
    1427             : /************************************************************************/
    1428             : 
    1429             : /** Returns whether the driver can translate from a vector dataset,
    1430             :  * using the arguments passed to GDALVectorTranslate() stored in
    1431             :  * papszVectorTranslateArguments.
    1432             :  *
    1433             :  * This is used to determine if the driver supports the VectorTranslateFrom()
    1434             :  * operation.
    1435             :  *
    1436             :  * @param pszDestName Target dataset name
    1437             :  * @param poSourceDS  Source dataset
    1438             :  * @param papszVectorTranslateArguments Non-positional arguments passed to
    1439             :  *                                      GDALVectorTranslate() (may be nullptr)
    1440             :  * @param[out] ppapszFailureReasons nullptr, or a pointer to an null-terminated
    1441             :  * array of strings to record the reason(s) for the impossibility.
    1442             :  * @return true if VectorTranslateFrom() can be called with the same arguments.
    1443             :  * @since GDAL 3.8
    1444             :  */
    1445         881 : bool GDALDriver::CanVectorTranslateFrom(
    1446             :     const char *pszDestName, GDALDataset *poSourceDS,
    1447             :     CSLConstList papszVectorTranslateArguments, char ***ppapszFailureReasons)
    1448             : 
    1449             : {
    1450         881 :     if (ppapszFailureReasons)
    1451             :     {
    1452           0 :         *ppapszFailureReasons = nullptr;
    1453             :     }
    1454             : 
    1455         881 :     if (!pfnCanVectorTranslateFrom)
    1456             :     {
    1457         875 :         if (ppapszFailureReasons)
    1458             :         {
    1459           0 :             *ppapszFailureReasons = CSLAddString(
    1460             :                 nullptr,
    1461             :                 "CanVectorTranslateFrom() not implemented for this driver");
    1462             :         }
    1463         875 :         return false;
    1464             :     }
    1465             : 
    1466           6 :     char **papszFailureReasons = nullptr;
    1467           6 :     bool bRet = pfnCanVectorTranslateFrom(
    1468             :         pszDestName, poSourceDS, papszVectorTranslateArguments,
    1469             :         ppapszFailureReasons ? ppapszFailureReasons : &papszFailureReasons);
    1470           6 :     if (!ppapszFailureReasons)
    1471             :     {
    1472           2 :         for (const char *pszReason :
    1473          10 :              cpl::Iterate(static_cast<CSLConstList>(papszFailureReasons)))
    1474             :         {
    1475           2 :             CPLDebug("GDAL", "%s", pszReason);
    1476             :         }
    1477           6 :         CSLDestroy(papszFailureReasons);
    1478             :     }
    1479           6 :     return bRet;
    1480             : }
    1481             : 
    1482         193 : bool GDALDriver::HasOpenOption(const char *pszOpenOptionName) const
    1483             : {
    1484         193 :     if (pszOpenOptionName == nullptr)
    1485           0 :         return false;
    1486             : 
    1487             :     // Const cast is safe here since we are only reading the metadata
    1488         386 :     auto pszOOMd{const_cast<GDALDriver *>(this)->GetMetadataItem(
    1489         193 :         GDAL_DMD_OPENOPTIONLIST)};
    1490         193 :     if (pszOOMd == nullptr)
    1491          74 :         return false;
    1492             : 
    1493         238 :     const CPLXMLTreeCloser oXml{CPLParseXMLString(pszOOMd)};
    1494        1148 :     for (CPLXMLNode *option = oXml->psChild; option != nullptr;
    1495        1029 :          option = option->psNext)
    1496             :     {
    1497        1030 :         if (EQUAL(CPLGetXMLValue(CPLGetXMLNode(option, "name"), nullptr, ""),
    1498             :                   pszOpenOptionName))
    1499           1 :             return true;
    1500             :     }
    1501         118 :     return false;
    1502             : }
    1503             : 
    1504             : /************************************************************************/
    1505             : /*                         VectorTranslateFrom()                        */
    1506             : /************************************************************************/
    1507             : 
    1508             : /** Create a copy of a vector dataset, using the arguments passed to
    1509             :  * GDALVectorTranslate() stored in papszVectorTranslateArguments.
    1510             :  *
    1511             :  * This may be implemented by some drivers that can convert from an existing
    1512             :  * dataset in an optimized way.
    1513             :  *
    1514             :  * This is for example used by the PMTiles to convert from MBTiles.
    1515             :  *
    1516             :  * @param pszDestName Target dataset name
    1517             :  * @param poSourceDS  Source dataset
    1518             :  * @param papszVectorTranslateArguments Non-positional arguments passed to
    1519             :  *                                      GDALVectorTranslate() (may be nullptr)
    1520             :  * @param pfnProgress a function to be used to report progress of the copy.
    1521             :  * @param pProgressData application data passed into progress function.
    1522             :  * @return a new dataset in case of success, or nullptr in case of error.
    1523             :  * @since GDAL 3.8
    1524             :  */
    1525           4 : GDALDataset *GDALDriver::VectorTranslateFrom(
    1526             :     const char *pszDestName, GDALDataset *poSourceDS,
    1527             :     CSLConstList papszVectorTranslateArguments, GDALProgressFunc pfnProgress,
    1528             :     void *pProgressData)
    1529             : 
    1530             : {
    1531           4 :     if (!pfnVectorTranslateFrom)
    1532             :     {
    1533           0 :         CPLError(CE_Failure, CPLE_AppDefined,
    1534             :                  "VectorTranslateFrom() not implemented for this driver");
    1535           0 :         return nullptr;
    1536             :     }
    1537             : 
    1538           4 :     return pfnVectorTranslateFrom(pszDestName, poSourceDS,
    1539             :                                   papszVectorTranslateArguments, pfnProgress,
    1540           4 :                                   pProgressData);
    1541             : }
    1542             : 
    1543             : /************************************************************************/
    1544             : /*                            QuietDelete()                             */
    1545             : /************************************************************************/
    1546             : 
    1547             : /**
    1548             :  * \brief Delete dataset if found.
    1549             :  *
    1550             :  * This is a helper method primarily used by Create() and
    1551             :  * CreateCopy() to predelete any dataset of the name soon to be
    1552             :  * created.  It will attempt to delete the named dataset if
    1553             :  * one is found, otherwise it does nothing.  An error is only
    1554             :  * returned if the dataset is found but the delete fails.
    1555             :  *
    1556             :  * This is a static method and it doesn't matter what driver instance
    1557             :  * it is invoked on.  It will attempt to discover the correct driver
    1558             :  * using Identify().
    1559             :  *
    1560             :  * @param pszName the dataset name to try and delete.
    1561             :  * @param papszAllowedDrivers NULL to consider all candidate drivers, or a NULL
    1562             :  * terminated list of strings with the driver short names that must be
    1563             :  * considered. (Note: implemented only starting with GDAL 3.4.1)
    1564             :  * @return CE_None if the dataset does not exist, or is deleted without issues.
    1565             :  */
    1566             : 
    1567       24153 : CPLErr GDALDriver::QuietDelete(const char *pszName,
    1568             :                                CSLConstList papszAllowedDrivers)
    1569             : 
    1570             : {
    1571             :     VSIStatBufL sStat;
    1572             :     const bool bExists =
    1573       24153 :         VSIStatExL(pszName, &sStat,
    1574       24153 :                    VSI_STAT_EXISTS_FLAG | VSI_STAT_NATURE_FLAG) == 0;
    1575             : 
    1576             : #ifdef S_ISFIFO
    1577       24153 :     if (bExists && S_ISFIFO(sStat.st_mode))
    1578           0 :         return CE_None;
    1579             : #endif
    1580             : 
    1581       24153 :     GDALDriver *poDriver = nullptr;
    1582       24153 :     if (papszAllowedDrivers)
    1583             :     {
    1584          70 :         GDALOpenInfo oOpenInfo(pszName, GDAL_OF_ALL);
    1585          35 :         for (const char *pszDriverName : cpl::Iterate(papszAllowedDrivers))
    1586             :         {
    1587             :             GDALDriver *poTmpDriver =
    1588          35 :                 GDALDriver::FromHandle(GDALGetDriverByName(pszDriverName));
    1589          35 :             if (poTmpDriver)
    1590             :             {
    1591             :                 const bool bIdentifyRes =
    1592          35 :                     poTmpDriver->pfnIdentifyEx
    1593          70 :                         ? poTmpDriver->pfnIdentifyEx(poTmpDriver, &oOpenInfo) >
    1594             :                               0
    1595          70 :                         : poTmpDriver->pfnIdentify &&
    1596          35 :                               poTmpDriver->pfnIdentify(&oOpenInfo) > 0;
    1597          35 :                 if (bIdentifyRes)
    1598             :                 {
    1599          35 :                     poDriver = poTmpDriver;
    1600          35 :                     break;
    1601             :                 }
    1602             :             }
    1603             :         }
    1604             :     }
    1605             :     else
    1606             :     {
    1607       48236 :         CPLErrorStateBackuper oErrorStateBackuper(CPLQuietErrorHandler);
    1608       24118 :         poDriver = GDALDriver::FromHandle(GDALIdentifyDriver(pszName, nullptr));
    1609             :     }
    1610             : 
    1611       24153 :     if (poDriver == nullptr)
    1612       23260 :         return CE_None;
    1613             : 
    1614         937 :     if (bExists && VSI_ISDIR(sStat.st_mode) &&
    1615          44 :         (EQUAL(poDriver->GetDescription(), "MapInfo File") ||
    1616          44 :          EQUAL(poDriver->GetDescription(), "ESRI Shapefile")))
    1617             :     {
    1618             :         // Those drivers are a bit special and handle directories as container
    1619             :         // of layers, but it is quite common to found other files too, and
    1620             :         // removing the directory might be non-desirable.
    1621          42 :         return CE_None;
    1622             :     }
    1623             : 
    1624         851 :     CPLDebug("GDAL", "QuietDelete(%s) invoking Delete()", pszName);
    1625             : 
    1626         851 :     poDriver->pfnDelete = poDriver->GetDeleteCallback();
    1627         889 :     const bool bQuiet = !bExists && poDriver->pfnDelete == nullptr &&
    1628          38 :                         poDriver->pfnDeleteDataSource == nullptr;
    1629         851 :     if (bQuiet)
    1630             :     {
    1631          76 :         CPLErrorStateBackuper oErrorStateBackuper(CPLQuietErrorHandler);
    1632          38 :         return poDriver->Delete(pszName);
    1633             :     }
    1634             :     else
    1635             :     {
    1636         813 :         return poDriver->Delete(pszName);
    1637             :     }
    1638             : }
    1639             : 
    1640             : /************************************************************************/
    1641             : /*                               Delete()                               */
    1642             : /************************************************************************/
    1643             : 
    1644             : /**
    1645             :  * \brief Delete named dataset.
    1646             :  *
    1647             :  * The driver will attempt to delete the named dataset in a driver specific
    1648             :  * fashion.  Full featured drivers will delete all associated files,
    1649             :  * database objects, or whatever is appropriate.  The default behavior when
    1650             :  * no driver specific behavior is provided is to attempt to delete all the
    1651             :  * files that are returned by GDALGetFileList() on the dataset handle.
    1652             :  *
    1653             :  * It is unwise to have open dataset handles on this dataset when it is
    1654             :  * deleted.
    1655             :  *
    1656             :  * Equivalent of the C function GDALDeleteDataset().
    1657             :  *
    1658             :  * @param pszFilename name of dataset to delete.
    1659             :  *
    1660             :  * @return CE_None on success, or CE_Failure if the operation fails.
    1661             :  */
    1662             : 
    1663        4365 : CPLErr GDALDriver::Delete(const char *pszFilename)
    1664             : 
    1665             : {
    1666        4365 :     pfnDelete = GetDeleteCallback();
    1667        4365 :     if (pfnDelete != nullptr)
    1668        1075 :         return pfnDelete(pszFilename);
    1669        3290 :     else if (pfnDeleteDataSource != nullptr)
    1670           0 :         return pfnDeleteDataSource(this, pszFilename);
    1671             : 
    1672             :     /* -------------------------------------------------------------------- */
    1673             :     /*      Collect file list.                                              */
    1674             :     /* -------------------------------------------------------------------- */
    1675        3290 :     GDALDatasetH hDS = GDALOpenEx(pszFilename, 0, nullptr, nullptr, nullptr);
    1676             : 
    1677        3290 :     if (hDS == nullptr)
    1678             :     {
    1679         238 :         if (CPLGetLastErrorNo() == 0)
    1680         211 :             CPLError(CE_Failure, CPLE_OpenFailed,
    1681             :                      "Unable to open %s to obtain file list.", pszFilename);
    1682             : 
    1683         238 :         return CE_Failure;
    1684             :     }
    1685             : 
    1686        6104 :     const CPLStringList aosFileList(GDALGetFileList(hDS));
    1687             : 
    1688        3052 :     GDALClose(hDS);
    1689        3052 :     hDS = nullptr;
    1690             : 
    1691        3052 :     if (aosFileList.empty())
    1692             :     {
    1693           0 :         CPLError(CE_Failure, CPLE_NotSupported,
    1694             :                  "Unable to determine files associated with %s, "
    1695             :                  "delete fails.",
    1696             :                  pszFilename);
    1697           0 :         return CE_Failure;
    1698             :     }
    1699             : 
    1700        3052 :     return Delete(nullptr, aosFileList.List());
    1701             : }
    1702             : 
    1703             : /************************************************************************/
    1704             : /*                               Delete()                               */
    1705             : /************************************************************************/
    1706             : 
    1707             : /**
    1708             :  * \brief Delete a currently opened dataset
    1709             :  *
    1710             :  * The driver will attempt to delete the passed dataset in a driver specific
    1711             :  * fashion.  Full featured drivers will delete all associated files,
    1712             :  * database objects, or whatever is appropriate.  The default behavior when
    1713             :  * no driver specific behavior is provided is to attempt to delete all the
    1714             :  * files that are returned by GDALGetFileList() on the dataset handle.
    1715             :  *
    1716             :  * Note that this will generally not work on Windows systems that don't accept
    1717             :  * deleting opened files.
    1718             :  *
    1719             :  * At least one of poDS or papszFileList must not be NULL
    1720             :  *
    1721             :  * @param poDS dataset to delete, or NULL
    1722             :  * @param papszFileList File list to delete, typically obtained with
    1723             :  *                      poDS->GetFileList(), or NULL
    1724             :  *
    1725             :  * @return CE_None on success, or CE_Failure if the operation fails.
    1726             :  *
    1727             :  * @since 3.12
    1728             :  */
    1729             : 
    1730        3063 : CPLErr GDALDriver::Delete(GDALDataset *poDS, CSLConstList papszFileList)
    1731             : 
    1732             : {
    1733        3063 :     if (poDS)
    1734             :     {
    1735          10 :         pfnDelete = GetDeleteCallback();
    1736          10 :         if (pfnDelete != nullptr)
    1737           6 :             return pfnDelete(poDS->GetDescription());
    1738           4 :         else if (pfnDeleteDataSource != nullptr)
    1739           0 :             return pfnDeleteDataSource(this, poDS->GetDescription());
    1740             :     }
    1741             : 
    1742             :     /* -------------------------------------------------------------------- */
    1743             :     /*      Delete all files.                                               */
    1744             :     /* -------------------------------------------------------------------- */
    1745        3057 :     CPLErr eErr = CE_None;
    1746        6765 :     for (int i = 0; papszFileList && papszFileList[i]; ++i)
    1747             :     {
    1748        3708 :         if (VSIUnlink(papszFileList[i]) != 0)
    1749             :         {
    1750           4 :             CPLError(CE_Failure, CPLE_AppDefined, "Deleting %s failed:\n%s",
    1751           2 :                      papszFileList[i], VSIStrerror(errno));
    1752           2 :             eErr = CE_Failure;
    1753             :         }
    1754             :     }
    1755             : 
    1756        3057 :     return eErr;
    1757             : }
    1758             : 
    1759             : /************************************************************************/
    1760             : /*                         GDALDeleteDataset()                          */
    1761             : /************************************************************************/
    1762             : 
    1763             : /**
    1764             :  * \brief Delete named dataset.
    1765             :  *
    1766             :  * @see GDALDriver::Delete()
    1767             :  */
    1768             : 
    1769        2391 : CPLErr CPL_STDCALL GDALDeleteDataset(GDALDriverH hDriver,
    1770             :                                      const char *pszFilename)
    1771             : 
    1772             : {
    1773        2391 :     if (hDriver == nullptr)
    1774          10 :         hDriver = GDALIdentifyDriver(pszFilename, nullptr);
    1775             : 
    1776        2391 :     if (hDriver == nullptr)
    1777             :     {
    1778           1 :         CPLError(CE_Failure, CPLE_AppDefined, "No identifiable driver for %s.",
    1779             :                  pszFilename);
    1780           1 :         return CE_Failure;
    1781             :     }
    1782             : 
    1783             : #ifdef OGRAPISPY_ENABLED
    1784        2390 :     if (GDALGetMetadataItem(hDriver, GDAL_DCAP_VECTOR, nullptr))
    1785             :     {
    1786         453 :         OGRAPISpyDeleteDataSource(hDriver, pszFilename);
    1787             :     }
    1788             : #endif
    1789             : 
    1790        2390 :     return GDALDriver::FromHandle(hDriver)->Delete(pszFilename);
    1791             : }
    1792             : 
    1793             : /************************************************************************/
    1794             : /*                           DefaultRename()                            */
    1795             : /*                                                                      */
    1796             : /*      The generic implementation based on the file list used when     */
    1797             : /*      there is no format specific implementation.                     */
    1798             : /************************************************************************/
    1799             : 
    1800             : //! @cond Doxygen_Suppress
    1801         173 : CPLErr GDALDriver::DefaultRename(const char *pszNewName, const char *pszOldName)
    1802             : 
    1803             : {
    1804             :     /* -------------------------------------------------------------------- */
    1805             :     /*      Collect file list.                                              */
    1806             :     /* -------------------------------------------------------------------- */
    1807         173 :     GDALDatasetH hDS = GDALOpen(pszOldName, GA_ReadOnly);
    1808             : 
    1809         173 :     if (hDS == nullptr)
    1810             :     {
    1811           0 :         if (CPLGetLastErrorNo() == 0)
    1812           0 :             CPLError(CE_Failure, CPLE_OpenFailed,
    1813             :                      "Unable to open %s to obtain file list.", pszOldName);
    1814             : 
    1815           0 :         return CE_Failure;
    1816             :     }
    1817             : 
    1818         173 :     char **papszFileList = GDALGetFileList(hDS);
    1819             : 
    1820         173 :     GDALClose(hDS);
    1821             : 
    1822         173 :     if (CSLCount(papszFileList) == 0)
    1823             :     {
    1824           0 :         CPLError(CE_Failure, CPLE_NotSupported,
    1825             :                  "Unable to determine files associated with %s,\n"
    1826             :                  "rename fails.",
    1827             :                  pszOldName);
    1828             : 
    1829           0 :         return CE_Failure;
    1830             :     }
    1831             : 
    1832             :     /* -------------------------------------------------------------------- */
    1833             :     /*      Produce a list of new filenames that correspond to the old      */
    1834             :     /*      names.                                                          */
    1835             :     /* -------------------------------------------------------------------- */
    1836         173 :     CPLErr eErr = CE_None;
    1837             :     char **papszNewFileList =
    1838         173 :         CPLCorrespondingPaths(pszOldName, pszNewName, papszFileList);
    1839             : 
    1840         173 :     if (papszNewFileList == nullptr)
    1841           0 :         return CE_Failure;
    1842             : 
    1843         353 :     for (int i = 0; papszFileList[i] != nullptr; ++i)
    1844             :     {
    1845         180 :         if (CPLMoveFile(papszNewFileList[i], papszFileList[i]) != 0)
    1846             :         {
    1847           0 :             eErr = CE_Failure;
    1848             :             // Try to put the ones we moved back.
    1849           0 :             for (--i; i >= 0; i--)
    1850             :             {
    1851             :                 // Nothing we can do if the moving back doesn't work...
    1852           0 :                 CPL_IGNORE_RET_VAL(
    1853           0 :                     CPLMoveFile(papszFileList[i], papszNewFileList[i]));
    1854             :             }
    1855           0 :             break;
    1856             :         }
    1857             :     }
    1858             : 
    1859         173 :     CSLDestroy(papszNewFileList);
    1860         173 :     CSLDestroy(papszFileList);
    1861             : 
    1862         173 :     return eErr;
    1863             : }
    1864             : 
    1865             : //! @endcond
    1866             : 
    1867             : /************************************************************************/
    1868             : /*                               Rename()                               */
    1869             : /************************************************************************/
    1870             : 
    1871             : /**
    1872             :  * \brief Rename a dataset.
    1873             :  *
    1874             :  * Rename a dataset. This may including moving the dataset to a new directory
    1875             :  * or even a new filesystem.
    1876             :  *
    1877             :  * It is unwise to have open dataset handles on this dataset when it is
    1878             :  * being renamed.
    1879             :  *
    1880             :  * Equivalent of the C function GDALRenameDataset().
    1881             :  *
    1882             :  * @param pszNewName new name for the dataset.
    1883             :  * @param pszOldName old name for the dataset.
    1884             :  *
    1885             :  * @return CE_None on success, or CE_Failure if the operation fails.
    1886             :  */
    1887             : 
    1888         175 : CPLErr GDALDriver::Rename(const char *pszNewName, const char *pszOldName)
    1889             : 
    1890             : {
    1891         175 :     pfnRename = GetRenameCallback();
    1892         175 :     if (pfnRename != nullptr)
    1893           3 :         return pfnRename(pszNewName, pszOldName);
    1894             : 
    1895         172 :     return DefaultRename(pszNewName, pszOldName);
    1896             : }
    1897             : 
    1898             : /************************************************************************/
    1899             : /*                         GDALRenameDataset()                          */
    1900             : /************************************************************************/
    1901             : 
    1902             : /**
    1903             :  * \brief Rename a dataset.
    1904             :  *
    1905             :  * @see GDALDriver::Rename()
    1906             :  */
    1907             : 
    1908         176 : CPLErr CPL_STDCALL GDALRenameDataset(GDALDriverH hDriver,
    1909             :                                      const char *pszNewName,
    1910             :                                      const char *pszOldName)
    1911             : 
    1912             : {
    1913         176 :     if (hDriver == nullptr)
    1914           3 :         hDriver = GDALIdentifyDriver(pszOldName, nullptr);
    1915             : 
    1916         176 :     if (hDriver == nullptr)
    1917             :     {
    1918           1 :         CPLError(CE_Failure, CPLE_AppDefined, "No identifiable driver for %s.",
    1919             :                  pszOldName);
    1920           1 :         return CE_Failure;
    1921             :     }
    1922             : 
    1923         175 :     return GDALDriver::FromHandle(hDriver)->Rename(pszNewName, pszOldName);
    1924             : }
    1925             : 
    1926             : /************************************************************************/
    1927             : /*                          DefaultCopyFiles()                          */
    1928             : /*                                                                      */
    1929             : /*      The default implementation based on file lists used when        */
    1930             : /*      there is no format specific implementation.                     */
    1931             : /************************************************************************/
    1932             : 
    1933             : //! @cond Doxygen_Suppress
    1934          10 : CPLErr GDALDriver::DefaultCopyFiles(const char *pszNewName,
    1935             :                                     const char *pszOldName)
    1936             : 
    1937             : {
    1938             :     /* -------------------------------------------------------------------- */
    1939             :     /*      Collect file list.                                              */
    1940             :     /* -------------------------------------------------------------------- */
    1941          10 :     GDALDatasetH hDS = GDALOpen(pszOldName, GA_ReadOnly);
    1942             : 
    1943          10 :     if (hDS == nullptr)
    1944             :     {
    1945           0 :         if (CPLGetLastErrorNo() == 0)
    1946           0 :             CPLError(CE_Failure, CPLE_OpenFailed,
    1947             :                      "Unable to open %s to obtain file list.", pszOldName);
    1948             : 
    1949           0 :         return CE_Failure;
    1950             :     }
    1951             : 
    1952          10 :     char **papszFileList = GDALGetFileList(hDS);
    1953             : 
    1954          10 :     GDALClose(hDS);
    1955          10 :     hDS = nullptr;
    1956             : 
    1957          10 :     if (CSLCount(papszFileList) == 0)
    1958             :     {
    1959           0 :         CPLError(CE_Failure, CPLE_NotSupported,
    1960             :                  "Unable to determine files associated with %s,\n"
    1961             :                  "rename fails.",
    1962             :                  pszOldName);
    1963             : 
    1964           0 :         return CE_Failure;
    1965             :     }
    1966             : 
    1967             :     /* -------------------------------------------------------------------- */
    1968             :     /*      Produce a list of new filenames that correspond to the old      */
    1969             :     /*      names.                                                          */
    1970             :     /* -------------------------------------------------------------------- */
    1971          10 :     CPLErr eErr = CE_None;
    1972             :     char **papszNewFileList =
    1973          10 :         CPLCorrespondingPaths(pszOldName, pszNewName, papszFileList);
    1974             : 
    1975          10 :     if (papszNewFileList == nullptr)
    1976           0 :         return CE_Failure;
    1977             : 
    1978          28 :     for (int i = 0; papszFileList[i] != nullptr; ++i)
    1979             :     {
    1980          18 :         if (CPLCopyFile(papszNewFileList[i], papszFileList[i]) != 0)
    1981             :         {
    1982           0 :             eErr = CE_Failure;
    1983             :             // Try to put the ones we moved back.
    1984           0 :             for (--i; i >= 0; --i)
    1985           0 :                 VSIUnlink(papszNewFileList[i]);
    1986           0 :             break;
    1987             :         }
    1988             :     }
    1989             : 
    1990          10 :     CSLDestroy(papszNewFileList);
    1991          10 :     CSLDestroy(papszFileList);
    1992             : 
    1993          10 :     return eErr;
    1994             : }
    1995             : 
    1996             : //! @endcond
    1997             : 
    1998             : /************************************************************************/
    1999             : /*                             CopyFiles()                              */
    2000             : /************************************************************************/
    2001             : 
    2002             : /**
    2003             :  * \brief Copy the files of a dataset.
    2004             :  *
    2005             :  * Copy all the files associated with a dataset.
    2006             :  *
    2007             :  * Equivalent of the C function GDALCopyDatasetFiles().
    2008             :  *
    2009             :  * @param pszNewName new name for the dataset.
    2010             :  * @param pszOldName old name for the dataset.
    2011             :  *
    2012             :  * @return CE_None on success, or CE_Failure if the operation fails.
    2013             :  */
    2014             : 
    2015          12 : CPLErr GDALDriver::CopyFiles(const char *pszNewName, const char *pszOldName)
    2016             : 
    2017             : {
    2018          12 :     pfnCopyFiles = GetCopyFilesCallback();
    2019          12 :     if (pfnCopyFiles != nullptr)
    2020           3 :         return pfnCopyFiles(pszNewName, pszOldName);
    2021             : 
    2022           9 :     return DefaultCopyFiles(pszNewName, pszOldName);
    2023             : }
    2024             : 
    2025             : /************************************************************************/
    2026             : /*                        GDALCopyDatasetFiles()                        */
    2027             : /************************************************************************/
    2028             : 
    2029             : /**
    2030             :  * \brief Copy the files of a dataset.
    2031             :  *
    2032             :  * @see GDALDriver::CopyFiles()
    2033             :  */
    2034             : 
    2035          13 : CPLErr CPL_STDCALL GDALCopyDatasetFiles(GDALDriverH hDriver,
    2036             :                                         const char *pszNewName,
    2037             :                                         const char *pszOldName)
    2038             : 
    2039             : {
    2040          13 :     if (hDriver == nullptr)
    2041           8 :         hDriver = GDALIdentifyDriver(pszOldName, nullptr);
    2042             : 
    2043          13 :     if (hDriver == nullptr)
    2044             :     {
    2045           1 :         CPLError(CE_Failure, CPLE_AppDefined, "No identifiable driver for %s.",
    2046             :                  pszOldName);
    2047           1 :         return CE_Failure;
    2048             :     }
    2049             : 
    2050          12 :     return GDALDriver::FromHandle(hDriver)->CopyFiles(pszNewName, pszOldName);
    2051             : }
    2052             : 
    2053             : /************************************************************************/
    2054             : /*                       GDALDriverHasOpenOption()                      */
    2055             : /************************************************************************/
    2056             : 
    2057             : /**
    2058             :  * \brief Returns TRUE if the given open option is supported by the driver.
    2059             :  * @param hDriver the handle of the driver
    2060             :  * @param pszOpenOptionName name of the open option to be checked
    2061             :  * @return TRUE if the driver supports the open option
    2062             :  * @since GDAL 3.11
    2063             :  */
    2064           2 : bool GDALDriverHasOpenOption(GDALDriverH hDriver, const char *pszOpenOptionName)
    2065             : {
    2066           2 :     VALIDATE_POINTER1(hDriver, "GDALDriverHasOpenOption", false);
    2067           2 :     return GDALDriver::FromHandle(hDriver)->HasOpenOption(pszOpenOptionName);
    2068             : }
    2069             : 
    2070             : /************************************************************************/
    2071             : /*                       GDALGetDriverShortName()                       */
    2072             : /************************************************************************/
    2073             : 
    2074             : /**
    2075             :  * \brief Return the short name of a driver
    2076             :  *
    2077             :  * This is the string that can be
    2078             :  * passed to the GDALGetDriverByName() function.
    2079             :  *
    2080             :  * For the GeoTIFF driver, this is "GTiff"
    2081             :  *
    2082             :  * @param hDriver the handle of the driver
    2083             :  * @return the short name of the driver. The
    2084             :  *         returned string should not be freed and is owned by the driver.
    2085             :  */
    2086             : 
    2087     3722540 : const char *CPL_STDCALL GDALGetDriverShortName(GDALDriverH hDriver)
    2088             : 
    2089             : {
    2090     3722540 :     VALIDATE_POINTER1(hDriver, "GDALGetDriverShortName", nullptr);
    2091             : 
    2092     3722540 :     return GDALDriver::FromHandle(hDriver)->GetDescription();
    2093             : }
    2094             : 
    2095             : /************************************************************************/
    2096             : /*                       GDALGetDriverLongName()                        */
    2097             : /************************************************************************/
    2098             : 
    2099             : /**
    2100             :  * \brief Return the long name of a driver
    2101             :  *
    2102             :  * For the GeoTIFF driver, this is "GeoTIFF"
    2103             :  *
    2104             :  * @param hDriver the handle of the driver
    2105             :  * @return the long name of the driver or empty string. The
    2106             :  *         returned string should not be freed and is owned by the driver.
    2107             :  */
    2108             : 
    2109         496 : const char *CPL_STDCALL GDALGetDriverLongName(GDALDriverH hDriver)
    2110             : 
    2111             : {
    2112         496 :     VALIDATE_POINTER1(hDriver, "GDALGetDriverLongName", nullptr);
    2113             : 
    2114             :     const char *pszLongName =
    2115         496 :         GDALDriver::FromHandle(hDriver)->GetMetadataItem(GDAL_DMD_LONGNAME);
    2116             : 
    2117         496 :     if (pszLongName == nullptr)
    2118           0 :         return "";
    2119             : 
    2120         496 :     return pszLongName;
    2121             : }
    2122             : 
    2123             : /************************************************************************/
    2124             : /*                       GDALGetDriverHelpTopic()                       */
    2125             : /************************************************************************/
    2126             : 
    2127             : /**
    2128             :  * \brief Return the URL to the help that describes the driver
    2129             :  *
    2130             :  * That URL is relative to the GDAL documentation directory.
    2131             :  *
    2132             :  * For the GeoTIFF driver, this is "frmt_gtiff.html"
    2133             :  *
    2134             :  * @param hDriver the handle of the driver
    2135             :  * @return the URL to the help that describes the driver or NULL. The
    2136             :  *         returned string should not be freed and is owned by the driver.
    2137             :  */
    2138             : 
    2139           0 : const char *CPL_STDCALL GDALGetDriverHelpTopic(GDALDriverH hDriver)
    2140             : 
    2141             : {
    2142           0 :     VALIDATE_POINTER1(hDriver, "GDALGetDriverHelpTopic", nullptr);
    2143             : 
    2144           0 :     return GDALDriver::FromHandle(hDriver)->GetMetadataItem(GDAL_DMD_HELPTOPIC);
    2145             : }
    2146             : 
    2147             : /************************************************************************/
    2148             : /*                   GDALGetDriverCreationOptionList()                  */
    2149             : /************************************************************************/
    2150             : 
    2151             : /**
    2152             :  * \brief Return the list of creation options of the driver
    2153             :  *
    2154             :  * Return the list of creation options of the driver used by Create() and
    2155             :  * CreateCopy() as an XML string
    2156             :  *
    2157             :  * @param hDriver the handle of the driver
    2158             :  * @return an XML string that describes the list of creation options or
    2159             :  *         empty string. The returned string should not be freed and is
    2160             :  *         owned by the driver.
    2161             :  */
    2162             : 
    2163           0 : const char *CPL_STDCALL GDALGetDriverCreationOptionList(GDALDriverH hDriver)
    2164             : 
    2165             : {
    2166           0 :     VALIDATE_POINTER1(hDriver, "GDALGetDriverCreationOptionList", nullptr);
    2167             : 
    2168             :     const char *pszOptionList =
    2169           0 :         GDALDriver::FromHandle(hDriver)->GetMetadataItem(
    2170           0 :             GDAL_DMD_CREATIONOPTIONLIST);
    2171             : 
    2172           0 :     if (pszOptionList == nullptr)
    2173           0 :         return "";
    2174             : 
    2175           0 :     return pszOptionList;
    2176             : }
    2177             : 
    2178             : /************************************************************************/
    2179             : /*                   GDALValidateCreationOptions()                      */
    2180             : /************************************************************************/
    2181             : 
    2182             : /**
    2183             :  * \brief Validate the list of creation options that are handled by a driver
    2184             :  *
    2185             :  * This is a helper method primarily used by Create() and
    2186             :  * CreateCopy() to validate that the passed in list of creation options
    2187             :  * is compatible with the GDAL_DMD_CREATIONOPTIONLIST metadata item defined
    2188             :  * by some drivers. @see GDALGetDriverCreationOptionList()
    2189             :  *
    2190             :  * If the GDAL_DMD_CREATIONOPTIONLIST metadata item is not defined, this
    2191             :  * function will return TRUE. Otherwise it will check that the keys and values
    2192             :  * in the list of creation options are compatible with the capabilities declared
    2193             :  * by the GDAL_DMD_CREATIONOPTIONLIST metadata item. In case of incompatibility
    2194             :  * a (non fatal) warning will be emitted and FALSE will be returned.
    2195             :  *
    2196             :  * @param hDriver the handle of the driver with whom the lists of creation
    2197             :  * option must be validated
    2198             :  * @param papszCreationOptions the list of creation options. An array of
    2199             :  * strings, whose last element is a NULL pointer
    2200             :  * @return TRUE if the list of creation options is compatible with the Create()
    2201             :  *         and CreateCopy() method of the driver, FALSE otherwise.
    2202             :  */
    2203             : 
    2204       35145 : int CPL_STDCALL GDALValidateCreationOptions(GDALDriverH hDriver,
    2205             :                                             CSLConstList papszCreationOptions)
    2206             : {
    2207       35145 :     VALIDATE_POINTER1(hDriver, "GDALValidateCreationOptions", FALSE);
    2208             :     const char *pszOptionList =
    2209       35145 :         GDALDriver::FromHandle(hDriver)->GetMetadataItem(
    2210       35145 :             GDAL_DMD_CREATIONOPTIONLIST);
    2211       35145 :     CPLString osDriver;
    2212             :     osDriver.Printf("driver %s",
    2213       35145 :                     GDALDriver::FromHandle(hDriver)->GetDescription());
    2214       35145 :     bool bFoundOptionToRemove = false;
    2215       35145 :     constexpr const char *const apszExcludedOptions[] = {
    2216             :         "APPEND_SUBDATASET", "COPY_SRC_MDD", "SRC_MDD", "SKIP_HOLES"};
    2217       51112 :     for (const char *pszCO : cpl::Iterate(papszCreationOptions))
    2218             :     {
    2219       80460 :         for (const char *pszExcludedOptions : apszExcludedOptions)
    2220             :         {
    2221       64493 :             if (STARTS_WITH_CI(pszCO, pszExcludedOptions) &&
    2222         196 :                 pszCO[strlen(pszExcludedOptions)] == '=')
    2223             :             {
    2224         196 :                 bFoundOptionToRemove = true;
    2225         196 :                 break;
    2226             :             }
    2227             :         }
    2228       16163 :         if (bFoundOptionToRemove)
    2229         196 :             break;
    2230             :     }
    2231       35145 :     CSLConstList papszOptionsToValidate = papszCreationOptions;
    2232       35145 :     char **papszOptionsToFree = nullptr;
    2233       35145 :     if (bFoundOptionToRemove)
    2234             :     {
    2235         596 :         for (const char *pszCO : cpl::Iterate(papszCreationOptions))
    2236             :         {
    2237         400 :             bool bMatch = false;
    2238        1625 :             for (const char *pszExcludedOptions : apszExcludedOptions)
    2239             :             {
    2240        1434 :                 if (STARTS_WITH_CI(pszCO, pszExcludedOptions) &&
    2241         209 :                     pszCO[strlen(pszExcludedOptions)] == '=')
    2242             :                 {
    2243         209 :                     bMatch = true;
    2244         209 :                     break;
    2245             :                 }
    2246             :             }
    2247         400 :             if (!bMatch)
    2248         191 :                 papszOptionsToFree = CSLAddString(papszOptionsToFree, pszCO);
    2249             :         }
    2250         196 :         papszOptionsToValidate = papszOptionsToFree;
    2251             :     }
    2252             : 
    2253       35145 :     const bool bRet = CPL_TO_BOOL(GDALValidateOptions(
    2254             :         pszOptionList, papszOptionsToValidate, "creation option", osDriver));
    2255       35145 :     CSLDestroy(papszOptionsToFree);
    2256       35145 :     return bRet;
    2257             : }
    2258             : 
    2259             : /************************************************************************/
    2260             : /*                     GDALValidateOpenOptions()                        */
    2261             : /************************************************************************/
    2262             : 
    2263       57562 : int GDALValidateOpenOptions(GDALDriverH hDriver,
    2264             :                             const char *const *papszOpenOptions)
    2265             : {
    2266       57562 :     VALIDATE_POINTER1(hDriver, "GDALValidateOpenOptions", FALSE);
    2267             :     const char *pszOptionList =
    2268       57562 :         GDALDriver::FromHandle(hDriver)->GetMetadataItem(
    2269       57553 :             GDAL_DMD_OPENOPTIONLIST);
    2270      115043 :     CPLString osDriver;
    2271             :     osDriver.Printf("driver %s",
    2272       57520 :                     GDALDriver::FromHandle(hDriver)->GetDescription());
    2273       57537 :     return GDALValidateOptions(pszOptionList, papszOpenOptions, "open option",
    2274       57494 :                                osDriver);
    2275             : }
    2276             : 
    2277             : /************************************************************************/
    2278             : /*                           GDALValidateOptions()                      */
    2279             : /************************************************************************/
    2280             : 
    2281      106190 : int GDALValidateOptions(const char *pszOptionList,
    2282             :                         const char *const *papszOptionsToValidate,
    2283             :                         const char *pszErrorMessageOptionType,
    2284             :                         const char *pszErrorMessageContainerName)
    2285             : {
    2286      106190 :     if (papszOptionsToValidate == nullptr || *papszOptionsToValidate == nullptr)
    2287       89555 :         return TRUE;
    2288       16635 :     if (pszOptionList == nullptr)
    2289         178 :         return TRUE;
    2290             : 
    2291       16457 :     CPLXMLNode *psNode = CPLParseXMLString(pszOptionList);
    2292       16457 :     if (psNode == nullptr)
    2293             :     {
    2294           0 :         CPLError(CE_Warning, CPLE_AppDefined,
    2295             :                  "Could not parse %s list of %s. Assuming options are valid.",
    2296             :                  pszErrorMessageOptionType, pszErrorMessageContainerName);
    2297           0 :         return TRUE;
    2298             :     }
    2299             : 
    2300       16457 :     bool bRet = true;
    2301       44556 :     while (*papszOptionsToValidate)
    2302             :     {
    2303       28099 :         char *pszKey = nullptr;
    2304             :         const char *pszValue =
    2305       28099 :             CPLParseNameValue(*papszOptionsToValidate, &pszKey);
    2306       28099 :         if (pszKey == nullptr)
    2307             :         {
    2308           1 :             CPLError(CE_Warning, CPLE_NotSupported,
    2309             :                      "%s '%s' is not formatted with the key=value format",
    2310             :                      pszErrorMessageOptionType, *papszOptionsToValidate);
    2311           1 :             bRet = false;
    2312             : 
    2313           1 :             ++papszOptionsToValidate;
    2314        2132 :             continue;
    2315             :         }
    2316             : 
    2317       28098 :         if (EQUAL(pszKey, "VALIDATE_OPEN_OPTIONS"))
    2318             :         {
    2319           0 :             ++papszOptionsToValidate;
    2320           0 :             CPLFree(pszKey);
    2321           0 :             continue;
    2322             :         }
    2323             : 
    2324             :         // Must we be forgiving in case of missing option ?
    2325       28098 :         bool bWarnIfMissingKey = true;
    2326       28098 :         if (pszKey[0] == '@')
    2327             :         {
    2328        2116 :             bWarnIfMissingKey = false;
    2329        2116 :             memmove(pszKey, pszKey + 1, strlen(pszKey + 1) + 1);
    2330             :         }
    2331             : 
    2332       28098 :         CPLXMLNode *psChildNode = psNode->psChild;
    2333      275574 :         while (psChildNode)
    2334             :         {
    2335      273443 :             if (EQUAL(psChildNode->pszValue, "OPTION"))
    2336             :             {
    2337             :                 const char *pszOptionName =
    2338      273443 :                     CPLGetXMLValue(psChildNode, "name", "");
    2339             :                 /* For option names terminated by wildcard (NITF BLOCKA option
    2340             :                  * names for example) */
    2341      273443 :                 if (strlen(pszOptionName) > 0 &&
    2342      273443 :                     pszOptionName[strlen(pszOptionName) - 1] == '*' &&
    2343         378 :                     EQUALN(pszOptionName, pszKey, strlen(pszOptionName) - 1))
    2344             :                 {
    2345         216 :                     break;
    2346             :                 }
    2347             : 
    2348             :                 /* For option names beginning by a wildcard */
    2349      273227 :                 if (pszOptionName[0] == '*' &&
    2350          57 :                     strlen(pszKey) > strlen(pszOptionName) &&
    2351           9 :                     EQUAL(pszKey + strlen(pszKey) - strlen(pszOptionName + 1),
    2352             :                           pszOptionName + 1))
    2353             :                 {
    2354           2 :                     break;
    2355             :                 }
    2356             : 
    2357             :                 // For options names with * in the middle
    2358      273225 :                 const char *pszStarInOptionName = strchr(pszOptionName, '*');
    2359      273225 :                 if (pszStarInOptionName &&
    2360         183 :                     pszStarInOptionName != pszOptionName &&
    2361             :                     pszStarInOptionName !=
    2362         183 :                         pszOptionName + strlen(pszOptionName) - 1 &&
    2363          21 :                     strlen(pszKey) > static_cast<size_t>(pszStarInOptionName -
    2364          12 :                                                          pszOptionName) &&
    2365          12 :                     EQUALN(pszKey, pszOptionName,
    2366             :                            static_cast<size_t>(pszStarInOptionName -
    2367          12 :                                                pszOptionName)) &&
    2368          12 :                     EQUAL(pszKey +
    2369             :                               static_cast<size_t>(pszStarInOptionName -
    2370             :                                                   pszOptionName) +
    2371             :                               1,
    2372             :                           pszStarInOptionName + 1))
    2373             :                 {
    2374           6 :                     break;
    2375             :                 }
    2376             : 
    2377      273219 :                 if (EQUAL(pszOptionName, pszKey))
    2378             :                 {
    2379       25695 :                     break;
    2380             :                 }
    2381      247524 :                 const char *pszAlias = CPLGetXMLValue(
    2382             :                     psChildNode, "alias",
    2383             :                     CPLGetXMLValue(psChildNode, "deprecated_alias", ""));
    2384      247524 :                 if (EQUAL(pszAlias, pszKey))
    2385             :                 {
    2386          48 :                     CPLDebug("GDAL",
    2387             :                              "Using deprecated alias '%s'. New name is '%s'",
    2388             :                              pszAlias, pszOptionName);
    2389          48 :                     break;
    2390             :                 }
    2391             :             }
    2392      247476 :             psChildNode = psChildNode->psNext;
    2393             :         }
    2394       28098 :         if (psChildNode == nullptr)
    2395             :         {
    2396        2153 :             if (bWarnIfMissingKey &&
    2397          22 :                 (!EQUAL(pszErrorMessageOptionType, "open option") ||
    2398           0 :                  CPLFetchBool(papszOptionsToValidate, "VALIDATE_OPEN_OPTIONS",
    2399             :                               true)))
    2400             :             {
    2401          22 :                 CPLError(CE_Warning, CPLE_NotSupported,
    2402             :                          "%s does not support %s %s",
    2403             :                          pszErrorMessageContainerName,
    2404             :                          pszErrorMessageOptionType, pszKey);
    2405          22 :                 bRet = false;
    2406             :             }
    2407             : 
    2408        2131 :             CPLFree(pszKey);
    2409        2131 :             ++papszOptionsToValidate;
    2410        2131 :             continue;
    2411             :         }
    2412             : 
    2413             : #ifdef DEBUG
    2414       25967 :         CPLXMLNode *psChildSubNode = psChildNode->psChild;
    2415      154324 :         while (psChildSubNode)
    2416             :         {
    2417      128357 :             if (psChildSubNode->eType == CXT_Attribute)
    2418             :             {
    2419       90094 :                 if (!(EQUAL(psChildSubNode->pszValue, "name") ||
    2420       64127 :                       EQUAL(psChildSubNode->pszValue, "alias") ||
    2421       64004 :                       EQUAL(psChildSubNode->pszValue, "deprecated_alias") ||
    2422       63921 :                       EQUAL(psChildSubNode->pszValue, "alt_config_option") ||
    2423       63904 :                       EQUAL(psChildSubNode->pszValue, "description") ||
    2424       42127 :                       EQUAL(psChildSubNode->pszValue, "type") ||
    2425       16160 :                       EQUAL(psChildSubNode->pszValue, "min") ||
    2426       15871 :                       EQUAL(psChildSubNode->pszValue, "max") ||
    2427       15514 :                       EQUAL(psChildSubNode->pszValue, "default") ||
    2428        1020 :                       EQUAL(psChildSubNode->pszValue, "maxsize") ||
    2429         995 :                       EQUAL(psChildSubNode->pszValue, "required") ||
    2430         940 :                       EQUAL(psChildSubNode->pszValue, "scope")))
    2431             :                 {
    2432             :                     /* Driver error */
    2433           0 :                     CPLError(CE_Warning, CPLE_NotSupported,
    2434             :                              "%s : unhandled attribute '%s' for %s %s.",
    2435             :                              pszErrorMessageContainerName,
    2436             :                              psChildSubNode->pszValue, pszKey,
    2437             :                              pszErrorMessageOptionType);
    2438             :                 }
    2439             :             }
    2440      128357 :             psChildSubNode = psChildSubNode->psNext;
    2441             :         }
    2442             : #endif
    2443             : 
    2444       25967 :         const char *pszType = CPLGetXMLValue(psChildNode, "type", nullptr);
    2445       25967 :         const char *pszMin = CPLGetXMLValue(psChildNode, "min", nullptr);
    2446       25967 :         const char *pszMax = CPLGetXMLValue(psChildNode, "max", nullptr);
    2447       25967 :         if (pszType != nullptr)
    2448             :         {
    2449       25967 :             if (EQUAL(pszType, "INT") || EQUAL(pszType, "INTEGER"))
    2450             :             {
    2451        8632 :                 const char *pszValueIter = pszValue;
    2452       22076 :                 while (*pszValueIter)
    2453             :                 {
    2454       13446 :                     if (!((*pszValueIter >= '0' && *pszValueIter <= '9') ||
    2455          20 :                           *pszValueIter == '+' || *pszValueIter == '-'))
    2456             :                     {
    2457           2 :                         CPLError(CE_Warning, CPLE_NotSupported,
    2458             :                                  "'%s' is an unexpected value for %s %s of "
    2459             :                                  "type int.",
    2460             :                                  pszValue, pszKey, pszErrorMessageOptionType);
    2461           2 :                         bRet = false;
    2462           2 :                         break;
    2463             :                     }
    2464       13444 :                     ++pszValueIter;
    2465             :                 }
    2466        8632 :                 if (*pszValueIter == '\0')
    2467             :                 {
    2468        8630 :                     if (pszMin && atoi(pszValue) < atoi(pszMin))
    2469             :                     {
    2470          10 :                         CPLError(CE_Warning, CPLE_NotSupported,
    2471             :                                  "'%s' is an unexpected value for %s %s that "
    2472             :                                  "should be >= %s.",
    2473             :                                  pszValue, pszKey, pszErrorMessageOptionType,
    2474             :                                  pszMin);
    2475          10 :                         bRet = false;
    2476             :                     }
    2477        8630 :                     if (pszMax && atoi(pszValue) > atoi(pszMax))
    2478             :                     {
    2479          12 :                         CPLError(CE_Warning, CPLE_NotSupported,
    2480             :                                  "'%s' is an unexpected value for %s %s that "
    2481             :                                  "should be <= %s.",
    2482             :                                  pszValue, pszKey, pszErrorMessageOptionType,
    2483             :                                  pszMax);
    2484          12 :                         bRet = false;
    2485             :                     }
    2486        8632 :                 }
    2487             :             }
    2488       17335 :             else if (EQUAL(pszType, "UNSIGNED INT"))
    2489             :             {
    2490           3 :                 const char *pszValueIter = pszValue;
    2491          10 :                 while (*pszValueIter)
    2492             :                 {
    2493           7 :                     if (!((*pszValueIter >= '0' && *pszValueIter <= '9') ||
    2494           0 :                           *pszValueIter == '+'))
    2495             :                     {
    2496           0 :                         CPLError(CE_Warning, CPLE_NotSupported,
    2497             :                                  "'%s' is an unexpected value for %s %s of "
    2498             :                                  "type unsigned int.",
    2499             :                                  pszValue, pszKey, pszErrorMessageOptionType);
    2500           0 :                         bRet = false;
    2501           0 :                         break;
    2502             :                     }
    2503           7 :                     ++pszValueIter;
    2504             :                 }
    2505           3 :                 if (*pszValueIter == '\0')
    2506             :                 {
    2507           3 :                     if (pszMin && atoi(pszValue) < atoi(pszMin))
    2508             :                     {
    2509           0 :                         CPLError(CE_Warning, CPLE_NotSupported,
    2510             :                                  "'%s' is an unexpected value for %s %s that "
    2511             :                                  "should be >= %s.",
    2512             :                                  pszValue, pszKey, pszErrorMessageOptionType,
    2513             :                                  pszMin);
    2514           0 :                         bRet = false;
    2515             :                     }
    2516           3 :                     if (pszMax && atoi(pszValue) > atoi(pszMax))
    2517             :                     {
    2518           0 :                         CPLError(CE_Warning, CPLE_NotSupported,
    2519             :                                  "'%s' is an unexpected value for %s %s that "
    2520             :                                  "should be <= %s.",
    2521             :                                  pszValue, pszKey, pszErrorMessageOptionType,
    2522             :                                  pszMax);
    2523           0 :                         bRet = false;
    2524             :                     }
    2525             :                 }
    2526             :             }
    2527       17332 :             else if (EQUAL(pszType, "FLOAT"))
    2528             :             {
    2529         691 :                 char *endPtr = nullptr;
    2530         691 :                 double dfVal = CPLStrtod(pszValue, &endPtr);
    2531         691 :                 if (!(endPtr == nullptr || *endPtr == '\0'))
    2532             :                 {
    2533           0 :                     CPLError(
    2534             :                         CE_Warning, CPLE_NotSupported,
    2535             :                         "'%s' is an unexpected value for %s %s of type float.",
    2536             :                         pszValue, pszKey, pszErrorMessageOptionType);
    2537           0 :                     bRet = false;
    2538             :                 }
    2539             :                 else
    2540             :                 {
    2541         691 :                     if (pszMin && dfVal < CPLAtof(pszMin))
    2542             :                     {
    2543           2 :                         CPLError(CE_Warning, CPLE_NotSupported,
    2544             :                                  "'%s' is an unexpected value for %s %s that "
    2545             :                                  "should be >= %s.",
    2546             :                                  pszValue, pszKey, pszErrorMessageOptionType,
    2547             :                                  pszMin);
    2548           2 :                         bRet = false;
    2549             :                     }
    2550         691 :                     if (pszMax && dfVal > CPLAtof(pszMax))
    2551             :                     {
    2552           0 :                         CPLError(CE_Warning, CPLE_NotSupported,
    2553             :                                  "'%s' is an unexpected value for %s %s that "
    2554             :                                  "should be <= %s.",
    2555             :                                  pszValue, pszKey, pszErrorMessageOptionType,
    2556             :                                  pszMax);
    2557           0 :                         bRet = false;
    2558             :                     }
    2559             :                 }
    2560             :             }
    2561       16641 :             else if (EQUAL(pszType, "BOOLEAN"))
    2562             :             {
    2563        3753 :                 if (!(EQUAL(pszValue, "ON") || EQUAL(pszValue, "TRUE") ||
    2564        3696 :                       EQUAL(pszValue, "YES") || EQUAL(pszValue, "OFF") ||
    2565         428 :                       EQUAL(pszValue, "FALSE") || EQUAL(pszValue, "NO")))
    2566             :                 {
    2567           0 :                     CPLError(CE_Warning, CPLE_NotSupported,
    2568             :                              "'%s' is an unexpected value for %s %s of type "
    2569             :                              "boolean.",
    2570             :                              pszValue, pszKey, pszErrorMessageOptionType);
    2571           0 :                     bRet = false;
    2572             :                 }
    2573             :             }
    2574       12888 :             else if (EQUAL(pszType, "STRING-SELECT"))
    2575             :             {
    2576        6646 :                 bool bMatchFound = false;
    2577        6646 :                 CPLXMLNode *psStringSelect = psChildNode->psChild;
    2578       41200 :                 while (psStringSelect)
    2579             :                 {
    2580       41163 :                     if (psStringSelect->eType == CXT_Element &&
    2581       20084 :                         EQUAL(psStringSelect->pszValue, "Value"))
    2582             :                     {
    2583       20084 :                         CPLXMLNode *psOptionNode = psStringSelect->psChild;
    2584       33861 :                         while (psOptionNode)
    2585             :                         {
    2586       20386 :                             if (psOptionNode->eType == CXT_Text &&
    2587       20074 :                                 EQUAL(psOptionNode->pszValue, pszValue))
    2588             :                             {
    2589        6599 :                                 bMatchFound = true;
    2590        6599 :                                 break;
    2591             :                             }
    2592       13787 :                             if (psOptionNode->eType == CXT_Attribute &&
    2593         312 :                                 (EQUAL(psOptionNode->pszValue, "alias") ||
    2594          15 :                                  EQUAL(psOptionNode->pszValue,
    2595         297 :                                        "deprecated_alias")) &&
    2596         297 :                                 EQUAL(psOptionNode->psChild->pszValue,
    2597             :                                       pszValue))
    2598             :                             {
    2599          10 :                                 bMatchFound = true;
    2600          10 :                                 break;
    2601             :                             }
    2602       13777 :                             psOptionNode = psOptionNode->psNext;
    2603             :                         }
    2604       20084 :                         if (bMatchFound)
    2605        6609 :                             break;
    2606             :                     }
    2607       34554 :                     psStringSelect = psStringSelect->psNext;
    2608             :                 }
    2609        6646 :                 if (!bMatchFound)
    2610             :                 {
    2611          37 :                     CPLError(CE_Warning, CPLE_NotSupported,
    2612             :                              "'%s' is an unexpected value for %s %s of type "
    2613             :                              "string-select.",
    2614             :                              pszValue, pszKey, pszErrorMessageOptionType);
    2615          37 :                     bRet = false;
    2616             :                 }
    2617             :             }
    2618        6242 :             else if (EQUAL(pszType, "STRING"))
    2619             :             {
    2620             :                 const char *pszMaxSize =
    2621        6242 :                     CPLGetXMLValue(psChildNode, "maxsize", nullptr);
    2622        6242 :                 if (pszMaxSize != nullptr)
    2623             :                 {
    2624          25 :                     if (static_cast<int>(strlen(pszValue)) > atoi(pszMaxSize))
    2625             :                     {
    2626           1 :                         CPLError(CE_Warning, CPLE_NotSupported,
    2627             :                                  "'%s' is of size %d, whereas maximum size for "
    2628             :                                  "%s %s is %d.",
    2629           1 :                                  pszValue, static_cast<int>(strlen(pszValue)),
    2630             :                                  pszKey, pszErrorMessageOptionType,
    2631             :                                  atoi(pszMaxSize));
    2632           1 :                         bRet = false;
    2633             :                     }
    2634             :                 }
    2635             :             }
    2636             :             else
    2637             :             {
    2638             :                 /* Driver error */
    2639           0 :                 CPLError(CE_Warning, CPLE_NotSupported,
    2640             :                          "%s : type '%s' for %s %s is not recognized.",
    2641             :                          pszErrorMessageContainerName, pszType, pszKey,
    2642             :                          pszErrorMessageOptionType);
    2643             :             }
    2644             :         }
    2645             :         else
    2646             :         {
    2647             :             /* Driver error */
    2648           0 :             CPLError(CE_Warning, CPLE_NotSupported, "%s : no type for %s %s.",
    2649             :                      pszErrorMessageContainerName, pszKey,
    2650             :                      pszErrorMessageOptionType);
    2651             :         }
    2652       25967 :         CPLFree(pszKey);
    2653       25967 :         ++papszOptionsToValidate;
    2654             :     }
    2655             : 
    2656       16457 :     CPLDestroyXMLNode(psNode);
    2657       16457 :     return bRet ? TRUE : FALSE;
    2658             : }
    2659             : 
    2660             : /************************************************************************/
    2661             : /*                         GDALIdentifyDriver()                         */
    2662             : /************************************************************************/
    2663             : 
    2664             : /**
    2665             :  * \brief Identify the driver that can open a dataset.
    2666             :  *
    2667             :  * This function will try to identify the driver that can open the passed file
    2668             :  * name by invoking the Identify method of each registered GDALDriver in turn.
    2669             :  * The first driver that successfully identifies the file name will be returned.
    2670             :  * If all drivers fail then NULL is returned.
    2671             :  *
    2672             :  * In order to reduce the need for such searches to touch the operating system
    2673             :  * file system machinery, it is possible to give an optional list of files.
    2674             :  * This is the list of all files at the same level in the file system as the
    2675             :  * target file, including the target file. The filenames will not include any
    2676             :  * path components, and are essentially just the output of VSIReadDir() on the
    2677             :  * parent directory. If the target object does not have filesystem semantics
    2678             :  * then the file list should be NULL.
    2679             :  *
    2680             :  * @param pszFilename the name of the file to access.  In the case of
    2681             :  * exotic drivers this may not refer to a physical file, but instead contain
    2682             :  * information for the driver on how to access a dataset.
    2683             :  *
    2684             :  * @param papszFileList an array of strings, whose last element is the NULL
    2685             :  * pointer.  These strings are filenames that are auxiliary to the main
    2686             :  * filename. The passed value may be NULL.
    2687             :  *
    2688             :  * @return A GDALDriverH handle or NULL on failure.  For C++ applications
    2689             :  * this handle can be cast to a GDALDriver *.
    2690             :  */
    2691             : 
    2692       25511 : GDALDriverH CPL_STDCALL GDALIdentifyDriver(const char *pszFilename,
    2693             :                                            CSLConstList papszFileList)
    2694             : 
    2695             : {
    2696       25511 :     return GDALIdentifyDriverEx(pszFilename, 0, nullptr, papszFileList);
    2697             : }
    2698             : 
    2699             : /************************************************************************/
    2700             : /*                         GDALIdentifyDriverEx()                       */
    2701             : /************************************************************************/
    2702             : 
    2703             : /**
    2704             :  * \brief Identify the driver that can open a dataset.
    2705             :  *
    2706             :  * This function will try to identify the driver that can open the passed file
    2707             :  * name by invoking the Identify method of each registered GDALDriver in turn.
    2708             :  * The first driver that successfully identifies the file name will be returned.
    2709             :  * If all drivers fail then NULL is returned.
    2710             :  *
    2711             :  * In order to reduce the need for such searches to touch the operating system
    2712             :  * file system machinery, it is possible to give an optional list of files.
    2713             :  * This is the list of all files at the same level in the file system as the
    2714             :  * target file, including the target file. The filenames will not include any
    2715             :  * path components, and are essentially just the output of VSIReadDir() on the
    2716             :  * parent directory. If the target object does not have filesystem semantics
    2717             :  * then the file list should be NULL.
    2718             :  *
    2719             :  * @param pszFilename the name of the file to access.  In the case of
    2720             :  * exotic drivers this may not refer to a physical file, but instead contain
    2721             :  * information for the driver on how to access a dataset.
    2722             :  *
    2723             :  * @param nIdentifyFlags a combination of GDAL_OF_RASTER for raster drivers
    2724             :  * or GDAL_OF_VECTOR for vector drivers. If none of the value is specified,
    2725             :  * both kinds are implied.
    2726             :  *
    2727             :  * @param papszAllowedDrivers NULL to consider all candidate drivers, or a NULL
    2728             :  * terminated list of strings with the driver short names that must be
    2729             :  * considered.
    2730             :  *
    2731             :  * @param papszFileList an array of strings, whose last element is the NULL
    2732             :  * pointer.  These strings are filenames that are auxiliary to the main
    2733             :  * filename. The passed value may be NULL.
    2734             :  *
    2735             :  * @return A GDALDriverH handle or NULL on failure.  For C++ applications
    2736             :  * this handle can be cast to a GDALDriver *.
    2737             :  */
    2738             : 
    2739       25601 : GDALDriverH CPL_STDCALL GDALIdentifyDriverEx(
    2740             :     const char *pszFilename, unsigned int nIdentifyFlags,
    2741             :     const char *const *papszAllowedDrivers, const char *const *papszFileList)
    2742             : {
    2743       25601 :     GDALDriverManager *poDM = GetGDALDriverManager();
    2744       25601 :     CPLAssert(nullptr != poDM);
    2745             : 
    2746             :     // If no driver kind is specified, assume all are to be probed.
    2747       25601 :     if ((nIdentifyFlags & GDAL_OF_KIND_MASK) == 0)
    2748       25558 :         nIdentifyFlags |= GDAL_OF_KIND_MASK & ~GDAL_OF_MULTIDIM_RASTER;
    2749             : 
    2750       51202 :     GDALOpenInfo oOpenInfo(pszFilename, nIdentifyFlags, papszFileList);
    2751       25601 :     oOpenInfo.papszAllowedDrivers = papszAllowedDrivers;
    2752             : 
    2753       51202 :     CPLErrorStateBackuper oBackuper;
    2754       25601 :     CPLErrorSetState(CE_None, CPLE_AppDefined, "");
    2755             : 
    2756       25601 :     const int nDriverCount = poDM->GetDriverCount();
    2757             : 
    2758             :     // First pass: only use drivers that have a pfnIdentify implementation.
    2759       51202 :     std::vector<GDALDriver *> apoSecondPassDrivers;
    2760     5566680 :     for (int iDriver = 0; iDriver < nDriverCount; ++iDriver)
    2761             :     {
    2762     5542320 :         GDALDriver *poDriver = poDM->GetDriver(iDriver);
    2763     5549620 :         if (papszAllowedDrivers != nullptr &&
    2764        7303 :             CSLFindString(papszAllowedDrivers,
    2765             :                           GDALGetDriverShortName(poDriver)) == -1)
    2766             :         {
    2767     1046740 :             continue;
    2768             :         }
    2769             : 
    2770     5536300 :         VALIDATE_POINTER1(poDriver, "GDALIdentifyDriver", nullptr);
    2771             : 
    2772     5535060 :         if (poDriver->pfnIdentify == nullptr &&
    2773     1035680 :             poDriver->pfnIdentifyEx == nullptr)
    2774             :         {
    2775     1035680 :             continue;
    2776             :         }
    2777             : 
    2778     4499420 :         if (papszAllowedDrivers != nullptr &&
    2779          44 :             CSLFindString(papszAllowedDrivers,
    2780             :                           GDALGetDriverShortName(poDriver)) == -1)
    2781           0 :             continue;
    2782    13493400 :         if ((nIdentifyFlags & GDAL_OF_RASTER) != 0 &&
    2783     4499880 :             (nIdentifyFlags & GDAL_OF_VECTOR) == 0 &&
    2784         505 :             poDriver->GetMetadataItem(GDAL_DCAP_RASTER) == nullptr)
    2785         141 :             continue;
    2786    13501000 :         if ((nIdentifyFlags & GDAL_OF_VECTOR) != 0 &&
    2787     4504110 :             (nIdentifyFlags & GDAL_OF_RASTER) == 0 &&
    2788        4876 :             poDriver->GetMetadataItem(GDAL_DCAP_VECTOR) == nullptr)
    2789        3657 :             continue;
    2790             : 
    2791     4495580 :         if (poDriver->pfnIdentifyEx)
    2792             :         {
    2793           0 :             if (poDriver->pfnIdentifyEx(poDriver, &oOpenInfo) > 0)
    2794           0 :                 return poDriver;
    2795             :         }
    2796             :         else
    2797             :         {
    2798     4495580 :             const int nIdentifyRes = poDriver->pfnIdentify(&oOpenInfo);
    2799     4495580 :             if (nIdentifyRes > 0)
    2800        1244 :                 return poDriver;
    2801     4519710 :             if (nIdentifyRes < 0 &&
    2802       25374 :                 poDriver->GetMetadataItem("IS_NON_LOADED_PLUGIN"))
    2803             :             {
    2804             :                 // Not loaded plugin
    2805          36 :                 apoSecondPassDrivers.push_back(poDriver);
    2806             :             }
    2807             :         }
    2808             :     }
    2809             : 
    2810             :     // second pass: try loading plugin drivers
    2811       24390 :     for (auto poDriver : apoSecondPassDrivers)
    2812             :     {
    2813             :         // Force plugin driver loading
    2814          34 :         poDriver->GetMetadata();
    2815          34 :         if (poDriver->pfnIdentify(&oOpenInfo) > 0)
    2816           1 :             return poDriver;
    2817             :     }
    2818             : 
    2819             :     // third pass: slow method.
    2820     5465930 :     for (int iDriver = 0; iDriver < nDriverCount; ++iDriver)
    2821             :     {
    2822     5441660 :         GDALDriver *poDriver = poDM->GetDriver(iDriver);
    2823     5445470 :         if (papszAllowedDrivers != nullptr &&
    2824        3807 :             CSLFindString(papszAllowedDrivers,
    2825             :                           GDALGetDriverShortName(poDriver)) == -1)
    2826             :         {
    2827        3790 :             continue;
    2828             :         }
    2829             : 
    2830     5437870 :         VALIDATE_POINTER1(poDriver, "GDALIdentifyDriver", nullptr);
    2831             : 
    2832    16312200 :         if ((nIdentifyFlags & GDAL_OF_RASTER) != 0 &&
    2833     5438320 :             (nIdentifyFlags & GDAL_OF_VECTOR) == 0 &&
    2834         446 :             poDriver->GetMetadataItem(GDAL_DCAP_RASTER) == nullptr)
    2835         137 :             continue;
    2836    16313800 :         if ((nIdentifyFlags & GDAL_OF_VECTOR) != 0 &&
    2837     5439300 :             (nIdentifyFlags & GDAL_OF_RASTER) == 0 &&
    2838        1563 :             poDriver->GetMetadataItem(GDAL_DCAP_VECTOR) == nullptr)
    2839         946 :             continue;
    2840             : 
    2841     5436790 :         if (poDriver->pfnIdentifyEx != nullptr)
    2842             :         {
    2843           0 :             if (poDriver->pfnIdentifyEx(poDriver, &oOpenInfo) == 0)
    2844           0 :                 continue;
    2845             :         }
    2846     5436790 :         else if (poDriver->pfnIdentify != nullptr)
    2847             :         {
    2848     4418910 :             if (poDriver->pfnIdentify(&oOpenInfo) == 0)
    2849     4394010 :                 continue;
    2850             :         }
    2851             : 
    2852             :         GDALDataset *poDS;
    2853     1042780 :         if (poDriver->pfnOpen != nullptr)
    2854             :         {
    2855      994189 :             poDS = poDriver->pfnOpen(&oOpenInfo);
    2856      994189 :             if (poDS != nullptr)
    2857             :             {
    2858          91 :                 delete poDS;
    2859          91 :                 return GDALDriver::ToHandle(poDriver);
    2860             :             }
    2861             : 
    2862      994098 :             if (CPLGetLastErrorType() != CE_None)
    2863           0 :                 return nullptr;
    2864             :         }
    2865       48595 :         else if (poDriver->pfnOpenWithDriverArg != nullptr)
    2866             :         {
    2867           0 :             poDS = poDriver->pfnOpenWithDriverArg(poDriver, &oOpenInfo);
    2868           0 :             if (poDS != nullptr)
    2869             :             {
    2870           0 :                 delete poDS;
    2871           0 :                 return GDALDriver::ToHandle(poDriver);
    2872             :             }
    2873             : 
    2874           0 :             if (CPLGetLastErrorType() != CE_None)
    2875           0 :                 return nullptr;
    2876             :         }
    2877             :     }
    2878             : 
    2879       24265 :     return nullptr;
    2880             : }
    2881             : 
    2882             : /************************************************************************/
    2883             : /*                          GetMetadataItem()                           */
    2884             : /************************************************************************/
    2885             : 
    2886    12027900 : const char *GDALDriver::GetMetadataItem(const char *pszName,
    2887             :                                         const char *pszDomain)
    2888             : {
    2889    12027900 :     if (pszDomain == nullptr || pszDomain[0] == '\0')
    2890             :     {
    2891    12021500 :         if (EQUAL(pszName, GDAL_DMD_OVERVIEW_CREATIONOPTIONLIST))
    2892             :         {
    2893        2168 :             const char *pszVal = GDALMajorObject::GetMetadataItem(pszName, "");
    2894        2168 :             if (pszVal)
    2895        1947 :                 return pszVal;
    2896         221 :             if (GetMetadataItem(GDAL_DCAP_RASTER))
    2897             :             {
    2898         152 :                 auto poDM = GetGDALDriverManager();
    2899         152 :                 auto poGTiffDrv = poDM->GetDriverByName("GTiff");
    2900         152 :                 if (poGTiffDrv)
    2901             :                 {
    2902             :                     const char *pszXML =
    2903         152 :                         poGTiffDrv->GetMetadataItem(pszName, "");
    2904         152 :                     if (pszXML)
    2905             :                     {
    2906         304 :                         CPLString osXML(pszXML);
    2907         152 :                         osXML.replaceAll("<Value>INTERNAL</Value>", "");
    2908         152 :                         return CPLSPrintf("%s", osXML.c_str());
    2909             :                     }
    2910             :                 }
    2911             :             }
    2912             :         }
    2913             :     }
    2914    12025800 :     return GDALMajorObject::GetMetadataItem(pszName, pszDomain);
    2915             : }
    2916             : 
    2917             : /************************************************************************/
    2918             : /*                          SetMetadataItem()                           */
    2919             : /************************************************************************/
    2920             : 
    2921     4431320 : CPLErr GDALDriver::SetMetadataItem(const char *pszName, const char *pszValue,
    2922             :                                    const char *pszDomain)
    2923             : 
    2924             : {
    2925     4431320 :     if (pszDomain == nullptr || pszDomain[0] == '\0')
    2926             :     {
    2927             :         /* Automatically sets GDAL_DMD_EXTENSIONS from GDAL_DMD_EXTENSION */
    2928     4623300 :         if (EQUAL(pszName, GDAL_DMD_EXTENSION) &&
    2929      197263 :             GDALMajorObject::GetMetadataItem(GDAL_DMD_EXTENSIONS) == nullptr)
    2930             :         {
    2931      197263 :             GDALMajorObject::SetMetadataItem(GDAL_DMD_EXTENSIONS, pszValue);
    2932             :         }
    2933             :         /* and vice-versa if there is a single extension in GDAL_DMD_EXTENSIONS */
    2934     8535540 :         else if (EQUAL(pszName, GDAL_DMD_EXTENSIONS) &&
    2935     4235800 :                  strchr(pszValue, ' ') == nullptr &&
    2936        7032 :                  GDALMajorObject::GetMetadataItem(GDAL_DMD_EXTENSION) ==
    2937             :                      nullptr)
    2938             :         {
    2939        7032 :             GDALMajorObject::SetMetadataItem(GDAL_DMD_EXTENSION, pszValue);
    2940             :         }
    2941             :     }
    2942     4431320 :     return GDALMajorObject::SetMetadataItem(pszName, pszValue, pszDomain);
    2943             : }
    2944             : 
    2945             : /************************************************************************/
    2946             : /*                         InstantiateAlgorithm()                       */
    2947             : /************************************************************************/
    2948             : 
    2949             : //! @cond Doxygen_Suppress
    2950             : 
    2951             : GDALAlgorithm *
    2952          56 : GDALDriver::InstantiateAlgorithm(const std::vector<std::string> &aosPath)
    2953             : {
    2954          56 :     pfnInstantiateAlgorithm = GetInstantiateAlgorithmCallback();
    2955          56 :     if (pfnInstantiateAlgorithm)
    2956          56 :         return pfnInstantiateAlgorithm(aosPath);
    2957           0 :     return nullptr;
    2958             : }
    2959             : 
    2960             : /************************************************************************/
    2961             : /*                        DeclareAlgorithm()                            */
    2962             : /************************************************************************/
    2963             : 
    2964        7036 : void GDALDriver::DeclareAlgorithm(const std::vector<std::string> &aosPath)
    2965             : {
    2966       14072 :     const std::string osDriverName = GetDescription();
    2967        7036 :     auto &singleton = GDALGlobalAlgorithmRegistry::GetSingleton();
    2968             : 
    2969       14072 :     if (!singleton.HasDeclaredSubAlgorithm({"driver"}))
    2970             :     {
    2971        3110 :         singleton.DeclareAlgorithm(
    2972             :             {"driver"},
    2973          41 :             []() -> std::unique_ptr<GDALAlgorithm>
    2974             :             {
    2975          82 :                 return std::make_unique<GDALContainerAlgorithm>(
    2976          41 :                     "driver", "Command for driver specific operations.");
    2977        1555 :             });
    2978             :     }
    2979             : 
    2980             :     std::vector<std::string> path = {"driver",
    2981       42216 :                                      CPLString(osDriverName).tolower()};
    2982        7036 :     if (!singleton.HasDeclaredSubAlgorithm(path))
    2983             :     {
    2984         137 :         auto lambda = [osDriverName]() -> std::unique_ptr<GDALAlgorithm>
    2985             :         {
    2986             :             auto poDriver =
    2987         137 :                 GetGDALDriverManager()->GetDriverByName(osDriverName.c_str());
    2988         137 :             if (poDriver)
    2989             :             {
    2990             :                 const char *pszHelpTopic =
    2991         137 :                     poDriver->GetMetadataItem(GDAL_DMD_HELPTOPIC);
    2992         274 :                 return std::make_unique<GDALContainerAlgorithm>(
    2993         274 :                     CPLString(osDriverName).tolower(),
    2994         274 :                     std::string("Command for ")
    2995         137 :                         .append(osDriverName)
    2996             :                         .append(" driver specific operations."),
    2997         274 :                     pszHelpTopic ? std::string("/").append(pszHelpTopic)
    2998         137 :                                  : std::string());
    2999             :             }
    3000           0 :             return nullptr;
    3001        6220 :         };
    3002        6220 :         singleton.DeclareAlgorithm(path, std::move(lambda));
    3003             :     }
    3004             : 
    3005        7036 :     path.insert(path.end(), aosPath.begin(), aosPath.end());
    3006             : 
    3007          56 :     auto lambda = [osDriverName, aosPath]() -> std::unique_ptr<GDALAlgorithm>
    3008             :     {
    3009             :         auto poDriver =
    3010          56 :             GetGDALDriverManager()->GetDriverByName(osDriverName.c_str());
    3011          56 :         if (poDriver)
    3012             :             return std::unique_ptr<GDALAlgorithm>(
    3013          56 :                 poDriver->InstantiateAlgorithm(aosPath));
    3014           0 :         return nullptr;
    3015       14072 :     };
    3016             : 
    3017        7036 :     singleton.DeclareAlgorithm(path, std::move(lambda));
    3018             : 
    3019        7036 :     CPL_IGNORE_RET_VAL(osDriverName);
    3020        7036 : }
    3021             : 
    3022             : //! @endcond
    3023             : 
    3024             : /************************************************************************/
    3025             : /*                   DoesDriverHandleExtension()                        */
    3026             : /************************************************************************/
    3027             : 
    3028      175762 : static bool DoesDriverHandleExtension(GDALDriverH hDriver, const char *pszExt)
    3029             : {
    3030      175762 :     bool bRet = false;
    3031             :     const char *pszDriverExtensions =
    3032      175762 :         GDALGetMetadataItem(hDriver, GDAL_DMD_EXTENSIONS, nullptr);
    3033      175762 :     if (pszDriverExtensions)
    3034             :     {
    3035      291948 :         const CPLStringList aosTokens(CSLTokenizeString(pszDriverExtensions));
    3036      145974 :         const int nTokens = aosTokens.size();
    3037      326965 :         for (int j = 0; j < nTokens; ++j)
    3038             :         {
    3039      185424 :             if (EQUAL(pszExt, aosTokens[j]))
    3040             :             {
    3041        4433 :                 bRet = true;
    3042        4433 :                 break;
    3043             :             }
    3044             :         }
    3045             :     }
    3046      175762 :     return bRet;
    3047             : }
    3048             : 
    3049             : /************************************************************************/
    3050             : /*                     IsOnlyExpectedGDBDrivers()                       */
    3051             : /************************************************************************/
    3052             : 
    3053           1 : static bool IsOnlyExpectedGDBDrivers(const CPLStringList &aosDriverNames)
    3054             : {
    3055           3 :     for (const char *pszDrvName : aosDriverNames)
    3056             :     {
    3057           2 :         if (!EQUAL(pszDrvName, "OpenFileGDB") &&
    3058           1 :             !EQUAL(pszDrvName, "FileGDB") && !EQUAL(pszDrvName, "GPSBabel"))
    3059             :         {
    3060           0 :             return false;
    3061             :         }
    3062             :     }
    3063           1 :     return true;
    3064             : }
    3065             : 
    3066             : /************************************************************************/
    3067             : /*                  GDALGetOutputDriversForDatasetName()                */
    3068             : /************************************************************************/
    3069             : 
    3070             : /** Return a list of driver short names that are likely candidates for the
    3071             :  * provided output file name.
    3072             :  *
    3073             :  * @param pszDestDataset Output dataset name (might not exist).
    3074             :  * @param nDatasetTypeFlag GDAL_OF_RASTER, GDAL_OF_VECTOR, GDAL_OF_MULTIDIM_RASTER
    3075             :  *                         or a binary-or'ed combination of them
    3076             :  * @param bSingleMatch Whether a single match is desired, that is to say the
    3077             :  *                     returned list will contain at most one item, which will
    3078             :  *                     be the first driver in the order they are registered to
    3079             :  *                     match the output dataset name. Note that in this mode, if
    3080             :  *                     nDatasetTypeFlag==GDAL_OF_RASTER and pszDestDataset has
    3081             :  *                     no extension, GTiff will be selected.
    3082             :  * @param bEmitWarning Whether a warning should be emitted when bSingleMatch is
    3083             :  *                     true and there are more than 2 candidates.
    3084             :  * @return NULL terminated list of driver short names.
    3085             :  * To be freed with CSLDestroy()
    3086             :  * @since 3.9
    3087             :  */
    3088        2584 : char **GDALGetOutputDriversForDatasetName(const char *pszDestDataset,
    3089             :                                           int nDatasetTypeFlag,
    3090             :                                           bool bSingleMatch, bool bEmitWarning)
    3091             : {
    3092        5168 :     CPLStringList aosDriverNames;
    3093        5168 :     CPLStringList aosMissingDriverNames;
    3094             : 
    3095        5168 :     std::string osExt = CPLGetExtensionSafe(pszDestDataset);
    3096        2584 :     if (EQUAL(osExt.c_str(), "zip"))
    3097             :     {
    3098           2 :         const CPLString osLower(CPLString(pszDestDataset).tolower());
    3099           1 :         if (osLower.endsWith(".shp.zip"))
    3100             :         {
    3101           1 :             osExt = "shp.zip";
    3102             :         }
    3103           0 :         else if (osLower.endsWith(".gpkg.zip"))
    3104             :         {
    3105           0 :             osExt = "gpkg.zip";
    3106             :         }
    3107             :     }
    3108        2583 :     else if (EQUAL(osExt.c_str(), "json"))
    3109             :     {
    3110           1 :         const CPLString osLower(CPLString(pszDestDataset).tolower());
    3111           1 :         if (osLower.endsWith(".gdalg.json"))
    3112           0 :             return nullptr;
    3113             :     }
    3114             : 
    3115        2584 :     auto poDM = GetGDALDriverManager();
    3116        2584 :     const int nDriverCount = poDM->GetDriverCount(true);
    3117        2584 :     GDALDriver *poMissingPluginDriver = nullptr;
    3118        5168 :     std::string osMatchingPrefix;
    3119      581007 :     for (int i = 0; i < nDriverCount; i++)
    3120             :     {
    3121      578423 :         GDALDriver *poDriver = poDM->GetDriver(i, true);
    3122      578423 :         bool bOk = false;
    3123      578423 :         if ((poDriver->GetMetadataItem(GDAL_DCAP_CREATE) != nullptr ||
    3124      353618 :              poDriver->GetMetadataItem(GDAL_DCAP_CREATECOPY) != nullptr ||
    3125     1156850 :              poDriver->GetMetadataItem(GDAL_DCAP_UPDATE) != nullptr) &&
    3126      294573 :             (((nDatasetTypeFlag & GDAL_OF_RASTER) &&
    3127      238829 :               poDriver->GetMetadataItem(GDAL_DCAP_RASTER) != nullptr) ||
    3128      143734 :              ((nDatasetTypeFlag & GDAL_OF_VECTOR) &&
    3129       55402 :               poDriver->GetMetadataItem(GDAL_DCAP_VECTOR) != nullptr) ||
    3130      116520 :              ((nDatasetTypeFlag & GDAL_OF_MULTIDIM_RASTER) &&
    3131         342 :               poDriver->GetMetadataItem(GDAL_DCAP_MULTIDIM_RASTER) != nullptr)))
    3132             :         {
    3133      178074 :             bOk = true;
    3134             :         }
    3135      404545 :         else if (poDriver->GetMetadataItem(GDAL_DCAP_VECTOR_TRANSLATE_FROM) &&
    3136        4196 :                  (nDatasetTypeFlag & GDAL_OF_VECTOR) != 0)
    3137             :         {
    3138           0 :             bOk = true;
    3139             :         }
    3140      578423 :         if (bOk)
    3141             :         {
    3142      353836 :             if (!osExt.empty() &&
    3143      175762 :                 DoesDriverHandleExtension(GDALDriver::ToHandle(poDriver),
    3144             :                                           osExt.c_str()))
    3145             :             {
    3146        4433 :                 if (poDriver->GetMetadataItem("MISSING_PLUGIN_FILENAME"))
    3147             :                 {
    3148           0 :                     poMissingPluginDriver = poDriver;
    3149           0 :                     aosMissingDriverNames.AddString(poDriver->GetDescription());
    3150             :                 }
    3151             :                 else
    3152        4433 :                     aosDriverNames.AddString(poDriver->GetDescription());
    3153             :             }
    3154             :             else
    3155             :             {
    3156             :                 const char *pszPrefix =
    3157      173641 :                     poDriver->GetMetadataItem(GDAL_DMD_CONNECTION_PREFIX);
    3158      173641 :                 if (pszPrefix && STARTS_WITH_CI(pszDestDataset, pszPrefix))
    3159             :                 {
    3160           9 :                     if (poDriver->GetMetadataItem("MISSING_PLUGIN_FILENAME"))
    3161             :                     {
    3162           0 :                         osMatchingPrefix = pszPrefix;
    3163           0 :                         poMissingPluginDriver = poDriver;
    3164             :                         aosMissingDriverNames.AddString(
    3165           0 :                             poDriver->GetDescription());
    3166             :                     }
    3167             :                     else
    3168           9 :                         aosDriverNames.AddString(poDriver->GetDescription());
    3169             :                 }
    3170             :             }
    3171             :         }
    3172             :     }
    3173             : 
    3174             :     // GMT is registered before netCDF for opening reasons, but we want
    3175             :     // netCDF to be used by default for output.
    3176        2589 :     if (EQUAL(osExt.c_str(), "nc") && aosDriverNames.size() == 2 &&
    3177        2589 :         EQUAL(aosDriverNames[0], "GMT") && EQUAL(aosDriverNames[1], "netCDF"))
    3178             :     {
    3179           0 :         aosDriverNames.Clear();
    3180           0 :         aosDriverNames.AddString("netCDF");
    3181           0 :         aosDriverNames.AddString("GMT");
    3182             :     }
    3183             : 
    3184        2584 :     if (bSingleMatch)
    3185             :     {
    3186        2516 :         if (nDatasetTypeFlag == GDAL_OF_RASTER)
    3187             :         {
    3188        2095 :             if (aosDriverNames.empty())
    3189             :             {
    3190          12 :                 if (osExt.empty())
    3191             :                 {
    3192           8 :                     aosDriverNames.AddString("GTiff");
    3193             :                 }
    3194             :             }
    3195        2083 :             else if (aosDriverNames.size() >= 2)
    3196             :             {
    3197        3786 :                 if (bEmitWarning && !(EQUAL(aosDriverNames[0], "GTiff") &&
    3198        1893 :                                       EQUAL(aosDriverNames[1], "COG")))
    3199             :                 {
    3200           0 :                     CPLError(CE_Warning, CPLE_AppDefined,
    3201             :                              "Several drivers matching %s extension. Using %s",
    3202             :                              osExt.c_str(), aosDriverNames[0]);
    3203             :                 }
    3204        3786 :                 const std::string osDrvName = aosDriverNames[0];
    3205        1893 :                 aosDriverNames.Clear();
    3206        1893 :                 aosDriverNames.AddString(osDrvName.c_str());
    3207             :             }
    3208             :         }
    3209         422 :         else if (EQUAL(osExt.c_str(), "gdb") &&
    3210           1 :                  IsOnlyExpectedGDBDrivers(aosDriverNames))
    3211             :         {
    3212             :             // Do not warn about that case given that FileGDB write support
    3213             :             // forwards to OpenFileGDB one. And also consider GPSBabel as too
    3214             :             // marginal to deserve the warning.
    3215           1 :             aosDriverNames.Clear();
    3216           1 :             aosDriverNames.AddString("OpenFileGDB");
    3217             :         }
    3218         420 :         else if (aosDriverNames.size() >= 2)
    3219             :         {
    3220           0 :             if (bEmitWarning)
    3221             :             {
    3222           0 :                 CPLError(CE_Warning, CPLE_AppDefined,
    3223             :                          "Several drivers matching %s %s. Using %s",
    3224           0 :                          osMatchingPrefix.empty() ? osExt.c_str()
    3225           0 :                                                   : osMatchingPrefix.c_str(),
    3226           0 :                          osMatchingPrefix.empty() ? "extension" : "prefix",
    3227             :                          aosDriverNames[0]);
    3228             :             }
    3229           0 :             const std::string osDrvName = aosDriverNames[0];
    3230           0 :             aosDriverNames.Clear();
    3231           0 :             aosDriverNames.AddString(osDrvName.c_str());
    3232             :         }
    3233             :     }
    3234             : 
    3235        2613 :     if (aosDriverNames.empty() && bEmitWarning &&
    3236        2613 :         aosMissingDriverNames.size() == 1 && poMissingPluginDriver)
    3237             :     {
    3238           0 :         CPLError(CE_Failure, CPLE_AppDefined,
    3239             :                  "No installed driver matching %s %s, but %s driver is "
    3240             :                  "known. However plugin %s",
    3241           0 :                  osMatchingPrefix.empty() ? osExt.c_str()
    3242           0 :                                           : osMatchingPrefix.c_str(),
    3243           0 :                  osMatchingPrefix.empty() ? "extension" : "prefix",
    3244           0 :                  poMissingPluginDriver->GetDescription(),
    3245           0 :                  GDALGetMessageAboutMissingPluginDriver(poMissingPluginDriver)
    3246             :                      .c_str());
    3247             :     }
    3248        2612 :     else if (aosDriverNames.empty() && bEmitWarning &&
    3249          28 :              aosMissingDriverNames.empty())
    3250             :     {
    3251         771 :         for (const auto &sConnectionPrefix : asKnownConnectionPrefixes)
    3252             :         {
    3253         744 :             if (STARTS_WITH_CI(pszDestDataset, sConnectionPrefix.pszPrefix))
    3254             :             {
    3255           1 :                 CPLError(CE_Failure, CPLE_AppDefined,
    3256             :                          "Filename %s starts with the connection prefix of "
    3257             :                          "driver %s, which is not enabled in this GDAL build. "
    3258             :                          "If that filename is really intended, explicitly "
    3259             :                          "specify its output format.",
    3260           1 :                          pszDestDataset, sConnectionPrefix.pszDriverName);
    3261           1 :                 break;
    3262             :             }
    3263             :         }
    3264             :     }
    3265             : 
    3266        2584 :     return aosDriverNames.StealList();
    3267             : }
    3268             : 
    3269             : /************************************************************************/
    3270             : /*                GDALGetMessageAboutMissingPluginDriver()              */
    3271             : /************************************************************************/
    3272             : 
    3273             : std::string
    3274           0 : GDALGetMessageAboutMissingPluginDriver(GDALDriver *poMissingPluginDriver)
    3275             : {
    3276             :     std::string osMsg =
    3277           0 :         poMissingPluginDriver->GetMetadataItem("MISSING_PLUGIN_FILENAME");
    3278             :     osMsg += " is not available in your "
    3279           0 :              "installation.";
    3280           0 :     if (const char *pszInstallationMsg = poMissingPluginDriver->GetMetadataItem(
    3281           0 :             GDAL_DMD_PLUGIN_INSTALLATION_MESSAGE))
    3282             :     {
    3283           0 :         osMsg += " ";
    3284           0 :         osMsg += pszInstallationMsg;
    3285             :     }
    3286             : 
    3287             :     VSIStatBuf sStat;
    3288           0 :     if (const char *pszGDALDriverPath =
    3289           0 :             CPLGetConfigOption("GDAL_DRIVER_PATH", nullptr))
    3290             :     {
    3291           0 :         if (VSIStat(pszGDALDriverPath, &sStat) != 0)
    3292             :         {
    3293           0 :             if (osMsg.back() != '.')
    3294           0 :                 osMsg += ".";
    3295           0 :             osMsg += " Directory '";
    3296           0 :             osMsg += pszGDALDriverPath;
    3297           0 :             osMsg += "' pointed by GDAL_DRIVER_PATH does not exist.";
    3298             :         }
    3299             :     }
    3300             :     else
    3301             :     {
    3302           0 :         if (osMsg.back() != '.')
    3303           0 :             osMsg += ".";
    3304             : #ifdef INSTALL_PLUGIN_FULL_DIR
    3305             :         if (VSIStat(INSTALL_PLUGIN_FULL_DIR, &sStat) != 0)
    3306             :         {
    3307             :             osMsg += " Directory '";
    3308             :             osMsg += INSTALL_PLUGIN_FULL_DIR;
    3309             :             osMsg += "' hardcoded in the GDAL library does not "
    3310             :                      "exist and the GDAL_DRIVER_PATH "
    3311             :                      "configuration option is not set.";
    3312             :         }
    3313             :         else
    3314             : #endif
    3315             :         {
    3316             :             osMsg += " The GDAL_DRIVER_PATH configuration "
    3317           0 :                      "option is not set.";
    3318             :         }
    3319             :     }
    3320           0 :     return osMsg;
    3321             : }

Generated by: LCOV version 1.14