@crossbind/port-gdal-wasm 2.0.0-beta.50

package/dist/prebuilt/wasm-wasm32-mt-release/include/ogr_p.h

@@ -0,0 +1,330 @@
+/******************************************************************************
+ *
+ * Project:  OpenGIS Simple Features Reference Implementation
+ * Purpose:  Some private helper functions and stuff for OGR implementation.
+ * Author:   Frank Warmerdam, warmerdam@pobox.com
+ *
+ ******************************************************************************
+ * Copyright (c) 1999, Frank Warmerdam
+ * Copyright (c) 2008-2014, Even Rouault <even dot rouault at spatialys.com>
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+#ifndef OGR_P_H_INCLUDED
+#define OGR_P_H_INCLUDED
+
+/* -------------------------------------------------------------------- */
+/*      Include the common portability library ... lets us do lots      */
+/*      of stuff easily.                                                */
+/* -------------------------------------------------------------------- */
+
+#include "cpl_string.h"
+#include "cpl_conv.h"
+#include "cpl_minixml.h"
+
+#include "ogr_core.h"
+
+#include <limits>
+#include <string_view>
+
+class OGRGeometry;
+class OGRFieldDefn;
+
+/* A default name for the default geometry column, instead of '' */
+#define OGR_GEOMETRY_DEFAULT_NON_EMPTY_NAME "_ogr_geometry_"
+
+#ifdef CPL_MSB
+#define OGR_SWAP(x) (x == wkbNDR)
+#else
+#define OGR_SWAP(x) (x == wkbXDR)
+#endif
+
+/* PostGIS 1.X has non standard codes for the following geometry types */
+#define POSTGIS15_CURVEPOLYGON 13 /* instead of 10 */
+#define POSTGIS15_MULTICURVE 14   /* instead of 11 */
+#define POSTGIS15_MULTISURFACE 15 /* instead of 12 */
+
+/* Has been deprecated. Can only be used in very specific circumstances */
+#ifdef GDAL_COMPILATION
+#define wkb25DBitInternalUse 0x80000000
+#endif
+
+/* -------------------------------------------------------------------- */
+/*      helper function for parsing well known text format vector objects.*/
+/* -------------------------------------------------------------------- */
+
+#ifdef OGR_GEOMETRY_H_INCLUDED
+#define OGR_WKT_TOKEN_MAX 64
+
+const char CPL_DLL *OGRWktReadToken(const char *pszInput, char *pszToken);
+
+const char CPL_DLL *OGRWktReadPoints(const char *pszInput,
+                                     OGRRawPoint **ppaoPoints, double **ppadfZ,
+                                     int *pnMaxPoints, int *pnReadPoints);
+
+const char CPL_DLL *
+OGRWktReadPointsM(const char *pszInput, OGRRawPoint **ppaoPoints,
+                  double **ppadfZ, double **ppadfM,
+                  int *flags, /* geometry flags, are we expecting Z, M, or both;
+                                 may change due to input */
+                  int *pnMaxPoints, int *pnReadPoints);
+
+void CPL_DLL OGRMakeWktCoordinate(char *, double, double, double, int);
+std::string CPL_DLL OGRMakeWktCoordinate(double, double, double, int,
+                                         const OGRWktOptions &opts);
+void CPL_DLL OGRMakeWktCoordinateM(char *, double, double, double, double,
+                                   OGRBoolean, OGRBoolean);
+std::string CPL_DLL OGRMakeWktCoordinateM(double, double, double, double,
+                                          OGRBoolean, OGRBoolean,
+                                          const OGRWktOptions &opts);
+
+#endif
+
+void CPL_DLL OGRFormatDouble(char *pszBuffer, int nBufferLen, double dfVal,
+                             char chDecimalSep, int nPrecision = 15,
+                             char chConversionSpecifier = 'f');
+
+#ifdef OGR_GEOMETRY_H_INCLUDED
+std::string CPL_DLL OGRFormatDouble(double val, const OGRWktOptions &opts,
+                                    int nDimIdx);
+#endif
+
+int OGRFormatFloat(char *pszBuffer, int nBufferLen, float fVal, int nPrecision,
+                   char chConversionSpecifier);
+
+/* -------------------------------------------------------------------- */
+/*      Date-time parsing and processing functions                      */
+/* -------------------------------------------------------------------- */
+
+/* Internal use by OGR drivers only, CPL_DLL is just there in case */
+/* they are compiled as plugins  */
+
+int CPL_DLL OGRTimezoneToTZFlag(const char *pszTZ,
+                                bool bEmitErrorIfUnhandledFormat);
+std::string CPL_DLL OGRTZFlagToTimezone(int nTZFlag,
+                                        const char *pszUTCRepresentation);
+
+int CPL_DLL OGRGetDayOfWeek(int day, int month, int year);
+int CPL_DLL OGRParseXMLDateTime(const char *pszXMLDateTime, OGRField *psField);
+int CPL_DLL OGRParseRFC822DateTime(const char *pszRFC822DateTime,
+                                   OGRField *psField);
+char CPL_DLL *OGRGetRFC822DateTime(const OGRField *psField);
+char CPL_DLL *OGRGetXMLDateTime(const OGRField *psField);
+char CPL_DLL *OGRGetXMLDateTime(const OGRField *psField,
+                                bool bAlwaysMillisecond);
+// 30 = strlen("YYYY-MM-DDThh:mm:ss.sss+hh:mm") + 1
+#define OGR_SIZEOF_ISO8601_DATETIME_BUFFER 30
+int CPL_DLL
+OGRGetISO8601DateTime(const OGRField *psField, bool bAlwaysMillisecond,
+                      char szBuffer[OGR_SIZEOF_ISO8601_DATETIME_BUFFER]);
+
+/** Precision of formatting */
+enum class OGRISO8601Precision
+{
+    /** Automated mode: millisecond included if non zero, otherwise truncated at second */
+    AUTO,
+    /** Always include millisecond */
+    MILLISECOND,
+    /** Always include second, but no millisecond */
+    SECOND,
+    /** Always include minute, but no second */
+    MINUTE
+};
+
+/** Configuration of the ISO8601 formatting output */
+struct OGRISO8601Format
+{
+    /** Precision of formatting */
+    OGRISO8601Precision ePrecision;
+};
+
+int CPL_DLL
+OGRGetISO8601DateTime(const OGRField *psField, const OGRISO8601Format &sFormat,
+                      char szBuffer[OGR_SIZEOF_ISO8601_DATETIME_BUFFER]);
+char CPL_DLL *OGRGetXML_UTF8_EscapedString(const char *pszString);
+
+#ifdef GDAL_COMPILATION
+bool CPL_DLL OGRParseDateTimeYYYYMMDDTHHMMZ(std::string_view sInput,
+                                            OGRField *psField);
+bool CPL_DLL OGRParseDateTimeYYYYMMDDTHHMMSSZ(std::string_view sInput,
+                                              OGRField *psField);
+bool CPL_DLL OGRParseDateTimeYYYYMMDDTHHMMSSsssZ(std::string_view sInput,
+                                                 OGRField *psField);
+#endif
+
+int OGRCompareDate(const OGRField *psFirstTuple,
+                   const OGRField *psSecondTuple); /* used by ogr_gensql.cpp and
+                                                      ogrfeaturequery.cpp */
+
+bool CPL_DLL OGRIsGeoJSONMediaType(const char *pszMediaType);
+
+/* General utility option processing. */
+int CPL_DLL OGRGeneralCmdLineProcessor(int nArgc, char ***ppapszArgv,
+                                       int nOptions);
+
+/************************************************************************/
+/*     Support for special attributes (feature query and selection)     */
+/************************************************************************/
+#define SPF_FID 0
+#define SPF_OGR_GEOMETRY 1
+#define SPF_OGR_STYLE 2
+#define SPF_OGR_GEOM_WKT 3
+#define SPF_OGR_GEOM_AREA 4
+#define SPECIAL_FIELD_COUNT 5
+
+extern const char *const SpecialFieldNames[SPECIAL_FIELD_COUNT];
+
+/************************************************************************/
+/*          Some SRS related stuff, search in SRS data files.           */
+/************************************************************************/
+
+OGRErr CPL_DLL OSRGetEllipsoidInfo(int, char **, double *, double *);
+
+/* Fast atof function */
+double OGRFastAtof(const char *pszStr);
+
+OGRErr CPL_DLL OGRCheckPermutation(const int *panPermutation, int nSize);
+
+/************************************************************************/
+/*                        PostGIS EWKB encoding                         */
+/************************************************************************/
+
+OGRGeometry CPL_DLL *OGRGeometryFromEWKB(GByte *pabyWKB, int nLength,
+                                         int *pnSRID, int bIsPostGIS1_EWKB);
+OGRGeometry CPL_DLL *OGRGeometryFromHexEWKB(const char *pszBytea, int *pnSRID,
+                                            int bIsPostGIS1_EWKB);
+char CPL_DLL *OGRGeometryToHexEWKB(const OGRGeometry *poGeometry, int nSRSId,
+                                   int nPostGISMajor, int nPostGISMinor);
+
+/************************************************************************/
+/*                      WKB Type Handling encoding                      */
+/************************************************************************/
+
+OGRErr CPL_DLL OGRReadWKBGeometryType(const unsigned char *pabyData,
+                                      OGRwkbVariant wkbVariant,
+                                      OGRwkbGeometryType *eGeometryType);
+
+/************************************************************************/
+/*                      WKT Type Handling encoding                      */
+/************************************************************************/
+
+OGRErr CPL_DLL OGRReadWKTGeometryType(const char *pszWKT,
+                                      OGRwkbGeometryType *peGeometryType);
+
+/************************************************************************/
+/*                                Other                                 */
+/************************************************************************/
+
+void CPL_DLL OGRUpdateFieldType(OGRFieldDefn *poFDefn, OGRFieldType eNewType,
+                                OGRFieldSubType eNewSubType);
+
+/************************************************************************/
+/*                        OGRRoundValueIEEE754()                        */
+/************************************************************************/
+
+/** Set to zero least significants bits of a double precision floating-point
+ * number (passed as an integer), taking into account a desired bit precision.
+ *
+ * @param nVal Integer representation of a IEEE754 double-precision number.
+ * @param nBitsPrecision Desired precision (number of bits after integral part)
+ * @return quantized nVal.
+ * @since GDAL 3.9
+ */
+inline uint64_t OGRRoundValueIEEE754(uint64_t nVal,
+                                     int nBitsPrecision) CPL_WARN_UNUSED_RESULT;
+
+inline uint64_t OGRRoundValueIEEE754(uint64_t nVal, int nBitsPrecision)
+{
+    constexpr int MANTISSA_SIZE = std::numeric_limits<double>::digits - 1;
+    constexpr int MAX_EXPONENT = std::numeric_limits<double>::max_exponent;
+#if __cplusplus >= 201703L
+    static_assert(MANTISSA_SIZE == 52);
+    static_assert(MAX_EXPONENT == 1024);
+#endif
+    // Extract the binary exponent from the IEEE754 representation
+    const int nExponent =
+        ((nVal >> MANTISSA_SIZE) & (2 * MAX_EXPONENT - 1)) - (MAX_EXPONENT - 1);
+    // Add 1 to round-up and the desired precision
+    const int nBitsRequired = 1 + nExponent + nBitsPrecision;
+    // Compute number of nullified bits
+    int nNullifiedBits = MANTISSA_SIZE - nBitsRequired;
+    // this will also capture NaN and Inf since nExponent = 1023,
+    // and thus nNullifiedBits < 0
+    if (nNullifiedBits <= 0)
+        return nVal;
+    if (nNullifiedBits >= MANTISSA_SIZE)
+        nNullifiedBits = MANTISSA_SIZE;
+    nVal >>= nNullifiedBits;
+    nVal <<= nNullifiedBits;
+    return nVal;
+}
+
+/************************************************************************/
+/*                 OGRRoundCoordinatesIEEE754XYValues()                 */
+/************************************************************************/
+
+/** Quantize XY values.
+ *
+ * @since GDAL 3.9
+ */
+template <int SPACING>
+inline void OGRRoundCoordinatesIEEE754XYValues(int nBitsPrecision,
+                                               GByte *pabyBase, size_t nPoints)
+{
+    // Note: we use SPACING as template for improved code generation.
+
+    if (nBitsPrecision != INT_MIN)
+    {
+        for (size_t i = 0; i < nPoints; i++)
+        {
+            uint64_t nVal;
+
+            memcpy(&nVal, pabyBase + SPACING * i, sizeof(uint64_t));
+            nVal = OGRRoundValueIEEE754(nVal, nBitsPrecision);
+            memcpy(pabyBase + SPACING * i, &nVal, sizeof(uint64_t));
+
+            memcpy(&nVal, pabyBase + sizeof(uint64_t) + SPACING * i,
+                   sizeof(uint64_t));
+            nVal = OGRRoundValueIEEE754(nVal, nBitsPrecision);
+            memcpy(pabyBase + sizeof(uint64_t) + SPACING * i, &nVal,
+                   sizeof(uint64_t));
+        }
+    }
+}
+
+/************************************************************************/
+/*                     OGRRoundCoordinatesIEEE754()                     */
+/************************************************************************/
+
+/** Quantize Z or M values.
+ *
+ * @since GDAL 3.9
+ */
+template <int SPACING>
+inline void OGRRoundCoordinatesIEEE754(int nBitsPrecision, GByte *pabyBase,
+                                       size_t nPoints)
+{
+    if (nBitsPrecision != INT_MIN)
+    {
+        for (size_t i = 0; i < nPoints; i++)
+        {
+            uint64_t nVal;
+
+            memcpy(&nVal, pabyBase + SPACING * i, sizeof(uint64_t));
+            nVal = OGRRoundValueIEEE754(nVal, nBitsPrecision);
+            memcpy(pabyBase + SPACING * i, &nVal, sizeof(uint64_t));
+        }
+    }
+}
+
+/* -------------------------------------------------------------------- */
+/*      helper functions for string escaping.                           */
+/* -------------------------------------------------------------------- */
+
+/** Replace all occurrences of ch by it repeated twice.
+ * Typically used for SQL string literal or identifier escaping.
+ */
+std::string CPL_DLL OGRDuplicateCharacter(const std::string &osStr, char ch);
+
+#endif /* ndef OGR_P_H_INCLUDED */

package/dist/prebuilt/wasm-wasm32-mt-release/include/ogr_recordbatch.h

@@ -0,0 +1,128 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// This file is an extract
+// https://github.com/apache/arrow/blob/main/cpp/src/arrow/c/abi.h WARNING: DO
+// NOT MODIFY the content as it would break interoperability !
+
+#ifndef OGR_RECORDBATCH_H_INCLUDED
+#define OGR_RECORDBATCH_H_INCLUDED
+
+/*! @cond Doxygen_Suppress */
+
+#include <stdint.h>
+
+// Spec and documentation: https://arrow.apache.org/docs/format/CDataInterface.html
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifndef ARROW_C_DATA_INTERFACE
+#define ARROW_C_DATA_INTERFACE
+
+#define ARROW_FLAG_DICTIONARY_ORDERED 1
+#define ARROW_FLAG_NULLABLE 2
+#define ARROW_FLAG_MAP_KEYS_SORTED 4
+
+    struct ArrowSchema
+    {
+        // Array type description
+        const char *format;
+        const char *name;
+        const char *metadata;
+        int64_t flags;
+        int64_t n_children;
+        struct ArrowSchema **children;
+        struct ArrowSchema *dictionary;
+
+        // Release callback
+        void (*release)(struct ArrowSchema *);
+        // Opaque producer-specific data
+        void *private_data;
+    };
+
+    struct ArrowArray
+    {
+        // Array data description
+        int64_t length;
+        int64_t null_count;
+        int64_t offset;
+        int64_t n_buffers;
+        int64_t n_children;
+        const void **buffers;
+        struct ArrowArray **children;
+        struct ArrowArray *dictionary;
+
+        // Release callback
+        void (*release)(struct ArrowArray *);
+        // Opaque producer-specific data
+        void *private_data;
+    };
+
+#endif  // ARROW_C_DATA_INTERFACE
+
+#ifndef ARROW_C_STREAM_INTERFACE
+#define ARROW_C_STREAM_INTERFACE
+
+    struct ArrowArrayStream
+    {
+        // Callback to get the stream type
+        // (will be the same for all arrays in the stream).
+        //
+        // Return value: 0 if successful, an `errno`-compatible error code otherwise.
+        //
+        // If successful, the ArrowSchema must be released independently from the stream.
+        int (*get_schema)(struct ArrowArrayStream *, struct ArrowSchema *out);
+
+        // Callback to get the next array
+        // (if no error and the array is released, the stream has ended)
+        //
+        // Return value: 0 if successful, an `errno`-compatible error code otherwise.
+        //
+        // If successful, the ArrowArray must be released independently from the stream.
+        int (*get_next)(struct ArrowArrayStream *, struct ArrowArray *out);
+
+        // Callback to get optional detailed error information.
+        // This must only be called if the last stream operation failed
+        // with a non-0 return code.
+        //
+        // Return value: pointer to a null-terminated character array describing
+        // the last error, or NULL if no description is available.
+        //
+        // The returned pointer is only valid until the next operation on this stream
+        // (including release).
+        const char *(*get_last_error)(struct ArrowArrayStream *);
+
+        // Release callback: release the stream's own resources.
+        // Note that arrays returned by `get_next` must be individually released.
+        void (*release)(struct ArrowArrayStream *);
+
+        // Opaque producer-specific data
+        void *private_data;
+    };
+
+#endif  // ARROW_C_STREAM_INTERFACE
+
+#ifdef __cplusplus
+}
+#endif
+
+/*! @endcond */
+
+#endif  // OGR_RECORDBATCH_H_INCLUDED

package/dist/prebuilt/wasm-wasm32-mt-release/include/ogr_refcountedptr.h

@@ -0,0 +1,198 @@
+/******************************************************************************
+ *
+ * Project:  OGR
+ * Purpose:  Smart pointer around a class that has built-in reference counting.
+ * Author:   Even Rouault <even dot rouault at spatialys.com>
+ *
+ ******************************************************************************
+ * Copyright (c) 2026, Even Rouault <even dot rouault at spatialys.com>
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+#ifndef OGR_REFCOUNTEDPTR_INCLUDED
+#define OGR_REFCOUNTEDPTR_INCLUDED
+
+/*! @cond Doxygen_Suppress */
+
+#include <cstddef>
+#include <utility>
+
+/** Base (non-instantiable) class for OGRRefCountedPtr.
+ *
+ * Only intended to be used as the base class for OGRRefCountedPtr.
+ * Done that way so its constructor is protected and force specializations
+ * of redefining a public one (calling it)
+ */
+template <class T> struct OGRRefCountedPtrBase
+{
+  public:
+    /** Destructor.
+     *
+     * Release the raw pointer, that is decrease its reference count and delete
+     * the object when it reaches zero.
+     */
+    inline ~OGRRefCountedPtrBase()
+    {
+        reset(nullptr);
+    }
+
+    /** Copy constructor.
+     *
+     * Increases the reference count
+     */
+    inline OGRRefCountedPtrBase(const OGRRefCountedPtrBase &other)
+        : OGRRefCountedPtrBase(other.m_poRawPtr, true)
+    {
+    }
+
+    /** Copy constructor
+     *
+     * Set the raw pointer to the one used by other, and increase the reference
+     * count.
+     */
+    // cppcheck-suppress operatorEqVarError
+    inline OGRRefCountedPtrBase &operator=(const OGRRefCountedPtrBase &other)
+    {
+        if (this != &other)
+        {
+            reset(other.m_poRawPtr);
+        }
+        return *this;
+    }
+
+    /** Move constructor
+     *
+     * Borrows the raw pointer managed by other, without changing its reference
+     * count, and set the managed raw pointer of other to null.
+     */
+    inline OGRRefCountedPtrBase(OGRRefCountedPtrBase &&other)
+    {
+        std::swap(m_poRawPtr, other.m_poRawPtr);
+    }
+
+    /** Move assignment operator.
+     *
+     * Release the current managed raw pointer and borrow the
+     * one from other.
+     * Does not change the reference count of the borrowed raw pointer.
+     */
+    inline OGRRefCountedPtrBase &operator=(OGRRefCountedPtrBase &&other)
+    {
+        reset(nullptr);
+        std::swap(m_poRawPtr, other.m_poRawPtr);
+        return *this;
+    }
+
+    /** Reset the managed raw pointer.
+     *
+     * Release the current managed raw pointer and manages a new one.
+     * By default, increases the reference count of the new raw pointer (when
+     * not null).
+     */
+    inline void reset(T *poRawPtr = nullptr, bool add_ref = true)
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+        if (m_poRawPtr)
+            m_poRawPtr->Release();
+        m_poRawPtr = poRawPtr;
+        if (m_poRawPtr && add_ref)
+            m_poRawPtr->Reference();
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+    /** Returns the raw pointer without changing its reference count */
+    inline T *get() const
+    {
+        return m_poRawPtr;
+    }
+
+    /** Returns a reference to the raw pointer without changing its reference
+     * count.
+     *
+     * Must be only called when get() != nullptr.
+     */
+    inline T &operator*() const
+    {
+        return *m_poRawPtr;
+    }
+
+    /** Forwards the access to a member or a call to a method of the raw
+     * pointer.
+     */
+    inline T *operator->() const
+    {
+        return m_poRawPtr;
+    }
+
+    /** Returns whether the raw pointer is null. */
+    inline explicit operator bool() const
+    {
+        return m_poRawPtr != nullptr;
+    }
+
+  protected:
+    inline explicit OGRRefCountedPtrBase(T *poRawPtr = nullptr,
+                                         bool add_ref = true)
+        : m_poRawPtr(poRawPtr)
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+        if (m_poRawPtr && add_ref)
+            m_poRawPtr->Reference();
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+  private:
+    T *m_poRawPtr{};
+};
+
+/** Smart pointer around a class that has built-in reference counting.
+ *
+ * It uses the Reference() and Release() methods of the wrapped class for
+ * reference counting. The reference count is increased when assigning a raw
+ * pointer to the smart pointer, and decreased when releasing it.
+ * Somewhat similar to https://www.boost.org/doc/libs/latest/libs/smart_ptr/doc/html/smart_ptr.html#intrusive_ptr
+ *
+ * Only meant for T = OGRFeatureDefn and OGRSpatialReference
+ */
+template <class T> struct OGRRefCountedPtr : public OGRRefCountedPtrBase<T>
+{
+};
+
+template <class T>
+inline bool operator==(const OGRRefCountedPtr<T> &lhs, std::nullptr_t)
+{
+    return lhs.get() == nullptr;
+}
+
+template <class T>
+inline bool operator==(std::nullptr_t, const OGRRefCountedPtr<T> &rhs)
+{
+    return rhs.get() == nullptr;
+}
+
+template <class T>
+inline bool operator!=(const OGRRefCountedPtr<T> &lhs, std::nullptr_t)
+{
+    return lhs.get() != nullptr;
+}
+
+template <class T>
+inline bool operator!=(std::nullptr_t, const OGRRefCountedPtr<T> &rhs)
+{
+    return rhs.get() != nullptr;
+}
+
+/*! @endcond */
+
+#endif /* OGR_REFCOUNTEDPTR_INCLUDED */