gdal_multidim.h

/******************************************************************************
 *
 * Name:     gdal_multidim.h
 * Project:  GDAL Core
 * Purpose:  Declaration of classes for multidimensional support
 * Author:   Even Rouault <even.rouault at spatialys.com>
 *
 ******************************************************************************
 * Copyright (c) 2019, Even Rouault <even.rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/
 
#ifndef GDALMULTIDIM_H_INCLUDED
#define GDALMULTIDIM_H_INCLUDED
 
#include "cpl_conv.h"
#include "cpl_string.h"
#include "gdal.h"
#include "gdal_geotransform.h"
 
#include <cstddef>
#include <cstdint>
#include <limits>
#include <memory>
#include <vector>
 
/* ******************************************************************** */
/*                       Multidimensional array API                     */
/* ******************************************************************** */
 
class GDALMDArray;
class GDALAttribute;
class GDALDataset;
class GDALDimension;
class GDALEDTComponent;
class GDALRasterAttributeTable;
class GDALRasterBand;
class OGRLayer;
class OGRSpatialReference;
 
/* ******************************************************************** */
/*                         GDALExtendedDataType                         */
/* ******************************************************************** */
 
class CPL_DLL GDALExtendedDataType
{
  public:
    ~GDALExtendedDataType();
 
    GDALExtendedDataType(GDALExtendedDataType &&);
    GDALExtendedDataType(const GDALExtendedDataType &);
 
    GDALExtendedDataType &operator=(const GDALExtendedDataType &);
    GDALExtendedDataType &operator=(GDALExtendedDataType &&);
 
    static GDALExtendedDataType Create(GDALDataType eType);
    static GDALExtendedDataType
    Create(const std::string &osName, GDALDataType eBaseType,
           std::unique_ptr<GDALRasterAttributeTable>);
    static GDALExtendedDataType
    Create(const std::string &osName, size_t nTotalSize,
           std::vector<std::unique_ptr<GDALEDTComponent>> &&components);
    static GDALExtendedDataType
    CreateString(size_t nMaxStringLength = 0,
                 GDALExtendedDataTypeSubType eSubType = GEDTST_NONE);
 
    bool operator==(const GDALExtendedDataType &) const;
 
    bool operator!=(const GDALExtendedDataType &other) const
    {
        return !(operator==(other));
    }
 
    const std::string &GetName() const
    {
        return m_osName;
    }
 
    GDALExtendedDataTypeClass GetClass() const
    {
        return m_eClass;
    }
 
    GDALDataType GetNumericDataType() const
    {
        return m_eNumericDT;
    }
 
    GDALExtendedDataTypeSubType GetSubType() const
    {
        return m_eSubType;
    }
 
    const std::vector<std::unique_ptr<GDALEDTComponent>> &GetComponents() const
    {
        return m_aoComponents;
    }
 
    size_t GetSize() const
    {
        return m_nSize;
    }
 
    size_t GetMaxStringLength() const
    {
        return m_nMaxStringLength;
    }
 
    const GDALRasterAttributeTable *GetRAT() const
    {
        return m_poRAT.get();
    }
 
    bool CanConvertTo(const GDALExtendedDataType &other) const;
 
    bool NeedsFreeDynamicMemory() const;
 
    void FreeDynamicMemory(void *pBuffer) const;
 
    static bool CopyValue(const void *pSrc, const GDALExtendedDataType &srcType,
                          void *pDst, const GDALExtendedDataType &dstType);
 
    static bool CopyValues(const void *pSrc,
                           const GDALExtendedDataType &srcType,
                           GPtrDiff_t nSrcStrideInElts, void *pDst,
                           const GDALExtendedDataType &dstType,
                           GPtrDiff_t nDstStrideInElts, size_t nValues);
 
  private:
    GDALExtendedDataType(size_t nMaxStringLength,
                         GDALExtendedDataTypeSubType eSubType);
    explicit GDALExtendedDataType(GDALDataType eType);
    GDALExtendedDataType(const std::string &osName, GDALDataType eBaseType,
                         std::unique_ptr<GDALRasterAttributeTable>);
    GDALExtendedDataType(
        const std::string &osName, size_t nTotalSize,
        std::vector<std::unique_ptr<GDALEDTComponent>> &&components);
 
    std::string m_osName{};
    GDALExtendedDataTypeClass m_eClass = GEDTC_NUMERIC;
    GDALExtendedDataTypeSubType m_eSubType = GEDTST_NONE;
    GDALDataType m_eNumericDT = GDT_Unknown;
    std::vector<std::unique_ptr<GDALEDTComponent>> m_aoComponents{};
    size_t m_nSize = 0;
    size_t m_nMaxStringLength = 0;
    std::unique_ptr<GDALRasterAttributeTable> m_poRAT{};
};
 
/* ******************************************************************** */
/*                            GDALEDTComponent                          */
/* ******************************************************************** */
 
class CPL_DLL GDALEDTComponent
{
  public:
    ~GDALEDTComponent();
    GDALEDTComponent(const std::string &name, size_t offset,
                     const GDALExtendedDataType &type);
    GDALEDTComponent(const GDALEDTComponent &);
 
    bool operator==(const GDALEDTComponent &) const;
 
    const std::string &GetName() const
    {
        return m_osName;
    }
 
    size_t GetOffset() const
    {
        return m_nOffset;
    }
 
    const GDALExtendedDataType &GetType() const
    {
        return m_oType;
    }
 
  private:
    std::string m_osName;
    size_t m_nOffset;
    GDALExtendedDataType m_oType;
};
 
/* ******************************************************************** */
/*                            GDALIHasAttribute                         */
/* ******************************************************************** */
 
class CPL_DLL GDALIHasAttribute
{
  protected:
    std::shared_ptr<GDALAttribute>
    GetAttributeFromAttributes(const std::string &osName) const;
 
  public:
    virtual ~GDALIHasAttribute();
 
    virtual std::shared_ptr<GDALAttribute>
    GetAttribute(const std::string &osName) const;
 
    virtual std::vector<std::shared_ptr<GDALAttribute>>
    GetAttributes(CSLConstList papszOptions = nullptr) const;
 
    virtual std::shared_ptr<GDALAttribute>
    CreateAttribute(const std::string &osName,
                    const std::vector<GUInt64> &anDimensions,
                    const GDALExtendedDataType &oDataType,
                    CSLConstList papszOptions = nullptr);
 
    virtual bool DeleteAttribute(const std::string &osName,
                                 CSLConstList papszOptions = nullptr);
};
 
/* ******************************************************************** */
/*                               GDALGroup                              */
/* ******************************************************************** */
 
/* clang-format off */
/* clang-format on */
 
class CPL_DLL GDALGroup : public GDALIHasAttribute
{
  protected:
    std::string m_osName{};
 
    // This is actually a path of the form "/parent_path/{m_osName}"
    std::string m_osFullName{};
 
    // Used for example by GDALSubsetGroup to distinguish a derived group
    //from its original, without altering its name
    const std::string m_osContext{};
 
    // List of types owned by the group.
    std::vector<std::shared_ptr<GDALExtendedDataType>> m_apoTypes{};
 
    std::weak_ptr<GDALGroup> m_pSelf{};
 
    bool m_bValid = true;
 
    GDALGroup(const std::string &osParentName, const std::string &osName,
              const std::string &osContext = std::string());
 
    const GDALGroup *
    GetInnerMostGroup(const std::string &osPathOrArrayOrDim,
                      std::shared_ptr<GDALGroup> &curGroupHolder,
                      std::string &osLastPart) const;
 
    void BaseRename(const std::string &osNewName);
 
    bool CheckValidAndErrorOutIfNot() const;
 
    void SetSelf(const std::shared_ptr<GDALGroup> &self)
    {
        m_pSelf = self;
    }
 
    virtual void NotifyChildrenOfRenaming()
    {
    }
 
    virtual void NotifyChildrenOfDeletion()
    {
    }
 
 
  public:
    ~GDALGroup() override;
 
    const std::string &GetName() const
    {
        return m_osName;
    }
 
    const std::string &GetFullName() const
    {
        return m_osFullName;
    }
 
    const std::vector<std::shared_ptr<GDALExtendedDataType>> &
    GetDataTypes() const
    {
        return m_apoTypes;
    }
 
    virtual std::vector<std::string>
    GetMDArrayNames(CSLConstList papszOptions = nullptr) const;
    virtual std::shared_ptr<GDALMDArray>
    OpenMDArray(const std::string &osName,
                CSLConstList papszOptions = nullptr) const;
 
    std::vector<std::string> GetMDArrayFullNamesRecursive(
        CSLConstList papszGroupOptions = nullptr,
        CSLConstList papszArrayOptions = nullptr) const;
 
    virtual std::vector<std::string>
    GetGroupNames(CSLConstList papszOptions = nullptr) const;
    virtual std::shared_ptr<GDALGroup>
    OpenGroup(const std::string &osName,
              CSLConstList papszOptions = nullptr) const;
 
    virtual std::vector<std::string>
    GetVectorLayerNames(CSLConstList papszOptions = nullptr) const;
    virtual OGRLayer *
    OpenVectorLayer(const std::string &osName,
                    CSLConstList papszOptions = nullptr) const;
 
    virtual std::vector<std::shared_ptr<GDALDimension>>
    GetDimensions(CSLConstList papszOptions = nullptr) const;
 
    virtual std::shared_ptr<GDALGroup>
    CreateGroup(const std::string &osName, CSLConstList papszOptions = nullptr);
 
    virtual bool DeleteGroup(const std::string &osName,
                             CSLConstList papszOptions = nullptr);
 
    virtual std::shared_ptr<GDALDimension>
    CreateDimension(const std::string &osName, const std::string &osType,
                    const std::string &osDirection, GUInt64 nSize,
                    CSLConstList papszOptions = nullptr);
 
    virtual std::shared_ptr<GDALMDArray> CreateMDArray(
        const std::string &osName,
        const std::vector<std::shared_ptr<GDALDimension>> &aoDimensions,
        const GDALExtendedDataType &oDataType,
        CSLConstList papszOptions = nullptr);
 
    virtual bool DeleteMDArray(const std::string &osName,
                               CSLConstList papszOptions = nullptr);
 
    GUInt64 GetTotalCopyCost() const;
 
    virtual bool CopyFrom(const std::shared_ptr<GDALGroup> &poDstRootGroup,
                          GDALDataset *poSrcDS,
                          const std::shared_ptr<GDALGroup> &poSrcGroup,
                          bool bStrict, GUInt64 &nCurCost,
                          const GUInt64 nTotalCost,
                          GDALProgressFunc pfnProgress, void *pProgressData,
                          CSLConstList papszOptions = nullptr);
 
    virtual CSLConstList GetStructuralInfo() const;
 
    std::shared_ptr<GDALMDArray>
    OpenMDArrayFromFullname(const std::string &osFullName,
                            CSLConstList papszOptions = nullptr) const;
 
    std::shared_ptr<GDALAttribute>
    OpenAttributeFromFullname(const std::string &osFullName,
                              CSLConstList papszOptions = nullptr) const;
 
    std::shared_ptr<GDALMDArray>
    ResolveMDArray(const std::string &osName, const std::string &osStartingPath,
                   CSLConstList papszOptions = nullptr) const;
 
    std::shared_ptr<GDALGroup>
    OpenGroupFromFullname(const std::string &osFullName,
                          CSLConstList papszOptions = nullptr) const;
 
    std::shared_ptr<GDALDimension>
    OpenDimensionFromFullname(const std::string &osFullName) const;
 
    virtual void ClearStatistics();
 
    virtual bool Rename(const std::string &osNewName);
 
    std::shared_ptr<GDALGroup>
    SubsetDimensionFromSelection(const std::string &osSelection) const;
 
    virtual void ParentRenamed(const std::string &osNewParentFullName);
 
    virtual void Deleted();
 
    virtual void ParentDeleted();
 
    const std::string &GetContext() const
    {
        return m_osContext;
    }
 
 
    static constexpr GUInt64 COPY_COST = 1000;
};
 
/* ******************************************************************** */
/*                          GDALAbstractMDArray                         */
/* ******************************************************************** */
 
class CPL_DLL GDALAbstractMDArray
{
  protected:
    std::string m_osName{};
 
    // This is actually a path of the form "/parent_path/{m_osName}"
    std::string m_osFullName{};
    std::weak_ptr<GDALAbstractMDArray> m_pSelf{};
 
    bool m_bValid = true;
 
    GDALAbstractMDArray(const std::string &osParentName,
                        const std::string &osName);
 
    void SetSelf(const std::shared_ptr<GDALAbstractMDArray> &self)
    {
        m_pSelf = self;
    }
 
    bool CheckValidAndErrorOutIfNot() const;
 
    bool CheckReadWriteParams(const GUInt64 *arrayStartIdx, const size_t *count,
                              const GInt64 *&arrayStep,
                              const GPtrDiff_t *&bufferStride,
                              const GDALExtendedDataType &bufferDataType,
                              const void *buffer,
                              const void *buffer_alloc_start,
                              size_t buffer_alloc_size,
                              std::vector<GInt64> &tmp_arrayStep,
                              std::vector<GPtrDiff_t> &tmp_bufferStride) const;
 
    virtual bool
    IRead(const GUInt64 *arrayStartIdx,    // array of size GetDimensionCount()
          const size_t *count,             // array of size GetDimensionCount()
          const GInt64 *arrayStep,         // step in elements
          const GPtrDiff_t *bufferStride,  // stride in elements
          const GDALExtendedDataType &bufferDataType,
          void *pDstBuffer) const = 0;
 
    virtual bool
    IWrite(const GUInt64 *arrayStartIdx,    // array of size GetDimensionCount()
           const size_t *count,             // array of size GetDimensionCount()
           const GInt64 *arrayStep,         // step in elements
           const GPtrDiff_t *bufferStride,  // stride in elements
           const GDALExtendedDataType &bufferDataType, const void *pSrcBuffer);
 
    void BaseRename(const std::string &osNewName);
 
    virtual void NotifyChildrenOfRenaming()
    {
    }
 
    virtual void NotifyChildrenOfDeletion()
    {
    }
 
 
  public:
    virtual ~GDALAbstractMDArray();
 
    const std::string &GetName() const
    {
        return m_osName;
    }
 
    const std::string &GetFullName() const
    {
        return m_osFullName;
    }
 
    GUInt64 GetTotalElementsCount() const;
 
    virtual size_t GetDimensionCount() const;
 
    virtual const std::vector<std::shared_ptr<GDALDimension>> &
    GetDimensions() const = 0;
 
    virtual const GDALExtendedDataType &GetDataType() const = 0;
 
    virtual std::vector<GUInt64> GetBlockSize() const;
 
    virtual std::vector<size_t>
    GetProcessingChunkSize(size_t nMaxChunkMemory) const;
 
    /* clang-format off */
    typedef bool (*FuncProcessPerChunkType)(
                        GDALAbstractMDArray *array,
                        const GUInt64 *chunkArrayStartIdx,
                        const size_t *chunkCount,
                        GUInt64 iCurChunk,
                        GUInt64 nChunkCount,
                        void *pUserData);
    /* clang-format on */
 
    virtual bool ProcessPerChunk(const GUInt64 *arrayStartIdx,
                                 const GUInt64 *count, const size_t *chunkSize,
                                 FuncProcessPerChunkType pfnFunc,
                                 void *pUserData);
 
    virtual bool
    Read(const GUInt64 *arrayStartIdx,    // array of size GetDimensionCount()
         const size_t *count,             // array of size GetDimensionCount()
         const GInt64 *arrayStep,         // step in elements
         const GPtrDiff_t *bufferStride,  // stride in elements
         const GDALExtendedDataType &bufferDataType, void *pDstBuffer,
         const void *pDstBufferAllocStart = nullptr,
         size_t nDstBufferAllocSize = 0) const;
 
    bool
    Write(const GUInt64 *arrayStartIdx,    // array of size GetDimensionCount()
          const size_t *count,             // array of size GetDimensionCount()
          const GInt64 *arrayStep,         // step in elements
          const GPtrDiff_t *bufferStride,  // stride in elements
          const GDALExtendedDataType &bufferDataType, const void *pSrcBuffer,
          const void *pSrcBufferAllocStart = nullptr,
          size_t nSrcBufferAllocSize = 0);
 
    virtual bool Rename(const std::string &osNewName);
 
    virtual void Deleted();
 
    virtual void ParentDeleted();
 
    virtual void ParentRenamed(const std::string &osNewParentFullName);
};
 
/* ******************************************************************** */
/*                              GDALRawResult                           */
/* ******************************************************************** */
 
class CPL_DLL GDALRawResult
{
  private:
    GDALExtendedDataType m_dt;
    size_t m_nEltCount;
    size_t m_nSize;
    GByte *m_raw;
 
    void FreeMe();
 
    GDALRawResult(const GDALRawResult &) = delete;
    GDALRawResult &operator=(const GDALRawResult &) = delete;
 
  protected:
    friend class GDALAttribute;
    GDALRawResult(GByte *raw, const GDALExtendedDataType &dt, size_t nEltCount);
 
  public:
    ~GDALRawResult();
    GDALRawResult(GDALRawResult &&);
    GDALRawResult &operator=(GDALRawResult &&);
 
    const GByte &operator[](size_t idx) const
    {
        return m_raw[idx];
    }
 
    const GByte *data() const
    {
        return m_raw;
    }
 
    size_t size() const
    {
        return m_nSize;
    }
 
    GByte *StealData();
};
 
/* ******************************************************************** */
/*                              GDALAttribute                           */
/* ******************************************************************** */
 
/* clang-format off */
/* clang-format on */
 
class CPL_DLL GDALAttribute : virtual public GDALAbstractMDArray
{
    mutable std::string m_osCachedVal{};
 
  protected:
    GDALAttribute(const std::string &osParentName, const std::string &osName);
 
  public:
    ~GDALAttribute() override;
 
    std::vector<GUInt64> GetDimensionsSize() const;
 
    GDALRawResult ReadAsRaw() const;
    const char *ReadAsString() const;
    int ReadAsInt() const;
    int64_t ReadAsInt64() const;
    double ReadAsDouble() const;
    CPLStringList ReadAsStringArray() const;
    std::vector<int> ReadAsIntArray() const;
    std::vector<int64_t> ReadAsInt64Array() const;
    std::vector<double> ReadAsDoubleArray() const;
 
    using GDALAbstractMDArray::Write;
    bool Write(const void *pabyValue, size_t nLen);
    bool Write(const char *);
    bool WriteInt(int);
    bool WriteInt64(int64_t);
    bool Write(double);
    bool Write(CSLConstList);
    bool Write(const int *, size_t);
    bool Write(const int64_t *, size_t);
    bool Write(const double *, size_t);
 
    static constexpr GUInt64 COPY_COST = 100;
};
 
/************************************************************************/
/*                         GDALAttributeString                          */
/************************************************************************/
 
class CPL_DLL GDALAttributeString final : public GDALAttribute
{
    std::vector<std::shared_ptr<GDALDimension>> m_dims{};
    GDALExtendedDataType m_dt = GDALExtendedDataType::CreateString();
    std::string m_osValue;
 
  protected:
    bool IRead(const GUInt64 *, const size_t *, const GInt64 *,
               const GPtrDiff_t *, const GDALExtendedDataType &bufferDataType,
               void *pDstBuffer) const override;
 
  public:
    GDALAttributeString(const std::string &osParentName,
                        const std::string &osName, const std::string &osValue,
                        GDALExtendedDataTypeSubType eSubType = GEDTST_NONE);
 
    const std::vector<std::shared_ptr<GDALDimension>> &
    GetDimensions() const override;
 
    const GDALExtendedDataType &GetDataType() const override;
};
 
 
/************************************************************************/
/*                         GDALAttributeNumeric                         */
/************************************************************************/
 
class CPL_DLL GDALAttributeNumeric final : public GDALAttribute
{
    std::vector<std::shared_ptr<GDALDimension>> m_dims{};
    GDALExtendedDataType m_dt;
    int m_nValue = 0;
    double m_dfValue = 0;
    std::vector<GUInt32> m_anValuesUInt32{};
 
  protected:
    bool IRead(const GUInt64 *, const size_t *, const GInt64 *,
               const GPtrDiff_t *, const GDALExtendedDataType &bufferDataType,
               void *pDstBuffer) const override;
 
  public:
    GDALAttributeNumeric(const std::string &osParentName,
                         const std::string &osName, double dfValue);
    GDALAttributeNumeric(const std::string &osParentName,
                         const std::string &osName, int nValue);
    GDALAttributeNumeric(const std::string &osParentName,
                         const std::string &osName,
                         const std::vector<GUInt32> &anValues);
 
    const std::vector<std::shared_ptr<GDALDimension>> &
    GetDimensions() const override;
 
    const GDALExtendedDataType &GetDataType() const override;
};
 
 
/* ******************************************************************** */
/*                              GDALMDArray                             */
/* ******************************************************************** */
 
/* clang-format off */
/* clang-format on */
 
class CPL_DLL GDALMDArray : virtual public GDALAbstractMDArray,
                            public GDALIHasAttribute
{
    friend class GDALMDArrayResampled;
    std::shared_ptr<GDALMDArray>
    GetView(const std::vector<GUInt64> &indices) const;
 
    inline std::shared_ptr<GDALMDArray>
    atInternal(const std::vector<GUInt64> &indices) const
    {
        return GetView(indices);
    }
 
    template <typename... GUInt64VarArg>
    // cppcheck-suppress functionStatic
    inline std::shared_ptr<GDALMDArray>
    atInternal(std::vector<GUInt64> &indices, GUInt64 idx,
               GUInt64VarArg... tail) const
    {
        indices.push_back(idx);
        return atInternal(indices, tail...);
    }
 
    // Used for example by GDALSubsetGroup to distinguish a derived group
    //from its original, without altering its name
    const std::string m_osContext{};
 
    mutable bool m_bHasTriedCachedArray = false;
    mutable std::shared_ptr<GDALMDArray> m_poCachedArray{};
 
  protected:
    GDALMDArray(const std::string &osParentName, const std::string &osName,
                const std::string &osContext = std::string());
 
    virtual bool IAdviseRead(const GUInt64 *arrayStartIdx, const size_t *count,
                             CSLConstList papszOptions) const;
 
    virtual bool IsCacheable() const
    {
        return true;
    }
 
    virtual bool SetStatistics(bool bApproxStats, double dfMin, double dfMax,
                               double dfMean, double dfStdDev,
                               GUInt64 nValidCount, CSLConstList papszOptions);
 
    static std::string MassageName(const std::string &inputName);
 
    std::shared_ptr<GDALGroup>
    GetCacheRootGroup(bool bCanCreate, std::string &osCacheFilenameOut) const;
 
    // Returns if bufferStride values express a transposed view of the array
    bool IsTransposedRequest(const size_t *count,
                             const GPtrDiff_t *bufferStride) const;
 
    // Should only be called if IsTransposedRequest() returns true
    bool ReadForTransposedRequest(const GUInt64 *arrayStartIdx,
                                  const size_t *count, const GInt64 *arrayStep,
                                  const GPtrDiff_t *bufferStride,
                                  const GDALExtendedDataType &bufferDataType,
                                  void *pDstBuffer) const;
 
    bool IsStepOneContiguousRowMajorOrderedSameDataType(
        const size_t *count, const GInt64 *arrayStep,
        const GPtrDiff_t *bufferStride,
        const GDALExtendedDataType &bufferDataType) const;
 
    // Should only be called if IsStepOneContiguousRowMajorOrderedSameDataType()
    // returns false
    bool ReadUsingContiguousIRead(const GUInt64 *arrayStartIdx,
                                  const size_t *count, const GInt64 *arrayStep,
                                  const GPtrDiff_t *bufferStride,
                                  const GDALExtendedDataType &bufferDataType,
                                  void *pDstBuffer) const;
 
    static std::shared_ptr<GDALMDArray> CreateGLTOrthorectified(
        const std::shared_ptr<GDALMDArray> &poParent,
        const std::shared_ptr<GDALGroup> &poRootGroup,
        const std::shared_ptr<GDALMDArray> &poGLTX,
        const std::shared_ptr<GDALMDArray> &poGLTY, int nGLTIndexOffset,
        const std::vector<double> &adfGeoTransform, CSLConstList papszOptions);
 
 
  public:
    GUInt64 GetTotalCopyCost() const;
 
    virtual bool CopyFrom(GDALDataset *poSrcDS, const GDALMDArray *poSrcArray,
                          bool bStrict, GUInt64 &nCurCost,
                          const GUInt64 nTotalCost,
                          GDALProgressFunc pfnProgress, void *pProgressData);
 
    virtual bool IsWritable() const = 0;
 
    virtual const std::string &GetFilename() const = 0;
 
    virtual CSLConstList GetStructuralInfo() const;
 
    virtual const std::string &GetUnit() const;
 
    virtual bool SetUnit(const std::string &osUnit);
 
    virtual bool SetSpatialRef(const OGRSpatialReference *poSRS);
 
    virtual std::shared_ptr<OGRSpatialReference> GetSpatialRef() const;
 
    virtual const void *GetRawNoDataValue() const;
 
    double GetNoDataValueAsDouble(bool *pbHasNoData = nullptr) const;
 
    int64_t GetNoDataValueAsInt64(bool *pbHasNoData = nullptr) const;
 
    uint64_t GetNoDataValueAsUInt64(bool *pbHasNoData = nullptr) const;
 
    virtual bool SetRawNoDataValue(const void *pRawNoData);
 
    bool SetNoDataValue(int nNoData)
    {
        return SetNoDataValue(static_cast<int64_t>(nNoData));
    }
 
 
    bool SetNoDataValue(double dfNoData);
 
    bool SetNoDataValue(int64_t nNoData);
 
    bool SetNoDataValue(uint64_t nNoData);
 
    virtual bool Resize(const std::vector<GUInt64> &anNewDimSizes,
                        CSLConstList papszOptions);
 
    virtual double GetOffset(bool *pbHasOffset = nullptr,
                             GDALDataType *peStorageType = nullptr) const;
 
    virtual double GetScale(bool *pbHasScale = nullptr,
                            GDALDataType *peStorageType = nullptr) const;
 
    virtual bool SetOffset(double dfOffset,
                           GDALDataType eStorageType = GDT_Unknown);
 
    virtual bool SetScale(double dfScale,
                          GDALDataType eStorageType = GDT_Unknown);
 
    std::shared_ptr<GDALMDArray> GetView(const std::string &viewExpr) const;
 
    std::shared_ptr<GDALMDArray> operator[](const std::string &fieldName) const;
 
    // sphinx 4.1.0 / breathe 4.30.0 don't like typename...
    template <typename... GUInt64VarArg>
    // cppcheck-suppress functionStatic
    std::shared_ptr<GDALMDArray> at(GUInt64 idx, GUInt64VarArg... tail) const
    {
        std::vector<GUInt64> indices;
        indices.push_back(idx);
        return atInternal(indices, tail...);
    }
 
    virtual std::shared_ptr<GDALMDArray>
    Transpose(const std::vector<int> &anMapNewAxisToOldAxis) const;
 
    std::shared_ptr<GDALMDArray> GetUnscaled(
        double dfOverriddenScale = std::numeric_limits<double>::quiet_NaN(),
        double dfOverriddenOffset = std::numeric_limits<double>::quiet_NaN(),
        double dfOverriddenDstNodata =
            std::numeric_limits<double>::quiet_NaN()) const;
 
    virtual std::shared_ptr<GDALMDArray>
    GetMask(CSLConstList papszOptions) const;
 
    virtual std::shared_ptr<GDALMDArray>
    GetResampled(const std::vector<std::shared_ptr<GDALDimension>> &apoNewDims,
                 GDALRIOResampleAlg resampleAlg,
                 const OGRSpatialReference *poTargetSRS,
                 CSLConstList papszOptions) const;
 
    std::shared_ptr<GDALMDArray>
    GetGridded(const std::string &osGridOptions,
               const std::shared_ptr<GDALMDArray> &poXArray = nullptr,
               const std::shared_ptr<GDALMDArray> &poYArray = nullptr,
               CSLConstList papszOptions = nullptr) const;
 
    static std::vector<std::shared_ptr<GDALMDArray>>
    GetMeshGrid(const std::vector<std::shared_ptr<GDALMDArray>> &apoArrays,
                CSLConstList papszOptions = nullptr);
 
    virtual GDALDataset *
    AsClassicDataset(size_t iXDim, size_t iYDim,
                     const std::shared_ptr<GDALGroup> &poRootGroup = nullptr,
                     CSLConstList papszOptions = nullptr) const;
 
    virtual CPLErr GetStatistics(bool bApproxOK, bool bForce, double *pdfMin,
                                 double *pdfMax, double *pdfMean,
                                 double *padfStdDev, GUInt64 *pnValidCount,
                                 GDALProgressFunc pfnProgress,
                                 void *pProgressData);
 
    virtual bool ComputeStatistics(bool bApproxOK, double *pdfMin,
                                   double *pdfMax, double *pdfMean,
                                   double *pdfStdDev, GUInt64 *pnValidCount,
                                   GDALProgressFunc, void *pProgressData,
                                   CSLConstList papszOptions);
 
    virtual void ClearStatistics();
 
    virtual std::vector<std::shared_ptr<GDALMDArray>>
    GetCoordinateVariables() const;
 
    bool AdviseRead(const GUInt64 *arrayStartIdx, const size_t *count,
                    CSLConstList papszOptions = nullptr) const;
 
    virtual bool IsRegularlySpaced(double &dfStart, double &dfIncrement) const;
 
    bool GuessGeoTransform(size_t nDimX, size_t nDimY, bool bPixelIsPoint,
                           GDALGeoTransform &gt) const;
 
    bool GuessGeoTransform(size_t nDimX, size_t nDimY, bool bPixelIsPoint,
                           double adfGeoTransform[6]) const;
 
    bool Cache(CSLConstList papszOptions = nullptr) const;
 
    bool
    Read(const GUInt64 *arrayStartIdx,    // array of size GetDimensionCount()
         const size_t *count,             // array of size GetDimensionCount()
         const GInt64 *arrayStep,         // step in elements
         const GPtrDiff_t *bufferStride,  // stride in elements
         const GDALExtendedDataType &bufferDataType, void *pDstBuffer,
         const void *pDstBufferAllocStart = nullptr,
         size_t nDstBufferAllocSize = 0) const override final;
 
    virtual std::shared_ptr<GDALGroup> GetRootGroup() const;
 
    virtual bool GetRawBlockInfo(const uint64_t *panBlockCoordinates,
                                 GDALMDArrayRawBlockInfo &info) const;
 
    virtual int GetOverviewCount() const;
 
    virtual std::shared_ptr<GDALMDArray> GetOverview(int idx) const;
 
    virtual CPLErr BuildOverviews(const char *pszResampling, int nOverviews,
                                  const int *panOverviewList,
                                  GDALProgressFunc pfnProgress,
                                  void *pProgressData,
                                  CSLConstList papszOptions);
 
    static constexpr GUInt64 COPY_COST = 1000;
 
    bool CopyFromAllExceptValues(const GDALMDArray *poSrcArray, bool bStrict,
                                 GUInt64 &nCurCost, const GUInt64 nTotalCost,
                                 GDALProgressFunc pfnProgress,
                                 void *pProgressData);
 
    struct Range
    {
        GUInt64 m_nStartIdx;
        GInt64 m_nIncr;
 
        explicit Range(GUInt64 nStartIdx = 0, GInt64 nIncr = 0)
            : m_nStartIdx(nStartIdx), m_nIncr(nIncr)
        {
        }
    };
 
    struct ViewSpec
    {
        std::string m_osFieldName{};
 
        // or
 
        std::vector<size_t>
            m_mapDimIdxToParentDimIdx{};  // of size m_dims.size()
        std::vector<Range>
            m_parentRanges{};  // of size m_poParent->GetDimensionCount()
    };
 
    virtual std::shared_ptr<GDALMDArray>
    GetView(const std::string &viewExpr, bool bRenameDimensions,
            std::vector<ViewSpec> &viewSpecs) const;
 
    const std::string &GetContext() const
    {
        return m_osContext;
    }
 
};
 
bool CPL_DLL GDALMDRasterIOFromBand(
    GDALRasterBand *poBand, GDALRWFlag eRWFlag, size_t iDimX, size_t iDimY,
    const GUInt64 *arrayStartIdx, const size_t *count, const GInt64 *arrayStep,
    const GPtrDiff_t *bufferStride, const GDALExtendedDataType &bufferDataType,
    void *pBuffer);
 
 
/************************************************************************/
/*                      GDALMDArrayRegularlySpaced                      */
/************************************************************************/
 
class CPL_DLL GDALMDArrayRegularlySpaced final : public GDALMDArray
{
    double m_dfStart = 0;
    double m_dfIncrement = 0;
    double m_dfOffsetInIncrement = 0;
    const GDALExtendedDataType m_dt = GDALExtendedDataType::Create(GDT_Float64);
    const std::vector<std::shared_ptr<GDALDimension>> m_dims;
    std::vector<std::shared_ptr<GDALAttribute>> m_attributes{};
    const std::string m_osEmptyFilename{};
 
  protected:
    bool IRead(const GUInt64 *, const size_t *, const GInt64 *,
               const GPtrDiff_t *, const GDALExtendedDataType &bufferDataType,
               void *pDstBuffer) const override;
 
  public:
    GDALMDArrayRegularlySpaced(const std::string &osParentName,
                               const std::string &osName,
                               const std::shared_ptr<GDALDimension> &poDim,
                               double dfStart, double dfIncrement,
                               double dfOffsetInIncrement);
 
    static std::shared_ptr<GDALMDArrayRegularlySpaced>
    Create(const std::string &osParentName, const std::string &osName,
           const std::shared_ptr<GDALDimension> &poDim, double dfStart,
           double dfIncrement, double dfOffsetInIncrement);
 
    bool IsWritable() const override
    {
        return false;
    }
 
    const std::string &GetFilename() const override
    {
        return m_osEmptyFilename;
    }
 
    const std::vector<std::shared_ptr<GDALDimension>> &
    GetDimensions() const override;
 
    const GDALExtendedDataType &GetDataType() const override;
 
    std::vector<std::shared_ptr<GDALAttribute>>
        GetAttributes(CSLConstList) const override;
 
    void AddAttribute(const std::shared_ptr<GDALAttribute> &poAttr);
 
    bool IsRegularlySpaced(double &dfStart, double &dfIncrement) const override;
};
 
 
/* ******************************************************************** */
/*                            GDALDimension                             */
/* ******************************************************************** */
 
class CPL_DLL GDALDimension
{
  public:
    GDALDimension(const std::string &osParentName, const std::string &osName,
                  const std::string &osType, const std::string &osDirection,
                  GUInt64 nSize);
 
    virtual ~GDALDimension();
 
    const std::string &GetName() const
    {
        return m_osName;
    }
 
    const std::string &GetFullName() const
    {
        return m_osFullName;
    }
 
    const std::string &GetType() const
    {
        return m_osType;
    }
 
    const std::string &GetDirection() const
    {
        return m_osDirection;
    }
 
    GUInt64 GetSize() const
    {
        return m_nSize;
    }
 
    virtual std::shared_ptr<GDALMDArray> GetIndexingVariable() const;
 
    virtual bool
    SetIndexingVariable(std::shared_ptr<GDALMDArray> poIndexingVariable);
 
    virtual bool Rename(const std::string &osNewName);
 
    virtual void ParentRenamed(const std::string &osNewParentFullName);
 
    virtual void ParentDeleted();
 
  protected:
    std::string m_osName;
    std::string m_osFullName;
    std::string m_osType;
    std::string m_osDirection;
    GUInt64 m_nSize;
 
    void BaseRename(const std::string &osNewName);
 
};
 
/************************************************************************/
/*                    GDALDimensionWeakIndexingVar()                    */
/************************************************************************/
 
class CPL_DLL GDALDimensionWeakIndexingVar : public GDALDimension
{
    std::weak_ptr<GDALMDArray> m_poIndexingVariable{};
 
  public:
    GDALDimensionWeakIndexingVar(const std::string &osParentName,
                                 const std::string &osName,
                                 const std::string &osType,
                                 const std::string &osDirection, GUInt64 nSize);
 
    std::shared_ptr<GDALMDArray> GetIndexingVariable() const override;
 
    bool SetIndexingVariable(
        std::shared_ptr<GDALMDArray> poIndexingVariable) override;
 
    void SetSize(GUInt64 nNewSize);
};
 
 
#endif