LCOV - code coverage report
Current view: top level - gcore - gdal_priv.h (source / functions) Hit Total Coverage
Test: gdal_filtered.info Lines: 416 434 95.9 %
Date: 2025-07-08 01:43:24 Functions: 213 229 93.0 %

          Line data    Source code
       1             : /******************************************************************************
       2             :  *
       3             :  * Name:     gdal_priv.h
       4             :  * Project:  GDAL Core
       5             :  * Purpose:  GDAL Core C++/Private declarations.
       6             :  * Author:   Frank Warmerdam, warmerdam@pobox.com
       7             :  *
       8             :  ******************************************************************************
       9             :  * Copyright (c) 1998, Frank Warmerdam
      10             :  * Copyright (c) 2007-2014, Even Rouault <even dot rouault at spatialys.com>
      11             :  *
      12             :  * SPDX-License-Identifier: MIT
      13             :  ****************************************************************************/
      14             : 
      15             : #ifndef GDAL_PRIV_H_INCLUDED
      16             : #define GDAL_PRIV_H_INCLUDED
      17             : 
      18             : /**
      19             :  * \file gdal_priv.h
      20             :  *
      21             :  * C++ GDAL entry points.
      22             :  */
      23             : 
      24             : /* -------------------------------------------------------------------- */
      25             : /*      Predeclare various classes before pulling in gdal.h, the        */
      26             : /*      public declarations.                                            */
      27             : /* -------------------------------------------------------------------- */
      28             : class GDALMajorObject;
      29             : class GDALDataset;
      30             : class GDALRasterBand;
      31             : class GDALDriver;
      32             : class GDALRasterAttributeTable;
      33             : class GDALProxyDataset;
      34             : class GDALProxyRasterBand;
      35             : class GDALAsyncReader;
      36             : class GDALRelationship;
      37             : class GDALAlgorithm;
      38             : 
      39             : /* -------------------------------------------------------------------- */
      40             : /*      Pull in the public declarations.  This gets the C apis, and     */
      41             : /*      also various constants.  However, we will still get to          */
      42             : /*      provide the real class definitions for the GDAL classes.        */
      43             : /* -------------------------------------------------------------------- */
      44             : 
      45             : #include "gdal.h"
      46             : #include "gdal_frmts.h"
      47             : #include "gdalsubdatasetinfo.h"
      48             : #include "cpl_vsi.h"
      49             : #include "cpl_conv.h"
      50             : #include "cpl_string.h"
      51             : #include "cpl_minixml.h"
      52             : #include "cpl_multiproc.h"
      53             : #include "cpl_atomic_ops.h"
      54             : 
      55             : #include <stdarg.h>
      56             : 
      57             : #include <algorithm>
      58             : #include <cmath>
      59             : #include <complex>
      60             : #include <cstdint>
      61             : #include <iterator>
      62             : #include <limits>
      63             : #include <map>
      64             : #include <memory>
      65             : #include <set>
      66             : #if __cplusplus >= 202002L
      67             : #include <span>
      68             : #endif
      69             : #include <type_traits>
      70             : #include <utility>
      71             : #include <vector>
      72             : 
      73             : #include "ogr_core.h"
      74             : #include "ogr_feature.h"
      75             : 
      76             : //! @cond Doxygen_Suppress
      77             : #define GMO_VALID 0x0001
      78             : #define GMO_IGNORE_UNIMPLEMENTED 0x0002
      79             : #define GMO_SUPPORT_MD 0x0004
      80             : #define GMO_SUPPORT_MDMD 0x0008
      81             : #define GMO_MD_DIRTY 0x0010
      82             : #define GMO_PAM_CLASS 0x0020
      83             : 
      84             : //! @endcond
      85             : 
      86             : /************************************************************************/
      87             : /*                       GDALMultiDomainMetadata                        */
      88             : /************************************************************************/
      89             : 
      90             : //! @cond Doxygen_Suppress
      91     7020238 : class CPL_DLL GDALMultiDomainMetadata
      92             : {
      93             :   private:
      94             :     CPLStringList aosDomainList{};
      95             : 
      96             :     struct Comparator
      97             :     {
      98    31993600 :         bool operator()(const char *a, const char *b) const
      99             :         {
     100    31993600 :             return STRCASECMP(a, b) < 0;
     101             :         }
     102             :     };
     103             : 
     104             :     std::map<const char *, CPLStringList, Comparator> oMetadata{};
     105             : 
     106             :   public:
     107             :     GDALMultiDomainMetadata();
     108             : 
     109             :     /** Copy constructor */
     110             :     GDALMultiDomainMetadata(const GDALMultiDomainMetadata &) = default;
     111             : 
     112             :     /** Copy assignment operator */
     113             :     GDALMultiDomainMetadata &
     114             :     operator=(const GDALMultiDomainMetadata &) = default;
     115             : 
     116             :     /** Move constructor */
     117             :     GDALMultiDomainMetadata(GDALMultiDomainMetadata &&) = default;
     118             : 
     119             :     /** Move assignment operator */
     120             :     GDALMultiDomainMetadata &operator=(GDALMultiDomainMetadata &&) = default;
     121             : 
     122             :     ~GDALMultiDomainMetadata();
     123             : 
     124             :     int XMLInit(const CPLXMLNode *psMetadata, int bMerge);
     125             :     CPLXMLNode *Serialize() const;
     126             : 
     127      711432 :     CSLConstList GetDomainList() const
     128             :     {
     129      711432 :         return aosDomainList.List();
     130             :     }
     131             : 
     132             :     char **GetMetadata(const char *pszDomain = "");
     133             :     CPLErr SetMetadata(CSLConstList papszMetadata, const char *pszDomain = "");
     134             :     const char *GetMetadataItem(const char *pszName,
     135             :                                 const char *pszDomain = "");
     136             :     CPLErr SetMetadataItem(const char *pszName, const char *pszValue,
     137             :                            const char *pszDomain = "");
     138             : 
     139             :     void Clear();
     140             : 
     141             :     inline void clear()
     142             :     {
     143             :         Clear();
     144             :     }
     145             : };
     146             : 
     147             : //! @endcond
     148             : 
     149             : /* ******************************************************************** */
     150             : /*                           GDALMajorObject                            */
     151             : /*                                                                      */
     152             : /*      Base class providing metadata, description and other            */
     153             : /*      services shared by major objects.                               */
     154             : /* ******************************************************************** */
     155             : 
     156             : /** Object with metadata. */
     157             : class CPL_DLL GDALMajorObject
     158             : {
     159             :   protected:
     160             :     //! @cond Doxygen_Suppress
     161             :     int nFlags;  // GMO_* flags.
     162             :     CPLString sDescription{};
     163             :     GDALMultiDomainMetadata oMDMD{};
     164             : 
     165             :     //! @endcond
     166             : 
     167             :     char **BuildMetadataDomainList(char **papszList, int bCheckNonEmpty,
     168             :                                    ...) CPL_NULL_TERMINATED;
     169             : 
     170             :     /** Copy constructor */
     171             :     GDALMajorObject(const GDALMajorObject &) = default;
     172             : 
     173             :     /** Copy assignment operator */
     174             :     GDALMajorObject &operator=(const GDALMajorObject &) = default;
     175             : 
     176             :     /** Move constructor */
     177             :     GDALMajorObject(GDALMajorObject &&) = default;
     178             : 
     179             :     /** Move assignment operator */
     180             :     GDALMajorObject &operator=(GDALMajorObject &&) = default;
     181             : 
     182             :   public:
     183             :     GDALMajorObject();
     184             :     virtual ~GDALMajorObject();
     185             : 
     186             :     int GetMOFlags() const;
     187             :     void SetMOFlags(int nFlagsIn);
     188             : 
     189             :     virtual const char *GetDescription() const;
     190             :     virtual void SetDescription(const char *);
     191             : 
     192             :     virtual char **GetMetadataDomainList();
     193             : 
     194             :     virtual char **GetMetadata(const char *pszDomain = "");
     195             :     virtual CPLErr SetMetadata(char **papszMetadata,
     196             :                                const char *pszDomain = "");
     197             :     virtual const char *GetMetadataItem(const char *pszName,
     198             :                                         const char *pszDomain = "");
     199             :     virtual CPLErr SetMetadataItem(const char *pszName, const char *pszValue,
     200             :                                    const char *pszDomain = "");
     201             : 
     202             :     /** Convert a GDALMajorObject* to a GDALMajorObjectH.
     203             :      * @since GDAL 2.3
     204             :      */
     205         248 :     static inline GDALMajorObjectH ToHandle(GDALMajorObject *poMajorObject)
     206             :     {
     207         248 :         return static_cast<GDALMajorObjectH>(poMajorObject);
     208             :     }
     209             : 
     210             :     /** Convert a GDALMajorObjectH to a GDALMajorObject*.
     211             :      * @since GDAL 2.3
     212             :      */
     213      297321 :     static inline GDALMajorObject *FromHandle(GDALMajorObjectH hMajorObject)
     214             :     {
     215      297321 :         return static_cast<GDALMajorObject *>(hMajorObject);
     216             :     }
     217             : };
     218             : 
     219             : /* ******************************************************************** */
     220             : /*                         GDALDefaultOverviews                         */
     221             : /* ******************************************************************** */
     222             : 
     223             : //! @cond Doxygen_Suppress
     224             : class GDALOpenInfo;
     225             : 
     226             : class CPL_DLL GDALDefaultOverviews
     227             : {
     228             :     friend class GDALDataset;
     229             : 
     230             :     GDALDataset *poDS;
     231             :     GDALDataset *poODS;
     232             : 
     233             :     CPLString osOvrFilename{};
     234             : 
     235             :     bool bOvrIsAux;
     236             : 
     237             :     bool bCheckedForMask;
     238             :     bool bOwnMaskDS;
     239             :     GDALDataset *poMaskDS;
     240             : 
     241             :     // For "overview datasets" we record base level info so we can
     242             :     // find our way back to get overview masks.
     243             :     GDALDataset *poBaseDS;
     244             : 
     245             :     // Stuff for deferred initialize/overviewscans.
     246             :     bool bCheckedForOverviews;
     247             :     void OverviewScan();
     248             :     char *pszInitName;
     249             :     bool bInitNameIsOVR;
     250             :     char **papszInitSiblingFiles;
     251             : 
     252             :   public:
     253             :     GDALDefaultOverviews();
     254             :     ~GDALDefaultOverviews();
     255             : 
     256             :     void Initialize(GDALDataset *poDSIn, const char *pszName = nullptr,
     257             :                     CSLConstList papszSiblingFiles = nullptr,
     258             :                     bool bNameIsOVR = false);
     259             : 
     260             :     void Initialize(GDALDataset *poDSIn, GDALOpenInfo *poOpenInfo,
     261             :                     const char *pszName = nullptr,
     262             :                     bool bTransferSiblingFilesIfLoaded = true);
     263             : 
     264             :     void TransferSiblingFiles(char **papszSiblingFiles);
     265             : 
     266             :     int IsInitialized();
     267             : 
     268             :     int CloseDependentDatasets();
     269             : 
     270             :     // Overview Related
     271             : 
     272             :     int GetOverviewCount(int nBand);
     273             :     GDALRasterBand *GetOverview(int nBand, int iOverview);
     274             : 
     275             :     CPLErr BuildOverviews(const char *pszBasename, const char *pszResampling,
     276             :                           int nOverviews, const int *panOverviewList,
     277             :                           int nBands, const int *panBandList,
     278             :                           GDALProgressFunc pfnProgress, void *pProgressData,
     279             :                           CSLConstList papszOptions);
     280             : 
     281             :     CPLErr BuildOverviewsSubDataset(const char *pszPhysicalFile,
     282             :                                     const char *pszResampling, int nOverviews,
     283             :                                     const int *panOverviewList, int nBands,
     284             :                                     const int *panBandList,
     285             :                                     GDALProgressFunc pfnProgress,
     286             :                                     void *pProgressData,
     287             :                                     CSLConstList papszOptions);
     288             : 
     289             :     CPLErr BuildOverviewsMask(const char *pszResampling, int nOverviews,
     290             :                               const int *panOverviewList,
     291             :                               GDALProgressFunc pfnProgress, void *pProgressData,
     292             :                               CSLConstList papszOptions);
     293             : 
     294             :     static bool CheckSrcOverviewsConsistencyWithBase(
     295             :         GDALDataset *poFullResDS,
     296             :         const std::vector<GDALDataset *> &apoSrcOvrDS);
     297             : 
     298             :     CPLErr AddOverviews(const char *pszBasename,
     299             :                         const std::vector<GDALDataset *> &apoSrcOvrDS,
     300             :                         GDALProgressFunc pfnProgress, void *pProgressData,
     301             :                         CSLConstList papszOptions);
     302             : 
     303             :     CPLErr CleanOverviews();
     304             : 
     305             :     // Mask Related
     306             : 
     307             :     CPLErr CreateMaskBand(int nFlags, int nBand = -1);
     308             :     GDALRasterBand *GetMaskBand(int nBand);
     309             :     int GetMaskFlags(int nBand);
     310             : 
     311             :     int HaveMaskFile(char **papszSiblings = nullptr,
     312             :                      const char *pszBasename = nullptr);
     313             : 
     314       58276 :     char **GetSiblingFiles()
     315             :     {
     316       58276 :         return papszInitSiblingFiles;
     317             :     }
     318             : 
     319             :   private:
     320             :     CPL_DISALLOW_COPY_ASSIGN(GDALDefaultOverviews)
     321             : 
     322             :     CPLErr CreateOrOpenOverviewFile(const char *pszBasename,
     323             :                                     CSLConstList papszOptions);
     324             : };
     325             : 
     326             : //! @endcond
     327             : 
     328             : /* ******************************************************************** */
     329             : /*                             GDALOpenInfo                             */
     330             : /* ******************************************************************** */
     331             : 
     332             : /** Class for dataset open functions. */
     333             : class CPL_DLL GDALOpenInfo
     334             : {
     335             :     bool bHasGotSiblingFiles = false;
     336             :     char **papszSiblingFiles = nullptr;
     337             :     int nHeaderBytesTried = 0;
     338             : 
     339             :   public:
     340             :     GDALOpenInfo(const char *pszFile, int nOpenFlagsIn,
     341             :                  const char *const *papszSiblingFiles = nullptr);
     342             :     ~GDALOpenInfo(void);
     343             : 
     344             :     /** Filename */
     345             :     char *pszFilename = nullptr;
     346             : 
     347             :     /** Result of CPLGetExtension(pszFilename); */
     348             :     std::string osExtension{};
     349             : 
     350             :     /** Open options */
     351             :     char **papszOpenOptions = nullptr;
     352             : 
     353             :     /** Access flag */
     354             :     GDALAccess eAccess = GA_ReadOnly;
     355             :     /** Open flags */
     356             :     int nOpenFlags = 0;
     357             : 
     358             :     /** Whether stat()'ing the file was successful */
     359             :     bool bStatOK = false;
     360             :     /** Whether the file is a directory */
     361             :     bool bIsDirectory = false;
     362             : 
     363             :     /** Pointer to the file */
     364             :     VSILFILE *fpL = nullptr;
     365             : 
     366             :     /** Number of bytes in pabyHeader */
     367             :     int nHeaderBytes = 0;
     368             :     /** Buffer with first bytes of the file */
     369             :     GByte *pabyHeader = nullptr;
     370             : 
     371             :     /** Allowed drivers (NULL for all) */
     372             :     const char *const *papszAllowedDrivers = nullptr;
     373             : 
     374             :     int TryToIngest(int nBytes);
     375             :     char **GetSiblingFiles();
     376             :     char **StealSiblingFiles();
     377             :     bool AreSiblingFilesLoaded() const;
     378             : 
     379             :     bool IsSingleAllowedDriver(const char *pszDriverName) const;
     380             : 
     381             :     /** Return whether the extension of the file is equal to pszExt, using
     382             :      * case-insensitive comparison.
     383             :      * @since 3.11 */
     384      889841 :     inline bool IsExtensionEqualToCI(const char *pszExt) const
     385             :     {
     386      889841 :         return EQUAL(osExtension.c_str(), pszExt);
     387             :     }
     388             : 
     389             :   private:
     390             :     CPL_DISALLOW_COPY_ASSIGN(GDALOpenInfo)
     391             : };
     392             : 
     393             : /* ******************************************************************** */
     394             : /*                             gdal::GCP                                */
     395             : /* ******************************************************************** */
     396             : 
     397             : namespace gdal
     398             : {
     399             : /** C++ wrapper over the C GDAL_GCP structure.
     400             :  *
     401             :  * It has the same binary layout, and thus a gdal::GCP pointer can be cast as a
     402             :  * GDAL_GCP pointer.
     403             :  *
     404             :  * @since 3.9
     405             :  */
     406             : class CPL_DLL GCP
     407             : {
     408             :   public:
     409             :     explicit GCP(const char *pszId = "", const char *pszInfo = "",
     410             :                  double dfPixel = 0, double dfLine = 0, double dfX = 0,
     411             :                  double dfY = 0, double dfZ = 0);
     412             :     ~GCP();
     413             :     GCP(const GCP &);
     414             :     explicit GCP(const GDAL_GCP &other);
     415             :     GCP &operator=(const GCP &);
     416             :     GCP(GCP &&);
     417             :     GCP &operator=(GCP &&);
     418             : 
     419             :     /** Returns the "id" member. */
     420       21898 :     inline const char *Id() const
     421             :     {
     422       21898 :         return gcp.pszId;
     423             :     }
     424             : 
     425             :     void SetId(const char *pszId);
     426             : 
     427             :     /** Returns the "info" member. */
     428       43778 :     inline const char *Info() const
     429             :     {
     430       43778 :         return gcp.pszInfo;
     431             :     }
     432             : 
     433             :     void SetInfo(const char *pszInfo);
     434             : 
     435             :     /** Returns the "pixel" member. */
     436       21917 :     inline double Pixel() const
     437             :     {
     438       21917 :         return gcp.dfGCPPixel;
     439             :     }
     440             : 
     441             :     /** Returns a reference to the "pixel" member. */
     442       24724 :     inline double &Pixel()
     443             :     {
     444       24724 :         return gcp.dfGCPPixel;
     445             :     }
     446             : 
     447             :     /** Returns the "line" member. */
     448       21917 :     inline double Line() const
     449             :     {
     450       21917 :         return gcp.dfGCPLine;
     451             :     }
     452             : 
     453             :     /** Returns a reference to the "line" member. */
     454       24725 :     inline double &Line()
     455             :     {
     456       24725 :         return gcp.dfGCPLine;
     457             :     }
     458             : 
     459             :     /** Returns the "X" member. */
     460       21917 :     inline double X() const
     461             :     {
     462       21917 :         return gcp.dfGCPX;
     463             :     }
     464             : 
     465             :     /** Returns a reference to the "X" member. */
     466       24651 :     inline double &X()
     467             :     {
     468       24651 :         return gcp.dfGCPX;
     469             :     }
     470             : 
     471             :     /** Returns the "Y" member. */
     472       21917 :     inline double Y() const
     473             :     {
     474       21917 :         return gcp.dfGCPY;
     475             :     }
     476             : 
     477             :     /** Returns a reference to the "Y" member. */
     478       24651 :     inline double &Y()
     479             :     {
     480       24651 :         return gcp.dfGCPY;
     481             :     }
     482             : 
     483             :     /** Returns the "Z" member. */
     484       43745 :     inline double Z() const
     485             :     {
     486       43745 :         return gcp.dfGCPZ;
     487             :     }
     488             : 
     489             :     /** Returns a reference to the "Z" member. */
     490       24532 :     inline double &Z()
     491             :     {
     492       24532 :         return gcp.dfGCPZ;
     493             :     }
     494             : 
     495             :     /** Casts as a C GDAL_GCP pointer */
     496         449 :     inline const GDAL_GCP *c_ptr() const
     497             :     {
     498         449 :         return &gcp;
     499             :     }
     500             : 
     501             :     static const GDAL_GCP *c_ptr(const std::vector<GCP> &asGCPs);
     502             : 
     503             :     static std::vector<GCP> fromC(const GDAL_GCP *pasGCPList, int nGCPCount);
     504             : 
     505             :   private:
     506             :     GDAL_GCP gcp;
     507             : };
     508             : 
     509             : } /* namespace gdal */
     510             : 
     511             : /* ******************************************************************** */
     512             : /*                             GDALGeoTransform                         */
     513             : /* ******************************************************************** */
     514             : 
     515             : /** Class that encapsulates a geotransform matrix.
     516             :  *
     517             :  * It contains 6 coefficients expressing an affine transformation from
     518             :  * (column, line) raster space to (X, Y) georeferenced space, such that
     519             :  *
     520             :  * \code{.c}
     521             :  *  X = xorig + column * xscale + line * xrot;
     522             :  *  Y = yorig + column * yrot   + line * yscale;
     523             :  * \endcode
     524             :  *
     525             :  * The default value is the identity transformation.
     526             :  *
     527             :  * @since 3.12
     528             :  */
     529             : class GDALGeoTransform
     530             : {
     531             :   public:
     532             :     // NOTE to GDAL developers: do not reorder those coefficients!
     533             : 
     534             :     /** X value of the origin of the raster */
     535             :     double xorig = 0;
     536             : 
     537             :     /** X scale factor */
     538             :     double xscale = 1;
     539             : 
     540             :     /** X rotation factor */
     541             :     double xrot = 0;
     542             : 
     543             :     /** Y value of the origin of the raster */
     544             :     double yorig = 0;
     545             : 
     546             :     /** Y rotation factor */
     547             :     double yrot = 0;
     548             : 
     549             :     /** Y scale factor */
     550             :     double yscale = 1;
     551             : 
     552             :     /** Default constructor for an identity geotransformation matrix. */
     553      185367 :     inline GDALGeoTransform() = default;
     554             : 
     555             :     /** Constructor from a array of 6 double */
     556          93 :     inline explicit GDALGeoTransform(const double coeffs[6])
     557          93 :     {
     558             :         static_assert(sizeof(GDALGeoTransform) == 6 * sizeof(double),
     559             :                       "Wrong size for GDALGeoTransform");
     560          93 :         xorig = coeffs[0];
     561          93 :         xscale = coeffs[1];
     562          93 :         xrot = coeffs[2];
     563          93 :         yorig = coeffs[3];
     564          93 :         yrot = coeffs[4];
     565          93 :         yscale = coeffs[5];
     566          93 :     }
     567             : 
     568             :     /** Constructor from 6 double values */
     569        5952 :     inline GDALGeoTransform(double xorigIn, double xscaleIn, double xrotIn,
     570             :                             double yorigIn, double yrotIn, double yscaleIn)
     571        5952 :     {
     572        5952 :         xorig = xorigIn;
     573        5952 :         xscale = xscaleIn;
     574        5952 :         xrot = xrotIn;
     575        5952 :         yorig = yorigIn;
     576        5952 :         yrot = yrotIn;
     577        5952 :         yscale = yscaleIn;
     578        5952 :     }
     579             : 
     580             :     /** Element accessor. idx must be in [0,5] range */
     581       13548 :     template <typename T> inline double operator[](T idx) const
     582             :     {
     583       13548 :         return *(&xorig + idx);
     584             :     }
     585             : 
     586             :     /** Element accessor. idx must be in [0,5] range */
     587    81873025 :     template <typename T> inline double &operator[](T idx)
     588             :     {
     589    81873025 :         return *(&xorig + idx);
     590             :     }
     591             : 
     592             :     /** Equality test operator */
     593        3967 :     inline bool operator==(const GDALGeoTransform &other) const
     594             :     {
     595        2918 :         return xorig == other.xorig && xscale == other.xscale &&
     596        2894 :                xrot == other.xrot && yorig == other.yorig &&
     597        6885 :                yrot == other.yrot && yscale == other.yscale;
     598             :     }
     599             : 
     600             :     /** Inequality test operator */
     601        3904 :     inline bool operator!=(const GDALGeoTransform &other) const
     602             :     {
     603        3904 :         return !(operator==(other));
     604             :     }
     605             : 
     606             :     /** Cast to const double* */
     607         641 :     inline const double *data() const
     608             :     {
     609         641 :         return &xorig;
     610             :     }
     611             : 
     612             :     /** Cast to double* */
     613       24816 :     inline double *data()
     614             :     {
     615       24816 :         return &xorig;
     616             :     }
     617             : 
     618             :     /**
     619             :      * Apply GeoTransform to x/y coordinate.
     620             :      *
     621             :      * Applies the following computation, converting a (pixel, line) coordinate
     622             :      * into a georeferenced (geo_x, geo_y) location.
     623             :      * \code{.c}
     624             :      *  *pdfGeoX = padfGeoTransform[0] + dfPixel * padfGeoTransform[1]
     625             :      *                                 + dfLine  * padfGeoTransform[2];
     626             :      *  *pdfGeoY = padfGeoTransform[3] + dfPixel * padfGeoTransform[4]
     627             :      *                                 + dfLine  * padfGeoTransform[5];
     628             :      * \endcode
     629             :      *
     630             :      * @param dfPixel Input pixel position.
     631             :      * @param dfLine Input line position.
     632             :      * @param pdfGeoX output location where geo_x (easting/longitude)
     633             :      * location is placed.
     634             :      * @param pdfGeoY output location where geo_y (northing/latitude)
     635             :      * location is placed.
     636             :      */
     637             : 
     638         480 :     inline void Apply(double dfPixel, double dfLine, double *pdfGeoX,
     639             :                       double *pdfGeoY) const
     640             :     {
     641         480 :         GDALApplyGeoTransform(data(), dfPixel, dfLine, pdfGeoX, pdfGeoY);
     642         480 :     }
     643             : 
     644             :     /**
     645             :      * Invert Geotransform.
     646             :      *
     647             :      * This function will invert a standard 3x2 set of GeoTransform coefficients.
     648             :      * This converts the equation from being pixel to geo to being geo to pixel.
     649             :      *
     650             :      * @param[out] inverse Output geotransform
     651             :      *
     652             :      * @return true on success or false if the equation is uninvertable.
     653             :      */
     654         161 :     inline bool GetInverse(GDALGeoTransform &inverse) const
     655             :     {
     656         161 :         return GDALInvGeoTransform(data(), inverse.data()) == TRUE;
     657             :     }
     658             : 
     659             :     /** Rescale a geotransform by multiplying its scale and rotation terms by
     660             :      * the provided ratios.
     661             :      *
     662             :      * This is typically used to compute the geotransform matrix of an overview
     663             :      * dataset from the full resolution dataset, where the ratios are the size
     664             :      * of the full resolution dataset divided by the size of the overview.
     665             :      */
     666        1799 :     inline void Rescale(double dfXRatio, double dfYRatio)
     667             :     {
     668        1799 :         xscale *= dfXRatio;
     669        1799 :         xrot *= dfYRatio;
     670        1799 :         yrot *= dfXRatio;
     671        1799 :         yscale *= dfYRatio;
     672        1799 :     }
     673             : };
     674             : 
     675             : /* ******************************************************************** */
     676             : /*                             GDALDataset                              */
     677             : /* ******************************************************************** */
     678             : 
     679             : class OGRLayer;
     680             : class OGRGeometry;
     681             : class OGRSpatialReference;
     682             : class OGRStyleTable;
     683             : class swq_select;
     684             : class swq_select_parse_options;
     685             : class GDALGroup;
     686             : 
     687             : //! @cond Doxygen_Suppress
     688             : typedef struct GDALSQLParseInfo GDALSQLParseInfo;
     689             : //! @endcond
     690             : 
     691             : //! @cond Doxygen_Suppress
     692             : #ifdef GDAL_COMPILATION
     693             : #define OPTIONAL_OUTSIDE_GDAL(val)
     694             : #else
     695             : #define OPTIONAL_OUTSIDE_GDAL(val) = val
     696             : #endif
     697             : //! @endcond
     698             : 
     699             : //! @cond Doxygen_Suppress
     700             : // This macro can be defined to check that GDALDataset::IRasterIO()
     701             : // implementations do not alter the passed panBandList. It is not defined
     702             : // by default (and should not!), hence int* is used.
     703             : #if defined(GDAL_BANDMAP_TYPE_CONST_SAFE)
     704             : #define BANDMAP_TYPE const int *
     705             : #else
     706             : #define BANDMAP_TYPE int *
     707             : #endif
     708             : //! @endcond
     709             : 
     710             : /** A set of associated raster bands, usually from one file. */
     711             : class CPL_DLL GDALDataset : public GDALMajorObject
     712             : {
     713             :     friend GDALDatasetH CPL_STDCALL
     714             :     GDALOpenEx(const char *pszFilename, unsigned int nOpenFlags,
     715             :                const char *const *papszAllowedDrivers,
     716             :                const char *const *papszOpenOptions,
     717             :                const char *const *papszSiblingFiles);
     718             :     friend CPLErr CPL_STDCALL GDALClose(GDALDatasetH hDS);
     719             : 
     720             :     friend class GDALDriver;
     721             :     friend class GDALDefaultOverviews;
     722             :     friend class GDALProxyDataset;
     723             :     friend class GDALDriverManager;
     724             : 
     725             :     CPL_INTERNAL void AddToDatasetOpenList();
     726             : 
     727             :     CPL_INTERNAL void UnregisterFromSharedDataset();
     728             : 
     729             :     CPL_INTERNAL static void ReportErrorV(const char *pszDSName,
     730             :                                           CPLErr eErrClass, CPLErrorNum err_no,
     731             :                                           const char *fmt, va_list args);
     732             : 
     733             :   protected:
     734             :     //! @cond Doxygen_Suppress
     735             :     GDALDriver *poDriver = nullptr;
     736             :     GDALAccess eAccess = GA_ReadOnly;
     737             : 
     738             :     // Stored raster information.
     739             :     int nRasterXSize = 512;
     740             :     int nRasterYSize = 512;
     741             :     int nBands = 0;
     742             :     GDALRasterBand **papoBands = nullptr;
     743             : 
     744             :     static constexpr int OPEN_FLAGS_CLOSED = -1;
     745             :     int nOpenFlags =
     746             :         0;  // set to OPEN_FLAGS_CLOSED after Close() has been called
     747             : 
     748             :     int nRefCount = 1;
     749             :     bool bForceCachedIO = false;
     750             :     bool bShared = false;
     751             :     bool bIsInternal = true;
     752             :     bool bSuppressOnClose = false;
     753             : 
     754             :     mutable std::map<std::string, std::unique_ptr<OGRFieldDomain>>
     755             :         m_oMapFieldDomains{};
     756             : 
     757             :     GDALDataset(void);
     758             :     explicit GDALDataset(int bForceCachedIO);
     759             : 
     760             :     void RasterInitialize(int, int);
     761             :     void SetBand(int nNewBand, GDALRasterBand *poBand);
     762             :     void SetBand(int nNewBand, std::unique_ptr<GDALRasterBand> poBand);
     763             : 
     764             :     GDALDefaultOverviews oOvManager{};
     765             : 
     766             :     virtual CPLErr IBuildOverviews(const char *pszResampling, int nOverviews,
     767             :                                    const int *panOverviewList, int nListBands,
     768             :                                    const int *panBandList,
     769             :                                    GDALProgressFunc pfnProgress,
     770             :                                    void *pProgressData,
     771             :                                    CSLConstList papszOptions);
     772             : 
     773             :     virtual CPLErr
     774             :     IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize,
     775             :               void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType,
     776             :               int nBandCount, BANDMAP_TYPE panBandMap, GSpacing nPixelSpace,
     777             :               GSpacing nLineSpace, GSpacing nBandSpace,
     778             :               GDALRasterIOExtraArg *psExtraArg) CPL_WARN_UNUSED_RESULT;
     779             : 
     780             :     /* This method should only be be overloaded by GDALProxyDataset */
     781             :     virtual CPLErr
     782             :     BlockBasedRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
     783             :                        int nYSize, void *pData, int nBufXSize, int nBufYSize,
     784             :                        GDALDataType eBufType, int nBandCount,
     785             :                        const int *panBandMap, GSpacing nPixelSpace,
     786             :                        GSpacing nLineSpace, GSpacing nBandSpace,
     787             :                        GDALRasterIOExtraArg *psExtraArg) CPL_WARN_UNUSED_RESULT;
     788             :     CPLErr BlockBasedFlushCache(bool bAtClosing);
     789             : 
     790             :     CPLErr
     791             :     BandBasedRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
     792             :                       int nYSize, void *pData, int nBufXSize, int nBufYSize,
     793             :                       GDALDataType eBufType, int nBandCount,
     794             :                       const int *panBandMap, GSpacing nPixelSpace,
     795             :                       GSpacing nLineSpace, GSpacing nBandSpace,
     796             :                       GDALRasterIOExtraArg *psExtraArg) CPL_WARN_UNUSED_RESULT;
     797             : 
     798             :     CPLErr
     799             :     RasterIOResampled(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
     800             :                       int nYSize, void *pData, int nBufXSize, int nBufYSize,
     801             :                       GDALDataType eBufType, int nBandCount,
     802             :                       const int *panBandMap, GSpacing nPixelSpace,
     803             :                       GSpacing nLineSpace, GSpacing nBandSpace,
     804             :                       GDALRasterIOExtraArg *psExtraArg) CPL_WARN_UNUSED_RESULT;
     805             : 
     806             :     CPLErr ValidateRasterIOOrAdviseReadParameters(
     807             :         const char *pszCallingFunc, int *pbStopProcessingOnCENone, int nXOff,
     808             :         int nYOff, int nXSize, int nYSize, int nBufXSize, int nBufYSize,
     809             :         int nBandCount, const int *panBandMap);
     810             : 
     811             :     CPLErr TryOverviewRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
     812             :                                int nXSize, int nYSize, void *pData,
     813             :                                int nBufXSize, int nBufYSize,
     814             :                                GDALDataType eBufType, int nBandCount,
     815             :                                const int *panBandMap, GSpacing nPixelSpace,
     816             :                                GSpacing nLineSpace, GSpacing nBandSpace,
     817             :                                GDALRasterIOExtraArg *psExtraArg, int *pbTried);
     818             : 
     819             :     void ShareLockWithParentDataset(GDALDataset *poParentDataset);
     820             : 
     821             :     bool m_bCanBeReopened = false;
     822             : 
     823             :     virtual bool CanBeCloned(int nScopeFlags, bool bCanShareState) const;
     824             : 
     825             :     friend class GDALThreadSafeDataset;
     826             :     friend class MEMDataset;
     827             :     virtual std::unique_ptr<GDALDataset> Clone(int nScopeFlags,
     828             :                                                bool bCanShareState) const;
     829             : 
     830             :     //! @endcond
     831             : 
     832             :     void CleanupPostFileClosing();
     833             : 
     834             :     virtual int CloseDependentDatasets();
     835             :     //! @cond Doxygen_Suppress
     836             :     int ValidateLayerCreationOptions(const char *const *papszLCO);
     837             : 
     838             :     char **papszOpenOptions = nullptr;
     839             : 
     840             :     friend class GDALRasterBand;
     841             : 
     842             :     // The below methods related to read write mutex are fragile logic, and
     843             :     // should not be used by out-of-tree code if possible.
     844             :     int EnterReadWrite(GDALRWFlag eRWFlag);
     845             :     void LeaveReadWrite();
     846             :     void InitRWLock();
     847             : 
     848             :     void TemporarilyDropReadWriteLock();
     849             :     void ReacquireReadWriteLock();
     850             : 
     851             :     void DisableReadWriteMutex();
     852             : 
     853             :     int AcquireMutex();
     854             :     void ReleaseMutex();
     855             : 
     856             :     bool IsAllBands(int nBandCount, const int *panBandList) const;
     857             :     //! @endcond
     858             : 
     859             :   public:
     860             :     ~GDALDataset() override;
     861             : 
     862             :     virtual CPLErr Close();
     863             : 
     864             :     int GetRasterXSize() const;
     865             :     int GetRasterYSize() const;
     866             :     int GetRasterCount() const;
     867             :     GDALRasterBand *GetRasterBand(int);
     868             :     const GDALRasterBand *GetRasterBand(int) const;
     869             : 
     870             :     /**
     871             :      * @brief SetQueryLoggerFunc
     872             :      * @param pfnQueryLoggerFuncIn query logger function callback
     873             :      * @param poQueryLoggerArgIn arguments passed to the query logger function
     874             :      * @return true on success
     875             :      */
     876             :     virtual bool SetQueryLoggerFunc(GDALQueryLoggerFunc pfnQueryLoggerFuncIn,
     877             :                                     void *poQueryLoggerArgIn);
     878             : 
     879             :     /** Class returned by GetBands() that act as a container for raster bands.
     880             :      */
     881             :     class CPL_DLL Bands
     882             :     {
     883             :       private:
     884             :         friend class GDALDataset;
     885             :         GDALDataset *m_poSelf;
     886             : 
     887           7 :         CPL_INTERNAL explicit Bands(GDALDataset *poSelf) : m_poSelf(poSelf)
     888             :         {
     889           7 :         }
     890             : 
     891           6 :         class CPL_DLL Iterator
     892             :         {
     893             :             struct Private;
     894             :             std::unique_ptr<Private> m_poPrivate;
     895             : 
     896             :           public:
     897             :             Iterator(GDALDataset *poDS, bool bStart);
     898             :             Iterator(const Iterator &oOther);  // declared but not defined.
     899             :                                                // Needed for gcc 5.4 at least
     900             :             Iterator(Iterator &&oOther) noexcept;  // declared but not defined.
     901             :                 // Needed for gcc 5.4 at least
     902             :             ~Iterator();
     903             :             GDALRasterBand *operator*();
     904             :             Iterator &operator++();
     905             :             bool operator!=(const Iterator &it) const;
     906             :         };
     907             : 
     908             :       public:
     909             :         const Iterator begin() const;
     910             : 
     911             :         const Iterator end() const;
     912             : 
     913             :         size_t size() const;
     914             : 
     915             :         GDALRasterBand *operator[](int iBand);
     916             :         GDALRasterBand *operator[](size_t iBand);
     917             :     };
     918             : 
     919             :     Bands GetBands();
     920             : 
     921             :     virtual CPLErr FlushCache(bool bAtClosing = false);
     922             :     virtual CPLErr DropCache();
     923             : 
     924             :     virtual GIntBig GetEstimatedRAMUsage();
     925             : 
     926             :     virtual const OGRSpatialReference *GetSpatialRef() const;
     927             :     virtual CPLErr SetSpatialRef(const OGRSpatialReference *poSRS);
     928             : 
     929             :     // Compatibility layer
     930             :     const char *GetProjectionRef(void) const;
     931             :     CPLErr SetProjection(const char *pszProjection);
     932             : 
     933             :     virtual CPLErr GetGeoTransform(GDALGeoTransform &gt) const;
     934             :     virtual CPLErr SetGeoTransform(const GDALGeoTransform &gt);
     935             : 
     936             :     CPLErr GetGeoTransform(double *padfGeoTransform) const
     937             : #if defined(GDAL_COMPILATION) && !defined(DOXYGEN_XML)
     938             :         CPL_WARN_DEPRECATED("Use GetGeoTransform(GDALGeoTransform&) instead")
     939             : #endif
     940             :             ;
     941             : 
     942             :     CPLErr SetGeoTransform(const double *padfGeoTransform)
     943             : #if defined(GDAL_COMPILATION) && !defined(DOXYGEN_XML)
     944             :         CPL_WARN_DEPRECATED(
     945             :             "Use SetGeoTransform(const GDALGeoTransform&) instead")
     946             : #endif
     947             :             ;
     948             : 
     949             :     virtual CPLErr GetExtent(OGREnvelope *psExtent,
     950             :                              const OGRSpatialReference *poCRS = nullptr) const;
     951             :     virtual CPLErr GetExtentWGS84LongLat(OGREnvelope *psExtent) const;
     952             : 
     953             :     CPLErr GeolocationToPixelLine(
     954             :         double dfGeolocX, double dfGeolocY, const OGRSpatialReference *poSRS,
     955             :         double *pdfPixel, double *pdfLine,
     956             :         CSLConstList papszTransformerOptions = nullptr) const;
     957             : 
     958             :     virtual CPLErr AddBand(GDALDataType eType, char **papszOptions = nullptr);
     959             : 
     960             :     virtual void *GetInternalHandle(const char *pszHandleName);
     961             :     virtual GDALDriver *GetDriver(void);
     962             :     virtual char **GetFileList(void);
     963             : 
     964             :     virtual const char *GetDriverName();
     965             : 
     966             :     virtual const OGRSpatialReference *GetGCPSpatialRef() const;
     967             :     virtual int GetGCPCount();
     968             :     virtual const GDAL_GCP *GetGCPs();
     969             :     virtual CPLErr SetGCPs(int nGCPCount, const GDAL_GCP *pasGCPList,
     970             :                            const OGRSpatialReference *poGCP_SRS);
     971             : 
     972             :     // Compatibility layer
     973             :     const char *GetGCPProjection();
     974             :     CPLErr SetGCPs(int nGCPCount, const GDAL_GCP *pasGCPList,
     975             :                    const char *pszGCPProjection);
     976             : 
     977             :     virtual CPLErr AdviseRead(int nXOff, int nYOff, int nXSize, int nYSize,
     978             :                               int nBufXSize, int nBufYSize, GDALDataType eDT,
     979             :                               int nBandCount, int *panBandList,
     980             :                               char **papszOptions);
     981             : 
     982             :     virtual CPLErr CreateMaskBand(int nFlagsIn);
     983             : 
     984             :     virtual GDALAsyncReader *
     985             :     BeginAsyncReader(int nXOff, int nYOff, int nXSize, int nYSize, void *pBuf,
     986             :                      int nBufXSize, int nBufYSize, GDALDataType eBufType,
     987             :                      int nBandCount, int *panBandMap, int nPixelSpace,
     988             :                      int nLineSpace, int nBandSpace, char **papszOptions);
     989             :     virtual void EndAsyncReader(GDALAsyncReader *poARIO);
     990             : 
     991             :     //! @cond Doxygen_Suppress
     992             :     struct RawBinaryLayout
     993             :     {
     994             :         enum class Interleaving
     995             :         {
     996             :             UNKNOWN,
     997             :             BIP,
     998             :             BIL,
     999             :             BSQ
    1000             :         };
    1001             :         std::string osRawFilename{};
    1002             :         Interleaving eInterleaving = Interleaving::UNKNOWN;
    1003             :         GDALDataType eDataType = GDT_Unknown;
    1004             :         bool bLittleEndianOrder = false;
    1005             : 
    1006             :         vsi_l_offset nImageOffset = 0;
    1007             :         GIntBig nPixelOffset = 0;
    1008             :         GIntBig nLineOffset = 0;
    1009             :         GIntBig nBandOffset = 0;
    1010             :     };
    1011             : 
    1012             :     virtual bool GetRawBinaryLayout(RawBinaryLayout &);
    1013             :     //! @endcond
    1014             : 
    1015             : #ifndef DOXYGEN_SKIP
    1016             :     CPLErr RasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
    1017             :                     int nYSize, void *pData, int nBufXSize, int nBufYSize,
    1018             :                     GDALDataType eBufType, int nBandCount,
    1019             :                     const int *panBandMap, GSpacing nPixelSpace,
    1020             :                     GSpacing nLineSpace, GSpacing nBandSpace,
    1021             :                     GDALRasterIOExtraArg *psExtraArg
    1022             :                         OPTIONAL_OUTSIDE_GDAL(nullptr)) CPL_WARN_UNUSED_RESULT;
    1023             : #else
    1024             :     CPLErr RasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
    1025             :                     int nYSize, void *pData, int nBufXSize, int nBufYSize,
    1026             :                     GDALDataType eBufType, int nBandCount,
    1027             :                     const int *panBandMap, GSpacing nPixelSpace,
    1028             :                     GSpacing nLineSpace, GSpacing nBandSpace,
    1029             :                     GDALRasterIOExtraArg *psExtraArg) CPL_WARN_UNUSED_RESULT;
    1030             : #endif
    1031             : 
    1032             :     virtual CPLStringList GetCompressionFormats(int nXOff, int nYOff,
    1033             :                                                 int nXSize, int nYSize,
    1034             :                                                 int nBandCount,
    1035             :                                                 const int *panBandList);
    1036             :     virtual CPLErr ReadCompressedData(const char *pszFormat, int nXOff,
    1037             :                                       int nYOff, int nXSize, int nYSize,
    1038             :                                       int nBands, const int *panBandList,
    1039             :                                       void **ppBuffer, size_t *pnBufferSize,
    1040             :                                       char **ppszDetailedFormat);
    1041             : 
    1042             :     int Reference();
    1043             :     int Dereference();
    1044             :     int ReleaseRef();
    1045             : 
    1046             :     /** Return access mode.
    1047             :      * @return access mode.
    1048             :      */
    1049      190988 :     GDALAccess GetAccess() const
    1050             :     {
    1051      190988 :         return eAccess;
    1052             :     }
    1053             : 
    1054             :     int GetShared() const;
    1055             :     void MarkAsShared();
    1056             : 
    1057             :     void MarkSuppressOnClose();
    1058             :     void UnMarkSuppressOnClose();
    1059             : 
    1060             :     /** Return MarkSuppressOnClose flag.
    1061             :     * @return MarkSuppressOnClose flag.
    1062             :     */
    1063     5763785 :     bool IsMarkedSuppressOnClose() const
    1064             :     {
    1065     5763785 :         return bSuppressOnClose;
    1066             :     }
    1067             : 
    1068             :     /** Return open options.
    1069             :      * @return open options.
    1070             :      */
    1071      142671 :     char **GetOpenOptions()
    1072             :     {
    1073      142671 :         return papszOpenOptions;
    1074             :     }
    1075             : 
    1076             :     bool IsThreadSafe(int nScopeFlags) const;
    1077             : 
    1078             : #ifndef DOXYGEN_SKIP
    1079             :     /** Return open options.
    1080             :      * @return open options.
    1081             :      */
    1082           7 :     CSLConstList GetOpenOptions() const
    1083             :     {
    1084           7 :         return papszOpenOptions;
    1085             :     }
    1086             : #endif
    1087             : 
    1088             :     static GDALDataset **GetOpenDatasets(int *pnDatasetCount);
    1089             : 
    1090             : #ifndef DOXYGEN_SKIP
    1091             :     CPLErr
    1092             :     BuildOverviews(const char *pszResampling, int nOverviews,
    1093             :                    const int *panOverviewList, int nListBands,
    1094             :                    const int *panBandList, GDALProgressFunc pfnProgress,
    1095             :                    void *pProgressData,
    1096             :                    CSLConstList papszOptions OPTIONAL_OUTSIDE_GDAL(nullptr));
    1097             : #else
    1098             :     CPLErr BuildOverviews(const char *pszResampling, int nOverviews,
    1099             :                           const int *panOverviewList, int nListBands,
    1100             :                           const int *panBandList, GDALProgressFunc pfnProgress,
    1101             :                           void *pProgressData, CSLConstList papszOptions);
    1102             : #endif
    1103             : 
    1104             :     virtual CPLErr AddOverviews(const std::vector<GDALDataset *> &apoSrcOvrDS,
    1105             :                                 GDALProgressFunc pfnProgress,
    1106             :                                 void *pProgressData, CSLConstList papszOptions);
    1107             : 
    1108             : #ifndef DOXYGEN_XML
    1109             :     void ReportError(CPLErr eErrClass, CPLErrorNum err_no, const char *fmt,
    1110             :                      ...) const CPL_PRINT_FUNC_FORMAT(4, 5);
    1111             : 
    1112             :     static void ReportError(const char *pszDSName, CPLErr eErrClass,
    1113             :                             CPLErrorNum err_no, const char *fmt, ...)
    1114             :         CPL_PRINT_FUNC_FORMAT(4, 5);
    1115             : #endif
    1116             : 
    1117             :     char **GetMetadata(const char *pszDomain = "") override;
    1118             : 
    1119             : // Only defined when Doxygen enabled
    1120             : #ifdef DOXYGEN_SKIP
    1121             :     CPLErr SetMetadata(char **papszMetadata, const char *pszDomain) override;
    1122             :     CPLErr SetMetadataItem(const char *pszName, const char *pszValue,
    1123             :                            const char *pszDomain) override;
    1124             : #endif
    1125             : 
    1126             :     char **GetMetadataDomainList() override;
    1127             : 
    1128             :     virtual void ClearStatistics();
    1129             : 
    1130             :     /** Convert a GDALDataset* to a GDALDatasetH.
    1131             :      * @since GDAL 2.3
    1132             :      */
    1133       30134 :     static inline GDALDatasetH ToHandle(GDALDataset *poDS)
    1134             :     {
    1135       30134 :         return static_cast<GDALDatasetH>(poDS);
    1136             :     }
    1137             : 
    1138             :     /** Convert a GDALDatasetH to a GDALDataset*.
    1139             :      * @since GDAL 2.3
    1140             :      */
    1141     1500297 :     static inline GDALDataset *FromHandle(GDALDatasetH hDS)
    1142             :     {
    1143     1500297 :         return static_cast<GDALDataset *>(hDS);
    1144             :     }
    1145             : 
    1146             :     /** @see GDALOpenEx().
    1147             :      * @since GDAL 2.3
    1148             :      */
    1149       30035 :     static GDALDataset *Open(const char *pszFilename,
    1150             :                              unsigned int nOpenFlags = 0,
    1151             :                              const char *const *papszAllowedDrivers = nullptr,
    1152             :                              const char *const *papszOpenOptions = nullptr,
    1153             :                              const char *const *papszSiblingFiles = nullptr)
    1154             :     {
    1155       30035 :         return FromHandle(GDALOpenEx(pszFilename, nOpenFlags,
    1156             :                                      papszAllowedDrivers, papszOpenOptions,
    1157       29929 :                                      papszSiblingFiles));
    1158             :     }
    1159             : 
    1160             :     /** Object returned by GetFeatures() iterators */
    1161             :     struct FeatureLayerPair
    1162             :     {
    1163             :         /** Unique pointer to a OGRFeature. */
    1164             :         OGRFeatureUniquePtr feature{};
    1165             : 
    1166             :         /** Layer to which the feature belongs to. */
    1167             :         OGRLayer *layer = nullptr;
    1168             :     };
    1169             : 
    1170             :     //! @cond Doxygen_Suppress
    1171             :     // SetEnableOverviews() only to be used by GDALOverviewDataset
    1172             :     void SetEnableOverviews(bool bEnable);
    1173             : 
    1174             :     // Only to be used by driver's GetOverviewCount() method.
    1175             :     bool AreOverviewsEnabled() const;
    1176             : 
    1177             :     static void ReportUpdateNotSupportedByDriver(const char *pszDriverName);
    1178             :     //! @endcond
    1179             : 
    1180             :   private:
    1181             :     class Private;
    1182             :     Private *m_poPrivate;
    1183             : 
    1184             :     CPL_INTERNAL OGRLayer *BuildLayerFromSelectInfo(
    1185             :         swq_select *psSelectInfo, OGRGeometry *poSpatialFilter,
    1186             :         const char *pszDialect, swq_select_parse_options *poSelectParseOptions);
    1187             :     CPLStringList oDerivedMetadataList{};
    1188             : 
    1189             :   public:
    1190             :     virtual int GetLayerCount();
    1191             :     virtual OGRLayer *GetLayer(int iLayer);
    1192             : 
    1193             :     virtual bool IsLayerPrivate(int iLayer) const;
    1194             : 
    1195             :     /** Class returned by GetLayers() that acts as a range of layers.
    1196             :      * @since GDAL 2.3
    1197             :      */
    1198             :     class CPL_DLL Layers
    1199             :     {
    1200             :       private:
    1201             :         friend class GDALDataset;
    1202             :         GDALDataset *m_poSelf;
    1203             : 
    1204         208 :         CPL_INTERNAL explicit Layers(GDALDataset *poSelf) : m_poSelf(poSelf)
    1205             :         {
    1206         208 :         }
    1207             : 
    1208             :       public:
    1209             :         /** Layer iterator.
    1210             :          * @since GDAL 2.3
    1211             :          */
    1212         426 :         class CPL_DLL Iterator
    1213             :         {
    1214             :             struct Private;
    1215             :             std::unique_ptr<Private> m_poPrivate;
    1216             : 
    1217             :           public:
    1218             :             using value_type = OGRLayer *; /**< value_type */
    1219             :             using reference = OGRLayer *;  /**< reference */
    1220             :             using difference_type = void;  /**< difference_type */
    1221             :             using pointer = void;          /**< pointer */
    1222             :             using iterator_category =
    1223             :                 std::input_iterator_tag; /**< iterator_category */
    1224             : 
    1225             :             Iterator(); /**< Default constructor */
    1226             :             Iterator(GDALDataset *poDS, bool bStart); /**< Constructor */
    1227             :             Iterator(const Iterator &oOther);         /**< Copy constructor */
    1228             :             Iterator(Iterator &&oOther) noexcept;     /**< Move constructor */
    1229             :             ~Iterator();                              /**< Destructor */
    1230             : 
    1231             :             Iterator &
    1232             :             operator=(const Iterator &oOther); /**< Assignment operator */
    1233             :             Iterator &operator=(
    1234             :                 Iterator &&oOther) noexcept; /**< Move assignment operator */
    1235             : 
    1236             :             OGRLayer *operator*() const; /**< Dereference operator */
    1237             :             Iterator &operator++();      /**< Pre-increment operator */
    1238             :             Iterator operator++(int);    /**< Post-increment operator */
    1239             :             bool operator!=(const Iterator &it)
    1240             :                 const; /**< Difference comparison operator */
    1241             :         };
    1242             : 
    1243             :         Iterator begin() const;
    1244             :         Iterator end() const;
    1245             : 
    1246             :         size_t size() const;
    1247             : 
    1248             :         OGRLayer *operator[](int iLayer);
    1249             :         OGRLayer *operator[](size_t iLayer);
    1250             :         OGRLayer *operator[](const char *pszLayername);
    1251             :     };
    1252             : 
    1253             :     Layers GetLayers();
    1254             : 
    1255             :     virtual OGRLayer *GetLayerByName(const char *);
    1256             : 
    1257             :     int GetLayerIndex(const char *pszName);
    1258             : 
    1259             :     virtual OGRErr DeleteLayer(int iLayer);
    1260             : 
    1261             :     virtual void ResetReading();
    1262             :     virtual OGRFeature *GetNextFeature(OGRLayer **ppoBelongingLayer,
    1263             :                                        double *pdfProgressPct,
    1264             :                                        GDALProgressFunc pfnProgress,
    1265             :                                        void *pProgressData);
    1266             : 
    1267             :     /** Class returned by GetFeatures() that act as a container for vector
    1268             :      * features. */
    1269             :     class CPL_DLL Features
    1270             :     {
    1271             :       private:
    1272             :         friend class GDALDataset;
    1273             :         GDALDataset *m_poSelf;
    1274             : 
    1275           2 :         CPL_INTERNAL explicit Features(GDALDataset *poSelf) : m_poSelf(poSelf)
    1276             :         {
    1277           2 :         }
    1278             : 
    1279           4 :         class CPL_DLL Iterator
    1280             :         {
    1281             :             struct Private;
    1282             :             std::unique_ptr<Private> m_poPrivate;
    1283             : 
    1284             :           public:
    1285             :             Iterator(GDALDataset *poDS, bool bStart);
    1286             :             Iterator(const Iterator &oOther);  // declared but not defined.
    1287             :                                                // Needed for gcc 5.4 at least
    1288             :             Iterator(Iterator &&oOther) noexcept;  // declared but not defined.
    1289             :                 // Needed for gcc 5.4 at least
    1290             :             ~Iterator();
    1291             :             const FeatureLayerPair &operator*() const;
    1292             :             Iterator &operator++();
    1293             :             bool operator!=(const Iterator &it) const;
    1294             :         };
    1295             : 
    1296             :       public:
    1297             :         const Iterator begin() const;
    1298             : 
    1299             :         const Iterator end() const;
    1300             :     };
    1301             : 
    1302             :     Features GetFeatures();
    1303             : 
    1304             :     virtual int TestCapability(const char *);
    1305             : 
    1306             :     virtual std::vector<std::string>
    1307             :     GetFieldDomainNames(CSLConstList papszOptions = nullptr) const;
    1308             : 
    1309             :     virtual const OGRFieldDomain *GetFieldDomain(const std::string &name) const;
    1310             : 
    1311             :     virtual bool AddFieldDomain(std::unique_ptr<OGRFieldDomain> &&domain,
    1312             :                                 std::string &failureReason);
    1313             : 
    1314             :     virtual bool DeleteFieldDomain(const std::string &name,
    1315             :                                    std::string &failureReason);
    1316             : 
    1317             :     virtual bool UpdateFieldDomain(std::unique_ptr<OGRFieldDomain> &&domain,
    1318             :                                    std::string &failureReason);
    1319             : 
    1320             :     virtual std::vector<std::string>
    1321             :     GetRelationshipNames(CSLConstList papszOptions = nullptr) const;
    1322             : 
    1323             :     virtual const GDALRelationship *
    1324             :     GetRelationship(const std::string &name) const;
    1325             : 
    1326             :     virtual bool
    1327             :     AddRelationship(std::unique_ptr<GDALRelationship> &&relationship,
    1328             :                     std::string &failureReason);
    1329             : 
    1330             :     virtual bool DeleteRelationship(const std::string &name,
    1331             :                                     std::string &failureReason);
    1332             : 
    1333             :     virtual bool
    1334             :     UpdateRelationship(std::unique_ptr<GDALRelationship> &&relationship,
    1335             :                        std::string &failureReason);
    1336             : 
    1337             :     //! @cond Doxygen_Suppress
    1338             :     OGRLayer *CreateLayer(const char *pszName);
    1339             : 
    1340             :     OGRLayer *CreateLayer(const char *pszName, std::nullptr_t);
    1341             :     //! @endcond
    1342             : 
    1343             :     OGRLayer *CreateLayer(const char *pszName,
    1344             :                           const OGRSpatialReference *poSpatialRef,
    1345             :                           OGRwkbGeometryType eGType = wkbUnknown,
    1346             :                           CSLConstList papszOptions = nullptr);
    1347             : 
    1348             :     OGRLayer *CreateLayer(const char *pszName,
    1349             :                           const OGRGeomFieldDefn *poGeomFieldDefn,
    1350             :                           CSLConstList papszOptions = nullptr);
    1351             : 
    1352             :     virtual OGRLayer *CopyLayer(OGRLayer *poSrcLayer, const char *pszNewName,
    1353             :                                 char **papszOptions = nullptr);
    1354             : 
    1355             :     virtual OGRStyleTable *GetStyleTable();
    1356             :     virtual void SetStyleTableDirectly(OGRStyleTable *poStyleTable);
    1357             : 
    1358             :     virtual void SetStyleTable(OGRStyleTable *poStyleTable);
    1359             : 
    1360             :     virtual OGRLayer *ExecuteSQL(const char *pszStatement,
    1361             :                                  OGRGeometry *poSpatialFilter,
    1362             :                                  const char *pszDialect);
    1363             :     virtual void ReleaseResultSet(OGRLayer *poResultsSet);
    1364             :     virtual OGRErr AbortSQL();
    1365             : 
    1366             :     int GetRefCount() const;
    1367             :     int GetSummaryRefCount() const;
    1368             :     OGRErr Release();
    1369             : 
    1370             :     virtual OGRErr StartTransaction(int bForce = FALSE);
    1371             :     virtual OGRErr CommitTransaction();
    1372             :     virtual OGRErr RollbackTransaction();
    1373             : 
    1374             :     virtual std::shared_ptr<GDALGroup> GetRootGroup() const;
    1375             : 
    1376             :     static std::string BuildFilename(const char *pszFilename,
    1377             :                                      const char *pszReferencePath,
    1378             :                                      bool bRelativeToReferencePath);
    1379             : 
    1380             :     //! @cond Doxygen_Suppress
    1381             :     static int IsGenericSQLDialect(const char *pszDialect);
    1382             : 
    1383             :     // Semi-public methods. Only to be used by in-tree drivers.
    1384             :     GDALSQLParseInfo *
    1385             :     BuildParseInfo(swq_select *psSelectInfo,
    1386             :                    swq_select_parse_options *poSelectParseOptions);
    1387             :     static void DestroyParseInfo(GDALSQLParseInfo *psParseInfo);
    1388             :     OGRLayer *ExecuteSQL(const char *pszStatement, OGRGeometry *poSpatialFilter,
    1389             :                          const char *pszDialect,
    1390             :                          swq_select_parse_options *poSelectParseOptions);
    1391             : 
    1392             :     static constexpr const char *const apszSpecialSubDatasetSyntax[] = {
    1393             :         "NITF_IM:{ANY}:{FILENAME}", "PDF:{ANY}:{FILENAME}",
    1394             :         "RASTERLITE:{FILENAME},{ANY}", "TILEDB:\"{FILENAME}\":{ANY}",
    1395             :         "TILEDB:{FILENAME}:{ANY}"};
    1396             : 
    1397             :     //! @endcond
    1398             : 
    1399             :   protected:
    1400             :     virtual OGRLayer *ICreateLayer(const char *pszName,
    1401             :                                    const OGRGeomFieldDefn *poGeomFieldDefn,
    1402             :                                    CSLConstList papszOptions);
    1403             : 
    1404             :     //! @cond Doxygen_Suppress
    1405             :     OGRErr ProcessSQLCreateIndex(const char *);
    1406             :     OGRErr ProcessSQLDropIndex(const char *);
    1407             :     OGRErr ProcessSQLDropTable(const char *);
    1408             :     OGRErr ProcessSQLAlterTableAddColumn(const char *);
    1409             :     OGRErr ProcessSQLAlterTableDropColumn(const char *);
    1410             :     OGRErr ProcessSQLAlterTableAlterColumn(const char *);
    1411             :     OGRErr ProcessSQLAlterTableRenameColumn(const char *);
    1412             : 
    1413             :     OGRStyleTable *m_poStyleTable = nullptr;
    1414             : 
    1415             :     friend class GDALProxyPoolDataset;
    1416             :     //! @endcond
    1417             : 
    1418             :   private:
    1419             :     CPL_DISALLOW_COPY_ASSIGN(GDALDataset)
    1420             : };
    1421             : 
    1422             : //! @cond Doxygen_Suppress
    1423             : struct CPL_DLL GDALDatasetUniquePtrDeleter
    1424             : {
    1425          74 :     void operator()(GDALDataset *poDataset) const
    1426             :     {
    1427          74 :         GDALClose(poDataset);
    1428          74 :     }
    1429             : };
    1430             : 
    1431             : //! @endcond
    1432             : 
    1433             : //! @cond Doxygen_Suppress
    1434             : struct CPL_DLL GDALDatasetUniquePtrReleaser
    1435             : {
    1436        2038 :     void operator()(GDALDataset *poDataset) const
    1437             :     {
    1438        2038 :         if (poDataset)
    1439        2035 :             poDataset->Release();
    1440        2038 :     }
    1441             : };
    1442             : 
    1443             : //! @endcond
    1444             : 
    1445             : /** Unique pointer type for GDALDataset.
    1446             :  * Appropriate for use on datasets open in non-shared mode and onto which
    1447             :  * reference counter has not been manually modified.
    1448             :  * @since GDAL 2.3
    1449             :  */
    1450             : using GDALDatasetUniquePtr =
    1451             :     std::unique_ptr<GDALDataset, GDALDatasetUniquePtrDeleter>;
    1452             : 
    1453             : /* ******************************************************************** */
    1454             : /*                           GDALRasterBlock                            */
    1455             : /* ******************************************************************** */
    1456             : 
    1457             : /** A single raster block in the block cache.
    1458             :  *
    1459             :  * And the global block manager that manages a least-recently-used list of
    1460             :  * blocks from various datasets/bands */
    1461             : class CPL_DLL GDALRasterBlock
    1462             : {
    1463             :     friend class GDALAbstractBandBlockCache;
    1464             : 
    1465             :     GDALDataType eType;
    1466             : 
    1467             :     bool bDirty;
    1468             :     volatile int nLockCount;
    1469             : 
    1470             :     int nXOff;
    1471             :     int nYOff;
    1472             : 
    1473             :     int nXSize;
    1474             :     int nYSize;
    1475             : 
    1476             :     void *pData;
    1477             : 
    1478             :     GDALRasterBand *poBand;
    1479             : 
    1480             :     GDALRasterBlock *poNext;
    1481             :     GDALRasterBlock *poPrevious;
    1482             : 
    1483             :     bool bMustDetach;
    1484             : 
    1485             :     CPL_INTERNAL void Detach_unlocked(void);
    1486             :     CPL_INTERNAL void Touch_unlocked(void);
    1487             : 
    1488             :     CPL_INTERNAL void RecycleFor(int nXOffIn, int nYOffIn);
    1489             : 
    1490             :   public:
    1491             :     GDALRasterBlock(GDALRasterBand *, int, int);
    1492             :     GDALRasterBlock(int nXOffIn, int nYOffIn); /* only for lookup purpose */
    1493             :     virtual ~GDALRasterBlock();
    1494             : 
    1495             :     CPLErr Internalize(void);
    1496             :     void Touch(void);
    1497             :     void MarkDirty(void);
    1498             :     void MarkClean(void);
    1499             : 
    1500             :     /** Increment the lock count */
    1501    10501900 :     int AddLock(void)
    1502             :     {
    1503    10501900 :         return CPLAtomicInc(&nLockCount);
    1504             :     }
    1505             : 
    1506             :     /** Decrement the lock count */
    1507    10501995 :     int DropLock(void)
    1508             :     {
    1509    10501995 :         return CPLAtomicDec(&nLockCount);
    1510             :     }
    1511             : 
    1512             :     void Detach();
    1513             : 
    1514             :     CPLErr Write();
    1515             : 
    1516             :     /** Return the data type
    1517             :      * @return data type
    1518             :      */
    1519       19542 :     GDALDataType GetDataType() const
    1520             :     {
    1521       19542 :         return eType;
    1522             :     }
    1523             : 
    1524             :     /** Return the x offset of the top-left corner of the block
    1525             :      * @return x offset
    1526             :      */
    1527    12325700 :     int GetXOff() const
    1528             :     {
    1529    12325700 :         return nXOff;
    1530             :     }
    1531             : 
    1532             :     /** Return the y offset of the top-left corner of the block
    1533             :      * @return y offset
    1534             :      */
    1535   483164000 :     int GetYOff() const
    1536             :     {
    1537   483164000 :         return nYOff;
    1538             :     }
    1539             : 
    1540             :     /** Return the width of the block
    1541             :      * @return width
    1542             :      */
    1543             :     int GetXSize() const
    1544             :     {
    1545             :         return nXSize;
    1546             :     }
    1547             : 
    1548             :     /** Return the height of the block
    1549             :      * @return height
    1550             :      */
    1551             :     int GetYSize() const
    1552             :     {
    1553             :         return nYSize;
    1554             :     }
    1555             : 
    1556             :     /** Return the dirty flag
    1557             :      * @return dirty flag
    1558             :      */
    1559     3977240 :     int GetDirty() const
    1560             :     {
    1561     3977240 :         return bDirty;
    1562             :     }
    1563             : 
    1564             :     /** Return the data buffer
    1565             :      * @return data buffer
    1566             :      */
    1567    13905238 :     void *GetDataRef(void)
    1568             :     {
    1569    13905238 :         return pData;
    1570             :     }
    1571             : 
    1572             :     /** Return the block size in bytes
    1573             :      * @return block size.
    1574             :      */
    1575     6749630 :     GPtrDiff_t GetBlockSize() const
    1576             :     {
    1577     6749630 :         return static_cast<GPtrDiff_t>(nXSize) * nYSize *
    1578     6749630 :                GDALGetDataTypeSizeBytes(eType);
    1579             :     }
    1580             : 
    1581             :     int TakeLock();
    1582             :     int DropLockForRemovalFromStorage();
    1583             : 
    1584             :     /// @brief Accessor to source GDALRasterBand object.
    1585             :     /// @return source raster band of the raster block.
    1586       59290 :     GDALRasterBand *GetBand()
    1587             :     {
    1588       59290 :         return poBand;
    1589             :     }
    1590             : 
    1591             :     static void FlushDirtyBlocks();
    1592             :     static int FlushCacheBlock(int bDirtyBlocksOnly = FALSE);
    1593             :     static void Verify();
    1594             : 
    1595             :     static void EnterDisableDirtyBlockFlush();
    1596             :     static void LeaveDisableDirtyBlockFlush();
    1597             : 
    1598             : #ifdef notdef
    1599             :     static void CheckNonOrphanedBlocks(GDALRasterBand *poBand);
    1600             :     void DumpBlock();
    1601             :     static void DumpAll();
    1602             : #endif
    1603             : 
    1604             :     /* Should only be called by GDALDestroyDriverManager() */
    1605             :     //! @cond Doxygen_Suppress
    1606             :     CPL_INTERNAL static void DestroyRBMutex();
    1607             :     //! @endcond
    1608             : 
    1609             :   private:
    1610             :     CPL_DISALLOW_COPY_ASSIGN(GDALRasterBlock)
    1611             : };
    1612             : 
    1613             : /* ******************************************************************** */
    1614             : /*                             GDALColorTable                           */
    1615             : /* ******************************************************************** */
    1616             : 
    1617             : /** A color table / palette. */
    1618             : 
    1619        2117 : class CPL_DLL GDALColorTable
    1620             : {
    1621             :     GDALPaletteInterp eInterp;
    1622             : 
    1623             :     std::vector<GDALColorEntry> aoEntries{};
    1624             : 
    1625             :   public:
    1626             :     explicit GDALColorTable(GDALPaletteInterp = GPI_RGB);
    1627             : 
    1628             :     /** Copy constructor */
    1629         286 :     GDALColorTable(const GDALColorTable &) = default;
    1630             : 
    1631             :     /** Copy assignment operator */
    1632             :     GDALColorTable &operator=(const GDALColorTable &) = default;
    1633             : 
    1634             :     /** Move constructor */
    1635             :     GDALColorTable(GDALColorTable &&) = default;
    1636             : 
    1637             :     /** Move assignment operator */
    1638             :     GDALColorTable &operator=(GDALColorTable &&) = default;
    1639             : 
    1640             :     ~GDALColorTable();
    1641             : 
    1642             :     GDALColorTable *Clone() const;
    1643             :     int IsSame(const GDALColorTable *poOtherCT) const;
    1644             : 
    1645             :     GDALPaletteInterp GetPaletteInterpretation() const;
    1646             : 
    1647             :     int GetColorEntryCount() const;
    1648             :     const GDALColorEntry *GetColorEntry(int i) const;
    1649             :     int GetColorEntryAsRGB(int i, GDALColorEntry *poEntry) const;
    1650             :     void SetColorEntry(int i, const GDALColorEntry *poEntry);
    1651             :     int CreateColorRamp(int nStartIndex, const GDALColorEntry *psStartColor,
    1652             :                         int nEndIndex, const GDALColorEntry *psEndColor);
    1653             :     bool IsIdentity() const;
    1654             : 
    1655             :     static std::unique_ptr<GDALColorTable>
    1656             :     LoadFromFile(const char *pszFilename);
    1657             : 
    1658             :     /** Convert a GDALColorTable* to a GDALRasterBandH.
    1659             :      * @since GDAL 2.3
    1660             :      */
    1661        1986 :     static inline GDALColorTableH ToHandle(GDALColorTable *poCT)
    1662             :     {
    1663        1986 :         return static_cast<GDALColorTableH>(poCT);
    1664             :     }
    1665             : 
    1666             :     /** Convert a GDALColorTableH to a GDALColorTable*.
    1667             :      * @since GDAL 2.3
    1668             :      */
    1669       22075 :     static inline GDALColorTable *FromHandle(GDALColorTableH hCT)
    1670             :     {
    1671       22075 :         return static_cast<GDALColorTable *>(hCT);
    1672             :     }
    1673             : };
    1674             : 
    1675             : /* ******************************************************************** */
    1676             : /*                       GDALAbstractBandBlockCache                     */
    1677             : /* ******************************************************************** */
    1678             : 
    1679             : //! @cond Doxygen_Suppress
    1680             : 
    1681             : //! This manages how a raster band store its cached block.
    1682             : // only used by GDALRasterBand implementation.
    1683             : 
    1684             : class GDALAbstractBandBlockCache
    1685             : {
    1686             :     // List of blocks that can be freed or recycled, and its lock
    1687             :     CPLLock *hSpinLock = nullptr;
    1688             :     GDALRasterBlock *psListBlocksToFree = nullptr;
    1689             : 
    1690             :     // Band keep alive counter, and its lock & condition
    1691             :     CPLCond *hCond = nullptr;
    1692             :     CPLMutex *hCondMutex = nullptr;
    1693             :     volatile int nKeepAliveCounter = 0;
    1694             : 
    1695             :     volatile int m_nDirtyBlocks = 0;
    1696             : 
    1697             :     CPL_DISALLOW_COPY_ASSIGN(GDALAbstractBandBlockCache)
    1698             : 
    1699             :   protected:
    1700             :     GDALRasterBand *poBand;
    1701             : 
    1702             :     int m_nInitialDirtyBlocksInFlushCache = 0;
    1703             :     int m_nLastTick = -1;
    1704             :     size_t m_nWriteDirtyBlocksDisabled = 0;
    1705             : 
    1706             :     void FreeDanglingBlocks();
    1707             :     void UnreferenceBlockBase();
    1708             : 
    1709             :     void StartDirtyBlockFlushingLog();
    1710             :     void UpdateDirtyBlockFlushingLog();
    1711             :     void EndDirtyBlockFlushingLog();
    1712             : 
    1713             :   public:
    1714             :     explicit GDALAbstractBandBlockCache(GDALRasterBand *poBand);
    1715             :     virtual ~GDALAbstractBandBlockCache();
    1716             : 
    1717             :     GDALRasterBlock *CreateBlock(int nXBlockOff, int nYBlockOff);
    1718             :     void AddBlockToFreeList(GDALRasterBlock *poBlock);
    1719             :     void IncDirtyBlocks(int nInc);
    1720             :     void WaitCompletionPendingTasks();
    1721             : 
    1722           1 :     void EnableDirtyBlockWriting()
    1723             :     {
    1724           1 :         --m_nWriteDirtyBlocksDisabled;
    1725           1 :     }
    1726             : 
    1727        2999 :     void DisableDirtyBlockWriting()
    1728             :     {
    1729        2999 :         ++m_nWriteDirtyBlocksDisabled;
    1730        2999 :     }
    1731             : 
    1732           0 :     bool HasDirtyBlocks() const
    1733             :     {
    1734           0 :         return m_nDirtyBlocks > 0;
    1735             :     }
    1736             : 
    1737             :     virtual bool Init() = 0;
    1738             :     virtual bool IsInitOK() = 0;
    1739             :     virtual CPLErr FlushCache() = 0;
    1740             :     virtual CPLErr AdoptBlock(GDALRasterBlock *poBlock) = 0;
    1741             :     virtual GDALRasterBlock *TryGetLockedBlockRef(int nXBlockOff,
    1742             :                                                   int nYBlockYOff) = 0;
    1743             :     virtual CPLErr UnreferenceBlock(GDALRasterBlock *poBlock) = 0;
    1744             :     virtual CPLErr FlushBlock(int nXBlockOff, int nYBlockOff,
    1745             :                               int bWriteDirtyBlock) = 0;
    1746             : };
    1747             : 
    1748             : GDALAbstractBandBlockCache *
    1749             : GDALArrayBandBlockCacheCreate(GDALRasterBand *poBand);
    1750             : GDALAbstractBandBlockCache *
    1751             : GDALHashSetBandBlockCacheCreate(GDALRasterBand *poBand);
    1752             : 
    1753             : //! @endcond
    1754             : 
    1755             : /* ******************************************************************** */
    1756             : /*                            GDALRasterBand                            */
    1757             : /* ******************************************************************** */
    1758             : 
    1759             : class GDALMDArray;
    1760             : class GDALDoublePointsCache;
    1761             : 
    1762             : /** Range of values found in a mask band */
    1763             : typedef enum
    1764             : {
    1765             :     GMVR_UNKNOWN, /*! Unknown (can also be used for any values between 0 and 255
    1766             :                      for a Byte band) */
    1767             :     GMVR_0_AND_1_ONLY,   /*! Only 0 and 1 */
    1768             :     GMVR_0_AND_255_ONLY, /*! Only 0 and 255 */
    1769             : } GDALMaskValueRange;
    1770             : 
    1771             : /** Suggested/most efficient access pattern to blocks. */
    1772             : typedef int GDALSuggestedBlockAccessPattern;
    1773             : 
    1774             : /** Unknown, or no particular read order is suggested. */
    1775             : constexpr GDALSuggestedBlockAccessPattern GSBAP_UNKNOWN = 0;
    1776             : 
    1777             : /** Random access to blocks is efficient. */
    1778             : constexpr GDALSuggestedBlockAccessPattern GSBAP_RANDOM = 1;
    1779             : 
    1780             : /** Reading by strips from top to bottom is the most efficient. */
    1781             : constexpr GDALSuggestedBlockAccessPattern GSBAP_TOP_TO_BOTTOM = 2;
    1782             : 
    1783             : /** Reading by strips from bottom to top is the most efficient. */
    1784             : constexpr GDALSuggestedBlockAccessPattern GSBAP_BOTTOM_TO_TOP = 3;
    1785             : 
    1786             : /** Reading the largest chunk from the raster is the most efficient (can be
    1787             :  * combined with above values). */
    1788             : constexpr GDALSuggestedBlockAccessPattern GSBAP_LARGEST_CHUNK_POSSIBLE = 0x100;
    1789             : 
    1790             : class GDALComputedRasterBand;
    1791             : 
    1792             : /** A rectangular subset of pixels within a raster */
    1793             : class GDALRasterWindow
    1794             : {
    1795             :   public:
    1796             :     /** left offset of the window */
    1797             :     int nXOff;
    1798             : 
    1799             :     /** top offset of the window */
    1800             :     int nYOff;
    1801             : 
    1802             :     /** window width */
    1803             :     int nXSize;
    1804             : 
    1805             :     /** window height */
    1806             :     int nYSize;
    1807             : };
    1808             : 
    1809             : /** A single raster band (or channel). */
    1810             : 
    1811             : class CPL_DLL GDALRasterBand : public GDALMajorObject
    1812             : {
    1813             :   private:
    1814             :     friend class GDALArrayBandBlockCache;
    1815             :     friend class GDALHashSetBandBlockCache;
    1816             :     friend class GDALRasterBlock;
    1817             :     friend class GDALDataset;
    1818             : 
    1819             :     CPLErr eFlushBlockErr = CE_None;
    1820             :     GDALAbstractBandBlockCache *poBandBlockCache = nullptr;
    1821             : 
    1822             :     CPL_INTERNAL void SetFlushBlockErr(CPLErr eErr);
    1823             :     CPL_INTERNAL CPLErr UnreferenceBlock(GDALRasterBlock *poBlock);
    1824             :     CPL_INTERNAL void IncDirtyBlocks(int nInc);
    1825             : 
    1826             :     CPL_INTERNAL CPLErr RasterIOInternal(
    1827             :         GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize,
    1828             :         void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType,
    1829             :         GSpacing nPixelSpace, GSpacing nLineSpace,
    1830             :         GDALRasterIOExtraArg *psExtraArg) CPL_WARN_UNUSED_RESULT;
    1831             : 
    1832             :   protected:
    1833             :     //! @cond Doxygen_Suppress
    1834             :     GDALDataset *poDS = nullptr;
    1835             :     int nBand = 0; /* 1 based */
    1836             : 
    1837             :     int nRasterXSize = 0;
    1838             :     int nRasterYSize = 0;
    1839             : 
    1840             :     GDALDataType eDataType = GDT_Byte;
    1841             :     GDALAccess eAccess = GA_ReadOnly;
    1842             : 
    1843             :     /* stuff related to blocking, and raster cache */
    1844             :     int nBlockXSize = -1;
    1845             :     int nBlockYSize = -1;
    1846             :     int nBlocksPerRow = 0;
    1847             :     int nBlocksPerColumn = 0;
    1848             : 
    1849             :     int nBlockReads = 0;
    1850             :     int bForceCachedIO = 0;
    1851             : 
    1852             :     friend class GDALComputedRasterBand;
    1853             :     friend class GDALComputedDataset;
    1854             : 
    1855             :     class GDALRasterBandOwnedOrNot
    1856             :     {
    1857             :       public:
    1858     1909960 :         GDALRasterBandOwnedOrNot() = default;
    1859             : 
    1860             :         GDALRasterBandOwnedOrNot(GDALRasterBandOwnedOrNot &&) = default;
    1861             : 
    1862     1910130 :         void reset()
    1863             :         {
    1864     1910130 :             m_poBandOwned.reset();
    1865     1910120 :             m_poBandRef = nullptr;
    1866     1910120 :         }
    1867             : 
    1868        1658 :         void resetNotOwned(GDALRasterBand *poBand)
    1869             :         {
    1870        1658 :             m_poBandOwned.reset();
    1871        1658 :             m_poBandRef = poBand;
    1872        1658 :         }
    1873             : 
    1874      160374 :         void reset(std::unique_ptr<GDALRasterBand> poBand)
    1875             :         {
    1876      160374 :             m_poBandOwned = std::move(poBand);
    1877      160374 :             m_poBandRef = nullptr;
    1878      160374 :         }
    1879             : 
    1880           2 :         const GDALRasterBand *get() const
    1881             :         {
    1882           2 :             return static_cast<const GDALRasterBand *>(*this);
    1883             :         }
    1884             : 
    1885     1440710 :         GDALRasterBand *get()
    1886             :         {
    1887     1440710 :             return static_cast<GDALRasterBand *>(*this);
    1888             :         }
    1889             : 
    1890      712695 :         bool IsOwned() const
    1891             :         {
    1892      712695 :             return m_poBandOwned != nullptr;
    1893             :         }
    1894             : 
    1895           2 :         operator const GDALRasterBand *() const
    1896             :         {
    1897           2 :             return m_poBandOwned ? m_poBandOwned.get() : m_poBandRef;
    1898             :         }
    1899             : 
    1900     3108820 :         operator GDALRasterBand *()
    1901             :         {
    1902     3108820 :             return m_poBandOwned ? m_poBandOwned.get() : m_poBandRef;
    1903             :         }
    1904             : 
    1905             :       private:
    1906             :         CPL_DISALLOW_COPY_ASSIGN(GDALRasterBandOwnedOrNot)
    1907             :         std::unique_ptr<GDALRasterBand> m_poBandOwned{};
    1908             :         GDALRasterBand *m_poBandRef = nullptr;
    1909             :     };
    1910             : 
    1911             :     GDALRasterBandOwnedOrNot poMask{};
    1912             :     bool m_bEnablePixelTypeSignedByteWarning =
    1913             :         true;  // Remove me in GDAL 4.0. See GetMetadataItem() implementation
    1914             :     int nMaskFlags = 0;
    1915             : 
    1916             :     void InvalidateMaskBand();
    1917             : 
    1918             :     friend class GDALProxyRasterBand;
    1919             :     friend class GDALDefaultOverviews;
    1920             : 
    1921             :     CPLErr
    1922             :     RasterIOResampled(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
    1923             :                       int nYSize, void *pData, int nBufXSize, int nBufYSize,
    1924             :                       GDALDataType eBufType, GSpacing nPixelSpace,
    1925             :                       GSpacing nLineSpace,
    1926             :                       GDALRasterIOExtraArg *psExtraArg) CPL_WARN_UNUSED_RESULT;
    1927             : 
    1928             :     int EnterReadWrite(GDALRWFlag eRWFlag);
    1929             :     void LeaveReadWrite();
    1930             :     void InitRWLock();
    1931             :     void SetValidPercent(GUIntBig nSampleCount, GUIntBig nValidCount);
    1932             : 
    1933             :     mutable GDALDoublePointsCache *m_poPointsCache = nullptr;
    1934             : 
    1935             :     //! @endcond
    1936             : 
    1937             :   protected:
    1938             :     virtual CPLErr IReadBlock(int nBlockXOff, int nBlockYOff, void *pData) = 0;
    1939             :     virtual CPLErr IWriteBlock(int nBlockXOff, int nBlockYOff, void *pData);
    1940             : 
    1941             :     virtual CPLErr
    1942             :     IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize,
    1943             :               void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType,
    1944             :               GSpacing nPixelSpace, GSpacing nLineSpace,
    1945             :               GDALRasterIOExtraArg *psExtraArg) CPL_WARN_UNUSED_RESULT;
    1946             : 
    1947             :     virtual int IGetDataCoverageStatus(int nXOff, int nYOff, int nXSize,
    1948             :                                        int nYSize, int nMaskFlagStop,
    1949             :                                        double *pdfDataPct);
    1950             : 
    1951             :     virtual bool
    1952             :     EmitErrorMessageIfWriteNotSupported(const char *pszCaller) const;
    1953             : 
    1954             :     //! @cond Doxygen_Suppress
    1955             :     CPLErr
    1956             :     OverviewRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
    1957             :                      int nYSize, void *pData, int nBufXSize, int nBufYSize,
    1958             :                      GDALDataType eBufType, GSpacing nPixelSpace,
    1959             :                      GSpacing nLineSpace,
    1960             :                      GDALRasterIOExtraArg *psExtraArg) CPL_WARN_UNUSED_RESULT;
    1961             : 
    1962             :     CPLErr TryOverviewRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
    1963             :                                int nXSize, int nYSize, void *pData,
    1964             :                                int nBufXSize, int nBufYSize,
    1965             :                                GDALDataType eBufType, GSpacing nPixelSpace,
    1966             :                                GSpacing nLineSpace,
    1967             :                                GDALRasterIOExtraArg *psExtraArg, int *pbTried);
    1968             : 
    1969             :     CPLErr SplitRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
    1970             :                          int nYSize, void *pData, int nBufXSize, int nBufYSize,
    1971             :                          GDALDataType eBufType, GSpacing nPixelSpace,
    1972             :                          GSpacing nLineSpace, GDALRasterIOExtraArg *psExtraArg)
    1973             :         CPL_WARN_UNUSED_RESULT;
    1974             : 
    1975             :     int InitBlockInfo();
    1976             : 
    1977             :     void AddBlockToFreeList(GDALRasterBlock *);
    1978             : 
    1979     2296980 :     bool HasBlockCache() const
    1980             :     {
    1981     2296980 :         return poBandBlockCache != nullptr;
    1982             :     }
    1983             : 
    1984          17 :     bool HasDirtyBlocks() const
    1985             :     {
    1986          17 :         return poBandBlockCache && poBandBlockCache->HasDirtyBlocks();
    1987             :     }
    1988             : 
    1989             :     //! @endcond
    1990             : 
    1991             :   public:
    1992             :     GDALRasterBand();
    1993             :     explicit GDALRasterBand(int bForceCachedIO);
    1994             : 
    1995             :     //! @cond Doxygen_Suppress
    1996             :     GDALRasterBand(GDALRasterBand &&) = default;
    1997             :     //! @endcond
    1998             : 
    1999             :     ~GDALRasterBand() override;
    2000             : 
    2001             :     int GetXSize() const;
    2002             :     int GetYSize() const;
    2003             :     int GetBand() const;
    2004             :     GDALDataset *GetDataset() const;
    2005             : 
    2006             :     GDALDataType GetRasterDataType(void) const;
    2007             :     void GetBlockSize(int *pnXSize, int *pnYSize) const;
    2008             :     CPLErr GetActualBlockSize(int nXBlockOff, int nYBlockOff, int *pnXValid,
    2009             :                               int *pnYValid) const;
    2010             : 
    2011             :     virtual GDALSuggestedBlockAccessPattern
    2012             :     GetSuggestedBlockAccessPattern() const;
    2013             : 
    2014             :     GDALAccess GetAccess();
    2015             : 
    2016             : #ifndef DOXYGEN_SKIP
    2017             :     CPLErr RasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
    2018             :                     int nYSize, void *pData, int nBufXSize, int nBufYSize,
    2019             :                     GDALDataType eBufType, GSpacing nPixelSpace,
    2020             :                     GSpacing nLineSpace,
    2021             :                     GDALRasterIOExtraArg *psExtraArg
    2022             :                         OPTIONAL_OUTSIDE_GDAL(nullptr)) CPL_WARN_UNUSED_RESULT;
    2023             : #else
    2024             :     CPLErr RasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
    2025             :                     int nYSize, void *pData, int nBufXSize, int nBufYSize,
    2026             :                     GDALDataType eBufType, GSpacing nPixelSpace,
    2027             :                     GSpacing nLineSpace,
    2028             :                     GDALRasterIOExtraArg *psExtraArg) CPL_WARN_UNUSED_RESULT;
    2029             : #endif
    2030             : 
    2031             :     template <class T>
    2032             :     CPLErr ReadRaster(T *pData, size_t nArrayEltCount = 0, double dfXOff = 0,
    2033             :                       double dfYOff = 0, double dfXSize = 0, double dfYSize = 0,
    2034             :                       size_t nBufXSize = 0, size_t nBufYSize = 0,
    2035             :                       GDALRIOResampleAlg eResampleAlg = GRIORA_NearestNeighbour,
    2036             :                       GDALProgressFunc pfnProgress = nullptr,
    2037             :                       void *pProgressData = nullptr) const;
    2038             : 
    2039             :     template <class T>
    2040             :     CPLErr ReadRaster(std::vector<T> &vData, double dfXOff = 0,
    2041             :                       double dfYOff = 0, double dfXSize = 0, double dfYSize = 0,
    2042             :                       size_t nBufXSize = 0, size_t nBufYSize = 0,
    2043             :                       GDALRIOResampleAlg eResampleAlg = GRIORA_NearestNeighbour,
    2044             :                       GDALProgressFunc pfnProgress = nullptr,
    2045             :                       void *pProgressData = nullptr) const;
    2046             : 
    2047             : #if __cplusplus >= 202002L
    2048             :     //! @cond Doxygen_Suppress
    2049             :     template <class T>
    2050             :     inline CPLErr
    2051             :     ReadRaster(std::span<T> pData, double dfXOff = 0, double dfYOff = 0,
    2052             :                double dfXSize = 0, double dfYSize = 0, size_t nBufXSize = 0,
    2053             :                size_t nBufYSize = 0,
    2054             :                GDALRIOResampleAlg eResampleAlg = GRIORA_NearestNeighbour,
    2055             :                GDALProgressFunc pfnProgress = nullptr,
    2056             :                void *pProgressData = nullptr) const
    2057             :     {
    2058             :         return ReadRaster(pData.data(), pData.size(), dfXOff, dfYOff, dfXSize,
    2059             :                           dfYSize, nBufXSize, nBufYSize, eResampleAlg,
    2060             :                           pfnProgress, pProgressData);
    2061             :     }
    2062             : 
    2063             :     //! @endcond
    2064             : #endif
    2065             : 
    2066             :     GDALComputedRasterBand
    2067             :     operator+(const GDALRasterBand &other) const CPL_WARN_UNUSED_RESULT;
    2068             :     GDALComputedRasterBand operator+(double cst) const CPL_WARN_UNUSED_RESULT;
    2069             :     friend GDALComputedRasterBand CPL_DLL
    2070             :     operator+(double cst, const GDALRasterBand &other) CPL_WARN_UNUSED_RESULT;
    2071             : 
    2072             :     GDALComputedRasterBand
    2073             :     operator-(const GDALRasterBand &other) const CPL_WARN_UNUSED_RESULT;
    2074             :     GDALComputedRasterBand operator-(double cst) const CPL_WARN_UNUSED_RESULT;
    2075             :     friend GDALComputedRasterBand CPL_DLL
    2076             :     operator-(double cst, const GDALRasterBand &other) CPL_WARN_UNUSED_RESULT;
    2077             : 
    2078             :     GDALComputedRasterBand
    2079             :     operator*(const GDALRasterBand &other) const CPL_WARN_UNUSED_RESULT;
    2080             :     GDALComputedRasterBand operator*(double cst) const CPL_WARN_UNUSED_RESULT;
    2081             :     friend GDALComputedRasterBand CPL_DLL
    2082             :     operator*(double cst, const GDALRasterBand &other) CPL_WARN_UNUSED_RESULT;
    2083             : 
    2084             :     GDALComputedRasterBand
    2085             :     operator/(const GDALRasterBand &other) const CPL_WARN_UNUSED_RESULT;
    2086             :     GDALComputedRasterBand operator/(double cst) const CPL_WARN_UNUSED_RESULT;
    2087             :     friend GDALComputedRasterBand CPL_DLL
    2088             :     operator/(double cst, const GDALRasterBand &other) CPL_WARN_UNUSED_RESULT;
    2089             : 
    2090             :     GDALComputedRasterBand
    2091             :     operator>(const GDALRasterBand &other) const CPL_WARN_UNUSED_RESULT;
    2092             :     GDALComputedRasterBand operator>(double cst) const CPL_WARN_UNUSED_RESULT;
    2093             :     friend GDALComputedRasterBand CPL_DLL
    2094             :     operator>(double cst, const GDALRasterBand &other) CPL_WARN_UNUSED_RESULT;
    2095             : 
    2096             :     GDALComputedRasterBand
    2097             :     operator>=(const GDALRasterBand &other) const CPL_WARN_UNUSED_RESULT;
    2098             :     GDALComputedRasterBand operator>=(double cst) const CPL_WARN_UNUSED_RESULT;
    2099             :     friend GDALComputedRasterBand CPL_DLL
    2100             :     operator>=(double cst, const GDALRasterBand &other) CPL_WARN_UNUSED_RESULT;
    2101             : 
    2102             :     GDALComputedRasterBand
    2103             :     operator<(const GDALRasterBand &other) const CPL_WARN_UNUSED_RESULT;
    2104             :     GDALComputedRasterBand operator<(double cst) const CPL_WARN_UNUSED_RESULT;
    2105             :     friend GDALComputedRasterBand CPL_DLL
    2106             :     operator<(double cst, const GDALRasterBand &other) CPL_WARN_UNUSED_RESULT;
    2107             : 
    2108             :     GDALComputedRasterBand
    2109             :     operator<=(const GDALRasterBand &other) const CPL_WARN_UNUSED_RESULT;
    2110             :     GDALComputedRasterBand operator<=(double cst) const CPL_WARN_UNUSED_RESULT;
    2111             :     friend GDALComputedRasterBand CPL_DLL
    2112             :     operator<=(double cst, const GDALRasterBand &other) CPL_WARN_UNUSED_RESULT;
    2113             : 
    2114             :     GDALComputedRasterBand
    2115             :     operator==(const GDALRasterBand &other) const CPL_WARN_UNUSED_RESULT;
    2116             :     GDALComputedRasterBand operator==(double cst) const CPL_WARN_UNUSED_RESULT;
    2117             :     friend GDALComputedRasterBand CPL_DLL
    2118             :     operator==(double cst, const GDALRasterBand &other) CPL_WARN_UNUSED_RESULT;
    2119             : 
    2120             :     GDALComputedRasterBand
    2121             :     operator!=(const GDALRasterBand &other) const CPL_WARN_UNUSED_RESULT;
    2122             :     GDALComputedRasterBand operator!=(double cst) const CPL_WARN_UNUSED_RESULT;
    2123             :     friend GDALComputedRasterBand CPL_DLL
    2124             :     operator!=(double cst, const GDALRasterBand &other) CPL_WARN_UNUSED_RESULT;
    2125             : 
    2126             : #if defined(__GNUC__)
    2127             : #pragma GCC diagnostic push
    2128             : #pragma GCC diagnostic ignored "-Weffc++"
    2129             : #endif
    2130             : 
    2131             :     GDALComputedRasterBand
    2132             :     operator&&(const GDALRasterBand &other) const CPL_WARN_UNUSED_RESULT;
    2133             :     GDALComputedRasterBand operator&&(bool cst) const CPL_WARN_UNUSED_RESULT;
    2134             :     friend GDALComputedRasterBand CPL_DLL
    2135             :     operator&&(bool cst, const GDALRasterBand &other) CPL_WARN_UNUSED_RESULT;
    2136             : 
    2137             :     GDALComputedRasterBand
    2138             :     operator||(const GDALRasterBand &other) const CPL_WARN_UNUSED_RESULT;
    2139             :     GDALComputedRasterBand operator||(bool cst) const CPL_WARN_UNUSED_RESULT;
    2140             :     friend GDALComputedRasterBand CPL_DLL
    2141             :     operator||(bool cst, const GDALRasterBand &other) CPL_WARN_UNUSED_RESULT;
    2142             : 
    2143             : #if defined(__GNUC__)
    2144             : #pragma GCC diagnostic pop
    2145             : #endif
    2146             : 
    2147             :     GDALComputedRasterBand operator!() const CPL_WARN_UNUSED_RESULT;
    2148             : 
    2149             :     GDALComputedRasterBand AsType(GDALDataType) const CPL_WARN_UNUSED_RESULT;
    2150             : 
    2151             :     CPLErr ReadBlock(int nXBlockOff, int nYBlockOff,
    2152             :                      void *pImage) CPL_WARN_UNUSED_RESULT;
    2153             : 
    2154             :     CPLErr WriteBlock(int nXBlockOff, int nYBlockOff,
    2155             :                       void *pImage) CPL_WARN_UNUSED_RESULT;
    2156             : 
    2157             :     // This method should only be overloaded by GDALProxyRasterBand
    2158             :     virtual GDALRasterBlock *
    2159             :     GetLockedBlockRef(int nXBlockOff, int nYBlockOff,
    2160             :                       int bJustInitialize = FALSE) CPL_WARN_UNUSED_RESULT;
    2161             : 
    2162             :     // This method should only be overloaded by GDALProxyRasterBand
    2163             :     virtual GDALRasterBlock *
    2164             :     TryGetLockedBlockRef(int nXBlockOff,
    2165             :                          int nYBlockYOff) CPL_WARN_UNUSED_RESULT;
    2166             : 
    2167             :     // This method should only be overloaded by GDALProxyRasterBand
    2168             :     virtual CPLErr FlushBlock(int nXBlockOff, int nYBlockOff,
    2169             :                               int bWriteDirtyBlock = TRUE);
    2170             : 
    2171             :     unsigned char *
    2172             :     GetIndexColorTranslationTo(/* const */ GDALRasterBand *poReferenceBand,
    2173             :                                unsigned char *pTranslationTable = nullptr,
    2174             :                                int *pApproximateMatching = nullptr);
    2175             : 
    2176             :     // New OpengIS CV_SampleDimension stuff.
    2177             : 
    2178             :     virtual CPLErr FlushCache(bool bAtClosing = false);
    2179             :     virtual CPLErr DropCache();
    2180             :     virtual char **GetCategoryNames();
    2181             :     virtual double GetNoDataValue(int *pbSuccess = nullptr);
    2182             :     virtual int64_t GetNoDataValueAsInt64(int *pbSuccess = nullptr);
    2183             :     virtual uint64_t GetNoDataValueAsUInt64(int *pbSuccess = nullptr);
    2184             :     virtual double GetMinimum(int *pbSuccess = nullptr);
    2185             :     virtual double GetMaximum(int *pbSuccess = nullptr);
    2186             :     virtual double GetOffset(int *pbSuccess = nullptr);
    2187             :     virtual double GetScale(int *pbSuccess = nullptr);
    2188             :     virtual const char *GetUnitType();
    2189             :     virtual GDALColorInterp GetColorInterpretation();
    2190             :     virtual GDALColorTable *GetColorTable();
    2191             :     virtual CPLErr Fill(double dfRealValue, double dfImaginaryValue = 0);
    2192             : 
    2193             :     virtual CPLErr SetCategoryNames(char **papszNames);
    2194             :     virtual CPLErr SetNoDataValue(double dfNoData);
    2195             :     virtual CPLErr SetNoDataValueAsInt64(int64_t nNoData);
    2196             :     virtual CPLErr SetNoDataValueAsUInt64(uint64_t nNoData);
    2197             :     CPLErr SetNoDataValueAsString(const char *pszNoData,
    2198             :                                   bool *pbCannotBeExactlyRepresented = nullptr);
    2199             :     virtual CPLErr DeleteNoDataValue();
    2200             :     virtual CPLErr SetColorTable(GDALColorTable *poCT);
    2201             :     virtual CPLErr SetColorInterpretation(GDALColorInterp eColorInterp);
    2202             :     virtual CPLErr SetOffset(double dfNewOffset);
    2203             :     virtual CPLErr SetScale(double dfNewScale);
    2204             :     virtual CPLErr SetUnitType(const char *pszNewValue);
    2205             : 
    2206             :     virtual CPLErr GetStatistics(int bApproxOK, int bForce, double *pdfMin,
    2207             :                                  double *pdfMax, double *pdfMean,
    2208             :                                  double *padfStdDev);
    2209             :     virtual CPLErr ComputeStatistics(int bApproxOK, double *pdfMin,
    2210             :                                      double *pdfMax, double *pdfMean,
    2211             :                                      double *pdfStdDev, GDALProgressFunc,
    2212             :                                      void *pProgressData);
    2213             :     virtual CPLErr SetStatistics(double dfMin, double dfMax, double dfMean,
    2214             :                                  double dfStdDev);
    2215             :     virtual CPLErr ComputeRasterMinMax(int bApproxOK, double *adfMinMax);
    2216             :     virtual CPLErr ComputeRasterMinMaxLocation(double *pdfMin, double *pdfMax,
    2217             :                                                int *pnMinX, int *pnMinY,
    2218             :                                                int *pnMaxX, int *pnMaxY);
    2219             : 
    2220             : // Only defined when Doxygen enabled
    2221             : #ifdef DOXYGEN_SKIP
    2222             :     CPLErr SetMetadata(char **papszMetadata, const char *pszDomain) override;
    2223             :     CPLErr SetMetadataItem(const char *pszName, const char *pszValue,
    2224             :                            const char *pszDomain) override;
    2225             : #endif
    2226             :     virtual const char *GetMetadataItem(const char *pszName,
    2227             :                                         const char *pszDomain = "") override;
    2228             : 
    2229             :     virtual int HasArbitraryOverviews();
    2230             :     virtual int GetOverviewCount();
    2231             :     virtual GDALRasterBand *GetOverview(int i);
    2232             :     virtual GDALRasterBand *GetRasterSampleOverview(GUIntBig);
    2233             :     virtual CPLErr BuildOverviews(const char *pszResampling, int nOverviews,
    2234             :                                   const int *panOverviewList,
    2235             :                                   GDALProgressFunc pfnProgress,
    2236             :                                   void *pProgressData,
    2237             :                                   CSLConstList papszOptions);
    2238             : 
    2239             :     virtual CPLErr AdviseRead(int nXOff, int nYOff, int nXSize, int nYSize,
    2240             :                               int nBufXSize, int nBufYSize,
    2241             :                               GDALDataType eBufType, char **papszOptions);
    2242             : 
    2243             :     virtual CPLErr GetHistogram(double dfMin, double dfMax, int nBuckets,
    2244             :                                 GUIntBig *panHistogram, int bIncludeOutOfRange,
    2245             :                                 int bApproxOK, GDALProgressFunc,
    2246             :                                 void *pProgressData);
    2247             : 
    2248             :     virtual CPLErr GetDefaultHistogram(double *pdfMin, double *pdfMax,
    2249             :                                        int *pnBuckets, GUIntBig **ppanHistogram,
    2250             :                                        int bForce, GDALProgressFunc,
    2251             :                                        void *pProgressData);
    2252             :     virtual CPLErr SetDefaultHistogram(double dfMin, double dfMax, int nBuckets,
    2253             :                                        GUIntBig *panHistogram);
    2254             : 
    2255             :     virtual GDALRasterAttributeTable *GetDefaultRAT();
    2256             :     virtual CPLErr SetDefaultRAT(const GDALRasterAttributeTable *poRAT);
    2257             : 
    2258             :     virtual GDALRasterBand *GetMaskBand();
    2259             :     virtual int GetMaskFlags();
    2260             :     virtual CPLErr CreateMaskBand(int nFlagsIn);
    2261             :     virtual bool IsMaskBand() const;
    2262             :     virtual GDALMaskValueRange GetMaskValueRange() const;
    2263             : 
    2264             :     virtual CPLVirtualMem *
    2265             :     GetVirtualMemAuto(GDALRWFlag eRWFlag, int *pnPixelSpace,
    2266             :                       GIntBig *pnLineSpace,
    2267             :                       char **papszOptions) CPL_WARN_UNUSED_RESULT;
    2268             : 
    2269             :     int GetDataCoverageStatus(int nXOff, int nYOff, int nXSize, int nYSize,
    2270             :                               int nMaskFlagStop = 0,
    2271             :                               double *pdfDataPct = nullptr);
    2272             : 
    2273             :     std::shared_ptr<GDALMDArray> AsMDArray() const;
    2274             : 
    2275             :     CPLErr InterpolateAtGeolocation(
    2276             :         double dfGeolocX, double dfGeolocY, const OGRSpatialReference *poSRS,
    2277             :         GDALRIOResampleAlg eInterpolation, double *pdfRealValue,
    2278             :         double *pdfImagValue = nullptr,
    2279             :         CSLConstList papszTransformerOptions = nullptr) const;
    2280             : 
    2281             :     virtual CPLErr InterpolateAtPoint(double dfPixel, double dfLine,
    2282             :                                       GDALRIOResampleAlg eInterpolation,
    2283             :                                       double *pdfRealValue,
    2284             :                                       double *pdfImagValue = nullptr) const;
    2285             : 
    2286             :     //! @cond Doxygen_Suppress
    2287             :     class CPL_DLL WindowIterator
    2288             :     {
    2289             :       public:
    2290             :         using iterator_category = std::input_iterator_tag;
    2291             :         using difference_type = std::ptrdiff_t;
    2292             : 
    2293             :         using value_type = GDALRasterWindow;
    2294             :         using pointer = value_type *;
    2295             :         using reference = value_type &;
    2296             : 
    2297             :         WindowIterator(int nRasterXSize, int nRasterYSize, int nBlockXSize,
    2298             :                        int nBlockYSize, int nRow, int nCol);
    2299             : 
    2300             :         bool operator==(const WindowIterator &other) const;
    2301             : 
    2302             :         bool operator!=(const WindowIterator &other) const;
    2303             : 
    2304             :         value_type operator*() const;
    2305             : 
    2306             :         WindowIterator &operator++();
    2307             : 
    2308             :       private:
    2309             :         const int m_nRasterXSize;
    2310             :         const int m_nRasterYSize;
    2311             :         const int m_nBlockXSize;
    2312             :         const int m_nBlockYSize;
    2313             :         int m_row;
    2314             :         int m_col;
    2315             :     };
    2316             : 
    2317             :     class CPL_DLL WindowIteratorWrapper
    2318             :     {
    2319             :       public:
    2320             :         explicit WindowIteratorWrapper(const GDALRasterBand &band);
    2321             : 
    2322             :         WindowIterator begin() const;
    2323             : 
    2324             :         WindowIterator end() const;
    2325             : 
    2326             :       private:
    2327             :         const int m_nRasterXSize;
    2328             :         const int m_nRasterYSize;
    2329             :         int m_nBlockXSize;
    2330             :         int m_nBlockYSize;
    2331             :     };
    2332             : 
    2333             :     //! @endcond
    2334             : 
    2335             :     WindowIteratorWrapper IterateWindows() const;
    2336             : 
    2337             : #ifndef DOXYGEN_XML
    2338             :     void ReportError(CPLErr eErrClass, CPLErrorNum err_no, const char *fmt,
    2339             :                      ...) const CPL_PRINT_FUNC_FORMAT(4, 5);
    2340             : #endif
    2341             : 
    2342             :     //! @cond Doxygen_Suppress
    2343             :     static void ThrowIfNotSameDimensions(const GDALRasterBand &first,
    2344             :                                          const GDALRasterBand &second);
    2345             : 
    2346             :     //! @endcond
    2347             : 
    2348             :     /** Convert a GDALRasterBand* to a GDALRasterBandH.
    2349             :      * @since GDAL 2.3
    2350             :      */
    2351      421239 :     static inline GDALRasterBandH ToHandle(GDALRasterBand *poBand)
    2352             :     {
    2353      421239 :         return static_cast<GDALRasterBandH>(poBand);
    2354             :     }
    2355             : 
    2356             :     /** Convert a GDALRasterBandH to a GDALRasterBand*.
    2357             :      * @since GDAL 2.3
    2358             :      */
    2359     5266496 :     static inline GDALRasterBand *FromHandle(GDALRasterBandH hBand)
    2360             :     {
    2361     5266496 :         return static_cast<GDALRasterBand *>(hBand);
    2362             :     }
    2363             : 
    2364             :     //! @cond Doxygen_Suppress
    2365             :     // Remove me in GDAL 4.0. See GetMetadataItem() implementation
    2366             :     // Internal use in GDAL only !
    2367             :     virtual void EnablePixelTypeSignedByteWarning(bool b)
    2368             : #ifndef GDAL_COMPILATION
    2369             :         CPL_WARN_DEPRECATED("Do not use that method outside of GDAL!")
    2370             : #endif
    2371             :             ;
    2372             : 
    2373             :     //! @endcond
    2374             : 
    2375             :   private:
    2376             :     CPL_DISALLOW_COPY_ASSIGN(GDALRasterBand)
    2377             : };
    2378             : 
    2379             : //! @cond Doxygen_Suppress
    2380             : #define GDAL_EXTERN_TEMPLATE_READ_RASTER(T)                                    \
    2381             :     extern template CPLErr GDALRasterBand::ReadRaster<T>(                      \
    2382             :         T * pData, size_t nArrayEltCount, double dfXOff, double dfYOff,        \
    2383             :         double dfXSize, double dfYSize, size_t nBufXSize, size_t nBufYSize,    \
    2384             :         GDALRIOResampleAlg eResampleAlg, GDALProgressFunc pfnProgress,         \
    2385             :         void *pProgressData) const;
    2386             : 
    2387             : GDAL_EXTERN_TEMPLATE_READ_RASTER(uint8_t)
    2388             : GDAL_EXTERN_TEMPLATE_READ_RASTER(int8_t)
    2389             : GDAL_EXTERN_TEMPLATE_READ_RASTER(uint16_t)
    2390             : GDAL_EXTERN_TEMPLATE_READ_RASTER(int16_t)
    2391             : GDAL_EXTERN_TEMPLATE_READ_RASTER(uint32_t)
    2392             : GDAL_EXTERN_TEMPLATE_READ_RASTER(int32_t)
    2393             : GDAL_EXTERN_TEMPLATE_READ_RASTER(uint64_t)
    2394             : GDAL_EXTERN_TEMPLATE_READ_RASTER(int64_t)
    2395             : #ifdef CPL_FLOAT_H_INCLUDED
    2396             : GDAL_EXTERN_TEMPLATE_READ_RASTER(GFloat16)
    2397             : #endif
    2398             : GDAL_EXTERN_TEMPLATE_READ_RASTER(float)
    2399             : GDAL_EXTERN_TEMPLATE_READ_RASTER(double)
    2400             : // Not allowed by C++ standard
    2401             : // GDAL_EXTERN_TEMPLATE_READ_RASTER(std::complex<int16_t>)
    2402             : // GDAL_EXTERN_TEMPLATE_READ_RASTER(std::complex<int32_t>)
    2403             : GDAL_EXTERN_TEMPLATE_READ_RASTER(std::complex<float>)
    2404             : GDAL_EXTERN_TEMPLATE_READ_RASTER(std::complex<double>)
    2405             : 
    2406             : #define GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(T)                             \
    2407             :     extern template CPLErr GDALRasterBand::ReadRaster<T>(                      \
    2408             :         std::vector<T> & vData, double dfXOff, double dfYOff, double dfXSize,  \
    2409             :         double dfYSize, size_t nBufXSize, size_t nBufYSize,                    \
    2410             :         GDALRIOResampleAlg eResampleAlg, GDALProgressFunc pfnProgress,         \
    2411             :         void *pProgressData) const;
    2412             : 
    2413             : GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(uint8_t)
    2414             : GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(int8_t)
    2415             : GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(uint16_t)
    2416             : GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(int16_t)
    2417             : GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(uint32_t)
    2418             : GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(int32_t)
    2419             : GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(uint64_t)
    2420             : GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(int64_t)
    2421             : #ifdef CPL_FLOAT_H_INCLUDED
    2422             : GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(GFloat16)
    2423             : #endif
    2424             : GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(float)
    2425             : GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(double)
    2426             : // Not allowed by C++ standard
    2427             : // GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(std::complex<int16_t>)
    2428             : // GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(std::complex<int32_t>)
    2429             : GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(std::complex<float>)
    2430             : GDAL_EXTERN_TEMPLATE_READ_RASTER_VECTOR(std::complex<double>)
    2431             : 
    2432             : //! @endcond
    2433             : 
    2434             : /* ******************************************************************** */
    2435             : /*                       GDALComputedRasterBand                         */
    2436             : /* ******************************************************************** */
    2437             : 
    2438             : /** Class represented the result of an operation on one or two input bands.
    2439             :  *
    2440             :  * Such class is instantiated only by operators on GDALRasterBand.
    2441             :  * The resulting band is lazy evaluated.
    2442             :  *
    2443             :  * @since 3.12
    2444             :  */
    2445             : class CPL_DLL GDALComputedRasterBand final : public GDALRasterBand
    2446             : {
    2447             :   public:
    2448             :     /** Destructor */
    2449             :     ~GDALComputedRasterBand() override;
    2450             : 
    2451             :     //! @cond Doxygen_Suppress
    2452             :     enum class Operation
    2453             :     {
    2454             :         OP_ADD,
    2455             :         OP_SUBTRACT,
    2456             :         OP_MULTIPLY,
    2457             :         OP_DIVIDE,
    2458             :         OP_MIN,
    2459             :         OP_MAX,
    2460             :         OP_MEAN,
    2461             :         OP_GT,
    2462             :         OP_GE,
    2463             :         OP_LT,
    2464             :         OP_LE,
    2465             :         OP_EQ,
    2466             :         OP_NE,
    2467             :         OP_LOGICAL_AND,
    2468             :         OP_LOGICAL_OR,
    2469             :         OP_CAST,
    2470             :         OP_TERNARY,
    2471             :     };
    2472             : 
    2473             :     GDALComputedRasterBand(
    2474             :         Operation op, const std::vector<const GDALRasterBand *> &bands,
    2475             :         double constant = std::numeric_limits<double>::quiet_NaN());
    2476             :     GDALComputedRasterBand(Operation op, double constant,
    2477             :                            const GDALRasterBand &band);
    2478             :     GDALComputedRasterBand(Operation op, const GDALRasterBand &band,
    2479             :                            double constant);
    2480             :     GDALComputedRasterBand(Operation op, const GDALRasterBand &band,
    2481             :                            GDALDataType dt);
    2482             : 
    2483             :     // Semi-public for gdal::min(), gdal::max()
    2484             :     GDALComputedRasterBand(Operation op, const GDALRasterBand &firstBand,
    2485             :                            const GDALRasterBand &secondBand);
    2486             : 
    2487             :     GDALComputedRasterBand(GDALComputedRasterBand &&) = default;
    2488             : 
    2489             :     //! @endcond
    2490             : 
    2491             :     double GetNoDataValue(int *pbSuccess = nullptr) override;
    2492             : 
    2493             :     /** Convert a GDALComputedRasterBand* to a GDALComputedRasterBandH.
    2494             :      */
    2495             :     static inline GDALComputedRasterBandH
    2496             :     ToHandle(GDALComputedRasterBand *poBand)
    2497             :     {
    2498             :         return static_cast<GDALComputedRasterBandH>(poBand);
    2499             :     }
    2500             : 
    2501             :     /** Convert a GDALComputedRasterBandH to a GDALComputedRasterBand*.
    2502             :      */
    2503             :     static inline GDALComputedRasterBand *
    2504         156 :     FromHandle(GDALComputedRasterBandH hBand)
    2505             :     {
    2506         156 :         return static_cast<GDALComputedRasterBand *>(hBand);
    2507             :     }
    2508             : 
    2509             :   protected:
    2510             :     friend class GDALRasterBand;
    2511             : 
    2512             :     CPLErr IReadBlock(int, int, void *) override;
    2513             : 
    2514             :     CPLErr IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
    2515             :                      int nYSize, void *pData, int nBufXSize, int nBufYSize,
    2516             :                      GDALDataType eBufType, GSpacing nPixelSpace,
    2517             :                      GSpacing nLineSpace,
    2518             :                      GDALRasterIOExtraArg *psExtraArg) override;
    2519             : 
    2520             :   private:
    2521             :     friend class GDALComputedDataset;
    2522             :     std::unique_ptr<GDALDataset, GDALDatasetUniquePtrReleaser> m_poOwningDS{};
    2523             :     bool m_bHasNoData{false};
    2524             :     double m_dfNoDataValue{0};
    2525             : 
    2526             :     GDALComputedRasterBand(const GDALComputedRasterBand &, bool);
    2527             :     GDALComputedRasterBand(const GDALComputedRasterBand &) = delete;
    2528             :     GDALComputedRasterBand &operator=(const GDALComputedRasterBand &) = delete;
    2529             :     GDALComputedRasterBand &operator=(GDALComputedRasterBand &&) = delete;
    2530             : };
    2531             : 
    2532             : namespace gdal
    2533             : {
    2534             : 
    2535             : GDALComputedRasterBand CPL_DLL IfThenElse(const GDALRasterBand &condBand,
    2536             :                                           const GDALRasterBand &thenBand,
    2537             :                                           const GDALRasterBand &elseBand);
    2538             : 
    2539             : //! @cond Doxygen_Suppress
    2540             : 
    2541             : GDALComputedRasterBand CPL_DLL IfThenElse(const GDALRasterBand &condBand,
    2542             :                                           double thenValue,
    2543             :                                           const GDALRasterBand &elseBand);
    2544             : 
    2545             : GDALComputedRasterBand CPL_DLL IfThenElse(const GDALRasterBand &condBand,
    2546             :                                           const GDALRasterBand &thenBand,
    2547             :                                           double elseValue);
    2548             : 
    2549             : GDALComputedRasterBand CPL_DLL IfThenElse(const GDALRasterBand &condBand,
    2550             :                                           double thenValue, double elseValue);
    2551             : 
    2552             : //! @endcond
    2553             : 
    2554             : using std::max;
    2555             : using std::min;
    2556             : 
    2557             : GDALComputedRasterBand CPL_DLL min(const GDALRasterBand &first,
    2558             :                                    const GDALRasterBand &second);
    2559             : 
    2560             : //! @cond Doxygen_Suppress
    2561             : 
    2562             : namespace detail
    2563             : {
    2564             : 
    2565             : template <typename U, typename Enable> struct minDealFirstArg;
    2566             : 
    2567             : template <typename U>
    2568             : struct minDealFirstArg<
    2569             :     U, typename std::enable_if<std::is_arithmetic<U>::value>::type>
    2570             : {
    2571           2 :     inline static void process(std::vector<const GDALRasterBand *> &,
    2572             :                                double &constant, const U &first)
    2573             :     {
    2574           2 :         if (std::isnan(constant) || static_cast<double>(first) < constant)
    2575           2 :             constant = static_cast<double>(first);
    2576           2 :     }
    2577             : };
    2578             : 
    2579             : template <typename U>
    2580             : struct minDealFirstArg<
    2581             :     U, typename std::enable_if<!std::is_arithmetic<U>::value>::type>
    2582             : {
    2583          16 :     inline static void process(std::vector<const GDALRasterBand *> &bands,
    2584             :                                double &, const U &first)
    2585             :     {
    2586          16 :         if (!bands.empty())
    2587          10 :             GDALRasterBand::ThrowIfNotSameDimensions(first, *(bands.front()));
    2588          14 :         bands.push_back(&first);
    2589          14 :     }
    2590             : };
    2591             : 
    2592             : inline static GDALComputedRasterBand
    2593           4 : minInternal(std::vector<const GDALRasterBand *> &bands, double constant)
    2594             : {
    2595             :     return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_MIN,
    2596           4 :                                   bands, constant);
    2597             : }
    2598             : 
    2599             : template <typename U, typename... V>
    2600          18 : GDALComputedRasterBand minInternal(std::vector<const GDALRasterBand *> &bands,
    2601             :                                    double constant, const U &first, V &&...rest)
    2602             : {
    2603          18 :     minDealFirstArg<U, void>::process(bands, constant, first);
    2604          16 :     return minInternal(bands, constant, std::forward<V>(rest)...);
    2605             : }
    2606             : 
    2607             : }  // namespace detail
    2608             : 
    2609             : template <typename U, typename... V>
    2610           6 : inline GDALComputedRasterBand min(const U &first, V &&...rest)
    2611             : {
    2612          12 :     std::vector<const GDALRasterBand *> bands;
    2613             :     return detail::minInternal(bands, std::numeric_limits<double>::quiet_NaN(),
    2614          10 :                                first, std::forward<V>(rest)...);
    2615             : }
    2616             : 
    2617             : //! @endcond
    2618             : 
    2619             : GDALComputedRasterBand CPL_DLL max(const GDALRasterBand &first,
    2620             :                                    const GDALRasterBand &second);
    2621             : 
    2622             : //! @cond Doxygen_Suppress
    2623             : 
    2624             : namespace detail
    2625             : {
    2626             : 
    2627             : template <typename U, typename Enable> struct maxDealFirstArg;
    2628             : 
    2629             : template <typename U>
    2630             : struct maxDealFirstArg<
    2631             :     U, typename std::enable_if<std::is_arithmetic<U>::value>::type>
    2632             : {
    2633           2 :     inline static void process(std::vector<const GDALRasterBand *> &,
    2634             :                                double &constant, const U &first)
    2635             :     {
    2636           2 :         if (std::isnan(constant) || static_cast<double>(first) > constant)
    2637           2 :             constant = static_cast<double>(first);
    2638           2 :     }
    2639             : };
    2640             : 
    2641             : template <typename U>
    2642             : struct maxDealFirstArg<
    2643             :     U, typename std::enable_if<!std::is_arithmetic<U>::value>::type>
    2644             : {
    2645          14 :     inline static void process(std::vector<const GDALRasterBand *> &bands,
    2646             :                                double &, const U &first)
    2647             :     {
    2648          14 :         if (!bands.empty())
    2649           9 :             GDALRasterBand::ThrowIfNotSameDimensions(first, *(bands.front()));
    2650          12 :         bands.push_back(&first);
    2651          12 :     }
    2652             : };
    2653             : 
    2654             : inline static GDALComputedRasterBand
    2655           3 : maxInternal(std::vector<const GDALRasterBand *> &bands, double constant)
    2656             : {
    2657             :     return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_MAX,
    2658           3 :                                   bands, constant);
    2659             : }
    2660             : 
    2661             : template <typename U, typename... V>
    2662          16 : GDALComputedRasterBand maxInternal(std::vector<const GDALRasterBand *> &bands,
    2663             :                                    double constant, const U &first, V &&...rest)
    2664             : {
    2665          16 :     maxDealFirstArg<U, void>::process(bands, constant, first);
    2666          14 :     return maxInternal(bands, constant, std::forward<V>(rest)...);
    2667             : }
    2668             : 
    2669             : }  // namespace detail
    2670             : 
    2671             : template <typename U, typename... V>
    2672           5 : inline GDALComputedRasterBand max(const U &first, V &&...rest)
    2673             : {
    2674          10 :     std::vector<const GDALRasterBand *> bands;
    2675             :     return detail::maxInternal(bands, std::numeric_limits<double>::quiet_NaN(),
    2676           8 :                                first, std::forward<V>(rest)...);
    2677             : }
    2678             : 
    2679             : //! @endcond
    2680             : 
    2681             : GDALComputedRasterBand CPL_DLL mean(const GDALRasterBand &first,
    2682             :                                     const GDALRasterBand &second);
    2683             : 
    2684             : //! @cond Doxygen_Suppress
    2685             : inline GDALComputedRasterBand
    2686           1 : meanInternal(std::vector<const GDALRasterBand *> &bands)
    2687             : {
    2688             :     return GDALComputedRasterBand(GDALComputedRasterBand::Operation::OP_MEAN,
    2689           1 :                                   bands);
    2690             : }
    2691             : 
    2692             : template <typename U, typename... V>
    2693             : inline GDALComputedRasterBand
    2694           8 : meanInternal(std::vector<const GDALRasterBand *> &bands, const U &first,
    2695             :              V &&...rest)
    2696             : {
    2697           8 :     if (!bands.empty())
    2698           5 :         GDALRasterBand::ThrowIfNotSameDimensions(first, *(bands.front()));
    2699           6 :     bands.push_back(&first);
    2700           6 :     return meanInternal(bands, std::forward<V>(rest)...);
    2701             : }
    2702             : 
    2703           3 : template <typename... Args> inline GDALComputedRasterBand mean(Args &&...args)
    2704             : {
    2705           6 :     std::vector<const GDALRasterBand *> bands;
    2706           4 :     return meanInternal(bands, std::forward<Args>(args)...);
    2707             : }
    2708             : 
    2709             : //! @endcond
    2710             : 
    2711             : }  // namespace gdal
    2712             : 
    2713             : //! @cond Doxygen_Suppress
    2714             : /* ******************************************************************** */
    2715             : /*                         GDALAllValidMaskBand                         */
    2716             : /* ******************************************************************** */
    2717             : 
    2718      317572 : class CPL_DLL GDALAllValidMaskBand : public GDALRasterBand
    2719             : {
    2720             :   protected:
    2721             :     CPLErr IReadBlock(int, int, void *) override;
    2722             : 
    2723             :     CPLErr IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
    2724             :                      int nYSize, void *pData, int nBufXSize, int nBufYSize,
    2725             :                      GDALDataType eBufType, GSpacing nPixelSpace,
    2726             :                      GSpacing nLineSpace,
    2727             :                      GDALRasterIOExtraArg *psExtraArg) override;
    2728             : 
    2729             :     bool
    2730             :     EmitErrorMessageIfWriteNotSupported(const char *pszCaller) const override;
    2731             : 
    2732             :     CPL_DISALLOW_COPY_ASSIGN(GDALAllValidMaskBand)
    2733             : 
    2734             :   public:
    2735             :     explicit GDALAllValidMaskBand(GDALRasterBand *);
    2736             :     ~GDALAllValidMaskBand() override;
    2737             : 
    2738             :     GDALRasterBand *GetMaskBand() override;
    2739             :     int GetMaskFlags() override;
    2740             : 
    2741           1 :     bool IsMaskBand() const override
    2742             :     {
    2743           1 :         return true;
    2744             :     }
    2745             : 
    2746           0 :     GDALMaskValueRange GetMaskValueRange() const override
    2747             :     {
    2748           0 :         return GMVR_0_AND_255_ONLY;
    2749             :     }
    2750             : 
    2751             :     CPLErr ComputeStatistics(int bApproxOK, double *pdfMin, double *pdfMax,
    2752             :                              double *pdfMean, double *pdfStdDev,
    2753             :                              GDALProgressFunc, void *pProgressData) override;
    2754             : };
    2755             : 
    2756             : /* ******************************************************************** */
    2757             : /*                         GDALNoDataMaskBand                           */
    2758             : /* ******************************************************************** */
    2759             : 
    2760        2138 : class CPL_DLL GDALNoDataMaskBand : public GDALRasterBand
    2761             : {
    2762             :     friend class GDALRasterBand;
    2763             :     double m_dfNoDataValue = 0;
    2764             :     int64_t m_nNoDataValueInt64 = 0;
    2765             :     uint64_t m_nNoDataValueUInt64 = 0;
    2766             :     GDALRasterBand *m_poParent = nullptr;
    2767             : 
    2768             :     CPL_DISALLOW_COPY_ASSIGN(GDALNoDataMaskBand)
    2769             : 
    2770             :   protected:
    2771             :     CPLErr IReadBlock(int, int, void *) override;
    2772             :     CPLErr IRasterIO(GDALRWFlag, int, int, int, int, void *, int, int,
    2773             :                      GDALDataType, GSpacing, GSpacing,
    2774             :                      GDALRasterIOExtraArg *psExtraArg) override;
    2775             : 
    2776             :     bool
    2777             :     EmitErrorMessageIfWriteNotSupported(const char *pszCaller) const override;
    2778             : 
    2779             :   public:
    2780             :     explicit GDALNoDataMaskBand(GDALRasterBand *);
    2781             :     explicit GDALNoDataMaskBand(GDALRasterBand *, double dfNoDataValue);
    2782             :     ~GDALNoDataMaskBand() override;
    2783             : 
    2784           1 :     bool IsMaskBand() const override
    2785             :     {
    2786           1 :         return true;
    2787             :     }
    2788             : 
    2789           0 :     GDALMaskValueRange GetMaskValueRange() const override
    2790             :     {
    2791           0 :         return GMVR_0_AND_255_ONLY;
    2792             :     }
    2793             : 
    2794             :     static bool IsNoDataInRange(double dfNoDataValue, GDALDataType eDataType);
    2795             : };
    2796             : 
    2797             : /* ******************************************************************** */
    2798             : /*                  GDALNoDataValuesMaskBand                            */
    2799             : /* ******************************************************************** */
    2800             : 
    2801             : class CPL_DLL GDALNoDataValuesMaskBand : public GDALRasterBand
    2802             : {
    2803             :     double *padfNodataValues;
    2804             : 
    2805             :     CPL_DISALLOW_COPY_ASSIGN(GDALNoDataValuesMaskBand)
    2806             : 
    2807             :   protected:
    2808             :     CPLErr IReadBlock(int, int, void *) override;
    2809             : 
    2810             :     bool
    2811             :     EmitErrorMessageIfWriteNotSupported(const char *pszCaller) const override;
    2812             : 
    2813             :   public:
    2814             :     explicit GDALNoDataValuesMaskBand(GDALDataset *);
    2815             :     ~GDALNoDataValuesMaskBand() override;
    2816             : 
    2817           0 :     bool IsMaskBand() const override
    2818             :     {
    2819           0 :         return true;
    2820             :     }
    2821             : 
    2822           0 :     GDALMaskValueRange GetMaskValueRange() const override
    2823             :     {
    2824           0 :         return GMVR_0_AND_255_ONLY;
    2825             :     }
    2826             : };
    2827             : 
    2828             : /* ******************************************************************** */
    2829             : /*                         GDALRescaledAlphaBand                        */
    2830             : /* ******************************************************************** */
    2831             : 
    2832             : class GDALRescaledAlphaBand : public GDALRasterBand
    2833             : {
    2834             :     GDALRasterBand *poParent;
    2835             :     void *pTemp;
    2836             : 
    2837             :     CPL_DISALLOW_COPY_ASSIGN(GDALRescaledAlphaBand)
    2838             : 
    2839             :   protected:
    2840             :     CPLErr IReadBlock(int, int, void *) override;
    2841             :     CPLErr IRasterIO(GDALRWFlag, int, int, int, int, void *, int, int,
    2842             :                      GDALDataType, GSpacing, GSpacing,
    2843             :                      GDALRasterIOExtraArg *psExtraArg) override;
    2844             : 
    2845             :     bool
    2846             :     EmitErrorMessageIfWriteNotSupported(const char *pszCaller) const override;
    2847             : 
    2848             :   public:
    2849             :     explicit GDALRescaledAlphaBand(GDALRasterBand *);
    2850             :     ~GDALRescaledAlphaBand() override;
    2851             : 
    2852           0 :     bool IsMaskBand() const override
    2853             :     {
    2854           0 :         return true;
    2855             :     }
    2856             : };
    2857             : 
    2858             : //! @endcond
    2859             : 
    2860             : /* ******************************************************************** */
    2861             : /*                          GDALIdentifyEnum                            */
    2862             : /* ******************************************************************** */
    2863             : 
    2864             : /**
    2865             :  * Enumeration used by GDALDriver::pfnIdentify().
    2866             :  *
    2867             :  * @since GDAL 2.1
    2868             :  */
    2869             : typedef enum
    2870             : {
    2871             :     /** Identify could not determine if the file is recognized or not by the
    2872             :        probed driver. */
    2873             :     GDAL_IDENTIFY_UNKNOWN = -1,
    2874             :     /** Identify determined the file is not recognized by the probed driver. */
    2875             :     GDAL_IDENTIFY_FALSE = 0,
    2876             :     /** Identify determined the file is recognized by the probed driver. */
    2877             :     GDAL_IDENTIFY_TRUE = 1
    2878             : } GDALIdentifyEnum;
    2879             : 
    2880             : /* ******************************************************************** */
    2881             : /*                              GDALDriver                              */
    2882             : /* ******************************************************************** */
    2883             : 
    2884             : /**
    2885             :  * \brief Format specific driver.
    2886             :  *
    2887             :  * An instance of this class is created for each supported format, and
    2888             :  * manages information about the format.
    2889             :  *
    2890             :  * This roughly corresponds to a file format, though some
    2891             :  * drivers may be gateways to many formats through a secondary
    2892             :  * multi-library.
    2893             :  */
    2894             : 
    2895      366481 : class CPL_DLL GDALDriver : public GDALMajorObject
    2896             : {
    2897             :   public:
    2898             :     GDALDriver();
    2899             :     ~GDALDriver() override;
    2900             : 
    2901             :     CPLErr SetMetadataItem(const char *pszName, const char *pszValue,
    2902             :                            const char *pszDomain = "") override;
    2903             : 
    2904             :     /* -------------------------------------------------------------------- */
    2905             :     /*      Public C++ methods.                                             */
    2906             :     /* -------------------------------------------------------------------- */
    2907             :     GDALDataset *Create(const char *pszName, int nXSize, int nYSize, int nBands,
    2908             :                         GDALDataType eType,
    2909             :                         CSLConstList papszOptions) CPL_WARN_UNUSED_RESULT;
    2910             : 
    2911             :     GDALDataset *
    2912             :     CreateMultiDimensional(const char *pszName,
    2913             :                            CSLConstList papszRootGroupOptions,
    2914             :                            CSLConstList papszOptions) CPL_WARN_UNUSED_RESULT;
    2915             : 
    2916             :     CPLErr Delete(const char *pszName);
    2917             :     CPLErr Rename(const char *pszNewName, const char *pszOldName);
    2918             :     CPLErr CopyFiles(const char *pszNewName, const char *pszOldName);
    2919             : 
    2920             :     GDALDataset *CreateCopy(const char *, GDALDataset *, int,
    2921             :                             CSLConstList papszOptions,
    2922             :                             GDALProgressFunc pfnProgress,
    2923             :                             void *pProgressData) CPL_WARN_UNUSED_RESULT;
    2924             : 
    2925             :     bool CanVectorTranslateFrom(const char *pszDestName,
    2926             :                                 GDALDataset *poSourceDS,
    2927             :                                 CSLConstList papszVectorTranslateArguments,
    2928             :                                 char ***ppapszFailureReasons);
    2929             : 
    2930             :     /**
    2931             :      * \brief Returns TRUE if the given open option is supported by the driver.
    2932             :      * @param pszOpenOptionName name of the open option to be checked
    2933             :      * @return TRUE if the driver supports the open option
    2934             :      * @since GDAL 3.11
    2935             :      */
    2936             :     bool HasOpenOption(const char *pszOpenOptionName) const;
    2937             : 
    2938             :     GDALDataset *
    2939             :     VectorTranslateFrom(const char *pszDestName, GDALDataset *poSourceDS,
    2940             :                         CSLConstList papszVectorTranslateArguments,
    2941             :                         GDALProgressFunc pfnProgress,
    2942             :                         void *pProgressData) CPL_WARN_UNUSED_RESULT;
    2943             : 
    2944             :     /* -------------------------------------------------------------------- */
    2945             :     /*      The following are semiprivate, not intended to be accessed      */
    2946             :     /*      by anyone but the formats instantiating and populating the      */
    2947             :     /*      drivers.                                                        */
    2948             :     /* -------------------------------------------------------------------- */
    2949             :     //! @cond Doxygen_Suppress
    2950             : 
    2951             :     // Not aimed at being used outside of GDAL. Use GDALDataset::Open() instead
    2952             :     GDALDataset *Open(GDALOpenInfo *poOpenInfo, bool bSetOpenOptions);
    2953             : 
    2954             :     typedef GDALDataset *(*OpenCallback)(GDALOpenInfo *);
    2955             : 
    2956             :     OpenCallback pfnOpen = nullptr;
    2957             : 
    2958      435487 :     virtual OpenCallback GetOpenCallback()
    2959             :     {
    2960      435487 :         return pfnOpen;
    2961             :     }
    2962             : 
    2963             :     typedef GDALDataset *(*CreateCallback)(const char *pszName, int nXSize,
    2964             :                                            int nYSize, int nBands,
    2965             :                                            GDALDataType eType,
    2966             :                                            char **papszOptions);
    2967             : 
    2968             :     CreateCallback pfnCreate = nullptr;
    2969             : 
    2970       22109 :     virtual CreateCallback GetCreateCallback()
    2971             :     {
    2972       22109 :         return pfnCreate;
    2973             :     }
    2974             : 
    2975             :     GDALDataset *(*pfnCreateEx)(GDALDriver *, const char *pszName, int nXSize,
    2976             :                                 int nYSize, int nBands, GDALDataType eType,
    2977             :                                 char **papszOptions) = nullptr;
    2978             : 
    2979             :     typedef GDALDataset *(*CreateMultiDimensionalCallback)(
    2980             :         const char *pszName, CSLConstList papszRootGroupOptions,
    2981             :         CSLConstList papszOptions);
    2982             : 
    2983             :     CreateMultiDimensionalCallback pfnCreateMultiDimensional = nullptr;
    2984             : 
    2985         465 :     virtual CreateMultiDimensionalCallback GetCreateMultiDimensionalCallback()
    2986             :     {
    2987         465 :         return pfnCreateMultiDimensional;
    2988             :     }
    2989             : 
    2990             :     typedef CPLErr (*DeleteCallback)(const char *pszName);
    2991             :     DeleteCallback pfnDelete = nullptr;
    2992             : 
    2993        5438 :     virtual DeleteCallback GetDeleteCallback()
    2994             :     {
    2995        5438 :         return pfnDelete;
    2996             :     }
    2997             : 
    2998             :     typedef GDALDataset *(*CreateCopyCallback)(const char *, GDALDataset *, int,
    2999             :                                                char **,
    3000             :                                                GDALProgressFunc pfnProgress,
    3001             :                                                void *pProgressData);
    3002             : 
    3003             :     CreateCopyCallback pfnCreateCopy = nullptr;
    3004             : 
    3005       11273 :     virtual CreateCopyCallback GetCreateCopyCallback()
    3006             :     {
    3007       11273 :         return pfnCreateCopy;
    3008             :     }
    3009             : 
    3010             :     void *pDriverData = nullptr;
    3011             : 
    3012             :     void (*pfnUnloadDriver)(GDALDriver *) = nullptr;
    3013             : 
    3014             :     /** Identify() if the file is recognized or not by the driver.
    3015             : 
    3016             :        Return GDAL_IDENTIFY_TRUE (1) if the passed file is certainly recognized
    3017             :        by the driver. Return GDAL_IDENTIFY_FALSE (0) if the passed file is
    3018             :        certainly NOT recognized by the driver. Return GDAL_IDENTIFY_UNKNOWN (-1)
    3019             :        if the passed file may be or may not be recognized by the driver, and
    3020             :        that a potentially costly test must be done with pfnOpen.
    3021             :     */
    3022             :     int (*pfnIdentify)(GDALOpenInfo *) = nullptr;
    3023             :     int (*pfnIdentifyEx)(GDALDriver *, GDALOpenInfo *) = nullptr;
    3024             : 
    3025             :     typedef CPLErr (*RenameCallback)(const char *pszNewName,
    3026             :                                      const char *pszOldName);
    3027             :     RenameCallback pfnRename = nullptr;
    3028             : 
    3029         175 :     virtual RenameCallback GetRenameCallback()
    3030             :     {
    3031         175 :         return pfnRename;
    3032             :     }
    3033             : 
    3034             :     typedef CPLErr (*CopyFilesCallback)(const char *pszNewName,
    3035             :                                         const char *pszOldName);
    3036             :     CopyFilesCallback pfnCopyFiles = nullptr;
    3037             : 
    3038          12 :     virtual CopyFilesCallback GetCopyFilesCallback()
    3039             :     {
    3040          12 :         return pfnCopyFiles;
    3041             :     }
    3042             : 
    3043             :     // Used for legacy OGR drivers, and Python drivers
    3044             :     GDALDataset *(*pfnOpenWithDriverArg)(GDALDriver *,
    3045             :                                          GDALOpenInfo *) = nullptr;
    3046             : 
    3047             :     /* For legacy OGR drivers */
    3048             :     GDALDataset *(*pfnCreateVectorOnly)(GDALDriver *, const char *pszName,
    3049             :                                         char **papszOptions) = nullptr;
    3050             :     CPLErr (*pfnDeleteDataSource)(GDALDriver *, const char *pszName) = nullptr;
    3051             : 
    3052             :     /** Whether pfnVectorTranslateFrom() can be run given the source dataset
    3053             :      * and the non-positional arguments of GDALVectorTranslate() stored
    3054             :      * in papszVectorTranslateArguments.
    3055             :      */
    3056             :     bool (*pfnCanVectorTranslateFrom)(
    3057             :         const char *pszDestName, GDALDataset *poSourceDS,
    3058             :         CSLConstList papszVectorTranslateArguments,
    3059             :         char ***ppapszFailureReasons) = nullptr;
    3060             : 
    3061             :     /** Creates a copy from the specified source dataset, using the
    3062             :      * non-positional arguments of GDALVectorTranslate() stored
    3063             :      * in papszVectorTranslateArguments.
    3064             :      */
    3065             :     GDALDataset *(*pfnVectorTranslateFrom)(
    3066             :         const char *pszDestName, GDALDataset *poSourceDS,
    3067             :         CSLConstList papszVectorTranslateArguments,
    3068             :         GDALProgressFunc pfnProgress, void *pProgressData) = nullptr;
    3069             : 
    3070             :     /**
    3071             :      * Returns a (possibly null) pointer to the Subdataset informational function
    3072             :      * from the subdataset file name.
    3073             :      */
    3074             :     GDALSubdatasetInfo *(*pfnGetSubdatasetInfoFunc)(const char *pszFileName) =
    3075             :         nullptr;
    3076             : 
    3077             :     typedef GDALAlgorithm *(*InstantiateAlgorithmCallback)(
    3078             :         const std::vector<std::string> &aosPath);
    3079             :     InstantiateAlgorithmCallback pfnInstantiateAlgorithm = nullptr;
    3080             : 
    3081          56 :     virtual InstantiateAlgorithmCallback GetInstantiateAlgorithmCallback()
    3082             :     {
    3083          56 :         return pfnInstantiateAlgorithm;
    3084             :     }
    3085             : 
    3086             :     /** Instantiate an algorithm by its full path (omitting leading "gdal").
    3087             :      * For example {"driver", "pdf", "list-layers"}
    3088             :      */
    3089             :     GDALAlgorithm *
    3090             :     InstantiateAlgorithm(const std::vector<std::string> &aosPath);
    3091             : 
    3092             :     /** Declare an algorithm by its full path (omitting leading "gdal").
    3093             :      * For example {"driver", "pdf", "list-layers"}
    3094             :      */
    3095             :     void DeclareAlgorithm(const std::vector<std::string> &aosPath);
    3096             : 
    3097             :     //! @endcond
    3098             : 
    3099             :     /* -------------------------------------------------------------------- */
    3100             :     /*      Helper methods.                                                 */
    3101             :     /* -------------------------------------------------------------------- */
    3102             :     //! @cond Doxygen_Suppress
    3103             :     GDALDataset *DefaultCreateCopy(const char *, GDALDataset *, int,
    3104             :                                    CSLConstList papszOptions,
    3105             :                                    GDALProgressFunc pfnProgress,
    3106             :                                    void *pProgressData) CPL_WARN_UNUSED_RESULT;
    3107             : 
    3108             :     static CPLErr DefaultCreateCopyMultiDimensional(
    3109             :         GDALDataset *poSrcDS, GDALDataset *poDstDS, bool bStrict,
    3110             :         CSLConstList /*papszOptions*/, GDALProgressFunc pfnProgress,
    3111             :         void *pProgressData);
    3112             : 
    3113             :     static CPLErr DefaultCopyMasks(GDALDataset *poSrcDS, GDALDataset *poDstDS,
    3114             :                                    int bStrict);
    3115             :     static CPLErr DefaultCopyMasks(GDALDataset *poSrcDS, GDALDataset *poDstDS,
    3116             :                                    int bStrict, CSLConstList papszOptions,
    3117             :                                    GDALProgressFunc pfnProgress,
    3118             :                                    void *pProgressData);
    3119             : 
    3120             :     CPLErr QuietDeleteForCreateCopy(const char *pszFilename,
    3121             :                                     GDALDataset *poSrcDS);
    3122             : 
    3123             :     //! @endcond
    3124             :     static CPLErr QuietDelete(const char *pszName,
    3125             :                               CSLConstList papszAllowedDrivers = nullptr);
    3126             : 
    3127             :     //! @cond Doxygen_Suppress
    3128             :     static CPLErr DefaultRename(const char *pszNewName, const char *pszOldName);
    3129             :     static CPLErr DefaultCopyFiles(const char *pszNewName,
    3130             :                                    const char *pszOldName);
    3131             :     static void DefaultCopyMetadata(GDALDataset *poSrcDS, GDALDataset *poDstDS,
    3132             :                                     CSLConstList papszOptions,
    3133             :                                     CSLConstList papszExcludedDomains);
    3134             : 
    3135             :     //! @endcond
    3136             : 
    3137             :     /** Convert a GDALDriver* to a GDALDriverH.
    3138             :      * @since GDAL 2.3
    3139             :      */
    3140      169188 :     static inline GDALDriverH ToHandle(GDALDriver *poDriver)
    3141             :     {
    3142      169188 :         return static_cast<GDALDriverH>(poDriver);
    3143             :     }
    3144             : 
    3145             :     /** Convert a GDALDriverH to a GDALDriver*.
    3146             :      * @since GDAL 2.3
    3147             :      */
    3148     3869680 :     static inline GDALDriver *FromHandle(GDALDriverH hDriver)
    3149             :     {
    3150     3869680 :         return static_cast<GDALDriver *>(hDriver);
    3151             :     }
    3152             : 
    3153             :   private:
    3154             :     CPL_DISALLOW_COPY_ASSIGN(GDALDriver)
    3155             : };
    3156             : 
    3157             : /************************************************************************/
    3158             : /*                       GDALPluginDriverProxy                          */
    3159             : /************************************************************************/
    3160             : 
    3161             : // clang-format off
    3162             : /** Proxy for a plugin driver.
    3163             :  *
    3164             :  * Such proxy must be registered with
    3165             :  * GDALDriverManager::DeclareDeferredPluginDriver().
    3166             :  *
    3167             :  * If the real driver defines any of the following metadata items, the
    3168             :  * proxy driver should also define them with the same value:
    3169             :  * <ul>
    3170             :  * <li>GDAL_DMD_LONGNAME</li>
    3171             :  * <li>GDAL_DMD_EXTENSIONS</li>
    3172             :  * <li>GDAL_DMD_EXTENSION</li>
    3173             :  * <li>GDAL_DMD_OPENOPTIONLIST</li>
    3174             :  * <li>GDAL_DMD_SUBDATASETS</li>
    3175             :  * <li>GDAL_DMD_CONNECTION_PREFIX</li>
    3176             :  * <li>GDAL_DCAP_RASTER</li>
    3177             :  * <li>GDAL_DCAP_MULTIDIM_RASTER</li>
    3178             :  * <li>GDAL_DCAP_VECTOR</li>
    3179             :  * <li>GDAL_DCAP_GNM</li>
    3180             :  * <li>GDAL_DCAP_MULTIPLE_VECTOR_LAYERS</li>
    3181             :  * <li>GDAL_DCAP_NONSPATIAL</li>
    3182             :  * <li>GDAL_DCAP_VECTOR_TRANSLATE_FROM</li>
    3183             :  * </ul>
    3184             :  *
    3185             :  * The pfnIdentify and pfnGetSubdatasetInfoFunc callbacks, if they are
    3186             :  * defined in the real driver, should also be set on the proxy driver.
    3187             :  *
    3188             :  * Furthermore, the following metadata items must be defined if the real
    3189             :  * driver sets the corresponding callback:
    3190             :  * <ul>
    3191             :  * <li>GDAL_DCAP_OPEN: must be set to YES if the real driver defines pfnOpen</li>
    3192             :  * <li>GDAL_DCAP_CREATE: must be set to YES if the real driver defines pfnCreate</li>
    3193             :  * <li>GDAL_DCAP_CREATE_MULTIDIMENSIONAL: must be set to YES if the real driver defines pfnCreateMultiDimensional</li>
    3194             :  * <li>GDAL_DCAP_CREATECOPY: must be set to YES if the real driver defines pfnCreateCopy</li>
    3195             :  * </ul>
    3196             :  *
    3197             :  * @since 3.9
    3198             :  */
    3199             : // clang-format on
    3200             : 
    3201             : class GDALPluginDriverProxy : public GDALDriver
    3202             : {
    3203             :     const std::string m_osPluginFileName;
    3204             :     std::string m_osPluginFullPath{};
    3205             :     std::unique_ptr<GDALDriver> m_poRealDriver{};
    3206             :     std::set<std::string> m_oSetMetadataItems{};
    3207             : 
    3208             :     GDALDriver *GetRealDriver();
    3209             : 
    3210             :     CPL_DISALLOW_COPY_ASSIGN(GDALPluginDriverProxy)
    3211             : 
    3212             :   protected:
    3213             :     friend class GDALDriverManager;
    3214             : 
    3215             :     //! @cond Doxygen_Suppress
    3216       72424 :     void SetPluginFullPath(const std::string &osFullPath)
    3217             :     {
    3218       72424 :         m_osPluginFullPath = osFullPath;
    3219       72424 :     }
    3220             : 
    3221             :     //! @endcond
    3222             : 
    3223             :   public:
    3224             :     explicit GDALPluginDriverProxy(const std::string &osPluginFileName);
    3225             : 
    3226             :     /** Return the plugin file name (not a full path) */
    3227       72424 :     const std::string &GetPluginFileName() const
    3228             :     {
    3229       72424 :         return m_osPluginFileName;
    3230             :     }
    3231             : 
    3232             :     //! @cond Doxygen_Suppress
    3233             :     OpenCallback GetOpenCallback() override;
    3234             : 
    3235             :     CreateCallback GetCreateCallback() override;
    3236             : 
    3237             :     CreateMultiDimensionalCallback GetCreateMultiDimensionalCallback() override;
    3238             : 
    3239             :     CreateCopyCallback GetCreateCopyCallback() override;
    3240             : 
    3241             :     DeleteCallback GetDeleteCallback() override;
    3242             : 
    3243             :     RenameCallback GetRenameCallback() override;
    3244             : 
    3245             :     CopyFilesCallback GetCopyFilesCallback() override;
    3246             : 
    3247             :     InstantiateAlgorithmCallback GetInstantiateAlgorithmCallback() override;
    3248             :     //! @endcond
    3249             : 
    3250             :     CPLErr SetMetadataItem(const char *pszName, const char *pszValue,
    3251             :                            const char *pszDomain = "") override;
    3252             : 
    3253             :     char **GetMetadata(const char *pszDomain) override;
    3254             : 
    3255             :     const char *GetMetadataItem(const char *pszName,
    3256             :                                 const char *pszDomain = "") override;
    3257             : };
    3258             : 
    3259             : /* ******************************************************************** */
    3260             : /*                          GDALDriverManager                           */
    3261             : /* ******************************************************************** */
    3262             : 
    3263             : /**
    3264             :  * Class for managing the registration of file format drivers.
    3265             :  *
    3266             :  * Use GetGDALDriverManager() to fetch the global singleton instance of
    3267             :  * this class.
    3268             :  */
    3269             : 
    3270             : class CPL_DLL GDALDriverManager : public GDALMajorObject
    3271             : {
    3272             :     int nDrivers = 0;
    3273             :     GDALDriver **papoDrivers = nullptr;
    3274             :     std::map<CPLString, GDALDriver *> oMapNameToDrivers{};
    3275             :     std::string m_osPluginPath{};
    3276             :     std::string m_osDriversIniPath{};
    3277             :     mutable std::string m_osLastTriedDirectory{};
    3278             :     std::set<std::string> m_oSetPluginFileNames{};
    3279             :     bool m_bInDeferredDriverLoading = false;
    3280             :     std::map<std::string, std::unique_ptr<GDALDriver>> m_oMapRealDrivers{};
    3281             :     std::vector<std::unique_ptr<GDALDriver>> m_aoHiddenDrivers{};
    3282             : 
    3283    19892900 :     GDALDriver *GetDriver_unlocked(int iDriver)
    3284             :     {
    3285    19892900 :         return (iDriver >= 0 && iDriver < nDrivers) ? papoDrivers[iDriver]
    3286    19892900 :                                                     : nullptr;
    3287             :     }
    3288             : 
    3289             :     GDALDriver *GetDriverByName_unlocked(const char *pszName) const;
    3290             : 
    3291             :     static void CleanupPythonDrivers();
    3292             : 
    3293             :     std::string GetPluginFullPath(const char *pszFilename) const;
    3294             : 
    3295             :     int RegisterDriver(GDALDriver *, bool bHidden);
    3296             : 
    3297             :     CPL_DISALLOW_COPY_ASSIGN(GDALDriverManager)
    3298             : 
    3299             :   protected:
    3300             :     friend class GDALPluginDriverProxy;
    3301             :     friend GDALDatasetH CPL_STDCALL
    3302             :     GDALOpenEx(const char *pszFilename, unsigned int nOpenFlags,
    3303             :                const char *const *papszAllowedDrivers,
    3304             :                const char *const *papszOpenOptions,
    3305             :                const char *const *papszSiblingFiles);
    3306             : 
    3307             :     //! @cond Doxygen_Suppress
    3308             :     static char **GetSearchPaths(const char *pszGDAL_DRIVER_PATH);
    3309             :     //! @endcond
    3310             : 
    3311             :   public:
    3312             :     GDALDriverManager();
    3313             :     ~GDALDriverManager();
    3314             : 
    3315             :     int GetDriverCount(void) const;
    3316             :     GDALDriver *GetDriver(int);
    3317             :     GDALDriver *GetDriverByName(const char *);
    3318             : 
    3319             :     int RegisterDriver(GDALDriver *);
    3320             :     void DeregisterDriver(GDALDriver *);
    3321             : 
    3322             :     // AutoLoadDrivers is a no-op if compiled with GDAL_NO_AUTOLOAD defined.
    3323             :     void AutoLoadDrivers();
    3324             :     void AutoSkipDrivers();
    3325             :     void ReorderDrivers();
    3326             :     static CPLErr LoadPlugin(const char *name);
    3327             : 
    3328             :     static void AutoLoadPythonDrivers();
    3329             : 
    3330             :     void DeclareDeferredPluginDriver(GDALPluginDriverProxy *poProxyDriver);
    3331             : 
    3332             :     //! @cond Doxygen_Suppress
    3333             :     int GetDriverCount(bool bIncludeHidden) const;
    3334             :     GDALDriver *GetDriver(int iDriver, bool bIncludeHidden);
    3335             :     bool IsKnownDriver(const char *pszDriverName) const;
    3336             :     GDALDriver *GetHiddenDriverByName(const char *pszName);
    3337             :     //! @endcond
    3338             : };
    3339             : 
    3340             : CPL_C_START
    3341             : GDALDriverManager CPL_DLL *GetGDALDriverManager(void);
    3342             : CPL_C_END
    3343             : 
    3344             : /* ******************************************************************** */
    3345             : /*                          GDALAsyncReader                             */
    3346             : /* ******************************************************************** */
    3347             : 
    3348             : /**
    3349             :  * Class used as a session object for asynchronous requests.  They are
    3350             :  * created with GDALDataset::BeginAsyncReader(), and destroyed with
    3351             :  * GDALDataset::EndAsyncReader().
    3352             :  */
    3353           1 : class CPL_DLL GDALAsyncReader
    3354             : {
    3355             : 
    3356             :     CPL_DISALLOW_COPY_ASSIGN(GDALAsyncReader)
    3357             : 
    3358             :   protected:
    3359             :     //! @cond Doxygen_Suppress
    3360             :     GDALDataset *poDS;
    3361             :     int nXOff;
    3362             :     int nYOff;
    3363             :     int nXSize;
    3364             :     int nYSize;
    3365             :     void *pBuf;
    3366             :     int nBufXSize;
    3367             :     int nBufYSize;
    3368             :     GDALDataType eBufType;
    3369             :     int nBandCount;
    3370             :     int *panBandMap;
    3371             :     int nPixelSpace;
    3372             :     int nLineSpace;
    3373             :     int nBandSpace;
    3374             :     //! @endcond
    3375             : 
    3376             :   public:
    3377             :     GDALAsyncReader();
    3378             :     virtual ~GDALAsyncReader();
    3379             : 
    3380             :     /** Return dataset.
    3381             :      * @return dataset
    3382             :      */
    3383             :     GDALDataset *GetGDALDataset()
    3384             :     {
    3385             :         return poDS;
    3386             :     }
    3387             : 
    3388             :     /** Return x offset.
    3389             :      * @return x offset.
    3390             :      */
    3391             :     int GetXOffset() const
    3392             :     {
    3393             :         return nXOff;
    3394             :     }
    3395             : 
    3396             :     /** Return y offset.
    3397             :      * @return y offset.
    3398             :      */
    3399             :     int GetYOffset() const
    3400             :     {
    3401             :         return nYOff;
    3402             :     }
    3403             : 
    3404             :     /** Return width.
    3405             :      * @return width
    3406             :      */
    3407             :     int GetXSize() const
    3408             :     {
    3409             :         return nXSize;
    3410             :     }
    3411             : 
    3412             :     /** Return height.
    3413             :      * @return height
    3414             :      */
    3415             :     int GetYSize() const
    3416             :     {
    3417             :         return nYSize;
    3418             :     }
    3419             : 
    3420             :     /** Return buffer.
    3421             :      * @return buffer
    3422             :      */
    3423             :     void *GetBuffer()
    3424             :     {
    3425             :         return pBuf;
    3426             :     }
    3427             : 
    3428             :     /** Return buffer width.
    3429             :      * @return buffer width.
    3430             :      */
    3431             :     int GetBufferXSize() const
    3432             :     {
    3433             :         return nBufXSize;
    3434             :     }
    3435             : 
    3436             :     /** Return buffer height.
    3437             :      * @return buffer height.
    3438             :      */
    3439             :     int GetBufferYSize() const
    3440             :     {
    3441             :         return nBufYSize;
    3442             :     }
    3443             : 
    3444             :     /** Return buffer data type.
    3445             :      * @return buffer data type.
    3446             :      */
    3447             :     GDALDataType GetBufferType() const
    3448             :     {
    3449             :         return eBufType;
    3450             :     }
    3451             : 
    3452             :     /** Return band count.
    3453             :      * @return band count
    3454             :      */
    3455             :     int GetBandCount() const
    3456             :     {
    3457             :         return nBandCount;
    3458             :     }
    3459             : 
    3460             :     /** Return band map.
    3461             :      * @return band map.
    3462             :      */
    3463             :     int *GetBandMap()
    3464             :     {
    3465             :         return panBandMap;
    3466             :     }
    3467             : 
    3468             :     /** Return pixel spacing.
    3469             :      * @return pixel spacing.
    3470             :      */
    3471             :     int GetPixelSpace() const
    3472             :     {
    3473             :         return nPixelSpace;
    3474             :     }
    3475             : 
    3476             :     /** Return line spacing.
    3477             :      * @return line spacing.
    3478             :      */
    3479             :     int GetLineSpace() const
    3480             :     {
    3481             :         return nLineSpace;
    3482             :     }
    3483             : 
    3484             :     /** Return band spacing.
    3485             :      * @return band spacing.
    3486             :      */
    3487             :     int GetBandSpace() const
    3488             :     {
    3489             :         return nBandSpace;
    3490             :     }
    3491             : 
    3492             :     virtual GDALAsyncStatusType
    3493             :     GetNextUpdatedRegion(double dfTimeout, int *pnBufXOff, int *pnBufYOff,
    3494             :                          int *pnBufXSize, int *pnBufYSize) = 0;
    3495             :     virtual int LockBuffer(double dfTimeout = -1.0);
    3496             :     virtual void UnlockBuffer();
    3497             : };
    3498             : 
    3499             : /* ******************************************************************** */
    3500             : /*                       Multidimensional array API                     */
    3501             : /* ******************************************************************** */
    3502             : 
    3503             : class GDALMDArray;
    3504             : class GDALAttribute;
    3505             : class GDALDimension;
    3506             : class GDALEDTComponent;
    3507             : 
    3508             : /* ******************************************************************** */
    3509             : /*                         GDALExtendedDataType                         */
    3510             : /* ******************************************************************** */
    3511             : 
    3512             : /**
    3513             :  * Class used to represent potentially complex data types.
    3514             :  * Several classes of data types are supported: numeric (based on GDALDataType),
    3515             :  * compound or string.
    3516             :  *
    3517             :  * @since GDAL 3.1
    3518             :  */
    3519       64958 : class CPL_DLL GDALExtendedDataType
    3520             : {
    3521             :   public:
    3522             :     ~GDALExtendedDataType();
    3523             : 
    3524             :     GDALExtendedDataType(const GDALExtendedDataType &);
    3525             : 
    3526             :     GDALExtendedDataType &operator=(const GDALExtendedDataType &);
    3527             :     GDALExtendedDataType &operator=(GDALExtendedDataType &&);
    3528             : 
    3529             :     static GDALExtendedDataType Create(GDALDataType eType);
    3530             :     static GDALExtendedDataType
    3531             :     Create(const std::string &osName, GDALDataType eBaseType,
    3532             :            std::unique_ptr<GDALRasterAttributeTable>);
    3533             :     static GDALExtendedDataType
    3534             :     Create(const std::string &osName, size_t nTotalSize,
    3535             :            std::vector<std::unique_ptr<GDALEDTComponent>> &&components);
    3536             :     static GDALExtendedDataType
    3537             :     CreateString(size_t nMaxStringLength = 0,
    3538             :                  GDALExtendedDataTypeSubType eSubType = GEDTST_NONE);
    3539             : 
    3540             :     bool operator==(const GDALExtendedDataType &) const;
    3541             : 
    3542             :     /** Non-equality operator */
    3543        1062 :     bool operator!=(const GDALExtendedDataType &other) const
    3544             :     {
    3545        1062 :         return !(operator==(other));
    3546             :     }
    3547             : 
    3548             :     /** Return type name.
    3549             :      *
    3550             :      * This is the same as the C function GDALExtendedDataTypeGetName()
    3551             :      */
    3552          21 :     const std::string &GetName() const
    3553             :     {
    3554          21 :         return m_osName;
    3555             :     }
    3556             : 
    3557             :     /** Return type class.
    3558             :      *
    3559             :      * This is the same as the C function GDALExtendedDataTypeGetClass()
    3560             :      */
    3561      305087 :     GDALExtendedDataTypeClass GetClass() const
    3562             :     {
    3563      305087 :         return m_eClass;
    3564             :     }
    3565             : 
    3566             :     /** Return numeric data type (only valid when GetClass() == GEDTC_NUMERIC)
    3567             :      *
    3568             :      * This is the same as the C function
    3569             :      * GDALExtendedDataTypeGetNumericDataType()
    3570             :      */
    3571     1958073 :     GDALDataType GetNumericDataType() const
    3572             :     {
    3573     1958073 :         return m_eNumericDT;
    3574             :     }
    3575             : 
    3576             :     /** Return subtype.
    3577             :      *
    3578             :      * This is the same as the C function GDALExtendedDataTypeGetSubType()
    3579             :      *
    3580             :      * @since 3.4
    3581             :      */
    3582         360 :     GDALExtendedDataTypeSubType GetSubType() const
    3583             :     {
    3584         360 :         return m_eSubType;
    3585             :     }
    3586             : 
    3587             :     /** Return the components of the data type (only valid when GetClass() ==
    3588             :      * GEDTC_COMPOUND)
    3589             :      *
    3590             :      * This is the same as the C function GDALExtendedDataTypeGetComponents()
    3591             :      */
    3592        1231 :     const std::vector<std::unique_ptr<GDALEDTComponent>> &GetComponents() const
    3593             :     {
    3594        1231 :         return m_aoComponents;
    3595             :     }
    3596             : 
    3597             :     /** Return data type size in bytes.
    3598             :      *
    3599             :      * For a string, this will be size of a char* pointer.
    3600             :      *
    3601             :      * This is the same as the C function GDALExtendedDataTypeGetSize()
    3602             :      */
    3603       52900 :     size_t GetSize() const
    3604             :     {
    3605       52900 :         return m_nSize;
    3606             :     }
    3607             : 
    3608             :     /** Return the maximum length of a string in bytes.
    3609             :      *
    3610             :      * 0 indicates unknown/unlimited string.
    3611             :      */
    3612          21 :     size_t GetMaxStringLength() const
    3613             :     {
    3614          21 :         return m_nMaxStringLength;
    3615             :     }
    3616             : 
    3617             :     /** Return associated raster attribute table, when there is one.
    3618             :      *
    3619             :      * For the netCDF driver, the RAT will capture enumerated types, with
    3620             :      * a "value" column with an integer value and a "name" column with the
    3621             :      * associated name.
    3622             :      *
    3623             :      * This is the same as the C function GDALExtendedDataTypeGetRAT()
    3624             :      *
    3625             :      * @since 3.12
    3626             :      */
    3627         425 :     const GDALRasterAttributeTable *GetRAT() const
    3628             :     {
    3629         425 :         return m_poRAT.get();
    3630             :     }
    3631             : 
    3632             :     bool CanConvertTo(const GDALExtendedDataType &other) const;
    3633             : 
    3634             :     bool NeedsFreeDynamicMemory() const;
    3635             : 
    3636             :     void FreeDynamicMemory(void *pBuffer) const;
    3637             : 
    3638             :     static bool CopyValue(const void *pSrc, const GDALExtendedDataType &srcType,
    3639             :                           void *pDst, const GDALExtendedDataType &dstType);
    3640             : 
    3641             :     static bool CopyValues(const void *pSrc,
    3642             :                            const GDALExtendedDataType &srcType,
    3643             :                            GPtrDiff_t nSrcStrideInElts, void *pDst,
    3644             :                            const GDALExtendedDataType &dstType,
    3645             :                            GPtrDiff_t nDstStrideInElts, size_t nValues);
    3646             : 
    3647             :   private:
    3648             :     GDALExtendedDataType(size_t nMaxStringLength,
    3649             :                          GDALExtendedDataTypeSubType eSubType);
    3650             :     explicit GDALExtendedDataType(GDALDataType eType);
    3651             :     GDALExtendedDataType(const std::string &osName, GDALDataType eBaseType,
    3652             :                          std::unique_ptr<GDALRasterAttributeTable>);
    3653             :     GDALExtendedDataType(
    3654             :         const std::string &osName, size_t nTotalSize,
    3655             :         std::vector<std::unique_ptr<GDALEDTComponent>> &&components);
    3656             : 
    3657             :     std::string m_osName{};
    3658             :     GDALExtendedDataTypeClass m_eClass = GEDTC_NUMERIC;
    3659             :     GDALExtendedDataTypeSubType m_eSubType = GEDTST_NONE;
    3660             :     GDALDataType m_eNumericDT = GDT_Unknown;
    3661             :     std::vector<std::unique_ptr<GDALEDTComponent>> m_aoComponents{};
    3662             :     size_t m_nSize = 0;
    3663             :     size_t m_nMaxStringLength = 0;
    3664             :     std::unique_ptr<GDALRasterAttributeTable> m_poRAT{};
    3665             : };
    3666             : 
    3667             : /* ******************************************************************** */
    3668             : /*                            GDALEDTComponent                          */
    3669             : /* ******************************************************************** */
    3670             : 
    3671             : /**
    3672             :  * Class for a component of a compound extended data type.
    3673             :  *
    3674             :  * @since GDAL 3.1
    3675             :  */
    3676        4174 : class CPL_DLL GDALEDTComponent
    3677             : {
    3678             :   public:
    3679             :     ~GDALEDTComponent();
    3680             :     GDALEDTComponent(const std::string &name, size_t offset,
    3681             :                      const GDALExtendedDataType &type);
    3682             :     GDALEDTComponent(const GDALEDTComponent &);
    3683             : 
    3684             :     bool operator==(const GDALEDTComponent &) const;
    3685             : 
    3686             :     /** Return the name.
    3687             :      *
    3688             :      * This is the same as the C function GDALEDTComponentGetName().
    3689             :      */
    3690        3641 :     const std::string &GetName() const
    3691             :     {
    3692        3641 :         return m_osName;
    3693             :     }
    3694             : 
    3695             :     /** Return the offset (in bytes) of the component in the compound data type.
    3696             :      *
    3697             :      * This is the same as the C function GDALEDTComponentGetOffset().
    3698             :      */
    3699        8809 :     size_t GetOffset() const
    3700             :     {
    3701        8809 :         return m_nOffset;
    3702             :     }
    3703             : 
    3704             :     /** Return the data type of the component.
    3705             :      *
    3706             :      * This is the same as the C function GDALEDTComponentGetType().
    3707             :      */
    3708        8049 :     const GDALExtendedDataType &GetType() const
    3709             :     {
    3710        8049 :         return m_oType;
    3711             :     }
    3712             : 
    3713             :   private:
    3714             :     std::string m_osName;
    3715             :     size_t m_nOffset;
    3716             :     GDALExtendedDataType m_oType;
    3717             : };
    3718             : 
    3719             : /* ******************************************************************** */
    3720             : /*                            GDALIHasAttribute                         */
    3721             : /* ******************************************************************** */
    3722             : 
    3723             : /**
    3724             :  * Interface used to get a single GDALAttribute or a set of GDALAttribute
    3725             :  *
    3726             :  * @since GDAL 3.1
    3727             :  */
    3728       13481 : class CPL_DLL GDALIHasAttribute
    3729             : {
    3730             :   protected:
    3731             :     std::shared_ptr<GDALAttribute>
    3732             :     GetAttributeFromAttributes(const std::string &osName) const;
    3733             : 
    3734             :   public:
    3735             :     virtual ~GDALIHasAttribute();
    3736             : 
    3737             :     virtual std::shared_ptr<GDALAttribute>
    3738             :     GetAttribute(const std::string &osName) const;
    3739             : 
    3740             :     virtual std::vector<std::shared_ptr<GDALAttribute>>
    3741             :     GetAttributes(CSLConstList papszOptions = nullptr) const;
    3742             : 
    3743             :     virtual std::shared_ptr<GDALAttribute>
    3744             :     CreateAttribute(const std::string &osName,
    3745             :                     const std::vector<GUInt64> &anDimensions,
    3746             :                     const GDALExtendedDataType &oDataType,
    3747             :                     CSLConstList papszOptions = nullptr);
    3748             : 
    3749             :     virtual bool DeleteAttribute(const std::string &osName,
    3750             :                                  CSLConstList papszOptions = nullptr);
    3751             : };
    3752             : 
    3753             : /* ******************************************************************** */
    3754             : /*                               GDALGroup                              */
    3755             : /* ******************************************************************** */
    3756             : 
    3757             : /* clang-format off */
    3758             : /**
    3759             :  * Class modeling a named container of GDALAttribute, GDALMDArray, OGRLayer or
    3760             :  * other GDALGroup. Hence GDALGroup can describe a hierarchy of objects.
    3761             :  *
    3762             :  * This is based on the <a href="https://portal.opengeospatial.org/files/81716#_hdf5_group">HDF5 group
    3763             :  * concept</a>
    3764             :  *
    3765             :  * @since GDAL 3.1
    3766             :  */
    3767             : /* clang-format on */
    3768             : 
    3769        6915 : class CPL_DLL GDALGroup : public GDALIHasAttribute
    3770             : {
    3771             :   protected:
    3772             :     //! @cond Doxygen_Suppress
    3773             :     std::string m_osName{};
    3774             : 
    3775             :     // This is actually a path of the form "/parent_path/{m_osName}"
    3776             :     std::string m_osFullName{};
    3777             : 
    3778             :     // Used for example by GDALSubsetGroup to distinguish a derived group
    3779             :     //from its original, without altering its name
    3780             :     const std::string m_osContext{};
    3781             : 
    3782             :     // List of types owned by the group.
    3783             :     std::vector<std::shared_ptr<GDALExtendedDataType>> m_apoTypes{};
    3784             : 
    3785             :     //! Weak pointer to this
    3786             :     std::weak_ptr<GDALGroup> m_pSelf{};
    3787             : 
    3788             :     //! Can be set to false by the owing group, when deleting this object
    3789             :     bool m_bValid = true;
    3790             : 
    3791             :     GDALGroup(const std::string &osParentName, const std::string &osName,
    3792             :               const std::string &osContext = std::string());
    3793             : 
    3794             :     const GDALGroup *
    3795             :     GetInnerMostGroup(const std::string &osPathOrArrayOrDim,
    3796             :                       std::shared_ptr<GDALGroup> &curGroupHolder,
    3797             :                       std::string &osLastPart) const;
    3798             : 
    3799             :     void BaseRename(const std::string &osNewName);
    3800             : 
    3801             :     bool CheckValidAndErrorOutIfNot() const;
    3802             : 
    3803        6049 :     void SetSelf(const std::shared_ptr<GDALGroup> &self)
    3804             :     {
    3805        6049 :         m_pSelf = self;
    3806        6049 :     }
    3807             : 
    3808           0 :     virtual void NotifyChildrenOfRenaming()
    3809             :     {
    3810           0 :     }
    3811             : 
    3812           0 :     virtual void NotifyChildrenOfDeletion()
    3813             :     {
    3814           0 :     }
    3815             : 
    3816             :     //! @endcond
    3817             : 
    3818             :   public:
    3819             :     virtual ~GDALGroup();
    3820             : 
    3821             :     /** Return the name of the group.
    3822             :      *
    3823             :      * This is the same as the C function GDALGroupGetName().
    3824             :      */
    3825        1052 :     const std::string &GetName() const
    3826             :     {
    3827        1052 :         return m_osName;
    3828             :     }
    3829             : 
    3830             :     /** Return the full name of the group.
    3831             :      *
    3832             :      * This is the same as the C function GDALGroupGetFullName().
    3833             :      */
    3834       24283 :     const std::string &GetFullName() const
    3835             :     {
    3836       24283 :         return m_osFullName;
    3837             :     }
    3838             : 
    3839             :     /** Return data types associated with the group (typically enumerations)
    3840             :      *
    3841             :      * This is the same as the C function GDALGroupGetDataTypeCount() and GDALGroupGetDataType()
    3842             :      *
    3843             :      * @since 3.12
    3844             :      */
    3845             :     const std::vector<std::shared_ptr<GDALExtendedDataType>> &
    3846          55 :     GetDataTypes() const
    3847             :     {
    3848          55 :         return m_apoTypes;
    3849             :     }
    3850             : 
    3851             :     virtual std::vector<std::string>
    3852             :     GetMDArrayNames(CSLConstList papszOptions = nullptr) const;
    3853             :     virtual std::shared_ptr<GDALMDArray>
    3854             :     OpenMDArray(const std::string &osName,
    3855             :                 CSLConstList papszOptions = nullptr) const;
    3856             : 
    3857             :     std::vector<std::string> GetMDArrayFullNamesRecursive(
    3858             :         CSLConstList papszGroupOptions = nullptr,
    3859             :         CSLConstList papszArrayOptions = nullptr) const;
    3860             : 
    3861             :     virtual std::vector<std::string>
    3862             :     GetGroupNames(CSLConstList papszOptions = nullptr) const;
    3863             :     virtual std::shared_ptr<GDALGroup>
    3864             :     OpenGroup(const std::string &osName,
    3865             :               CSLConstList papszOptions = nullptr) const;
    3866             : 
    3867             :     virtual std::vector<std::string>
    3868             :     GetVectorLayerNames(CSLConstList papszOptions = nullptr) const;
    3869             :     virtual OGRLayer *
    3870             :     OpenVectorLayer(const std::string &osName,
    3871             :                     CSLConstList papszOptions = nullptr) const;
    3872             : 
    3873             :     virtual std::vector<std::shared_ptr<GDALDimension>>
    3874             :     GetDimensions(CSLConstList papszOptions = nullptr) const;
    3875             : 
    3876             :     virtual std::shared_ptr<GDALGroup>
    3877             :     CreateGroup(const std::string &osName, CSLConstList papszOptions = nullptr);
    3878             : 
    3879             :     virtual bool DeleteGroup(const std::string &osName,
    3880             :                              CSLConstList papszOptions = nullptr);
    3881             : 
    3882             :     virtual std::shared_ptr<GDALDimension>
    3883             :     CreateDimension(const std::string &osName, const std::string &osType,
    3884             :                     const std::string &osDirection, GUInt64 nSize,
    3885             :                     CSLConstList papszOptions = nullptr);
    3886             : 
    3887             :     virtual std::shared_ptr<GDALMDArray> CreateMDArray(
    3888             :         const std::string &osName,
    3889             :         const std::vector<std::shared_ptr<GDALDimension>> &aoDimensions,
    3890             :         const GDALExtendedDataType &oDataType,
    3891             :         CSLConstList papszOptions = nullptr);
    3892             : 
    3893             :     virtual bool DeleteMDArray(const std::string &osName,
    3894             :                                CSLConstList papszOptions = nullptr);
    3895             : 
    3896             :     GUInt64 GetTotalCopyCost() const;
    3897             : 
    3898             :     virtual bool CopyFrom(const std::shared_ptr<GDALGroup> &poDstRootGroup,
    3899             :                           GDALDataset *poSrcDS,
    3900             :                           const std::shared_ptr<GDALGroup> &poSrcGroup,
    3901             :                           bool bStrict, GUInt64 &nCurCost,
    3902             :                           const GUInt64 nTotalCost,
    3903             :                           GDALProgressFunc pfnProgress, void *pProgressData,
    3904             :                           CSLConstList papszOptions = nullptr);
    3905             : 
    3906             :     virtual CSLConstList GetStructuralInfo() const;
    3907             : 
    3908             :     std::shared_ptr<GDALMDArray>
    3909             :     OpenMDArrayFromFullname(const std::string &osFullName,
    3910             :                             CSLConstList papszOptions = nullptr) const;
    3911             : 
    3912             :     std::shared_ptr<GDALAttribute>
    3913             :     OpenAttributeFromFullname(const std::string &osFullName,
    3914             :                               CSLConstList papszOptions = nullptr) const;
    3915             : 
    3916             :     std::shared_ptr<GDALMDArray>
    3917             :     ResolveMDArray(const std::string &osName, const std::string &osStartingPath,
    3918             :                    CSLConstList papszOptions = nullptr) const;
    3919             : 
    3920             :     std::shared_ptr<GDALGroup>
    3921             :     OpenGroupFromFullname(const std::string &osFullName,
    3922             :                           CSLConstList papszOptions = nullptr) const;
    3923             : 
    3924             :     std::shared_ptr<GDALDimension>
    3925             :     OpenDimensionFromFullname(const std::string &osFullName) const;
    3926             : 
    3927             :     virtual void ClearStatistics();
    3928             : 
    3929             :     virtual bool Rename(const std::string &osNewName);
    3930             : 
    3931             :     std::shared_ptr<GDALGroup>
    3932             :     SubsetDimensionFromSelection(const std::string &osSelection) const;
    3933             : 
    3934             :     //! @cond Doxygen_Suppress
    3935             :     virtual void ParentRenamed(const std::string &osNewParentFullName);
    3936             : 
    3937             :     virtual void Deleted();
    3938             : 
    3939             :     virtual void ParentDeleted();
    3940             : 
    3941          23 :     const std::string &GetContext() const
    3942             :     {
    3943          23 :         return m_osContext;
    3944             :     }
    3945             : 
    3946             :     //! @endcond
    3947             : 
    3948             :     //! @cond Doxygen_Suppress
    3949             :     static constexpr GUInt64 COPY_COST = 1000;
    3950             :     //! @endcond
    3951             : };
    3952             : 
    3953             : /* ******************************************************************** */
    3954             : /*                          GDALAbstractMDArray                         */
    3955             : /* ******************************************************************** */
    3956             : 
    3957             : /**
    3958             :  * Abstract class, implemented by GDALAttribute and GDALMDArray.
    3959             :  *
    3960             :  * @since GDAL 3.1
    3961             :  */
    3962       20965 : class CPL_DLL GDALAbstractMDArray
    3963             : {
    3964             :   protected:
    3965             :     //! @cond Doxygen_Suppress
    3966             :     std::string m_osName{};
    3967             : 
    3968             :     // This is actually a path of the form "/parent_path/{m_osName}"
    3969             :     std::string m_osFullName{};
    3970             :     std::weak_ptr<GDALAbstractMDArray> m_pSelf{};
    3971             : 
    3972             :     //! Can be set to false by the owing object, when deleting this object
    3973             :     bool m_bValid = true;
    3974             : 
    3975             :     GDALAbstractMDArray(const std::string &osParentName,
    3976             :                         const std::string &osName);
    3977             : 
    3978        8344 :     void SetSelf(const std::shared_ptr<GDALAbstractMDArray> &self)
    3979             :     {
    3980        8344 :         m_pSelf = self;
    3981        8344 :     }
    3982             : 
    3983             :     bool CheckValidAndErrorOutIfNot() const;
    3984             : 
    3985             :     bool CheckReadWriteParams(const GUInt64 *arrayStartIdx, const size_t *count,
    3986             :                               const GInt64 *&arrayStep,
    3987             :                               const GPtrDiff_t *&bufferStride,
    3988             :                               const GDALExtendedDataType &bufferDataType,
    3989             :                               const void *buffer,
    3990             :                               const void *buffer_alloc_start,
    3991             :                               size_t buffer_alloc_size,
    3992             :                               std::vector<GInt64> &tmp_arrayStep,
    3993             :                               std::vector<GPtrDiff_t> &tmp_bufferStride) const;
    3994             : 
    3995             :     virtual bool
    3996             :     IRead(const GUInt64 *arrayStartIdx,    // array of size GetDimensionCount()
    3997             :           const size_t *count,             // array of size GetDimensionCount()
    3998             :           const GInt64 *arrayStep,         // step in elements
    3999             :           const GPtrDiff_t *bufferStride,  // stride in elements
    4000             :           const GDALExtendedDataType &bufferDataType,
    4001             :           void *pDstBuffer) const = 0;
    4002             : 
    4003             :     virtual bool
    4004             :     IWrite(const GUInt64 *arrayStartIdx,    // array of size GetDimensionCount()
    4005             :            const size_t *count,             // array of size GetDimensionCount()
    4006             :            const GInt64 *arrayStep,         // step in elements
    4007             :            const GPtrDiff_t *bufferStride,  // stride in elements
    4008             :            const GDALExtendedDataType &bufferDataType, const void *pSrcBuffer);
    4009             : 
    4010             :     void BaseRename(const std::string &osNewName);
    4011             : 
    4012          47 :     virtual void NotifyChildrenOfRenaming()
    4013             :     {
    4014          47 :     }
    4015             : 
    4016          42 :     virtual void NotifyChildrenOfDeletion()
    4017             :     {
    4018          42 :     }
    4019             : 
    4020             :     //! @endcond
    4021             : 
    4022             :   public:
    4023             :     virtual ~GDALAbstractMDArray();
    4024             : 
    4025             :     /** Return the name of an array or attribute.
    4026             :      *
    4027             :      * This is the same as the C function GDALMDArrayGetName() or
    4028             :      * GDALAttributeGetName().
    4029             :      */
    4030       19408 :     const std::string &GetName() const
    4031             :     {
    4032       19408 :         return m_osName;
    4033             :     }
    4034             : 
    4035             :     /** Return the name of an array or attribute.
    4036             :      *
    4037             :      * This is the same as the C function GDALMDArrayGetFullName() or
    4038             :      * GDALAttributeGetFullName().
    4039             :      */
    4040       12813 :     const std::string &GetFullName() const
    4041             :     {
    4042       12813 :         return m_osFullName;
    4043             :     }
    4044             : 
    4045             :     GUInt64 GetTotalElementsCount() const;
    4046             : 
    4047             :     virtual size_t GetDimensionCount() const;
    4048             : 
    4049             :     virtual const std::vector<std::shared_ptr<GDALDimension>> &
    4050             :     GetDimensions() const = 0;
    4051             : 
    4052             :     virtual const GDALExtendedDataType &GetDataType() const = 0;
    4053             : 
    4054             :     virtual std::vector<GUInt64> GetBlockSize() const;
    4055             : 
    4056             :     virtual std::vector<size_t>
    4057             :     GetProcessingChunkSize(size_t nMaxChunkMemory) const;
    4058             : 
    4059             :     /* clang-format off */
    4060             :     /** Type of pfnFunc argument of ProcessPerChunk().
    4061             :      * @param array Array on which ProcessPerChunk was called.
    4062             :      * @param chunkArrayStartIdx Values representing the starting index to use
    4063             :      *                           in each dimension (in [0, aoDims[i].GetSize()-1] range)
    4064             :      *                           for the current chunk.
    4065             :      *                           Will be nullptr for a zero-dimensional array.
    4066             :      * @param chunkCount         Values representing the number of values to use in
    4067             :      *                           each dimension for the current chunk.
    4068             :      *                           Will be nullptr for a zero-dimensional array.
    4069             :      * @param iCurChunk          Number of current chunk being processed.
    4070             :      *                           In [1, nChunkCount] range.
    4071             :      * @param nChunkCount        Total number of chunks to process.
    4072             :      * @param pUserData          User data.
    4073             :      * @return return true in case of success.
    4074             :      */
    4075             :     typedef bool (*FuncProcessPerChunkType)(
    4076             :                         GDALAbstractMDArray *array,
    4077             :                         const GUInt64 *chunkArrayStartIdx,
    4078             :                         const size_t *chunkCount,
    4079             :                         GUInt64 iCurChunk,
    4080             :                         GUInt64 nChunkCount,
    4081             :                         void *pUserData);
    4082             :     /* clang-format on */
    4083             : 
    4084             :     virtual bool ProcessPerChunk(const GUInt64 *arrayStartIdx,
    4085             :                                  const GUInt64 *count, const size_t *chunkSize,
    4086             :                                  FuncProcessPerChunkType pfnFunc,
    4087             :                                  void *pUserData);
    4088             : 
    4089             :     virtual bool
    4090             :     Read(const GUInt64 *arrayStartIdx,    // array of size GetDimensionCount()
    4091             :          const size_t *count,             // array of size GetDimensionCount()
    4092             :          const GInt64 *arrayStep,         // step in elements
    4093             :          const GPtrDiff_t *bufferStride,  // stride in elements
    4094             :          const GDALExtendedDataType &bufferDataType, void *pDstBuffer,
    4095             :          const void *pDstBufferAllocStart = nullptr,
    4096             :          size_t nDstBufferAllocSize = 0) const;
    4097             : 
    4098             :     bool
    4099             :     Write(const GUInt64 *arrayStartIdx,    // array of size GetDimensionCount()
    4100             :           const size_t *count,             // array of size GetDimensionCount()
    4101             :           const GInt64 *arrayStep,         // step in elements
    4102             :           const GPtrDiff_t *bufferStride,  // stride in elements
    4103             :           const GDALExtendedDataType &bufferDataType, const void *pSrcBuffer,
    4104             :           const void *pSrcBufferAllocStart = nullptr,
    4105             :           size_t nSrcBufferAllocSize = 0);
    4106             : 
    4107             :     virtual bool Rename(const std::string &osNewName);
    4108             : 
    4109             :     //! @cond Doxygen_Suppress
    4110             :     virtual void Deleted();
    4111             : 
    4112             :     virtual void ParentDeleted();
    4113             : 
    4114             :     virtual void ParentRenamed(const std::string &osNewParentFullName);
    4115             :     //! @endcond
    4116             : };
    4117             : 
    4118             : /* ******************************************************************** */
    4119             : /*                              GDALRawResult                           */
    4120             : /* ******************************************************************** */
    4121             : 
    4122             : /**
    4123             :  * Store the raw result of an attribute value, which might contain dynamically
    4124             :  * allocated structures (like pointer to strings).
    4125             :  *
    4126             :  * @since GDAL 3.1
    4127             :  */
    4128             : class CPL_DLL GDALRawResult
    4129             : {
    4130             :   private:
    4131             :     GDALExtendedDataType m_dt;
    4132             :     size_t m_nEltCount;
    4133             :     size_t m_nSize;
    4134             :     GByte *m_raw;
    4135             : 
    4136             :     void FreeMe();
    4137             : 
    4138             :     GDALRawResult(const GDALRawResult &) = delete;
    4139             :     GDALRawResult &operator=(const GDALRawResult &) = delete;
    4140             : 
    4141             :   protected:
    4142             :     friend class GDALAttribute;
    4143             :     //! @cond Doxygen_Suppress
    4144             :     GDALRawResult(GByte *raw, const GDALExtendedDataType &dt, size_t nEltCount);
    4145             :     //! @endcond
    4146             : 
    4147             :   public:
    4148             :     ~GDALRawResult();
    4149             :     GDALRawResult(GDALRawResult &&);
    4150             :     GDALRawResult &operator=(GDALRawResult &&);
    4151             : 
    4152             :     /** Return byte at specified index. */
    4153             :     const GByte &operator[](size_t idx) const
    4154             :     {
    4155             :         return m_raw[idx];
    4156             :     }
    4157             : 
    4158             :     /** Return pointer to the start of data. */
    4159         343 :     const GByte *data() const
    4160             :     {
    4161         343 :         return m_raw;
    4162             :     }
    4163             : 
    4164             :     /** Return the size in bytes of the raw result. */
    4165         125 :     size_t size() const
    4166             :     {
    4167         125 :         return m_nSize;
    4168             :     }
    4169             : 
    4170             :     //! @cond Doxygen_Suppress
    4171             :     GByte *StealData();
    4172             :     //! @endcond
    4173             : };
    4174             : 
    4175             : /* ******************************************************************** */
    4176             : /*                              GDALAttribute                           */
    4177             : /* ******************************************************************** */
    4178             : 
    4179             : /* clang-format off */
    4180             : /**
    4181             :  * Class modeling an attribute that has a name, a value and a type, and is
    4182             :  * typically used to describe a metadata item. The value can be (for the
    4183             :  * HDF5 format) in the general case a multidimensional array of "any" type
    4184             :  * (in most cases, this will be a single value of string or numeric type)
    4185             :  *
    4186             :  * This is based on the <a href="https://portal.opengeospatial.org/files/81716#_hdf5_attribute">HDF5
    4187             :  * attribute concept</a>
    4188             :  *
    4189             :  * @since GDAL 3.1
    4190             :  */
    4191             : /* clang-format on */
    4192             : 
    4193       14399 : class CPL_DLL GDALAttribute : virtual public GDALAbstractMDArray
    4194             : {
    4195             :     mutable std::string m_osCachedVal{};
    4196             : 
    4197             :   protected:
    4198             :     //! @cond Doxygen_Suppress
    4199             :     GDALAttribute(const std::string &osParentName, const std::string &osName);
    4200             :     //! @endcond
    4201             : 
    4202             :   public:
    4203             :     //! @cond Doxygen_Suppress
    4204             :     ~GDALAttribute();
    4205             :     //! @endcond
    4206             : 
    4207             :     std::vector<GUInt64> GetDimensionsSize() const;
    4208             : 
    4209             :     GDALRawResult ReadAsRaw() const;
    4210             :     const char *ReadAsString() const;
    4211             :     int ReadAsInt() const;
    4212             :     int64_t ReadAsInt64() const;
    4213             :     double ReadAsDouble() const;
    4214             :     CPLStringList ReadAsStringArray() const;
    4215             :     std::vector<int> ReadAsIntArray() const;
    4216             :     std::vector<int64_t> ReadAsInt64Array() const;
    4217             :     std::vector<double> ReadAsDoubleArray() const;
    4218             : 
    4219             :     using GDALAbstractMDArray::Write;
    4220             :     bool Write(const void *pabyValue, size_t nLen);
    4221             :     bool Write(const char *);
    4222             :     bool WriteInt(int);
    4223             :     bool WriteInt64(int64_t);
    4224             :     bool Write(double);
    4225             :     bool Write(CSLConstList);
    4226             :     bool Write(const int *, size_t);
    4227             :     bool Write(const int64_t *, size_t);
    4228             :     bool Write(const double *, size_t);
    4229             : 
    4230             :     //! @cond Doxygen_Suppress
    4231             :     static constexpr GUInt64 COPY_COST = 100;
    4232             :     //! @endcond
    4233             : };
    4234             : 
    4235             : /************************************************************************/
    4236             : /*                            GDALAttributeString                       */
    4237             : /************************************************************************/
    4238             : 
    4239             : //! @cond Doxygen_Suppress
    4240             : class CPL_DLL GDALAttributeString final : public GDALAttribute
    4241             : {
    4242             :     std::vector<std::shared_ptr<GDALDimension>> m_dims{};
    4243             :     GDALExtendedDataType m_dt = GDALExtendedDataType::CreateString();
    4244             :     std::string m_osValue;
    4245             : 
    4246             :   protected:
    4247             :     bool IRead(const GUInt64 *, const size_t *, const GInt64 *,
    4248             :                const GPtrDiff_t *, const GDALExtendedDataType &bufferDataType,
    4249             :                void *pDstBuffer) const override;
    4250             : 
    4251             :   public:
    4252             :     GDALAttributeString(const std::string &osParentName,
    4253             :                         const std::string &osName, const std::string &osValue,
    4254             :                         GDALExtendedDataTypeSubType eSubType = GEDTST_NONE);
    4255             : 
    4256             :     const std::vector<std::shared_ptr<GDALDimension>> &
    4257             :     GetDimensions() const override;
    4258             : 
    4259             :     const GDALExtendedDataType &GetDataType() const override;
    4260             : };
    4261             : 
    4262             : //! @endcond
    4263             : 
    4264             : /************************************************************************/
    4265             : /*                           GDALAttributeNumeric                       */
    4266             : /************************************************************************/
    4267             : 
    4268             : //! @cond Doxygen_Suppress
    4269             : class CPL_DLL GDALAttributeNumeric final : public GDALAttribute
    4270             : {
    4271             :     std::vector<std::shared_ptr<GDALDimension>> m_dims{};
    4272             :     GDALExtendedDataType m_dt;
    4273             :     int m_nValue = 0;
    4274             :     double m_dfValue = 0;
    4275             :     std::vector<GUInt32> m_anValuesUInt32{};
    4276             : 
    4277             :   protected:
    4278             :     bool IRead(const GUInt64 *, const size_t *, const GInt64 *,
    4279             :                const GPtrDiff_t *, const GDALExtendedDataType &bufferDataType,
    4280             :                void *pDstBuffer) const override;
    4281             : 
    4282             :   public:
    4283             :     GDALAttributeNumeric(const std::string &osParentName,
    4284             :                          const std::string &osName, double dfValue);
    4285             :     GDALAttributeNumeric(const std::string &osParentName,
    4286             :                          const std::string &osName, int nValue);
    4287             :     GDALAttributeNumeric(const std::string &osParentName,
    4288             :                          const std::string &osName,
    4289             :                          const std::vector<GUInt32> &anValues);
    4290             : 
    4291             :     const std::vector<std::shared_ptr<GDALDimension>> &
    4292             :     GetDimensions() const override;
    4293             : 
    4294             :     const GDALExtendedDataType &GetDataType() const override;
    4295             : };
    4296             : 
    4297             : //! @endcond
    4298             : 
    4299             : /* ******************************************************************** */
    4300             : /*                              GDALMDArray                             */
    4301             : /* ******************************************************************** */
    4302             : 
    4303             : /* clang-format off */
    4304             : /**
    4305             :  * Class modeling a multi-dimensional array. It has a name, values organized
    4306             :  * as an array and a list of GDALAttribute.
    4307             :  *
    4308             :  * This is based on the <a href="https://portal.opengeospatial.org/files/81716#_hdf5_dataset">HDF5
    4309             :  * dataset concept</a>
    4310             :  *
    4311             :  * @since GDAL 3.1
    4312             :  */
    4313             : /* clang-format on */
    4314             : 
    4315             : class CPL_DLL GDALMDArray : virtual public GDALAbstractMDArray,
    4316             :                             public GDALIHasAttribute
    4317             : {
    4318             :     friend class GDALMDArrayResampled;
    4319             :     std::shared_ptr<GDALMDArray>
    4320             :     GetView(const std::vector<GUInt64> &indices) const;
    4321             : 
    4322             :     inline std::shared_ptr<GDALMDArray>
    4323          19 :     atInternal(const std::vector<GUInt64> &indices) const
    4324             :     {
    4325          19 :         return GetView(indices);
    4326             :     }
    4327             : 
    4328             :     template <typename... GUInt64VarArg>
    4329             :     // cppcheck-suppress functionStatic
    4330             :     inline std::shared_ptr<GDALMDArray>
    4331           7 :     atInternal(std::vector<GUInt64> &indices, GUInt64 idx,
    4332             :                GUInt64VarArg... tail) const
    4333             :     {
    4334           7 :         indices.push_back(idx);
    4335           7 :         return atInternal(indices, tail...);
    4336             :     }
    4337             : 
    4338             :     // Used for example by GDALSubsetGroup to distinguish a derived group
    4339             :     //from its original, without altering its name
    4340             :     const std::string m_osContext{};
    4341             : 
    4342             :     mutable bool m_bHasTriedCachedArray = false;
    4343             :     mutable std::shared_ptr<GDALMDArray> m_poCachedArray{};
    4344             : 
    4345             :   protected:
    4346             :     //! @cond Doxygen_Suppress
    4347             :     GDALMDArray(const std::string &osParentName, const std::string &osName,
    4348             :                 const std::string &osContext = std::string());
    4349             : 
    4350             :     virtual bool IAdviseRead(const GUInt64 *arrayStartIdx, const size_t *count,
    4351             :                              CSLConstList papszOptions) const;
    4352             : 
    4353        1748 :     virtual bool IsCacheable() const
    4354             :     {
    4355        1748 :         return true;
    4356             :     }
    4357             : 
    4358             :     virtual bool SetStatistics(bool bApproxStats, double dfMin, double dfMax,
    4359             :                                double dfMean, double dfStdDev,
    4360             :                                GUInt64 nValidCount, CSLConstList papszOptions);
    4361             : 
    4362             :     static std::string MassageName(const std::string &inputName);
    4363             : 
    4364             :     std::shared_ptr<GDALGroup>
    4365             :     GetCacheRootGroup(bool bCanCreate, std::string &osCacheFilenameOut) const;
    4366             : 
    4367             :     // Returns if bufferStride values express a transposed view of the array
    4368             :     bool IsTransposedRequest(const size_t *count,
    4369             :                              const GPtrDiff_t *bufferStride) const;
    4370             : 
    4371             :     // Should only be called if IsTransposedRequest() returns true
    4372             :     bool ReadForTransposedRequest(const GUInt64 *arrayStartIdx,
    4373             :                                   const size_t *count, const GInt64 *arrayStep,
    4374             :                                   const GPtrDiff_t *bufferStride,
    4375             :                                   const GDALExtendedDataType &bufferDataType,
    4376             :                                   void *pDstBuffer) const;
    4377             : 
    4378             :     bool IsStepOneContiguousRowMajorOrderedSameDataType(
    4379             :         const size_t *count, const GInt64 *arrayStep,
    4380             :         const GPtrDiff_t *bufferStride,
    4381             :         const GDALExtendedDataType &bufferDataType) const;
    4382             : 
    4383             :     // Should only be called if IsStepOneContiguousRowMajorOrderedSameDataType()
    4384             :     // returns false
    4385             :     bool ReadUsingContiguousIRead(const GUInt64 *arrayStartIdx,
    4386             :                                   const size_t *count, const GInt64 *arrayStep,
    4387             :                                   const GPtrDiff_t *bufferStride,
    4388             :                                   const GDALExtendedDataType &bufferDataType,
    4389             :                                   void *pDstBuffer) const;
    4390             : 
    4391             :     static std::shared_ptr<GDALMDArray> CreateGLTOrthorectified(
    4392             :         const std::shared_ptr<GDALMDArray> &poParent,
    4393             :         const std::shared_ptr<GDALGroup> &poRootGroup,
    4394             :         const std::shared_ptr<GDALMDArray> &poGLTX,
    4395             :         const std::shared_ptr<GDALMDArray> &poGLTY, int nGLTIndexOffset,
    4396             :         const std::vector<double> &adfGeoTransform, CSLConstList papszOptions);
    4397             : 
    4398             :     //! @endcond
    4399             : 
    4400             :   public:
    4401             :     GUInt64 GetTotalCopyCost() const;
    4402             : 
    4403             :     virtual bool CopyFrom(GDALDataset *poSrcDS, const GDALMDArray *poSrcArray,
    4404             :                           bool bStrict, GUInt64 &nCurCost,
    4405             :                           const GUInt64 nTotalCost,
    4406             :                           GDALProgressFunc pfnProgress, void *pProgressData);
    4407             : 
    4408             :     /** Return whether an array is writable. */
    4409             :     virtual bool IsWritable() const = 0;
    4410             : 
    4411             :     /** Return the filename that contains that array.
    4412             :      *
    4413             :      * This is used in particular for caching.
    4414             :      *
    4415             :      * Might be empty if the array is not linked to a file.
    4416             :      *
    4417             :      * @since GDAL 3.4
    4418             :      */
    4419             :     virtual const std::string &GetFilename() const = 0;
    4420             : 
    4421             :     virtual CSLConstList GetStructuralInfo() const;
    4422             : 
    4423             :     virtual const std::string &GetUnit() const;
    4424             : 
    4425             :     virtual bool SetUnit(const std::string &osUnit);
    4426             : 
    4427             :     virtual bool SetSpatialRef(const OGRSpatialReference *poSRS);
    4428             : 
    4429             :     virtual std::shared_ptr<OGRSpatialReference> GetSpatialRef() const;
    4430             : 
    4431             :     virtual const void *GetRawNoDataValue() const;
    4432             : 
    4433             :     double GetNoDataValueAsDouble(bool *pbHasNoData = nullptr) const;
    4434             : 
    4435             :     int64_t GetNoDataValueAsInt64(bool *pbHasNoData = nullptr) const;
    4436             : 
    4437             :     uint64_t GetNoDataValueAsUInt64(bool *pbHasNoData = nullptr) const;
    4438             : 
    4439             :     virtual bool SetRawNoDataValue(const void *pRawNoData);
    4440             : 
    4441             :     //! @cond Doxygen_Suppress
    4442           2 :     bool SetNoDataValue(int nNoData)
    4443             :     {
    4444           2 :         return SetNoDataValue(static_cast<int64_t>(nNoData));
    4445             :     }
    4446             : 
    4447             :     //! @endcond
    4448             : 
    4449             :     bool SetNoDataValue(double dfNoData);
    4450             : 
    4451             :     bool SetNoDataValue(int64_t nNoData);
    4452             : 
    4453             :     bool SetNoDataValue(uint64_t nNoData);
    4454             : 
    4455             :     virtual bool Resize(const std::vector<GUInt64> &anNewDimSizes,
    4456             :                         CSLConstList papszOptions);
    4457             : 
    4458             :     virtual double GetOffset(bool *pbHasOffset = nullptr,
    4459             :                              GDALDataType *peStorageType = nullptr) const;
    4460             : 
    4461             :     virtual double GetScale(bool *pbHasScale = nullptr,
    4462             :                             GDALDataType *peStorageType = nullptr) const;
    4463             : 
    4464             :     virtual bool SetOffset(double dfOffset,
    4465             :                            GDALDataType eStorageType = GDT_Unknown);
    4466             : 
    4467             :     virtual bool SetScale(double dfScale,
    4468             :                           GDALDataType eStorageType = GDT_Unknown);
    4469             : 
    4470             :     std::shared_ptr<GDALMDArray> GetView(const std::string &viewExpr) const;
    4471             : 
    4472             :     std::shared_ptr<GDALMDArray> operator[](const std::string &fieldName) const;
    4473             : 
    4474             :     /** Return a view of the array using integer indexing.
    4475             :      *
    4476             :      * Equivalent of GetView("[indices_0,indices_1,.....,indices_last]")
    4477             :      *
    4478             :      * Example:
    4479             :      * \code
    4480             :      * ar->at(0,3,2)
    4481             :      * \endcode
    4482             :      */
    4483             :     // sphinx 4.1.0 / breathe 4.30.0 don't like typename...
    4484             :     //! @cond Doxygen_Suppress
    4485             :     template <typename... GUInt64VarArg>
    4486             :     //! @endcond
    4487             :     // cppcheck-suppress functionStatic
    4488          19 :     std::shared_ptr<GDALMDArray> at(GUInt64 idx, GUInt64VarArg... tail) const
    4489             :     {
    4490          38 :         std::vector<GUInt64> indices;
    4491          19 :         indices.push_back(idx);
    4492          38 :         return atInternal(indices, tail...);
    4493             :     }
    4494             : 
    4495             :     virtual std::shared_ptr<GDALMDArray>
    4496             :     Transpose(const std::vector<int> &anMapNewAxisToOldAxis) const;
    4497             : 
    4498             :     std::shared_ptr<GDALMDArray> GetUnscaled(
    4499             :         double dfOverriddenScale = std::numeric_limits<double>::quiet_NaN(),
    4500             :         double dfOverriddenOffset = std::numeric_limits<double>::quiet_NaN(),
    4501             :         double dfOverriddenDstNodata =
    4502             :             std::numeric_limits<double>::quiet_NaN()) const;
    4503             : 
    4504             :     virtual std::shared_ptr<GDALMDArray>
    4505             :     GetMask(CSLConstList papszOptions) const;
    4506             : 
    4507             :     virtual std::shared_ptr<GDALMDArray>
    4508             :     GetResampled(const std::vector<std::shared_ptr<GDALDimension>> &apoNewDims,
    4509             :                  GDALRIOResampleAlg resampleAlg,
    4510             :                  const OGRSpatialReference *poTargetSRS,
    4511             :                  CSLConstList papszOptions) const;
    4512             : 
    4513             :     std::shared_ptr<GDALMDArray>
    4514             :     GetGridded(const std::string &osGridOptions,
    4515             :                const std::shared_ptr<GDALMDArray> &poXArray = nullptr,
    4516             :                const std::shared_ptr<GDALMDArray> &poYArray = nullptr,
    4517             :                CSLConstList papszOptions = nullptr) const;
    4518             : 
    4519             :     static std::vector<std::shared_ptr<GDALMDArray>>
    4520             :     GetMeshGrid(const std::vector<std::shared_ptr<GDALMDArray>> &apoArrays,
    4521             :                 CSLConstList papszOptions = nullptr);
    4522             : 
    4523             :     virtual GDALDataset *
    4524             :     AsClassicDataset(size_t iXDim, size_t iYDim,
    4525             :                      const std::shared_ptr<GDALGroup> &poRootGroup = nullptr,
    4526             :                      CSLConstList papszOptions = nullptr) const;
    4527             : 
    4528             :     virtual CPLErr GetStatistics(bool bApproxOK, bool bForce, double *pdfMin,
    4529             :                                  double *pdfMax, double *pdfMean,
    4530             :                                  double *padfStdDev, GUInt64 *pnValidCount,
    4531             :                                  GDALProgressFunc pfnProgress,
    4532             :                                  void *pProgressData);
    4533             : 
    4534             :     virtual bool ComputeStatistics(bool bApproxOK, double *pdfMin,
    4535             :                                    double *pdfMax, double *pdfMean,
    4536             :                                    double *pdfStdDev, GUInt64 *pnValidCount,
    4537             :                                    GDALProgressFunc, void *pProgressData,
    4538             :                                    CSLConstList papszOptions);
    4539             : 
    4540             :     virtual void ClearStatistics();
    4541             : 
    4542             :     virtual std::vector<std::shared_ptr<GDALMDArray>>
    4543             :     GetCoordinateVariables() const;
    4544             : 
    4545             :     bool AdviseRead(const GUInt64 *arrayStartIdx, const size_t *count,
    4546             :                     CSLConstList papszOptions = nullptr) const;
    4547             : 
    4548             :     bool IsRegularlySpaced(double &dfStart, double &dfIncrement) const;
    4549             : 
    4550             :     bool GuessGeoTransform(size_t nDimX, size_t nDimY, bool bPixelIsPoint,
    4551             :                            GDALGeoTransform &gt) const;
    4552             : 
    4553             :     bool GuessGeoTransform(size_t nDimX, size_t nDimY, bool bPixelIsPoint,
    4554             :                            double adfGeoTransform[6]) const;
    4555             : 
    4556             :     bool Cache(CSLConstList papszOptions = nullptr) const;
    4557             : 
    4558             :     bool
    4559             :     Read(const GUInt64 *arrayStartIdx,    // array of size GetDimensionCount()
    4560             :          const size_t *count,             // array of size GetDimensionCount()
    4561             :          const GInt64 *arrayStep,         // step in elements
    4562             :          const GPtrDiff_t *bufferStride,  // stride in elements
    4563             :          const GDALExtendedDataType &bufferDataType, void *pDstBuffer,
    4564             :          const void *pDstBufferAllocStart = nullptr,
    4565             :          size_t nDstBufferAllocSize = 0) const override final;
    4566             : 
    4567             :     virtual std::shared_ptr<GDALGroup> GetRootGroup() const;
    4568             : 
    4569             :     //! @cond Doxygen_Suppress
    4570             :     static constexpr GUInt64 COPY_COST = 1000;
    4571             : 
    4572             :     bool CopyFromAllExceptValues(const GDALMDArray *poSrcArray, bool bStrict,
    4573             :                                  GUInt64 &nCurCost, const GUInt64 nTotalCost,
    4574             :                                  GDALProgressFunc pfnProgress,
    4575             :                                  void *pProgressData);
    4576             : 
    4577             :     struct Range
    4578             :     {
    4579             :         GUInt64 m_nStartIdx;
    4580             :         GInt64 m_nIncr;
    4581             : 
    4582        1331 :         explicit Range(GUInt64 nStartIdx = 0, GInt64 nIncr = 0)
    4583        1331 :             : m_nStartIdx(nStartIdx), m_nIncr(nIncr)
    4584             :         {
    4585        1331 :         }
    4586             :     };
    4587             : 
    4588             :     struct ViewSpec
    4589             :     {
    4590             :         std::string m_osFieldName{};
    4591             : 
    4592             :         // or
    4593             : 
    4594             :         std::vector<size_t>
    4595             :             m_mapDimIdxToParentDimIdx{};  // of size m_dims.size()
    4596             :         std::vector<Range>
    4597             :             m_parentRanges{};  // of size m_poParent->GetDimensionCount()
    4598             :     };
    4599             : 
    4600             :     virtual std::shared_ptr<GDALMDArray>
    4601             :     GetView(const std::string &viewExpr, bool bRenameDimensions,
    4602             :             std::vector<ViewSpec> &viewSpecs) const;
    4603             : 
    4604        1081 :     const std::string &GetContext() const
    4605             :     {
    4606        1081 :         return m_osContext;
    4607             :     }
    4608             : 
    4609             :     //! @endcond
    4610             : };
    4611             : 
    4612             : //! @cond Doxygen_Suppress
    4613             : bool GDALMDRasterIOFromBand(GDALRasterBand *poBand, GDALRWFlag eRWFlag,
    4614             :                             size_t iDimX, size_t iDimY,
    4615             :                             const GUInt64 *arrayStartIdx, const size_t *count,
    4616             :                             const GInt64 *arrayStep,
    4617             :                             const GPtrDiff_t *bufferStride,
    4618             :                             const GDALExtendedDataType &bufferDataType,
    4619             :                             void *pBuffer);
    4620             : 
    4621             : //! @endcond
    4622             : 
    4623             : /************************************************************************/
    4624             : /*                     GDALMDArrayRegularlySpaced                       */
    4625             : /************************************************************************/
    4626             : 
    4627             : //! @cond Doxygen_Suppress
    4628             : class CPL_DLL GDALMDArrayRegularlySpaced : public GDALMDArray
    4629             : {
    4630             :     double m_dfStart;
    4631             :     double m_dfIncrement;
    4632             :     double m_dfOffsetInIncrement;
    4633             :     GDALExtendedDataType m_dt = GDALExtendedDataType::Create(GDT_Float64);
    4634             :     std::vector<std::shared_ptr<GDALDimension>> m_dims;
    4635             :     std::vector<std::shared_ptr<GDALAttribute>> m_attributes{};
    4636             :     std::string m_osEmptyFilename{};
    4637             : 
    4638             :   protected:
    4639             :     bool IRead(const GUInt64 *, const size_t *, const GInt64 *,
    4640             :                const GPtrDiff_t *, const GDALExtendedDataType &bufferDataType,
    4641             :                void *pDstBuffer) const override;
    4642             : 
    4643             :   public:
    4644             :     GDALMDArrayRegularlySpaced(const std::string &osParentName,
    4645             :                                const std::string &osName,
    4646             :                                const std::shared_ptr<GDALDimension> &poDim,
    4647             :                                double dfStart, double dfIncrement,
    4648             :                                double dfOffsetInIncrement);
    4649             : 
    4650             :     static std::shared_ptr<GDALMDArrayRegularlySpaced>
    4651             :     Create(const std::string &osParentName, const std::string &osName,
    4652             :            const std::shared_ptr<GDALDimension> &poDim, double dfStart,
    4653             :            double dfIncrement, double dfOffsetInIncrement);
    4654             : 
    4655           0 :     bool IsWritable() const override
    4656             :     {
    4657           0 :         return false;
    4658             :     }
    4659             : 
    4660         104 :     const std::string &GetFilename() const override
    4661             :     {
    4662         104 :         return m_osEmptyFilename;
    4663             :     }
    4664             : 
    4665             :     const std::vector<std::shared_ptr<GDALDimension>> &
    4666             :     GetDimensions() const override;
    4667             : 
    4668             :     const GDALExtendedDataType &GetDataType() const override;
    4669             : 
    4670             :     std::vector<std::shared_ptr<GDALAttribute>>
    4671             :         GetAttributes(CSLConstList) const override;
    4672             : 
    4673             :     void AddAttribute(const std::shared_ptr<GDALAttribute> &poAttr);
    4674             : };
    4675             : 
    4676             : //! @endcond
    4677             : 
    4678             : /* ******************************************************************** */
    4679             : /*                            GDALDimension                             */
    4680             : /* ******************************************************************** */
    4681             : 
    4682             : /**
    4683             :  * Class modeling a a dimension / axis used to index multidimensional arrays.
    4684             :  * It has a name, a size (that is the number of values that can be indexed along
    4685             :  * the dimension), a type (see GDALDimension::GetType()), a direction
    4686             :  * (see GDALDimension::GetDirection()), a unit and can optionally point to a
    4687             :  * GDALMDArray variable, typically one-dimensional, describing the values taken
    4688             :  * by the dimension. For a georeferenced GDALMDArray and its X dimension, this
    4689             :  * will be typically the values of the easting/longitude for each grid point.
    4690             :  *
    4691             :  * @since GDAL 3.1
    4692             :  */
    4693        8492 : class CPL_DLL GDALDimension
    4694             : {
    4695             :   public:
    4696             :     //! @cond Doxygen_Suppress
    4697             :     GDALDimension(const std::string &osParentName, const std::string &osName,
    4698             :                   const std::string &osType, const std::string &osDirection,
    4699             :                   GUInt64 nSize);
    4700             :     //! @endcond
    4701             : 
    4702             :     virtual ~GDALDimension();
    4703             : 
    4704             :     /** Return the name.
    4705             :      *
    4706             :      * This is the same as the C function GDALDimensionGetName()
    4707             :      */
    4708        8337 :     const std::string &GetName() const
    4709             :     {
    4710        8337 :         return m_osName;
    4711             :     }
    4712             : 
    4713             :     /** Return the full name.
    4714             :      *
    4715             :      * This is the same as the C function GDALDimensionGetFullName()
    4716             :      */
    4717        1551 :     const std::string &GetFullName() const
    4718             :     {
    4719        1551 :         return m_osFullName;
    4720             :     }
    4721             : 
    4722             :     /** Return the axis type.
    4723             :      *
    4724             :      * Predefined values are:
    4725             :      * HORIZONTAL_X, HORIZONTAL_Y, VERTICAL, TEMPORAL, PARAMETRIC
    4726             :      * Other values might be returned. Empty value means unknown.
    4727             :      *
    4728             :      * This is the same as the C function GDALDimensionGetType()
    4729             :      */
    4730        1804 :     const std::string &GetType() const
    4731             :     {
    4732        1804 :         return m_osType;
    4733             :     }
    4734             : 
    4735             :     /** Return the axis direction.
    4736             :      *
    4737             :      * Predefined values are:
    4738             :      * EAST, WEST, SOUTH, NORTH, UP, DOWN, FUTURE, PAST
    4739             :      * Other values might be returned. Empty value means unknown.
    4740             :      *
    4741             :      * This is the same as the C function GDALDimensionGetDirection()
    4742             :      */
    4743         880 :     const std::string &GetDirection() const
    4744             :     {
    4745         880 :         return m_osDirection;
    4746             :     }
    4747             : 
    4748             :     /** Return the size, that is the number of values along the dimension.
    4749             :      *
    4750             :      * This is the same as the C function GDALDimensionGetSize()
    4751             :      */
    4752       82065 :     GUInt64 GetSize() const
    4753             :     {
    4754       82065 :         return m_nSize;
    4755             :     }
    4756             : 
    4757             :     virtual std::shared_ptr<GDALMDArray> GetIndexingVariable() const;
    4758             : 
    4759             :     virtual bool
    4760             :     SetIndexingVariable(std::shared_ptr<GDALMDArray> poIndexingVariable);
    4761             : 
    4762             :     virtual bool Rename(const std::string &osNewName);
    4763             : 
    4764             :     //! @cond Doxygen_Suppress
    4765             :     virtual void ParentRenamed(const std::string &osNewParentFullName);
    4766             : 
    4767             :     virtual void ParentDeleted();
    4768             :     //! @endcond
    4769             : 
    4770             :   protected:
    4771             :     //! @cond Doxygen_Suppress
    4772             :     std::string m_osName;
    4773             :     std::string m_osFullName;
    4774             :     std::string m_osType;
    4775             :     std::string m_osDirection;
    4776             :     GUInt64 m_nSize;
    4777             : 
    4778             :     void BaseRename(const std::string &osNewName);
    4779             : 
    4780             :     //! @endcond
    4781             : };
    4782             : 
    4783             : /************************************************************************/
    4784             : /*                   GDALDimensionWeakIndexingVar()                     */
    4785             : /************************************************************************/
    4786             : 
    4787             : //! @cond Doxygen_Suppress
    4788             : class CPL_DLL GDALDimensionWeakIndexingVar : public GDALDimension
    4789             : {
    4790             :     std::weak_ptr<GDALMDArray> m_poIndexingVariable{};
    4791             : 
    4792             :   public:
    4793             :     GDALDimensionWeakIndexingVar(const std::string &osParentName,
    4794             :                                  const std::string &osName,
    4795             :                                  const std::string &osType,
    4796             :                                  const std::string &osDirection, GUInt64 nSize);
    4797             : 
    4798             :     std::shared_ptr<GDALMDArray> GetIndexingVariable() const override;
    4799             : 
    4800             :     bool SetIndexingVariable(
    4801             :         std::shared_ptr<GDALMDArray> poIndexingVariable) override;
    4802             : 
    4803             :     void SetSize(GUInt64 nNewSize);
    4804             : };
    4805             : //! @endcond
    4806             : 
    4807             : /************************************************************************/
    4808             : /*                       GDALAntiRecursionGuard                         */
    4809             : /************************************************************************/
    4810             : 
    4811             : //! @cond Doxygen_Suppress
    4812             : struct GDALAntiRecursionStruct;
    4813             : 
    4814             : class GDALAntiRecursionGuard
    4815             : {
    4816             :     GDALAntiRecursionStruct *m_psAntiRecursionStruct;
    4817             :     std::string m_osIdentifier;
    4818             :     int m_nDepth;
    4819             : 
    4820             :     GDALAntiRecursionGuard(const GDALAntiRecursionGuard &) = delete;
    4821             :     GDALAntiRecursionGuard &operator=(const GDALAntiRecursionGuard &) = delete;
    4822             : 
    4823             :   public:
    4824             :     explicit GDALAntiRecursionGuard(const std::string &osIdentifier);
    4825             :     GDALAntiRecursionGuard(const GDALAntiRecursionGuard &other,
    4826             :                            const std::string &osIdentifier);
    4827             :     ~GDALAntiRecursionGuard();
    4828             : 
    4829      519642 :     int GetCallDepth() const
    4830             :     {
    4831      519642 :         return m_nDepth;
    4832             :     }
    4833             : };
    4834             : 
    4835             : //! @endcond
    4836             : 
    4837             : /************************************************************************/
    4838             : /*                           Relationships                              */
    4839             : /************************************************************************/
    4840             : 
    4841             : /**
    4842             :  * Definition of a table relationship.
    4843             :  *
    4844             :  * GDALRelationship describes the relationship between two tables, including
    4845             :  * properties such as the cardinality of the relationship and the participating
    4846             :  * tables.
    4847             :  *
    4848             :  * Not all relationship properties are supported by all data formats.
    4849             :  *
    4850             :  * @since GDAL 3.6
    4851             :  */
    4852             : class CPL_DLL GDALRelationship
    4853             : {
    4854             :   protected:
    4855             :     /*! @cond Doxygen_Suppress */
    4856             :     std::string m_osName{};
    4857             :     std::string m_osLeftTableName{};
    4858             :     std::string m_osRightTableName{};
    4859             :     GDALRelationshipCardinality m_eCardinality =
    4860             :         GDALRelationshipCardinality::GRC_ONE_TO_MANY;
    4861             :     std::string m_osMappingTableName{};
    4862             :     std::vector<std::string> m_osListLeftTableFields{};
    4863             :     std::vector<std::string> m_osListRightTableFields{};
    4864             :     std::vector<std::string> m_osListLeftMappingTableFields{};
    4865             :     std::vector<std::string> m_osListRightMappingTableFields{};
    4866             :     GDALRelationshipType m_eType = GDALRelationshipType::GRT_ASSOCIATION;
    4867             :     std::string m_osForwardPathLabel{};
    4868             :     std::string m_osBackwardPathLabel{};
    4869             :     std::string m_osRelatedTableType{};
    4870             : 
    4871             :     /*! @endcond */
    4872             : 
    4873             :   public:
    4874             :     /**
    4875             :      * Constructor for a relationship between two tables.
    4876             :      * @param osName relationship name
    4877             :      * @param osLeftTableName left table name
    4878             :      * @param osRightTableName right table name
    4879             :      * @param eCardinality cardinality of relationship
    4880             :      */
    4881         349 :     GDALRelationship(const std::string &osName,
    4882             :                      const std::string &osLeftTableName,
    4883             :                      const std::string &osRightTableName,
    4884             :                      GDALRelationshipCardinality eCardinality =
    4885             :                          GDALRelationshipCardinality::GRC_ONE_TO_MANY)
    4886         349 :         : m_osName(osName), m_osLeftTableName(osLeftTableName),
    4887         349 :           m_osRightTableName(osRightTableName), m_eCardinality(eCardinality)
    4888             :     {
    4889         349 :     }
    4890             : 
    4891             :     /** Get the name of the relationship */
    4892         393 :     const std::string &GetName() const
    4893             :     {
    4894         393 :         return m_osName;
    4895             :     }
    4896             : 
    4897             :     /** Get the cardinality of the relationship */
    4898         247 :     GDALRelationshipCardinality GetCardinality() const
    4899             :     {
    4900         247 :         return m_eCardinality;
    4901             :     }
    4902             : 
    4903             :     /** Get the name of the left (or base/origin) table in the relationship.
    4904             :      *
    4905             :      * @see GetRightTableName()
    4906             :      */
    4907         202 :     const std::string &GetLeftTableName() const
    4908             :     {
    4909         202 :         return m_osLeftTableName;
    4910             :     }
    4911             : 
    4912             :     /** Get the name of the right (or related/destination) table in the
    4913             :      * relationship */
    4914         197 :     const std::string &GetRightTableName() const
    4915             :     {
    4916         197 :         return m_osRightTableName;
    4917             :     }
    4918             : 
    4919             :     /** Get the name of the mapping table for many-to-many relationships.
    4920             :      *
    4921             :      * @see SetMappingTableName()
    4922             :      */
    4923         160 :     const std::string &GetMappingTableName() const
    4924             :     {
    4925         160 :         return m_osMappingTableName;
    4926             :     }
    4927             : 
    4928             :     /** Sets the name of the mapping table for many-to-many relationships.
    4929             :      *
    4930             :      * @see GetMappingTableName()
    4931             :      */
    4932         113 :     void SetMappingTableName(const std::string &osName)
    4933             :     {
    4934         113 :         m_osMappingTableName = osName;
    4935         113 :     }
    4936             : 
    4937             :     /** Get the names of the participating fields from the left table in the
    4938             :      * relationship.
    4939             :      *
    4940             :      * @see GetRightTableFields()
    4941             :      * @see SetLeftTableFields()
    4942             :      */
    4943         157 :     const std::vector<std::string> &GetLeftTableFields() const
    4944             :     {
    4945         157 :         return m_osListLeftTableFields;
    4946             :     }
    4947             : 
    4948             :     /** Get the names of the participating fields from the right table in the
    4949             :      * relationship.
    4950             :      *
    4951             :      * @see GetLeftTableFields()
    4952             :      * @see SetRightTableFields()
    4953             :      */
    4954         151 :     const std::vector<std::string> &GetRightTableFields() const
    4955             :     {
    4956         151 :         return m_osListRightTableFields;
    4957             :     }
    4958             : 
    4959             :     /** Sets the names of the participating fields from the left table in the
    4960             :      * relationship.
    4961             :      *
    4962             :      * @see GetLeftTableFields()
    4963             :      * @see SetRightTableFields()
    4964             :      */
    4965         362 :     void SetLeftTableFields(const std::vector<std::string> &osListFields)
    4966             :     {
    4967         362 :         m_osListLeftTableFields = osListFields;
    4968         362 :     }
    4969             : 
    4970             :     /** Sets the names of the participating fields from the right table in the
    4971             :      * relationship.
    4972             :      *
    4973             :      * @see GetRightTableFields()
    4974             :      * @see SetLeftTableFields()
    4975             :      */
    4976         363 :     void SetRightTableFields(const std::vector<std::string> &osListFields)
    4977             :     {
    4978         363 :         m_osListRightTableFields = osListFields;
    4979         363 :     }
    4980             : 
    4981             :     /** Get the names of the mapping table fields which correspond to the
    4982             :      * participating fields from the left table in the relationship.
    4983             :      *
    4984             :      * @see GetRightMappingTableFields()
    4985             :      * @see SetLeftMappingTableFields()
    4986             :      */
    4987          61 :     const std::vector<std::string> &GetLeftMappingTableFields() const
    4988             :     {
    4989          61 :         return m_osListLeftMappingTableFields;
    4990             :     }
    4991             : 
    4992             :     /** Get the names of the mapping table fields which correspond to the
    4993             :      * participating fields from the right table in the relationship.
    4994             :      *
    4995             :      * @see GetLeftMappingTableFields()
    4996             :      * @see SetRightMappingTableFields()
    4997             :      */
    4998          61 :     const std::vector<std::string> &GetRightMappingTableFields() const
    4999             :     {
    5000          61 :         return m_osListRightMappingTableFields;
    5001             :     }
    5002             : 
    5003             :     /** Sets the names of the mapping table fields which correspond to the
    5004             :      * participating fields from the left table in the relationship.
    5005             :      *
    5006             :      * @see GetLeftMappingTableFields()
    5007             :      * @see SetRightMappingTableFields()
    5008             :      */
    5009         313 :     void SetLeftMappingTableFields(const std::vector<std::string> &osListFields)
    5010             :     {
    5011         313 :         m_osListLeftMappingTableFields = osListFields;
    5012         313 :     }
    5013             : 
    5014             :     /** Sets the names of the mapping table fields which correspond to the
    5015             :      * participating fields from the right table in the relationship.
    5016             :      *
    5017             :      * @see GetRightMappingTableFields()
    5018             :      * @see SetLeftMappingTableFields()
    5019             :      */
    5020             :     void
    5021         313 :     SetRightMappingTableFields(const std::vector<std::string> &osListFields)
    5022             :     {
    5023         313 :         m_osListRightMappingTableFields = osListFields;
    5024         313 :     }
    5025             : 
    5026             :     /** Get the type of the relationship.
    5027             :      *
    5028             :      * @see SetType()
    5029             :      */
    5030         111 :     GDALRelationshipType GetType() const
    5031             :     {
    5032         111 :         return m_eType;
    5033             :     }
    5034             : 
    5035             :     /** Sets the type of the relationship.
    5036             :      *
    5037             :      * @see GetType()
    5038             :      */
    5039         263 :     void SetType(GDALRelationshipType eType)
    5040             :     {
    5041         263 :         m_eType = eType;
    5042         263 :     }
    5043             : 
    5044             :     /** Get the label of the forward path for the relationship.
    5045             :      *
    5046             :      * The forward and backward path labels are free-form, user-friendly strings
    5047             :      * which can be used to generate descriptions of the relationship between
    5048             :      * features from the right and left tables.
    5049             :      *
    5050             :      * E.g. when the left table contains buildings and the right table contains
    5051             :      * furniture, the forward path label could be "contains" and the backward
    5052             :      * path label could be "is located within". A client could then generate a
    5053             :      * user friendly description string such as "fire hose 1234 is located
    5054             :      * within building 15a".
    5055             :      *
    5056             :      * @see SetForwardPathLabel()
    5057             :      * @see GetBackwardPathLabel()
    5058             :      */
    5059          53 :     const std::string &GetForwardPathLabel() const
    5060             :     {
    5061          53 :         return m_osForwardPathLabel;
    5062             :     }
    5063             : 
    5064             :     /** Sets the label of the forward path for the relationship.
    5065             :      *
    5066             :      * The forward and backward path labels are free-form, user-friendly strings
    5067             :      * which can be used to generate descriptions of the relationship between
    5068             :      * features from the right and left tables.
    5069             :      *
    5070             :      * E.g. when the left table contains buildings and the right table contains
    5071             :      * furniture, the forward path label could be "contains" and the backward
    5072             :      * path label could be "is located within". A client could then generate a
    5073             :      * user friendly description string such as "fire hose 1234 is located
    5074             :      * within building 15a".
    5075             :      *
    5076             :      * @see GetForwardPathLabel()
    5077             :      * @see SetBackwardPathLabel()
    5078             :      */
    5079         260 :     void SetForwardPathLabel(const std::string &osLabel)
    5080             :     {
    5081         260 :         m_osForwardPathLabel = osLabel;
    5082         260 :     }
    5083             : 
    5084             :     /** Get the label of the backward path for the relationship.
    5085             :      *
    5086             :      * The forward and backward path labels are free-form, user-friendly strings
    5087             :      * which can be used to generate descriptions of the relationship between
    5088             :      * features from the right and left tables.
    5089             :      *
    5090             :      * E.g. when the left table contains buildings and the right table contains
    5091             :      * furniture, the forward path label could be "contains" and the backward
    5092             :      * path label could be "is located within". A client could then generate a
    5093             :      * user friendly description string such as "fire hose 1234 is located
    5094             :      * within building 15a".
    5095             :      *
    5096             :      * @see SetBackwardPathLabel()
    5097             :      * @see GetForwardPathLabel()
    5098             :      */
    5099          53 :     const std::string &GetBackwardPathLabel() const
    5100             :     {
    5101          53 :         return m_osBackwardPathLabel;
    5102             :     }
    5103             : 
    5104             :     /** Sets the label of the backward path for the relationship.
    5105             :      *
    5106             :      * The forward and backward path labels are free-form, user-friendly strings
    5107             :      * which can be used to generate descriptions of the relationship between
    5108             :      * features from the right and left tables.
    5109             :      *
    5110             :      * E.g. when the left table contains buildings and the right table contains
    5111             :      * furniture, the forward path label could be "contains" and the backward
    5112             :      * path label could be "is located within". A client could then generate a
    5113             :      * user friendly description string such as "fire hose 1234 is located
    5114             :      * within building 15a".
    5115             :      *
    5116             :      * @see GetBackwardPathLabel()
    5117             :      * @see SetForwardPathLabel()
    5118             :      */
    5119         260 :     void SetBackwardPathLabel(const std::string &osLabel)
    5120             :     {
    5121         260 :         m_osBackwardPathLabel = osLabel;
    5122         260 :     }
    5123             : 
    5124             :     /** Get the type string of the related table.
    5125             :      *
    5126             :      * This a free-form string representing the type of related features, where
    5127             :      * the exact interpretation is format dependent. For instance, table types
    5128             :      * from GeoPackage relationships will directly reflect the categories from
    5129             :      * the GeoPackage related tables extension (i.e. "media", "simple
    5130             :      * attributes", "features", "attributes" and "tiles").
    5131             :      *
    5132             :      * @see SetRelatedTableType()
    5133             :      */
    5134         144 :     const std::string &GetRelatedTableType() const
    5135             :     {
    5136         144 :         return m_osRelatedTableType;
    5137             :     }
    5138             : 
    5139             :     /** Sets the type string of the related table.
    5140             :      *
    5141             :      * This a free-form string representing the type of related features, where
    5142             :      * the exact interpretation is format dependent. For instance, table types
    5143             :      * from GeoPackage relationships will directly reflect the categories from
    5144             :      * the GeoPackage related tables extension (i.e. "media", "simple
    5145             :      * attributes", "features", "attributes" and "tiles").
    5146             :      *
    5147             :      * @see GetRelatedTableType()
    5148             :      */
    5149         340 :     void SetRelatedTableType(const std::string &osType)
    5150             :     {
    5151         340 :         m_osRelatedTableType = osType;
    5152         340 :     }
    5153             : 
    5154             :     /** Convert a GDALRelationship* to a GDALRelationshipH.
    5155             :      */
    5156          81 :     static inline GDALRelationshipH ToHandle(GDALRelationship *poRelationship)
    5157             :     {
    5158          81 :         return static_cast<GDALRelationshipH>(poRelationship);
    5159             :     }
    5160             : 
    5161             :     /** Convert a GDALRelationshipH to a GDALRelationship*.
    5162             :      */
    5163         706 :     static inline GDALRelationship *FromHandle(GDALRelationshipH hRelationship)
    5164             :     {
    5165         706 :         return static_cast<GDALRelationship *>(hRelationship);
    5166             :     }
    5167             : };
    5168             : 
    5169             : /* ==================================================================== */
    5170             : /*      An assortment of overview related stuff.                        */
    5171             : /* ==================================================================== */
    5172             : 
    5173             : //! @cond Doxygen_Suppress
    5174             : /* Only exported for drivers as plugin. Signature may change */
    5175             : CPLErr CPL_DLL GDALRegenerateOverviewsMultiBand(
    5176             :     int nBands, GDALRasterBand *const *papoSrcBands, int nOverviews,
    5177             :     GDALRasterBand *const *const *papapoOverviewBands,
    5178             :     const char *pszResampling, GDALProgressFunc pfnProgress,
    5179             :     void *pProgressData, CSLConstList papszOptions);
    5180             : 
    5181             : CPLErr CPL_DLL GDALRegenerateOverviewsMultiBand(
    5182             :     const std::vector<GDALRasterBand *> &apoSrcBands,
    5183             :     // First level of array is indexed by band (thus aapoOverviewBands.size() must be equal to apoSrcBands.size())
    5184             :     // Second level is indexed by overview
    5185             :     const std::vector<std::vector<GDALRasterBand *>> &aapoOverviewBands,
    5186             :     const char *pszResampling, GDALProgressFunc pfnProgress,
    5187             :     void *pProgressData, CSLConstList papszOptions);
    5188             : 
    5189             : /************************************************************************/
    5190             : /*                       GDALOverviewResampleArgs                       */
    5191             : /************************************************************************/
    5192             : 
    5193             : /** Arguments for overview resampling function. */
    5194             : // Should not contain any dataset/rasterband object, as this might be
    5195             : // read in a worker thread.
    5196             : struct GDALOverviewResampleArgs
    5197             : {
    5198             :     //! Datatype of the source band argument
    5199             :     GDALDataType eSrcDataType = GDT_Unknown;
    5200             :     //! Datatype of the destination/overview band
    5201             :     GDALDataType eOvrDataType = GDT_Unknown;
    5202             :     //! Width in pixel of the destination/overview band
    5203             :     int nOvrXSize = 0;
    5204             :     //! Height in pixel of the destination/overview band
    5205             :     int nOvrYSize = 0;
    5206             :     //! NBITS value of the destination/overview band (or 0 if not set)
    5207             :     int nOvrNBITS = 0;
    5208             :     //! Factor to convert from destination X to source X
    5209             :     // (source width divided by destination width)
    5210             :     double dfXRatioDstToSrc = 0;
    5211             :     //! Factor to convert from destination Y to source Y
    5212             :     // (source height divided by destination height)
    5213             :     double dfYRatioDstToSrc = 0;
    5214             :     //! Sub-pixel delta to add to get source X
    5215             :     double dfSrcXDelta = 0;
    5216             :     //! Sub-pixel delta to add to get source Y
    5217             :     double dfSrcYDelta = 0;
    5218             :     //! Working data type (data type of the pChunk argument)
    5219             :     GDALDataType eWrkDataType = GDT_Unknown;
    5220             :     //! Array of nChunkXSize * nChunkYSize values of mask, or nullptr
    5221             :     const GByte *pabyChunkNodataMask = nullptr;
    5222             :     //! X offset of the source chunk in the source band
    5223             :     int nChunkXOff = 0;
    5224             :     //! Width in pixel of the source chunk in the source band
    5225             :     int nChunkXSize = 0;
    5226             :     //! Y offset of the source chunk in the source band
    5227             :     int nChunkYOff = 0;
    5228             :     //! Height in pixel of the source chunk in the source band
    5229             :     int nChunkYSize = 0;
    5230             :     //! X Offset of the destination chunk in the destination band
    5231             :     int nDstXOff = 0;
    5232             :     //! X Offset of the end (not included) of the destination chunk in the destination band
    5233             :     int nDstXOff2 = 0;
    5234             :     //! Y Offset of the destination chunk in the destination band
    5235             :     int nDstYOff = 0;
    5236             :     //! Y Offset of the end (not included) of the destination chunk in the destination band
    5237             :     int nDstYOff2 = 0;
    5238             :     //! Resampling method
    5239             :     const char *pszResampling = nullptr;
    5240             :     //! Whether the source band has a nodata value
    5241             :     bool bHasNoData = false;
    5242             :     //! Source band nodata value
    5243             :     double dfNoDataValue = 0;
    5244             :     //! Source color table
    5245             :     const GDALColorTable *poColorTable = nullptr;
    5246             :     //! Whether a single contributing source pixel at nodata should result
    5247             :     // in the target pixel to be at nodata too (only taken into account by
    5248             :     // average resampling)
    5249             :     bool bPropagateNoData = false;
    5250             : };
    5251             : 
    5252             : typedef CPLErr (*GDALResampleFunction)(const GDALOverviewResampleArgs &args,
    5253             :                                        const void *pChunk, void **ppDstBuffer,
    5254             :                                        GDALDataType *peDstBufferDataType);
    5255             : 
    5256             : GDALResampleFunction GDALGetResampleFunction(const char *pszResampling,
    5257             :                                              int *pnRadius);
    5258             : 
    5259             : std::string CPL_DLL GDALGetNormalizedOvrResampling(const char *pszResampling);
    5260             : 
    5261             : GDALDataType GDALGetOvrWorkDataType(const char *pszResampling,
    5262             :                                     GDALDataType eSrcDataType);
    5263             : 
    5264             : CPL_C_START
    5265             : 
    5266             : CPLErr CPL_DLL
    5267             : HFAAuxBuildOverviews(const char *pszOvrFilename, GDALDataset *poParentDS,
    5268             :                      GDALDataset **ppoDS, int nBands, const int *panBandList,
    5269             :                      int nNewOverviews, const int *panNewOverviewList,
    5270             :                      const char *pszResampling, GDALProgressFunc pfnProgress,
    5271             :                      void *pProgressData, CSLConstList papszOptions);
    5272             : 
    5273             : CPLErr CPL_DLL GTIFFBuildOverviews(const char *pszFilename, int nBands,
    5274             :                                    GDALRasterBand *const *papoBandList,
    5275             :                                    int nOverviews, const int *panOverviewList,
    5276             :                                    const char *pszResampling,
    5277             :                                    GDALProgressFunc pfnProgress,
    5278             :                                    void *pProgressData,
    5279             :                                    CSLConstList papszOptions);
    5280             : 
    5281             : CPLErr CPL_DLL GTIFFBuildOverviewsEx(const char *pszFilename, int nBands,
    5282             :                                      GDALRasterBand *const *papoBandList,
    5283             :                                      int nOverviews, const int *panOverviewList,
    5284             :                                      const std::pair<int, int> *pasOverviewSize,
    5285             :                                      const char *pszResampling,
    5286             :                                      const char *const *papszOptions,
    5287             :                                      GDALProgressFunc pfnProgress,
    5288             :                                      void *pProgressData);
    5289             : 
    5290             : int CPL_DLL GDALBandGetBestOverviewLevel(GDALRasterBand *poBand, int &nXOff,
    5291             :                                          int &nYOff, int &nXSize, int &nYSize,
    5292             :                                          int nBufXSize, int nBufYSize)
    5293             :     CPL_WARN_DEPRECATED("Use GDALBandGetBestOverviewLevel2 instead");
    5294             : int CPL_DLL GDALBandGetBestOverviewLevel2(GDALRasterBand *poBand, int &nXOff,
    5295             :                                           int &nYOff, int &nXSize, int &nYSize,
    5296             :                                           int nBufXSize, int nBufYSize,
    5297             :                                           GDALRasterIOExtraArg *psExtraArg);
    5298             : 
    5299             : int CPL_DLL GDALOvLevelAdjust(int nOvLevel, int nXSize)
    5300             :     CPL_WARN_DEPRECATED("Use GDALOvLevelAdjust2 instead");
    5301             : int CPL_DLL GDALOvLevelAdjust2(int nOvLevel, int nXSize, int nYSize);
    5302             : int CPL_DLL GDALComputeOvFactor(int nOvrXSize, int nRasterXSize, int nOvrYSize,
    5303             :                                 int nRasterYSize);
    5304             : 
    5305             : GDALDataset CPL_DLL *GDALFindAssociatedAuxFile(const char *pszBasefile,
    5306             :                                                GDALAccess eAccess,
    5307             :                                                GDALDataset *poDependentDS);
    5308             : 
    5309             : /* ==================================================================== */
    5310             : /*  Infrastructure to check that dataset characteristics are valid      */
    5311             : /* ==================================================================== */
    5312             : 
    5313             : int CPL_DLL GDALCheckDatasetDimensions(int nXSize, int nYSize);
    5314             : int CPL_DLL GDALCheckBandCount(int nBands, int bIsZeroAllowed);
    5315             : 
    5316             : /* Internal use only */
    5317             : 
    5318             : /* CPL_DLL exported, but only for in-tree drivers that can be built as plugins
    5319             :  */
    5320             : int CPL_DLL GDALReadWorldFile2(const char *pszBaseFilename,
    5321             :                                const char *pszExtension,
    5322             :                                double *padfGeoTransform,
    5323             :                                CSLConstList papszSiblingFiles,
    5324             :                                char **ppszWorldFileNameOut);
    5325             : int CPL_DLL GDALReadTabFile2(const char *pszBaseFilename,
    5326             :                              double *padfGeoTransform, char **ppszWKT,
    5327             :                              int *pnGCPCount, GDAL_GCP **ppasGCPs,
    5328             :                              CSLConstList papszSiblingFiles,
    5329             :                              char **ppszTabFileNameOut);
    5330             : 
    5331             : void CPL_DLL GDALCopyRasterIOExtraArg(GDALRasterIOExtraArg *psDestArg,
    5332             :                                       GDALRasterIOExtraArg *psSrcArg);
    5333             : 
    5334             : void CPL_DLL GDALExpandPackedBitsToByteAt0Or1(
    5335             :     const GByte *CPL_RESTRICT pabyInput, GByte *CPL_RESTRICT pabyOutput,
    5336             :     size_t nInputBits);
    5337             : 
    5338             : void CPL_DLL GDALExpandPackedBitsToByteAt0Or255(
    5339             :     const GByte *CPL_RESTRICT pabyInput, GByte *CPL_RESTRICT pabyOutput,
    5340             :     size_t nInputBits);
    5341             : 
    5342             : CPL_C_END
    5343             : 
    5344             : int CPL_DLL GDALReadWorldFile2(const char *pszBaseFilename,
    5345             :                                const char *pszExtension, GDALGeoTransform &gt,
    5346             :                                CSLConstList papszSiblingFiles,
    5347             :                                char **ppszWorldFileNameOut);
    5348             : 
    5349             : std::unique_ptr<GDALDataset> CPL_DLL
    5350             : GDALGetThreadSafeDataset(std::unique_ptr<GDALDataset> poDS, int nScopeFlags);
    5351             : 
    5352             : GDALDataset CPL_DLL *GDALGetThreadSafeDataset(GDALDataset *poDS,
    5353             :                                               int nScopeFlags);
    5354             : 
    5355             : void GDALNullifyOpenDatasetsList();
    5356             : CPLMutex **GDALGetphDMMutex();
    5357             : CPLMutex **GDALGetphDLMutex();
    5358             : void GDALNullifyProxyPoolSingleton();
    5359             : void GDALSetResponsiblePIDForCurrentThread(GIntBig responsiblePID);
    5360             : GIntBig GDALGetResponsiblePIDForCurrentThread();
    5361             : 
    5362             : CPLString GDALFindAssociatedFile(const char *pszBasename, const char *pszExt,
    5363             :                                  CSLConstList papszSiblingFiles, int nFlags);
    5364             : 
    5365             : CPLErr CPL_DLL EXIFExtractMetadata(char **&papszMetadata, void *fpL,
    5366             :                                    int nOffset, int bSwabflag, int nTIFFHEADER,
    5367             :                                    int &nExifOffset, int &nInterOffset,
    5368             :                                    int &nGPSOffset);
    5369             : 
    5370             : int GDALValidateOpenOptions(GDALDriverH hDriver,
    5371             :                             const char *const *papszOptionOptions);
    5372             : int GDALValidateOptions(const char *pszOptionList,
    5373             :                         const char *const *papszOptionsToValidate,
    5374             :                         const char *pszErrorMessageOptionType,
    5375             :                         const char *pszErrorMessageContainerName);
    5376             : 
    5377             : GDALRIOResampleAlg CPL_DLL
    5378             : GDALRasterIOGetResampleAlg(const char *pszResampling);
    5379             : const char *GDALRasterIOGetResampleAlg(GDALRIOResampleAlg eResampleAlg);
    5380             : 
    5381             : void GDALRasterIOExtraArgSetResampleAlg(GDALRasterIOExtraArg *psExtraArg,
    5382             :                                         int nXSize, int nYSize, int nBufXSize,
    5383             :                                         int nBufYSize);
    5384             : 
    5385             : GDALDataset *GDALCreateOverviewDataset(GDALDataset *poDS, int nOvrLevel,
    5386             :                                        bool bThisLevelOnly);
    5387             : 
    5388             : // Should cover particular cases of #3573, #4183, #4506, #6578
    5389             : // Behavior is undefined if fVal1 or fVal2 are NaN (should be tested before
    5390             : // calling this function)
    5391             : 
    5392             : // TODO: The expression `abs(fVal1 + fVal2)` looks strange; is this a bug?
    5393             : // Should this be `abs(fVal1) + abs(fVal2)` instead?
    5394             : 
    5395    29052913 : inline bool ARE_REAL_EQUAL(float fVal1, float fVal2, int ulp = 2)
    5396             : {
    5397             :     using std::abs;
    5398    57039518 :     return fVal1 == fVal2 || /* Should cover infinity */
    5399    27986505 :            abs(fVal1 - fVal2) <
    5400    57039518 :                std::numeric_limits<float>::epsilon() * abs(fVal1 + fVal2) * ulp;
    5401             : }
    5402             : 
    5403             : // We are using `std::numeric_limits<float>::epsilon()` for backward
    5404             : // compatibility
    5405     3949679 : inline bool ARE_REAL_EQUAL(double dfVal1, double dfVal2, int ulp = 2)
    5406             : {
    5407             :     using std::abs;
    5408     4551755 :     return dfVal1 == dfVal2 || /* Should cover infinity */
    5409      602077 :            abs(dfVal1 - dfVal2) < std::numeric_limits<float>::epsilon() *
    5410     4551755 :                                       abs(dfVal1 + dfVal2) * ulp;
    5411             : }
    5412             : 
    5413             : double GDALAdjustNoDataCloseToFloatMax(double dfVal);
    5414             : 
    5415             : #define DIV_ROUND_UP(a, b) (((a) % (b)) == 0 ? ((a) / (b)) : (((a) / (b)) + 1))
    5416             : 
    5417             : // Number of data samples that will be used to compute approximate statistics
    5418             : // (minimum value, maximum value, etc.)
    5419             : #define GDALSTAT_APPROX_NUMSAMPLES 2500
    5420             : 
    5421             : void GDALSerializeGCPListToXML(CPLXMLNode *psParentNode,
    5422             :                                const std::vector<gdal::GCP> &asGCPs,
    5423             :                                const OGRSpatialReference *poGCP_SRS);
    5424             : void GDALDeserializeGCPListFromXML(const CPLXMLNode *psGCPList,
    5425             :                                    std::vector<gdal::GCP> &asGCPs,
    5426             :                                    OGRSpatialReference **ppoGCP_SRS);
    5427             : 
    5428             : void GDALSerializeOpenOptionsToXML(CPLXMLNode *psParentNode,
    5429             :                                    CSLConstList papszOpenOptions);
    5430             : char CPL_DLL **
    5431             : GDALDeserializeOpenOptionsFromXML(const CPLXMLNode *psParentNode);
    5432             : 
    5433             : int GDALCanFileAcceptSidecarFile(const char *pszFilename);
    5434             : 
    5435             : bool GDALCanReliablyUseSiblingFileList(const char *pszFilename);
    5436             : 
    5437             : typedef enum
    5438             : {
    5439             :     GSF_UNSIGNED_INT,
    5440             :     GSF_SIGNED_INT,
    5441             :     GSF_FLOATING_POINT,
    5442             : } GDALBufferSampleFormat;
    5443             : 
    5444             : bool CPL_DLL GDALBufferHasOnlyNoData(const void *pBuffer, double dfNoDataValue,
    5445             :                                      size_t nWidth, size_t nHeight,
    5446             :                                      size_t nLineStride, size_t nComponents,
    5447             :                                      int nBitsPerSample,
    5448             :                                      GDALBufferSampleFormat nSampleFormat);
    5449             : 
    5450             : bool CPL_DLL GDALCopyNoDataValue(GDALRasterBand *poDstBand,
    5451             :                                  GDALRasterBand *poSrcBand,
    5452             :                                  bool *pbCannotBeExactlyRepresented = nullptr);
    5453             : 
    5454             : double CPL_DLL GDALGetNoDataValueCastToDouble(int64_t nVal);
    5455             : double CPL_DLL GDALGetNoDataValueCastToDouble(uint64_t nVal);
    5456             : 
    5457             : // Remove me in GDAL 4.0. See GetMetadataItem() implementation
    5458             : // Internal use in GDAL only !
    5459             : // Declaration copied in swig/include/gdal.i
    5460             : void CPL_DLL GDALEnablePixelTypeSignedByteWarning(GDALRasterBandH hBand,
    5461             :                                                   bool b);
    5462             : 
    5463             : std::string CPL_DLL GDALGetCompressionFormatForJPEG(VSILFILE *fp);
    5464             : std::string CPL_DLL GDALGetCompressionFormatForJPEG(const void *pBuffer,
    5465             :                                                     size_t nBufferSize);
    5466             : 
    5467             : GDALRasterAttributeTable CPL_DLL *GDALCreateRasterAttributeTableFromMDArrays(
    5468             :     GDALRATTableType eTableType,
    5469             :     const std::vector<std::shared_ptr<GDALMDArray>> &apoArrays,
    5470             :     const std::vector<GDALRATFieldUsage> &aeUsages);
    5471             : 
    5472             : GDALColorInterp CPL_DLL
    5473             : GDALGetColorInterpFromSTACCommonName(const char *pszName);
    5474             : const char CPL_DLL *
    5475             : GDALGetSTACCommonNameFromColorInterp(GDALColorInterp eInterp);
    5476             : 
    5477             : std::string CPL_DLL GDALGetCacheDirectory();
    5478             : 
    5479             : bool GDALDoesFileOrDatasetExist(const char *pszName,
    5480             :                                 const char **ppszType = nullptr,
    5481             :                                 GDALDriver **ppDriver = nullptr);
    5482             : 
    5483             : std::string CPL_DLL
    5484             : GDALGetMessageAboutMissingPluginDriver(GDALDriver *poMissingPluginDriver);
    5485             : 
    5486             : std::string GDALPrintDriverList(int nOptions, bool bJSON);
    5487             : 
    5488             : struct GDALColorAssociation
    5489             : {
    5490             :     double dfVal;
    5491             :     int nR;
    5492             :     int nG;
    5493             :     int nB;
    5494             :     int nA;
    5495             : };
    5496             : 
    5497             : std::vector<GDALColorAssociation> GDALLoadTextColorMap(const char *pszFilename,
    5498             :                                                        GDALRasterBand *poBand);
    5499             : 
    5500             : // Macro used so that Identify and driver metadata methods in drivers built
    5501             : // as plugin can be duplicated in libgdal core and in the driver under different
    5502             : // names
    5503             : #ifdef PLUGIN_FILENAME
    5504             : #define PLUGIN_SYMBOL_NAME(x) GDAL_core_##x
    5505             : #else
    5506             : #define PLUGIN_SYMBOL_NAME(x) GDAL_driver_##x
    5507             : #endif
    5508             : 
    5509             : //! @endcond
    5510             : 
    5511             : #endif /* ndef GDAL_PRIV_H_INCLUDED */

Generated by: LCOV version 1.14