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

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

@@ -0,0 +1,398 @@
+/******************************************************************************
+ * Project:  Common Portability Library
+ * Purpose:  Function wrapper for libjson-c access.
+ * Author:   Dmitry Baryshnikov, dmitry.baryshnikov@nextgis.com
+ *
+ ******************************************************************************
+ * Copyright (c) 2017-2018 NextGIS, <info@nextgis.com>
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+#ifndef CPL_JSON_H_INCLUDED
+#define CPL_JSON_H_INCLUDED
+
+#include "cpl_progress.h"
+#include "cpl_string.h"
+
+#include <cstdint>
+#include <initializer_list>
+#include <iterator>
+#include <string>
+#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#include <string_view>
+#endif
+#include <vector>
+
+/**
+ * \file cpl_json.h
+ *
+ * Interface for read and write JSON documents
+ */
+
+/*! @cond Doxygen_Suppress */
+typedef void *JSONObjectH;
+
+class CPLJSONObject;
+class CPLJSONArray;
+
+class CPLJSONObjectProxy
+{
+    CPLJSONObject &oObj;
+    const std::string osName;
+
+  public:
+    explicit inline CPLJSONObjectProxy(CPLJSONObject &oObjIn,
+                                       const std::string &osNameIn)
+        : oObj(oObjIn), osName(osNameIn)
+    {
+    }
+
+    template <class T> inline CPLJSONObjectProxy &operator=(const T &val);
+};
+
+/*! @endcond */
+
+/**
+ * @brief The CPLJSONArray class holds JSON object from CPLJSONDocument
+ */
+class CPL_DLL CPLJSONObject
+{
+    friend class CPLJSONArray;
+    friend class CPLJSONDocument;
+
+  public:
+    /**
+     * Json object types
+     */
+    enum class Type
+    {
+        Unknown,
+        Null,
+        Object,
+        Array,
+        Boolean,
+        String,
+        Integer,
+        Long,
+        Double
+    };
+
+    /**
+     * Json object format to string options
+     */
+    enum class PrettyFormat
+    {
+        Plain,   ///< No extra whitespace or formatting applied
+        Spaced,  ///< Minimal whitespace inserted
+        Pretty   ///< Formatted output
+    };
+
+  public:
+    /*! @cond Doxygen_Suppress */
+    CPLJSONObject();
+    explicit CPLJSONObject(const std::string &osName,
+                           const CPLJSONObject &oParent);
+    explicit CPLJSONObject(std::nullptr_t);
+    explicit CPLJSONObject(const std::string &osVal);
+    explicit CPLJSONObject(const char *pszValue);
+    explicit CPLJSONObject(bool bVal);
+    explicit CPLJSONObject(int nVal);
+    explicit CPLJSONObject(int64_t nVal);
+    explicit CPLJSONObject(uint64_t nVal);
+    explicit CPLJSONObject(double dfVal);
+    ~CPLJSONObject();
+    CPLJSONObject(const CPLJSONObject &other);
+    CPLJSONObject(CPLJSONObject &&other);
+    CPLJSONObject &operator=(const CPLJSONObject &other);
+    CPLJSONObject &operator=(CPLJSONObject &&other);
+    CPLJSONObject &operator=(CPLJSONArray &&other);
+
+    // This method is not thread-safe
+    CPLJSONObject Clone() const;
+
+  private:
+    explicit CPLJSONObject(const std::string &osName, JSONObjectH poJsonObject);
+    /*! @endcond */
+
+  public:
+    // setters
+    void Add(const std::string &osName, const std::string &osValue);
+#if defined(DOXYGEN_SKIP) || __cplusplus >= 201703L ||                         \
+    (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+
+    void Add(const std::string &osName, std::string_view svValue);
+#endif
+    void Add(const std::string &osName, const char *pszValue);
+    void Add(const std::string &osName, double dfValue);
+    void Add(const std::string &osName, int nValue);
+    void Add(const std::string &osName, GInt64 nValue);
+    void Add(const std::string &osName, uint64_t nValue);
+    void Add(const std::string &osName, const CPLJSONArray &oValue);
+    void Add(const std::string &osName, const CPLJSONObject &oValue);
+    void AddNoSplitName(const std::string &osName, const CPLJSONObject &oValue);
+    void Add(const std::string &osName, bool bValue);
+    void AddNull(const std::string &osName);
+
+    /** Change value by key */
+    template <class T> void Set(const std::string &osName, const T &val)
+    {
+        Delete(osName);
+        Add(osName, val);
+    }
+
+    void SetNull(const std::string &osName);
+
+    CPLJSONObject operator[](const std::string &osName);
+
+/*! @cond Doxygen_Suppress */
+
+// GCC 9.4 seems to be confused by the template and doesn't realize it
+// returns *this
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Weffc++"
+#endif
+    template <class T> inline CPLJSONObject &operator=(const T &val)
+    {
+        CPLAssert(!m_osKeyForSet.empty());
+        std::string osKeyForSet = m_osKeyForSet;
+        m_osKeyForSet.clear();
+        Set(osKeyForSet, val);
+        return *this;
+    }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+    template <class T>
+    inline CPLJSONObject &operator=(std::initializer_list<T> list);
+
+    JSONObjectH GetInternalHandle() const
+    {
+        return m_poJsonObject;
+    }
+
+    /*! @endcond */
+
+    // getters
+    std::string GetString(const std::string &osName,
+                          const std::string &osDefault = "") const;
+    double GetDouble(const std::string &osName, double dfDefault = 0.0) const;
+    int GetInteger(const std::string &osName, int nDefault = 0) const;
+    GInt64 GetLong(const std::string &osName, GInt64 nDefault = 0) const;
+    bool GetBool(const std::string &osName, bool bDefault = false) const;
+    std::string ToString(const std::string &osDefault = "") const;
+    double ToDouble(double dfDefault = 0.0) const;
+    int ToInteger(int nDefault = 0) const;
+    GInt64 ToLong(GInt64 nDefault = 0) const;
+    bool ToBool(bool bDefault = false) const;
+    CPLJSONArray ToArray() const;
+    std::string Format(PrettyFormat eFormat) const;
+
+    //
+    void Delete(const std::string &osName);
+    void DeleteNoSplitName(const std::string &osName);
+    CPLJSONArray GetArray(const std::string &osName) const;
+    CPLJSONObject GetObj(const std::string &osName) const;
+    CPLJSONObject GetObjNoSplitName(const std::string &osName) const;
+    CPLJSONObject operator[](const std::string &osName) const;
+    Type GetType() const;
+
+    /*! @cond Doxygen_Suppress */
+    std::string GetName() const
+    {
+        return m_osKey;
+    }
+
+    /*! @endcond */
+
+    std::vector<CPLJSONObject> GetChildren() const;
+    bool IsValid() const;
+    void Deinit();
+
+  protected:
+    /*! @cond Doxygen_Suppress */
+    CPLJSONObject GetObjectByPath(const std::string &osPath,
+                                  std::string &osName) const;
+    /*! @endcond */
+
+  private:
+    JSONObjectH m_poJsonObject = nullptr;
+    std::string m_osKey{};
+    std::string m_osKeyForSet{};
+};
+
+/**
+ * @brief The JSONArray class JSON array from JSONDocument
+ */
+class CPL_DLL CPLJSONArray : public CPLJSONObject
+{
+    friend class CPLJSONObject;
+    friend class CPLJSONDocument;
+
+  public:
+    /*! @cond Doxygen_Suppress */
+    CPLJSONArray();
+    explicit CPLJSONArray(const std::string &osName);
+    explicit CPLJSONArray(const CPLJSONObject &other);
+
+    /** Constructor from a list of initial values */
+    template <class T> static CPLJSONArray Build(std::initializer_list<T> list)
+    {
+        CPLJSONArray oArray;
+        for (const auto &val : list)
+            oArray.Add(val);
+        return oArray;
+    }
+
+  private:
+    explicit CPLJSONArray(const std::string &osName, JSONObjectH poJsonObject);
+
+    class CPL_DLL ConstIterator
+    {
+        const CPLJSONArray &m_oSelf;
+        int m_nIdx;
+        mutable CPLJSONObject m_oObj{};
+
+      public:
+        using iterator_category = std::input_iterator_tag;
+        using value_type = CPLJSONObject;
+        using difference_type = std::ptrdiff_t;
+        using pointer = CPLJSONObject *;
+        using reference = CPLJSONObject &;
+
+        ConstIterator(const CPLJSONArray &oSelf, bool bStart)
+            : m_oSelf(oSelf), m_nIdx(bStart ? 0 : oSelf.Size())
+        {
+        }
+
+        ConstIterator(const ConstIterator &) = default;
+
+        ConstIterator &operator=(const ConstIterator &other)
+        {
+            if (this != &other)
+            {
+                CPLAssert(&m_oSelf == &(other.m_oSelf));
+                m_nIdx = other.m_nIdx;
+                m_oObj = other.m_oObj;
+            }
+            return *this;
+        }
+
+        ~ConstIterator() = default;
+
+        CPLJSONObject &operator*() const
+        {
+            m_oObj = m_oSelf[m_nIdx];
+            return m_oObj;
+        }
+
+        ConstIterator &operator++()
+        {
+            m_nIdx++;
+            return *this;
+        }
+
+        bool operator==(const ConstIterator &it) const
+        {
+            return m_nIdx == it.m_nIdx;
+        }
+
+        bool operator!=(const ConstIterator &it) const
+        {
+            return m_nIdx != it.m_nIdx;
+        }
+    };
+
+    /*! @endcond */
+  public:
+    int Size() const;
+
+    //! Return the size of the array
+    inline size_t size() const
+    {
+        return static_cast<size_t>(Size());
+    }
+
+    void AddNull();
+    void Add(const CPLJSONObject &oValue);
+    void Add(const std::string &osValue);
+#if defined(DOXYGEN_SKIP) || __cplusplus >= 201703L ||                         \
+    (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+
+    void Add(std::string_view svValue);
+#endif
+    void Add(const char *pszValue);
+    void Add(double dfValue);
+    void Add(int nValue);
+    void Add(GInt64 nValue);
+    void Add(uint64_t nValue);
+    void Add(bool bValue);
+
+    CPLJSONObject operator[](int nIndex);
+    const CPLJSONObject operator[](int nIndex) const;
+
+    CPLJSONObject operator[](size_t nIndex);
+    const CPLJSONObject operator[](size_t nIndex) const;
+
+    /** Iterator to first element */
+    ConstIterator begin() const
+    {
+        return ConstIterator(*this, true);
+    }
+
+    /** Iterator to after last element */
+    ConstIterator end() const
+    {
+        return ConstIterator(*this, false);
+    }
+};
+
+/**
+ * @brief The CPLJSONDocument class Wrapper class around json-c library
+ */
+class CPL_DLL CPLJSONDocument
+{
+  public:
+    /*! @cond Doxygen_Suppress */
+    CPLJSONDocument();
+    ~CPLJSONDocument();
+    CPLJSONDocument(const CPLJSONDocument &other);
+    CPLJSONDocument &operator=(const CPLJSONDocument &other);
+    CPLJSONDocument(CPLJSONDocument &&other);
+    CPLJSONDocument &operator=(CPLJSONDocument &&other);
+    /*! @endcond */
+
+    bool Save(const std::string &osPath) const;
+    std::string SaveAsString() const;
+
+    CPLJSONObject GetRoot();
+    const CPLJSONObject GetRoot() const;
+    void SetRoot(const CPLJSONObject &oRoot);
+    bool Load(const std::string &osPath);
+    bool LoadMemory(const std::string &osStr);
+    bool LoadMemory(const GByte *pabyData, int nLength = -1);
+    bool LoadChunks(const std::string &osPath, size_t nChunkSize = 16384,
+                    GDALProgressFunc pfnProgress = nullptr,
+                    void *pProgressArg = nullptr);
+    bool LoadUrl(const std::string &osUrl, const char *const *papszOptions,
+                 GDALProgressFunc pfnProgress = nullptr,
+                 void *pProgressArg = nullptr);
+
+  private:
+    mutable JSONObjectH m_poRootJsonObject;
+};
+
+/*! @cond Doxygen_Suppress */
+template <class T>
+inline CPLJSONObject &CPLJSONObject::operator=(std::initializer_list<T> list)
+{
+    return operator=(CPLJSONArray::Build(list));
+}
+
+/*! @endcond */
+
+CPLStringList CPLParseKeyValueJson(const char *pszJson);
+
+#endif  // CPL_JSON_H_INCLUDED

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

@@ -0,0 +1,58 @@
+/**********************************************************************
+ *
+ * Name:     cpl_list.h
+ * Project:  CPL - Common Portability Library
+ * Purpose:  List functions.
+ * Author:   Andrey Kiselev, dron@remotesensing.org
+ *
+ **********************************************************************
+ * Copyright (c) 2003, Andrey Kiselev <dron@remotesensing.org>
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+#ifndef CPL_LIST_H_INCLUDED
+#define CPL_LIST_H_INCLUDED
+
+#include "cpl_port.h"
+
+/**
+ * \file cpl_list.h
+ *
+ * Simplest list implementation.  List contains only pointers to stored
+ * objects, not objects itself. All operations regarding allocation and
+ * freeing memory for objects should be performed by the caller.
+ *
+ */
+
+CPL_C_START
+
+/** List element structure. */
+typedef struct _CPLList CPLList;
+
+/** List element structure. */
+struct _CPLList
+{
+    /*! Pointer to the data object. Should be allocated and freed by the
+     * caller.
+     * */
+    void *pData;
+    /*! Pointer to the next element in list. NULL, if current element is the
+     * last one.
+     */
+    struct _CPLList *psNext;
+};
+
+CPLList CPL_DLL *CPLListAppend(CPLList *psList, void *pData);
+CPLList CPL_DLL *CPLListInsert(CPLList *psList, void *pData, int nPosition);
+CPLList CPL_DLL *CPLListGetLast(CPLList *psList);
+CPLList CPL_DLL *CPLListGet(CPLList *const psList, int nPosition);
+int CPL_DLL CPLListCount(const CPLList *psList);
+CPLList CPL_DLL *CPLListRemove(CPLList *psList, int nPosition);
+void CPL_DLL CPLListDestroy(CPLList *psList);
+CPLList CPL_DLL *CPLListGetNext(const CPLList *psElement);
+void CPL_DLL *CPLListGetData(const CPLList *psElement);
+
+CPL_C_END
+
+#endif /* CPL_LIST_H_INCLUDED */

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

@@ -0,0 +1,210 @@
+/**********************************************************************
+ *
+ * Project:  CPL - Common Portability Library
+ * Purpose:  Declarations for MiniXML Handler.
+ * Author:   Frank Warmerdam, warmerdam@pobox.com
+ *
+ **********************************************************************
+ * Copyright (c) 2001, Frank Warmerdam
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+#ifndef CPL_MINIXML_H_INCLUDED
+#define CPL_MINIXML_H_INCLUDED
+
+#include "cpl_port.h"
+
+/**
+ * \file cpl_minixml.h
+ *
+ * Definitions for CPL mini XML Parser/Serializer.
+ */
+
+CPL_C_START
+
+/** XML node type */
+typedef enum
+{
+    /*! Node is an element */ CXT_Element = 0,
+    /*! Node is a raw text value */ CXT_Text = 1,
+    /*! Node is attribute */ CXT_Attribute = 2,
+    /*! Node is an XML comment. */ CXT_Comment = 3,
+    /*! Node is a special literal */ CXT_Literal = 4
+} CPLXMLNodeType;
+
+/*! @cond Doxygen_Suppress */
+typedef struct CPLXMLNode CPLXMLNode;
+
+/*! @endcond */
+
+/**
+ * Document node structure.
+ *
+ * This C structure is used to hold a single text fragment representing a
+ * component of the document when parsed.   It should be allocated with the
+ * appropriate CPL function, and freed with CPLDestroyXMLNode().  The structure
+ * contents should not normally be altered by application code, but may be
+ * freely examined by application code.
+ *
+ * Using the psChild and psNext pointers, a hierarchical tree structure
+ * for a document can be represented as a tree of CPLXMLNode structures.
+ */
+struct CPLXMLNode
+{
+    /**
+     * \brief Node type
+     *
+     * One of CXT_Element, CXT_Text, CXT_Attribute, CXT_Comment,
+     * or CXT_Literal.
+     */
+    CPLXMLNodeType eType;
+
+    /**
+     * \brief Node value
+     *
+     * For CXT_Element this is the name of the element, without the angle
+     * brackets.  Note there is a single CXT_Element even when the document
+     * contains a start and end element tag.  The node represents the pair.
+     * All text or other elements between the start and end tag will appear
+     * as children nodes of this CXT_Element node.
+     *
+     * For CXT_Attribute the pszValue is the attribute name.  The value of
+     * the attribute will be a CXT_Text child.
+     *
+     * For CXT_Text this is the text itself (value of an attribute, or a
+     * text fragment between an element start and end tags.
+     *
+     * For CXT_Literal it is all the literal text.  Currently this is just
+     * used for !DOCTYPE lines, and the value would be the entire line.
+     *
+     * For CXT_Comment the value is all the literal text within the comment,
+     * but not including the comment start/end indicators ("<--" and "-->").
+     */
+    char *pszValue;
+
+    /**
+     * \brief Next sibling.
+     *
+     * Pointer to next sibling, that is the next node appearing after this
+     * one that has the same parent as this node.  NULL if this node is the
+     * last child of the parent element.
+     */
+    struct CPLXMLNode *psNext;
+
+    /**
+     * \brief Child node.
+     *
+     * Pointer to first child node, if any.  Only CXT_Element and CXT_Attribute
+     * nodes should have children.  For CXT_Attribute it should be a single
+     * CXT_Text value node, while CXT_Element can have any kind of child.
+     * The full list of children for a node are identified by walking the
+     * psNext's starting with the psChild node.
+     */
+
+    struct CPLXMLNode *psChild;
+};
+
+CPLXMLNode CPL_DLL *CPLParseXMLString(const char *);
+void CPL_DLL CPLDestroyXMLNode(CPLXMLNode *);
+CPLXMLNode CPL_DLL *CPLGetXMLNode(CPLXMLNode *poRoot, const char *pszPath);
+#if defined(__cplusplus) && !defined(CPL_SUPRESS_CPLUSPLUS)
+/*! @cond Doxygen_Suppress */
+extern "C++"
+{
+    inline const CPLXMLNode *CPLGetXMLNode(const CPLXMLNode *poRoot,
+                                           const char *pszPath)
+    {
+        return const_cast<const CPLXMLNode *>(
+            CPLGetXMLNode(const_cast<CPLXMLNode *>(poRoot), pszPath));
+    }
+}
+/*! @endcond */
+#endif
+CPLXMLNode CPL_DLL *CPLSearchXMLNode(CPLXMLNode *poRoot, const char *pszTarget);
+#if defined(__cplusplus) && !defined(CPL_SUPRESS_CPLUSPLUS)
+/*! @cond Doxygen_Suppress */
+extern "C++"
+{
+    inline const CPLXMLNode *CPLSearchXMLNode(const CPLXMLNode *poRoot,
+                                              const char *pszTarget)
+    {
+        return const_cast<const CPLXMLNode *>(
+            CPLSearchXMLNode(const_cast<CPLXMLNode *>(poRoot), pszTarget));
+    }
+}
+/*! @endcond */
+#endif
+const char CPL_DLL *CPLGetXMLValue(const CPLXMLNode *poRoot,
+                                   const char *pszPath, const char *pszDefault);
+CPLXMLNode CPL_DLL *CPLCreateXMLNode(CPLXMLNode *poParent, CPLXMLNodeType eType,
+                                     const char *pszText);
+char CPL_DLL *CPLSerializeXMLTree(const CPLXMLNode *psNode);
+void CPL_DLL CPLAddXMLChild(CPLXMLNode *psParent, CPLXMLNode *psChild);
+int CPL_DLL CPLRemoveXMLChild(CPLXMLNode *psParent, CPLXMLNode *psChild);
+void CPL_DLL CPLAddXMLSibling(CPLXMLNode *psOlderSibling,
+                              CPLXMLNode *psNewSibling);
+CPLXMLNode CPL_DLL *CPLCreateXMLElementAndValue(CPLXMLNode *psParent,
+                                                const char *pszName,
+                                                const char *pszValue);
+void CPL_DLL CPLAddXMLAttributeAndValue(CPLXMLNode *psParent,
+                                        const char *pszName,
+                                        const char *pszValue);
+CPLXMLNode CPL_DLL *CPLCloneXMLTree(const CPLXMLNode *psTree);
+int CPL_DLL CPLSetXMLValue(CPLXMLNode *psRoot, const char *pszPath,
+                           const char *pszValue);
+void CPL_DLL CPLStripXMLNamespace(CPLXMLNode *psRoot, const char *pszNameSpace,
+                                  int bRecurse);
+void CPL_DLL CPLCleanXMLElementName(char *);
+
+CPLXMLNode CPL_DLL *CPLParseXMLFile(const char *pszFilename);
+int CPL_DLL CPLSerializeXMLTreeToFile(const CPLXMLNode *psTree,
+                                      const char *pszFilename);
+
+size_t CPL_DLL CPLXMLNodeGetRAMUsageEstimate(const CPLXMLNode *psNode);
+
+CPL_C_END
+
+#if defined(__cplusplus) && !defined(CPL_SUPRESS_CPLUSPLUS)
+
+extern "C++"
+{
+#ifndef DOXYGEN_SKIP
+#include <memory>
+#endif
+
+    /*! @cond Doxygen_Suppress */
+    struct CPL_DLL CPLXMLTreeCloserDeleter
+    {
+        void operator()(CPLXMLNode *psNode) const
+        {
+            CPLDestroyXMLNode(psNode);
+        }
+    };
+
+    /*! @endcond */
+
+    /** Manage a tree of XML nodes so that all nodes are freed when the instance
+     * goes out of scope.  Only the top level node should be in a
+     * CPLXMLTreeCloser.
+     */
+    class CPL_DLL CPLXMLTreeCloser
+        : public std::unique_ptr<CPLXMLNode, CPLXMLTreeCloserDeleter>
+    {
+      public:
+        /** Constructor */
+        explicit CPLXMLTreeCloser(CPLXMLNode *data)
+            : std::unique_ptr<CPLXMLNode, CPLXMLTreeCloserDeleter>(data)
+        {
+        }
+
+        /** Returns a pointer to the document (root) element
+         * @return the node pointer */
+        CPLXMLNode *getDocumentElement();
+    };
+
+}  // extern "C++"
+
+#endif /* __cplusplus */
+
+#endif /* CPL_MINIXML_H_INCLUDED */