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