@cpp.js/package-gdal 1.0.0-beta.21 → 1.0.0-beta.23

package/dist/prebuilt/Android-x86_64/include/cpl_minixml.h

@@ -0,0 +1,211 @@
+/**********************************************************************
+ * $Id$
+ *
+ * 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 */

package/dist/prebuilt/Android-x86_64/include/cpl_multiproc.h

@@ -0,0 +1,241 @@
+/**********************************************************************
+ * $Id$
+ *
+ * Project:  CPL - Common Portability Library
+ * Purpose:  CPL Multi-Threading, and process handling portability functions.
+ * Author:   Frank Warmerdam, warmerdam@pobox.com
+ *
+ **********************************************************************
+ * Copyright (c) 2002, Frank Warmerdam
+ * Copyright (c) 2008-2013, Even Rouault <even dot rouault at spatialys.com>
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+#ifndef CPL_MULTIPROC_H_INCLUDED_
+#define CPL_MULTIPROC_H_INCLUDED_
+
+#include "cpl_port.h"
+
+/*
+** There are three primary implementations of the multi-process support
+** controlled by one of CPL_MULTIPROC_WIN32, CPL_MULTIPROC_PTHREAD or
+** CPL_MULTIPROC_STUB being defined.  If none are defined, the stub
+** implementation will be used.
+*/
+
+#if defined(_WIN32) && !defined(CPL_MULTIPROC_STUB)
+#define CPL_MULTIPROC_WIN32
+/* MinGW can have pthread support, so disable it to avoid issues */
+/* in cpl_multiproc.cpp */
+#undef CPL_MULTIPROC_PTHREAD
+#endif
+
+#if !defined(CPL_MULTIPROC_WIN32) && !defined(CPL_MULTIPROC_PTHREAD) &&        \
+    !defined(CPL_MULTIPROC_STUB) && !defined(CPL_MULTIPROC_NONE)
+#define CPL_MULTIPROC_STUB
+#endif
+
+CPL_C_START
+
+typedef void (*CPLThreadFunc)(void *);
+
+void CPL_DLL *CPLLockFile(const char *pszPath, double dfWaitInSeconds);
+void CPL_DLL CPLUnlockFile(void *hLock);
+
+typedef struct _CPLMutex CPLMutex;
+typedef struct _CPLCond CPLCond;
+typedef struct _CPLJoinableThread CPLJoinableThread;
+
+/* Options for CPLCreateMutexEx() and CPLCreateOrAcquireMutexEx() */
+#define CPL_MUTEX_RECURSIVE 0
+#define CPL_MUTEX_ADAPTIVE 1
+#define CPL_MUTEX_REGULAR 2
+
+CPLMutex CPL_DLL *CPLCreateMutex(void);           /* returned acquired */
+CPLMutex CPL_DLL *CPLCreateMutexEx(int nOptions); /* returned acquired */
+int CPL_DLL CPLCreateOrAcquireMutex(CPLMutex **, double dfWaitInSeconds);
+int CPL_DLL CPLCreateOrAcquireMutexEx(CPLMutex **, double dfWaitInSeconds,
+                                      int nOptions);
+int CPL_DLL CPLAcquireMutex(CPLMutex *hMutex, double dfWaitInSeconds);
+void CPL_DLL CPLReleaseMutex(CPLMutex *hMutex);
+void CPL_DLL CPLDestroyMutex(CPLMutex *hMutex);
+void CPL_DLL CPLCleanupMasterMutex(void);
+
+CPLCond CPL_DLL *CPLCreateCond(void);
+void CPL_DLL CPLCondWait(CPLCond *hCond, CPLMutex *hMutex);
+
+typedef enum
+{
+    COND_TIMED_WAIT_COND,
+    COND_TIMED_WAIT_TIME_OUT,
+    COND_TIMED_WAIT_OTHER
+} CPLCondTimedWaitReason;
+
+CPLCondTimedWaitReason CPL_DLL CPLCondTimedWait(CPLCond *hCond,
+                                                CPLMutex *hMutex,
+                                                double dfWaitInSeconds);
+void CPL_DLL CPLCondSignal(CPLCond *hCond);
+void CPL_DLL CPLCondBroadcast(CPLCond *hCond);
+void CPL_DLL CPLDestroyCond(CPLCond *hCond);
+
+/** Contrary to what its name suggests, CPLGetPID() actually returns the thread
+ * id */
+GIntBig CPL_DLL CPLGetPID(void);
+int CPL_DLL CPLGetCurrentProcessID(void);
+int CPL_DLL CPLCreateThread(CPLThreadFunc pfnMain, void *pArg);
+CPLJoinableThread CPL_DLL *CPLCreateJoinableThread(CPLThreadFunc pfnMain,
+                                                   void *pArg);
+void CPL_DLL CPLJoinThread(CPLJoinableThread *hJoinableThread);
+void CPL_DLL CPLSleep(double dfWaitInSeconds);
+
+const char CPL_DLL *CPLGetThreadingModel(void);
+
+int CPL_DLL CPLGetNumCPUs(void);
+
+typedef struct _CPLLock CPLLock;
+
+/* Currently LOCK_ADAPTIVE_MUTEX is Linux-only and LOCK_SPIN only available */
+/* on systems with pthread_spinlock API (so not MacOsX). If a requested type */
+/* isn't available, it fallbacks to LOCK_RECURSIVE_MUTEX */
+typedef enum
+{
+    LOCK_RECURSIVE_MUTEX,
+    LOCK_ADAPTIVE_MUTEX,
+    LOCK_SPIN
+} CPLLockType;
+
+CPLLock CPL_DLL *CPLCreateLock(CPLLockType eType); /* returned NON acquired */
+int CPL_DLL CPLCreateOrAcquireLock(CPLLock **, CPLLockType eType);
+int CPL_DLL CPLAcquireLock(CPLLock *);
+void CPL_DLL CPLReleaseLock(CPLLock *);
+void CPL_DLL CPLDestroyLock(CPLLock *);
+void CPL_DLL CPLLockSetDebugPerf(
+    CPLLock *,
+    int bEnableIn); /* only available on x86/x86_64 with GCC for now */
+
+CPL_C_END
+
+#if defined(__cplusplus) && !defined(CPL_SUPRESS_CPLUSPLUS)
+
+/* Instantiates the mutex if not already done. The parameter x should be a
+ * (void**). */
+#define CPLMutexHolderD(x) CPLMutexHolder oHolder(x, 1000.0, __FILE__, __LINE__)
+
+/* Instantiates the mutex with options if not already done. */
+/* The parameter x should be a (void**). */
+#define CPLMutexHolderExD(x, nOptions)                                         \
+    CPLMutexHolder oHolder(x, 1000.0, __FILE__, __LINE__, nOptions)
+
+/* This variant assumes the mutex has already been created. If not, it will */
+/* be a no-op. The parameter x should be a (void*) */
+#define CPLMutexHolderOptionalLockD(x)                                         \
+    CPLMutexHolder oHolder(x, 1000.0, __FILE__, __LINE__)
+
+/** Object to hold a mutex */
+class CPL_DLL CPLMutexHolder
+{
+  private:
+    CPLMutex *hMutex = nullptr;
+    // Only used for debugging.
+    const char *pszFile = nullptr;
+    int nLine = 0;
+
+    CPL_DISALLOW_COPY_ASSIGN(CPLMutexHolder)
+
+  public:
+    /** Instantiates the mutex if not already done. */
+    explicit CPLMutexHolder(CPLMutex **phMutex, double dfWaitInSeconds = 1000.0,
+                            const char *pszFile = __FILE__,
+                            int nLine = __LINE__,
+                            int nOptions = CPL_MUTEX_RECURSIVE);
+
+    /** This variant assumes the mutex has already been created. If not, it will
+     * be a no-op */
+    explicit CPLMutexHolder(CPLMutex *hMutex, double dfWaitInSeconds = 1000.0,
+                            const char *pszFile = __FILE__,
+                            int nLine = __LINE__);
+
+    ~CPLMutexHolder();
+};
+
+/* Instantiates the lock if not already done. The parameter x should be a
+ * (CPLLock**). */
+#define CPLLockHolderD(x, eType)                                               \
+    CPLLockHolder oHolder(x, eType, __FILE__, __LINE__);
+
+/* This variant assumes the lock has already been created. If not, it will */
+/* be a no-op. The parameter should be (CPLLock*) */
+#define CPLLockHolderOptionalLockD(x)                                          \
+    CPLLockHolder oHolder(x, __FILE__, __LINE__);
+
+/** Object to hold a lock */
+class CPL_DLL CPLLockHolder
+{
+  private:
+    CPLLock *hLock = nullptr;
+    const char *pszFile = nullptr;
+    int nLine = 0;
+
+    CPL_DISALLOW_COPY_ASSIGN(CPLLockHolder)
+
+  public:
+    /** Instantiates the lock if not already done. */
+    CPLLockHolder(CPLLock **phSpin, CPLLockType eType,
+                  const char *pszFile = __FILE__, int nLine = __LINE__);
+
+    /** This variant assumes the lock has already been created. If not, it will
+     * be a no-op */
+    explicit CPLLockHolder(CPLLock *hSpin, const char *pszFile = __FILE__,
+                           int nLine = __LINE__);
+
+    ~CPLLockHolder();
+};
+
+#endif /* def __cplusplus */
+
+/* -------------------------------------------------------------------- */
+/*      Thread local storage.                                           */
+/* -------------------------------------------------------------------- */
+
+#define CTLS_RLBUFFERINFO 1             /* cpl_conv.cpp */
+#define CTLS_WIN32_COND 2               /* cpl_multiproc.cpp */
+#define CTLS_CSVTABLEPTR 3              /* cpl_csv.cpp */
+#define CTLS_CSVDEFAULTFILENAME 4       /* cpl_csv.cpp */
+#define CTLS_ERRORCONTEXT 5             /* cpl_error.cpp */
+#define CTLS_VSICURL_CACHEDCONNECTION 6 /* cpl_vsil_curl.cpp */
+#define CTLS_PATHBUF 7                  /* cpl_path.cpp */
+#define CTLS_ABSTRACTARCHIVE_SPLIT 8    /* cpl_vsil_abstract_archive.cpp */
+#define CTLS_GDALOPEN_ANTIRECURSION 9   /* gdaldataset.cpp */
+#define CTLS_CPLSPRINTF 10              /* cpl_string.h */
+#define CTLS_RESPONSIBLEPID 11          /* gdaldataset.cpp */
+#define CTLS_VERSIONINFO 12             /* gdal_misc.cpp */
+#define CTLS_VERSIONINFO_LICENCE 13     /* gdal_misc.cpp */
+#define CTLS_CONFIGOPTIONS 14           /* cpl_conv.cpp */
+#define CTLS_FINDFILE 15                /* cpl_findfile.cpp */
+#define CTLS_VSIERRORCONTEXT 16         /* cpl_vsi_error.cpp */
+/* 17: unused */
+#define CTLS_PROJCONTEXTHOLDER 18      /* ogr_proj_p.cpp */
+#define CTLS_GDALDEFAULTOVR_ANTIREC 19 /* gdaldefaultoverviews.cpp */
+#define CTLS_HTTPFETCHCALLBACK 20      /* cpl_http.cpp */
+
+#define CTLS_MAX 32
+
+CPL_C_START
+void CPL_DLL *CPLGetTLS(int nIndex);
+void CPL_DLL *CPLGetTLSEx(int nIndex, int *pbMemoryErrorOccurred);
+void CPL_DLL CPLSetTLS(int nIndex, void *pData, int bFreeOnExit);
+
+/* Warning : the CPLTLSFreeFunc must not in any case directly or indirectly */
+/* use or fetch any TLS data, or a terminating thread will hang ! */
+typedef void (*CPLTLSFreeFunc)(void *pData);
+void CPL_DLL CPLSetTLSWithFreeFunc(int nIndex, void *pData,
+                                   CPLTLSFreeFunc pfnFree);
+void CPL_DLL CPLSetTLSWithFreeFuncEx(int nIndex, void *pData,
+                                     CPLTLSFreeFunc pfnFree,
+                                     int *pbMemoryErrorOccurred);
+
+void CPL_DLL CPLCleanupTLS(void);
+CPL_C_END
+
+#endif /* CPL_MULTIPROC_H_INCLUDED_ */