@cpp.js/package-gdal 1.0.0-beta.22 → 1.0.0

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

@@ -0,0 +1,1024 @@
+/******************************************************************************
+ * $Id$
+ *
+ * Project:  OpenGIS Simple Features Reference Implementation
+ * Purpose:  C API for OGR Geometry, Feature, Layers, DataSource and drivers.
+ * 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 OGR_API_H_INCLUDED
+#define OGR_API_H_INCLUDED
+
+/**
+ * \file ogr_api.h
+ *
+ * C API and defines for OGRFeature, OGRGeometry, and OGRDataSource
+ * related classes.
+ *
+ * See also: ogr_geometry.h, ogr_feature.h, ogrsf_frmts.h, ogr_featurestyle.h
+ */
+
+#include "cpl_progress.h"
+#include "cpl_minixml.h"
+#include "ogr_core.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+CPL_C_START
+
+bool CPL_DLL OGRGetGEOSVersion(int *pnMajor, int *pnMinor, int *pnPatch);
+
+/* -------------------------------------------------------------------- */
+/*      Geometry related functions (ogr_geometry.h)                     */
+/* -------------------------------------------------------------------- */
+#ifndef DEFINEH_OGRGeometryH
+/*! @cond Doxygen_Suppress */
+#define DEFINEH_OGRGeometryH
+/*! @endcond */
+#ifdef DEBUG
+typedef struct OGRGeometryHS *OGRGeometryH;
+#else
+/** Opaque type for a geometry */
+typedef void *OGRGeometryH;
+#endif
+#endif /* DEFINEH_OGRGeometryH */
+
+#ifndef DEFINED_OGRSpatialReferenceH
+/*! @cond Doxygen_Suppress */
+#define DEFINED_OGRSpatialReferenceH
+/*! @endcond */
+
+#ifndef DOXYGEN_XML
+#ifdef DEBUG
+typedef struct OGRSpatialReferenceHS *OGRSpatialReferenceH;
+typedef struct OGRCoordinateTransformationHS *OGRCoordinateTransformationH;
+#else
+/** Opaque type for a spatial reference system */
+typedef void *OGRSpatialReferenceH;
+/** Opaque type for a coordinate transformation object */
+typedef void *OGRCoordinateTransformationH;
+#endif
+#endif
+
+#endif /* DEFINED_OGRSpatialReferenceH */
+
+struct _CPLXMLNode;
+
+/* OGRGeomCoordinatePrecisionH */
+
+/** Value for a unknown coordinate precision. */
+#define OGR_GEOM_COORD_PRECISION_UNKNOWN 0
+
+/** Opaque type for OGRGeomCoordinatePrecision */
+typedef struct OGRGeomCoordinatePrecision *OGRGeomCoordinatePrecisionH;
+
+OGRGeomCoordinatePrecisionH CPL_DLL OGRGeomCoordinatePrecisionCreate(void);
+void CPL_DLL OGRGeomCoordinatePrecisionDestroy(OGRGeomCoordinatePrecisionH);
+double CPL_DLL
+    OGRGeomCoordinatePrecisionGetXYResolution(OGRGeomCoordinatePrecisionH);
+double CPL_DLL
+    OGRGeomCoordinatePrecisionGetZResolution(OGRGeomCoordinatePrecisionH);
+double CPL_DLL
+    OGRGeomCoordinatePrecisionGetMResolution(OGRGeomCoordinatePrecisionH);
+char CPL_DLL **
+    OGRGeomCoordinatePrecisionGetFormats(OGRGeomCoordinatePrecisionH);
+CSLConstList CPL_DLL OGRGeomCoordinatePrecisionGetFormatSpecificOptions(
+    OGRGeomCoordinatePrecisionH, const char *pszFormatName);
+void CPL_DLL OGRGeomCoordinatePrecisionSet(OGRGeomCoordinatePrecisionH,
+                                           double dfXYResolution,
+                                           double dfZResolution,
+                                           double dfMResolution);
+void CPL_DLL OGRGeomCoordinatePrecisionSetFromMeter(OGRGeomCoordinatePrecisionH,
+                                                    OGRSpatialReferenceH hSRS,
+                                                    double dfXYMeterResolution,
+                                                    double dfZMeterResolution,
+                                                    double dfMResolution);
+void CPL_DLL OGRGeomCoordinatePrecisionSetFormatSpecificOptions(
+    OGRGeomCoordinatePrecisionH, const char *pszFormatName,
+    CSLConstList papszOptions);
+
+/* From base OGRGeometry class */
+
+OGRErr CPL_DLL OGR_G_CreateFromWkb(const void *, OGRSpatialReferenceH,
+                                   OGRGeometryH *, int);
+OGRErr CPL_DLL OGR_G_CreateFromWkbEx(const void *, OGRSpatialReferenceH,
+                                     OGRGeometryH *, size_t);
+OGRErr CPL_DLL OGR_G_CreateFromWkt(char **, OGRSpatialReferenceH,
+                                   OGRGeometryH *);
+OGRErr CPL_DLL OGR_G_CreateFromFgf(const void *, OGRSpatialReferenceH,
+                                   OGRGeometryH *, int, int *);
+void CPL_DLL OGR_G_DestroyGeometry(OGRGeometryH);
+OGRGeometryH
+    CPL_DLL OGR_G_CreateGeometry(OGRwkbGeometryType) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_ApproximateArcAngles(
+    double dfCenterX, double dfCenterY, double dfZ, double dfPrimaryRadius,
+    double dfSecondaryAxis, double dfRotation, double dfStartAngle,
+    double dfEndAngle, double dfMaxAngleStepSizeDegrees) CPL_WARN_UNUSED_RESULT;
+
+OGRGeometryH CPL_DLL OGR_G_ForceToPolygon(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH
+    CPL_DLL OGR_G_ForceToLineString(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH
+    CPL_DLL OGR_G_ForceToMultiPolygon(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH
+    CPL_DLL OGR_G_ForceToMultiPoint(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH
+    CPL_DLL OGR_G_ForceToMultiLineString(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_ForceTo(OGRGeometryH hGeom,
+                                   OGRwkbGeometryType eTargetType,
+                                   char **papszOptions) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_RemoveLowerDimensionSubGeoms(
+    const OGRGeometryH hGeom) CPL_WARN_UNUSED_RESULT;
+
+int CPL_DLL OGR_G_GetDimension(OGRGeometryH);
+int CPL_DLL OGR_G_GetCoordinateDimension(OGRGeometryH);
+int CPL_DLL OGR_G_CoordinateDimension(OGRGeometryH);
+void CPL_DLL OGR_G_SetCoordinateDimension(OGRGeometryH, int);
+int CPL_DLL OGR_G_Is3D(OGRGeometryH);
+int CPL_DLL OGR_G_IsMeasured(OGRGeometryH);
+void CPL_DLL OGR_G_Set3D(OGRGeometryH, int);
+void CPL_DLL OGR_G_SetMeasured(OGRGeometryH, int);
+OGRGeometryH CPL_DLL OGR_G_Clone(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+void CPL_DLL OGR_G_GetEnvelope(OGRGeometryH, OGREnvelope *);
+void CPL_DLL OGR_G_GetEnvelope3D(OGRGeometryH, OGREnvelope3D *);
+OGRErr CPL_DLL OGR_G_ImportFromWkb(OGRGeometryH, const void *, int);
+OGRErr CPL_DLL OGR_G_ExportToWkb(OGRGeometryH, OGRwkbByteOrder,
+                                 unsigned char *);
+OGRErr CPL_DLL OGR_G_ExportToIsoWkb(OGRGeometryH, OGRwkbByteOrder,
+                                    unsigned char *);
+
+/** Opaque type for WKB export options */
+typedef struct OGRwkbExportOptions OGRwkbExportOptions;
+
+OGRwkbExportOptions CPL_DLL *OGRwkbExportOptionsCreate(void);
+void CPL_DLL OGRwkbExportOptionsDestroy(OGRwkbExportOptions *);
+void CPL_DLL OGRwkbExportOptionsSetByteOrder(OGRwkbExportOptions *,
+                                             OGRwkbByteOrder);
+void CPL_DLL OGRwkbExportOptionsSetVariant(OGRwkbExportOptions *,
+                                           OGRwkbVariant);
+void CPL_DLL OGRwkbExportOptionsSetPrecision(OGRwkbExportOptions *,
+                                             OGRGeomCoordinatePrecisionH);
+OGRErr CPL_DLL OGR_G_ExportToWkbEx(OGRGeometryH, unsigned char *,
+                                   const OGRwkbExportOptions *);
+
+int CPL_DLL OGR_G_WkbSize(OGRGeometryH hGeom);
+size_t CPL_DLL OGR_G_WkbSizeEx(OGRGeometryH hGeom);
+OGRErr CPL_DLL OGR_G_ImportFromWkt(OGRGeometryH, char **);
+OGRErr CPL_DLL OGR_G_ExportToWkt(OGRGeometryH, char **);
+OGRErr CPL_DLL OGR_G_ExportToIsoWkt(OGRGeometryH, char **);
+OGRwkbGeometryType CPL_DLL OGR_G_GetGeometryType(OGRGeometryH);
+const char CPL_DLL *OGR_G_GetGeometryName(OGRGeometryH);
+void CPL_DLL OGR_G_DumpReadable(OGRGeometryH, FILE *, const char *);
+void CPL_DLL OGR_G_FlattenTo2D(OGRGeometryH);
+void CPL_DLL OGR_G_CloseRings(OGRGeometryH);
+
+OGRGeometryH CPL_DLL OGR_G_CreateFromGML(const char *) CPL_WARN_UNUSED_RESULT;
+char CPL_DLL *OGR_G_ExportToGML(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+char CPL_DLL *OGR_G_ExportToGMLEx(OGRGeometryH,
+                                  char **papszOptions) CPL_WARN_UNUSED_RESULT;
+
+OGRGeometryH CPL_DLL OGR_G_CreateFromGMLTree(const CPLXMLNode *)
+    CPL_WARN_UNUSED_RESULT;
+CPLXMLNode CPL_DLL *OGR_G_ExportToGMLTree(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+CPLXMLNode CPL_DLL *
+    OGR_G_ExportEnvelopeToGMLTree(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+
+char CPL_DLL *OGR_G_ExportToKML(OGRGeometryH, const char *pszAltitudeMode)
+    CPL_WARN_UNUSED_RESULT;
+
+char CPL_DLL *OGR_G_ExportToJson(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+char CPL_DLL *OGR_G_ExportToJsonEx(OGRGeometryH,
+                                   char **papszOptions) CPL_WARN_UNUSED_RESULT;
+/** Create a OGR geometry from a GeoJSON geometry object */
+OGRGeometryH CPL_DLL OGR_G_CreateGeometryFromJson(const char *)
+    CPL_WARN_UNUSED_RESULT;
+/** Create a OGR geometry from a ESRI JSON geometry object */
+OGRGeometryH CPL_DLL OGR_G_CreateGeometryFromEsriJson(const char *)
+    CPL_WARN_UNUSED_RESULT;
+
+void CPL_DLL OGR_G_AssignSpatialReference(OGRGeometryH, OGRSpatialReferenceH);
+OGRSpatialReferenceH CPL_DLL OGR_G_GetSpatialReference(OGRGeometryH);
+OGRErr CPL_DLL OGR_G_Transform(OGRGeometryH, OGRCoordinateTransformationH);
+OGRErr CPL_DLL OGR_G_TransformTo(OGRGeometryH, OGRSpatialReferenceH);
+
+/** Opaque type for a geometry transformer. */
+typedef struct OGRGeomTransformer *OGRGeomTransformerH;
+OGRGeomTransformerH CPL_DLL
+OGR_GeomTransformer_Create(OGRCoordinateTransformationH,
+                           CSLConstList papszOptions) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL
+OGR_GeomTransformer_Transform(OGRGeomTransformerH hTransformer,
+                              OGRGeometryH hGeom) CPL_WARN_UNUSED_RESULT;
+void CPL_DLL OGR_GeomTransformer_Destroy(OGRGeomTransformerH hTransformer);
+
+OGRGeometryH CPL_DLL OGR_G_Simplify(OGRGeometryH hThis,
+                                    double tolerance) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_SimplifyPreserveTopology(
+    OGRGeometryH hThis, double tolerance) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL
+OGR_G_DelaunayTriangulation(OGRGeometryH hThis, double dfTolerance,
+                            int bOnlyEdges) CPL_WARN_UNUSED_RESULT;
+
+void CPL_DLL OGR_G_Segmentize(OGRGeometryH hGeom, double dfMaxLength);
+int CPL_DLL OGR_G_Intersects(OGRGeometryH, OGRGeometryH);
+int CPL_DLL OGR_G_Equals(OGRGeometryH, OGRGeometryH);
+/*int    CPL_DLL OGR_G_EqualsExact( OGRGeometryH, OGRGeometryH, double );*/
+int CPL_DLL OGR_G_Disjoint(OGRGeometryH, OGRGeometryH);
+int CPL_DLL OGR_G_Touches(OGRGeometryH, OGRGeometryH);
+int CPL_DLL OGR_G_Crosses(OGRGeometryH, OGRGeometryH);
+int CPL_DLL OGR_G_Within(OGRGeometryH, OGRGeometryH);
+int CPL_DLL OGR_G_Contains(OGRGeometryH, OGRGeometryH);
+int CPL_DLL OGR_G_Overlaps(OGRGeometryH, OGRGeometryH);
+
+OGRGeometryH CPL_DLL OGR_G_Boundary(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_ConvexHull(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_ConcaveHull(OGRGeometryH, double dfRatio,
+                                       bool bAllowHoles) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_Buffer(OGRGeometryH, double dfDist,
+                                  int nQuadSegs) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_BufferEx(OGRGeometryH, double dfDist,
+                                    CSLConstList papszOptions)
+    CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_Intersection(OGRGeometryH,
+                                        OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_Union(OGRGeometryH,
+                                 OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_UnionCascaded(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_UnaryUnion(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_PointOnSurface(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+/*OGRGeometryH CPL_DLL OGR_G_Polygonize( OGRGeometryH *, int);*/
+/*OGRGeometryH CPL_DLL OGR_G_Polygonizer_getCutEdges( OGRGeometryH *, int);*/
+/*OGRGeometryH CPL_DLL OGR_G_LineMerge( OGRGeometryH );*/
+
+OGRGeometryH CPL_DLL OGR_G_Difference(OGRGeometryH,
+                                      OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_SymDifference(OGRGeometryH,
+                                         OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+double CPL_DLL OGR_G_Distance(OGRGeometryH, OGRGeometryH);
+double CPL_DLL OGR_G_Distance3D(OGRGeometryH, OGRGeometryH);
+double CPL_DLL OGR_G_Length(OGRGeometryH);
+double CPL_DLL OGR_G_GeodesicLength(OGRGeometryH);
+double CPL_DLL OGR_G_Area(OGRGeometryH);
+double CPL_DLL OGR_G_GeodesicArea(OGRGeometryH);
+bool CPL_DLL OGR_G_IsClockwise(OGRGeometryH hGeom);
+int CPL_DLL OGR_G_Centroid(OGRGeometryH, OGRGeometryH);
+OGRGeometryH CPL_DLL OGR_G_Value(OGRGeometryH,
+                                 double dfDistance) CPL_WARN_UNUSED_RESULT;
+
+void CPL_DLL OGR_G_Empty(OGRGeometryH);
+int CPL_DLL OGR_G_IsEmpty(OGRGeometryH);
+int CPL_DLL OGR_G_IsValid(OGRGeometryH);
+/*char    CPL_DLL *OGR_G_IsValidReason( OGRGeometryH );*/
+OGRGeometryH CPL_DLL OGR_G_MakeValid(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_MakeValidEx(OGRGeometryH,
+                                       CSLConstList) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_Normalize(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+int CPL_DLL OGR_G_IsSimple(OGRGeometryH);
+int CPL_DLL OGR_G_IsRing(OGRGeometryH);
+
+/** This option causes OGR_G_SetPrecision()
+  * to not attempt at preserving the topology */
+#define OGR_GEOS_PREC_NO_TOPO (1 << 0)
+
+/** This option causes OGR_G_SetPrecision()
+  * to retain collapsed elements */
+#define OGR_GEOS_PREC_KEEP_COLLAPSED (1 << 1)
+
+OGRGeometryH CPL_DLL OGR_G_SetPrecision(OGRGeometryH, double dfGridSize,
+                                        int nFlags) CPL_WARN_UNUSED_RESULT;
+
+OGRGeometryH CPL_DLL OGR_G_Polygonize(OGRGeometryH) CPL_WARN_UNUSED_RESULT;
+
+/*! @cond Doxygen_Suppress */
+/* backward compatibility (non-standard methods) */
+int CPL_DLL OGR_G_Intersect(OGRGeometryH, OGRGeometryH)
+    CPL_WARN_DEPRECATED("Non standard method. Use OGR_G_Intersects() instead");
+int CPL_DLL OGR_G_Equal(OGRGeometryH, OGRGeometryH)
+    CPL_WARN_DEPRECATED("Non standard method. Use OGR_G_Equals() instead");
+OGRGeometryH CPL_DLL OGR_G_SymmetricDifference(OGRGeometryH, OGRGeometryH)
+    CPL_WARN_DEPRECATED(
+        "Non standard method. Use OGR_G_SymDifference() instead");
+double CPL_DLL OGR_G_GetArea(OGRGeometryH)
+    CPL_WARN_DEPRECATED("Non standard method. Use OGR_G_Area() instead");
+OGRGeometryH CPL_DLL OGR_G_GetBoundary(OGRGeometryH)
+    CPL_WARN_DEPRECATED("Non standard method. Use OGR_G_Boundary() instead");
+/*! @endcond */
+
+/* Methods for getting/setting vertices in points, line strings and rings */
+int CPL_DLL OGR_G_GetPointCount(OGRGeometryH);
+int CPL_DLL OGR_G_GetPoints(OGRGeometryH hGeom, void *pabyX, int nXStride,
+                            void *pabyY, int nYStride, void *pabyZ,
+                            int nZStride);
+int CPL_DLL OGR_G_GetPointsZM(OGRGeometryH hGeom, void *pabyX, int nXStride,
+                              void *pabyY, int nYStride, void *pabyZ,
+                              int nZStride, void *pabyM, int nMStride);
+double CPL_DLL OGR_G_GetX(OGRGeometryH, int);
+double CPL_DLL OGR_G_GetY(OGRGeometryH, int);
+double CPL_DLL OGR_G_GetZ(OGRGeometryH, int);
+double CPL_DLL OGR_G_GetM(OGRGeometryH, int);
+void CPL_DLL OGR_G_GetPoint(OGRGeometryH, int iPoint, double *, double *,
+                            double *);
+void CPL_DLL OGR_G_GetPointZM(OGRGeometryH, int iPoint, double *, double *,
+                              double *, double *);
+void CPL_DLL OGR_G_SetPointCount(OGRGeometryH hGeom, int nNewPointCount);
+void CPL_DLL OGR_G_SetPoint(OGRGeometryH, int iPoint, double, double, double);
+void CPL_DLL OGR_G_SetPoint_2D(OGRGeometryH, int iPoint, double, double);
+void CPL_DLL OGR_G_SetPointM(OGRGeometryH, int iPoint, double, double, double);
+void CPL_DLL OGR_G_SetPointZM(OGRGeometryH, int iPoint, double, double, double,
+                              double);
+void CPL_DLL OGR_G_AddPoint(OGRGeometryH, double, double, double);
+void CPL_DLL OGR_G_AddPoint_2D(OGRGeometryH, double, double);
+void CPL_DLL OGR_G_AddPointM(OGRGeometryH, double, double, double);
+void CPL_DLL OGR_G_AddPointZM(OGRGeometryH, double, double, double, double);
+void CPL_DLL OGR_G_SetPoints(OGRGeometryH hGeom, int nPointsIn,
+                             const void *pabyX, int nXStride, const void *pabyY,
+                             int nYStride, const void *pabyZ, int nZStride);
+void CPL_DLL OGR_G_SetPointsZM(OGRGeometryH hGeom, int nPointsIn,
+                               const void *pabyX, int nXStride,
+                               const void *pabyY, int nYStride,
+                               const void *pabyZ, int nZStride,
+                               const void *pabyM, int nMStride);
+void CPL_DLL OGR_G_SwapXY(OGRGeometryH hGeom);
+
+/* Methods for getting/setting rings and members collections */
+
+int CPL_DLL OGR_G_GetGeometryCount(OGRGeometryH);
+OGRGeometryH CPL_DLL OGR_G_GetGeometryRef(OGRGeometryH, int);
+OGRErr CPL_DLL OGR_G_AddGeometry(OGRGeometryH, OGRGeometryH);
+OGRErr CPL_DLL OGR_G_AddGeometryDirectly(OGRGeometryH, OGRGeometryH);
+OGRErr CPL_DLL OGR_G_RemoveGeometry(OGRGeometryH, int, int);
+
+int CPL_DLL OGR_G_HasCurveGeometry(OGRGeometryH, int bLookForNonLinear);
+OGRGeometryH CPL_DLL
+OGR_G_GetLinearGeometry(OGRGeometryH hGeom, double dfMaxAngleStepSizeDegrees,
+                        char **papszOptions) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_G_GetCurveGeometry(
+    OGRGeometryH hGeom, char **papszOptions) CPL_WARN_UNUSED_RESULT;
+
+OGRGeometryH CPL_DLL OGRBuildPolygonFromEdges(
+    OGRGeometryH hLinesAsCollection, int bBestEffort, int bAutoClose,
+    double dfTolerance, OGRErr *peErr) CPL_WARN_UNUSED_RESULT;
+
+/*! @cond Doxygen_Suppress */
+OGRErr CPL_DLL
+OGRSetGenerate_DB2_V72_BYTE_ORDER(int bGenerate_DB2_V72_BYTE_ORDER);
+
+int CPL_DLL OGRGetGenerate_DB2_V72_BYTE_ORDER(void);
+/*! @endcond */
+
+void CPL_DLL OGRSetNonLinearGeometriesEnabledFlag(int bFlag);
+int CPL_DLL OGRGetNonLinearGeometriesEnabledFlag(void);
+
+/** Opaque type for a prepared geometry */
+typedef struct _OGRPreparedGeometry *OGRPreparedGeometryH;
+
+int CPL_DLL OGRHasPreparedGeometrySupport(void);
+OGRPreparedGeometryH CPL_DLL OGRCreatePreparedGeometry(OGRGeometryH hGeom);
+void CPL_DLL OGRDestroyPreparedGeometry(OGRPreparedGeometryH hPreparedGeom);
+int CPL_DLL OGRPreparedGeometryIntersects(OGRPreparedGeometryH hPreparedGeom,
+                                          OGRGeometryH hOtherGeom);
+int CPL_DLL OGRPreparedGeometryContains(OGRPreparedGeometryH hPreparedGeom,
+                                        OGRGeometryH hOtherGeom);
+
+/* -------------------------------------------------------------------- */
+/*      Feature related (ogr_feature.h)                                 */
+/* -------------------------------------------------------------------- */
+
+#ifndef DEFINE_OGRFeatureH
+/*! @cond Doxygen_Suppress */
+#define DEFINE_OGRFeatureH
+/*! @endcond */
+#ifdef DEBUG
+typedef struct OGRFieldDefnHS *OGRFieldDefnH;
+typedef struct OGRFeatureDefnHS *OGRFeatureDefnH;
+typedef struct OGRFeatureHS *OGRFeatureH;
+typedef struct OGRStyleTableHS *OGRStyleTableH;
+#else
+/** Opaque type for a field definition (OGRFieldDefn) */
+typedef void *OGRFieldDefnH;
+/** Opaque type for a feature definition (OGRFeatureDefn) */
+typedef void *OGRFeatureDefnH;
+/** Opaque type for a feature (OGRFeature) */
+typedef void *OGRFeatureH;
+/** Opaque type for a style table (OGRStyleTable) */
+typedef void *OGRStyleTableH;
+#endif
+/** Opaque type for a geometry field definition (OGRGeomFieldDefn) */
+typedef struct OGRGeomFieldDefnHS *OGRGeomFieldDefnH;
+
+/** Opaque type for a field domain definition (OGRFieldDomain) */
+typedef struct OGRFieldDomainHS *OGRFieldDomainH;
+#endif /* DEFINE_OGRFeatureH */
+
+/* OGRFieldDefn */
+
+OGRFieldDefnH CPL_DLL OGR_Fld_Create(const char *,
+                                     OGRFieldType) CPL_WARN_UNUSED_RESULT;
+void CPL_DLL OGR_Fld_Destroy(OGRFieldDefnH);
+
+void CPL_DLL OGR_Fld_SetName(OGRFieldDefnH, const char *);
+const char CPL_DLL *OGR_Fld_GetNameRef(OGRFieldDefnH);
+void CPL_DLL OGR_Fld_SetAlternativeName(OGRFieldDefnH, const char *);
+const char CPL_DLL *OGR_Fld_GetAlternativeNameRef(OGRFieldDefnH);
+OGRFieldType CPL_DLL OGR_Fld_GetType(OGRFieldDefnH);
+void CPL_DLL OGR_Fld_SetType(OGRFieldDefnH, OGRFieldType);
+OGRFieldSubType CPL_DLL OGR_Fld_GetSubType(OGRFieldDefnH);
+void CPL_DLL OGR_Fld_SetSubType(OGRFieldDefnH, OGRFieldSubType);
+OGRJustification CPL_DLL OGR_Fld_GetJustify(OGRFieldDefnH);
+void CPL_DLL OGR_Fld_SetJustify(OGRFieldDefnH, OGRJustification);
+int CPL_DLL OGR_Fld_GetWidth(OGRFieldDefnH);
+void CPL_DLL OGR_Fld_SetWidth(OGRFieldDefnH, int);
+int CPL_DLL OGR_Fld_GetPrecision(OGRFieldDefnH);
+void CPL_DLL OGR_Fld_SetPrecision(OGRFieldDefnH, int);
+int CPL_DLL OGR_Fld_GetTZFlag(OGRFieldDefnH);
+void CPL_DLL OGR_Fld_SetTZFlag(OGRFieldDefnH, int);
+void CPL_DLL OGR_Fld_Set(OGRFieldDefnH, const char *, OGRFieldType, int, int,
+                         OGRJustification);
+int CPL_DLL OGR_Fld_IsIgnored(OGRFieldDefnH hDefn);
+void CPL_DLL OGR_Fld_SetIgnored(OGRFieldDefnH hDefn, int);
+int CPL_DLL OGR_Fld_IsNullable(OGRFieldDefnH hDefn);
+void CPL_DLL OGR_Fld_SetNullable(OGRFieldDefnH hDefn, int);
+int CPL_DLL OGR_Fld_IsUnique(OGRFieldDefnH hDefn);
+void CPL_DLL OGR_Fld_SetUnique(OGRFieldDefnH hDefn, int);
+const char CPL_DLL *OGR_Fld_GetDefault(OGRFieldDefnH hDefn);
+void CPL_DLL OGR_Fld_SetDefault(OGRFieldDefnH hDefn, const char *);
+int CPL_DLL OGR_Fld_IsDefaultDriverSpecific(OGRFieldDefnH hDefn);
+const char CPL_DLL *OGR_Fld_GetDomainName(OGRFieldDefnH hDefn);
+void CPL_DLL OGR_Fld_SetDomainName(OGRFieldDefnH hDefn, const char *);
+const char CPL_DLL *OGR_Fld_GetComment(OGRFieldDefnH hDefn);
+void CPL_DLL OGR_Fld_SetComment(OGRFieldDefnH hDefn, const char *);
+
+const char CPL_DLL *OGR_GetFieldTypeName(OGRFieldType);
+const char CPL_DLL *OGR_GetFieldSubTypeName(OGRFieldSubType);
+int CPL_DLL OGR_AreTypeSubTypeCompatible(OGRFieldType eType,
+                                         OGRFieldSubType eSubType);
+
+/* OGRGeomFieldDefnH */
+
+OGRGeomFieldDefnH CPL_DLL OGR_GFld_Create(const char *, OGRwkbGeometryType)
+    CPL_WARN_UNUSED_RESULT;
+void CPL_DLL OGR_GFld_Destroy(OGRGeomFieldDefnH);
+
+void CPL_DLL OGR_GFld_SetName(OGRGeomFieldDefnH, const char *);
+const char CPL_DLL *OGR_GFld_GetNameRef(OGRGeomFieldDefnH);
+
+OGRwkbGeometryType CPL_DLL OGR_GFld_GetType(OGRGeomFieldDefnH);
+void CPL_DLL OGR_GFld_SetType(OGRGeomFieldDefnH, OGRwkbGeometryType);
+
+OGRSpatialReferenceH CPL_DLL OGR_GFld_GetSpatialRef(OGRGeomFieldDefnH);
+void CPL_DLL OGR_GFld_SetSpatialRef(OGRGeomFieldDefnH,
+                                    OGRSpatialReferenceH hSRS);
+
+int CPL_DLL OGR_GFld_IsNullable(OGRGeomFieldDefnH hDefn);
+void CPL_DLL OGR_GFld_SetNullable(OGRGeomFieldDefnH hDefn, int);
+
+int CPL_DLL OGR_GFld_IsIgnored(OGRGeomFieldDefnH hDefn);
+void CPL_DLL OGR_GFld_SetIgnored(OGRGeomFieldDefnH hDefn, int);
+
+OGRGeomCoordinatePrecisionH
+    CPL_DLL OGR_GFld_GetCoordinatePrecision(OGRGeomFieldDefnH);
+void CPL_DLL OGR_GFld_SetCoordinatePrecision(OGRGeomFieldDefnH,
+                                             OGRGeomCoordinatePrecisionH);
+
+/* OGRFeatureDefn */
+
+OGRFeatureDefnH CPL_DLL OGR_FD_Create(const char *) CPL_WARN_UNUSED_RESULT;
+void CPL_DLL OGR_FD_Destroy(OGRFeatureDefnH);
+void CPL_DLL OGR_FD_Release(OGRFeatureDefnH);
+const char CPL_DLL *OGR_FD_GetName(OGRFeatureDefnH);
+int CPL_DLL OGR_FD_GetFieldCount(OGRFeatureDefnH);
+OGRFieldDefnH CPL_DLL OGR_FD_GetFieldDefn(OGRFeatureDefnH, int);
+int CPL_DLL OGR_FD_GetFieldIndex(OGRFeatureDefnH, const char *);
+void CPL_DLL OGR_FD_AddFieldDefn(OGRFeatureDefnH, OGRFieldDefnH);
+OGRErr CPL_DLL OGR_FD_DeleteFieldDefn(OGRFeatureDefnH hDefn, int iField);
+OGRErr CPL_DLL OGR_FD_ReorderFieldDefns(OGRFeatureDefnH hDefn,
+                                        const int *panMap);
+OGRwkbGeometryType CPL_DLL OGR_FD_GetGeomType(OGRFeatureDefnH);
+void CPL_DLL OGR_FD_SetGeomType(OGRFeatureDefnH, OGRwkbGeometryType);
+int CPL_DLL OGR_FD_IsGeometryIgnored(OGRFeatureDefnH);
+void CPL_DLL OGR_FD_SetGeometryIgnored(OGRFeatureDefnH, int);
+int CPL_DLL OGR_FD_IsStyleIgnored(OGRFeatureDefnH);
+void CPL_DLL OGR_FD_SetStyleIgnored(OGRFeatureDefnH, int);
+int CPL_DLL OGR_FD_Reference(OGRFeatureDefnH);
+int CPL_DLL OGR_FD_Dereference(OGRFeatureDefnH);
+int CPL_DLL OGR_FD_GetReferenceCount(OGRFeatureDefnH);
+
+int CPL_DLL OGR_FD_GetGeomFieldCount(OGRFeatureDefnH hFDefn);
+OGRGeomFieldDefnH CPL_DLL OGR_FD_GetGeomFieldDefn(OGRFeatureDefnH hFDefn,
+                                                  int i);
+int CPL_DLL OGR_FD_GetGeomFieldIndex(OGRFeatureDefnH hFDefn,
+                                     const char *pszName);
+
+void CPL_DLL OGR_FD_AddGeomFieldDefn(OGRFeatureDefnH hFDefn,
+                                     OGRGeomFieldDefnH hGFldDefn);
+OGRErr CPL_DLL OGR_FD_DeleteGeomFieldDefn(OGRFeatureDefnH hFDefn,
+                                          int iGeomField);
+int CPL_DLL OGR_FD_IsSame(OGRFeatureDefnH hFDefn, OGRFeatureDefnH hOtherFDefn);
+/* OGRFeature */
+
+OGRFeatureH CPL_DLL OGR_F_Create(OGRFeatureDefnH) CPL_WARN_UNUSED_RESULT;
+void CPL_DLL OGR_F_Destroy(OGRFeatureH);
+OGRFeatureDefnH CPL_DLL OGR_F_GetDefnRef(OGRFeatureH);
+
+OGRErr CPL_DLL OGR_F_SetGeometryDirectly(OGRFeatureH, OGRGeometryH);
+OGRErr CPL_DLL OGR_F_SetGeometry(OGRFeatureH, OGRGeometryH);
+OGRGeometryH CPL_DLL OGR_F_GetGeometryRef(OGRFeatureH);
+OGRGeometryH CPL_DLL OGR_F_StealGeometry(OGRFeatureH) CPL_WARN_UNUSED_RESULT;
+OGRGeometryH CPL_DLL OGR_F_StealGeometryEx(OGRFeatureH, int iGeomField)
+    CPL_WARN_UNUSED_RESULT;
+OGRFeatureH CPL_DLL OGR_F_Clone(OGRFeatureH) CPL_WARN_UNUSED_RESULT;
+int CPL_DLL OGR_F_Equal(OGRFeatureH, OGRFeatureH);
+
+int CPL_DLL OGR_F_GetFieldCount(OGRFeatureH);
+OGRFieldDefnH CPL_DLL OGR_F_GetFieldDefnRef(OGRFeatureH, int);
+int CPL_DLL OGR_F_GetFieldIndex(OGRFeatureH, const char *);
+
+int CPL_DLL OGR_F_IsFieldSet(OGRFeatureH, int);
+void CPL_DLL OGR_F_UnsetField(OGRFeatureH, int);
+
+int CPL_DLL OGR_F_IsFieldNull(OGRFeatureH, int);
+int CPL_DLL OGR_F_IsFieldSetAndNotNull(OGRFeatureH, int);
+void CPL_DLL OGR_F_SetFieldNull(OGRFeatureH, int);
+
+OGRField CPL_DLL *OGR_F_GetRawFieldRef(OGRFeatureH, int);
+
+int CPL_DLL OGR_RawField_IsUnset(const OGRField *);
+int CPL_DLL OGR_RawField_IsNull(const OGRField *);
+void CPL_DLL OGR_RawField_SetUnset(OGRField *);
+void CPL_DLL OGR_RawField_SetNull(OGRField *);
+
+int CPL_DLL OGR_F_GetFieldAsInteger(OGRFeatureH, int);
+GIntBig CPL_DLL OGR_F_GetFieldAsInteger64(OGRFeatureH, int);
+double CPL_DLL OGR_F_GetFieldAsDouble(OGRFeatureH, int);
+const char CPL_DLL *OGR_F_GetFieldAsString(OGRFeatureH, int);
+const char CPL_DLL *OGR_F_GetFieldAsISO8601DateTime(OGRFeatureH, int,
+                                                    CSLConstList);
+const int CPL_DLL *OGR_F_GetFieldAsIntegerList(OGRFeatureH, int, int *);
+const GIntBig CPL_DLL *OGR_F_GetFieldAsInteger64List(OGRFeatureH, int, int *);
+const double CPL_DLL *OGR_F_GetFieldAsDoubleList(OGRFeatureH, int, int *);
+char CPL_DLL **OGR_F_GetFieldAsStringList(OGRFeatureH, int);
+GByte CPL_DLL *OGR_F_GetFieldAsBinary(OGRFeatureH, int, int *);
+int CPL_DLL OGR_F_GetFieldAsDateTime(OGRFeatureH, int, int *, int *, int *,
+                                     int *, int *, int *, int *);
+int CPL_DLL OGR_F_GetFieldAsDateTimeEx(OGRFeatureH hFeat, int iField,
+                                       int *pnYear, int *pnMonth, int *pnDay,
+                                       int *pnHour, int *pnMinute,
+                                       float *pfSecond, int *pnTZFlag);
+
+void CPL_DLL OGR_F_SetFieldInteger(OGRFeatureH, int, int);
+void CPL_DLL OGR_F_SetFieldInteger64(OGRFeatureH, int, GIntBig);
+void CPL_DLL OGR_F_SetFieldDouble(OGRFeatureH, int, double);
+void CPL_DLL OGR_F_SetFieldString(OGRFeatureH, int, const char *);
+void CPL_DLL OGR_F_SetFieldIntegerList(OGRFeatureH, int, int, const int *);
+void CPL_DLL OGR_F_SetFieldInteger64List(OGRFeatureH, int, int,
+                                         const GIntBig *);
+void CPL_DLL OGR_F_SetFieldDoubleList(OGRFeatureH, int, int, const double *);
+void CPL_DLL OGR_F_SetFieldStringList(OGRFeatureH, int, CSLConstList);
+void CPL_DLL OGR_F_SetFieldRaw(OGRFeatureH, int, const OGRField *);
+void CPL_DLL OGR_F_SetFieldBinary(OGRFeatureH, int, int, const void *);
+void CPL_DLL OGR_F_SetFieldDateTime(OGRFeatureH, int, int, int, int, int, int,
+                                    int, int);
+void CPL_DLL OGR_F_SetFieldDateTimeEx(OGRFeatureH, int, int, int, int, int, int,
+                                      float, int);
+
+int CPL_DLL OGR_F_GetGeomFieldCount(OGRFeatureH hFeat);
+OGRGeomFieldDefnH CPL_DLL OGR_F_GetGeomFieldDefnRef(OGRFeatureH hFeat,
+                                                    int iField);
+int CPL_DLL OGR_F_GetGeomFieldIndex(OGRFeatureH hFeat, const char *pszName);
+
+OGRGeometryH CPL_DLL OGR_F_GetGeomFieldRef(OGRFeatureH hFeat, int iField);
+OGRErr CPL_DLL OGR_F_SetGeomFieldDirectly(OGRFeatureH hFeat, int iField,
+                                          OGRGeometryH hGeom);
+OGRErr CPL_DLL OGR_F_SetGeomField(OGRFeatureH hFeat, int iField,
+                                  OGRGeometryH hGeom);
+
+GIntBig CPL_DLL OGR_F_GetFID(OGRFeatureH);
+OGRErr CPL_DLL OGR_F_SetFID(OGRFeatureH, GIntBig);
+void CPL_DLL OGR_F_DumpReadable(OGRFeatureH, FILE *);
+char CPL_DLL *OGR_F_DumpReadableAsString(OGRFeatureH,
+                                         CSLConstList) CPL_WARN_UNUSED_RESULT;
+OGRErr CPL_DLL OGR_F_SetFrom(OGRFeatureH, OGRFeatureH, int);
+OGRErr CPL_DLL OGR_F_SetFromWithMap(OGRFeatureH, OGRFeatureH, int, const int *);
+
+const char CPL_DLL *OGR_F_GetStyleString(OGRFeatureH);
+void CPL_DLL OGR_F_SetStyleString(OGRFeatureH, const char *);
+void CPL_DLL OGR_F_SetStyleStringDirectly(OGRFeatureH, char *);
+/** Return style table */
+OGRStyleTableH CPL_DLL OGR_F_GetStyleTable(OGRFeatureH);
+/** Set style table and take ownership */
+void CPL_DLL OGR_F_SetStyleTableDirectly(OGRFeatureH, OGRStyleTableH);
+/** Set style table */
+void CPL_DLL OGR_F_SetStyleTable(OGRFeatureH, OGRStyleTableH);
+
+const char CPL_DLL *OGR_F_GetNativeData(OGRFeatureH);
+void CPL_DLL OGR_F_SetNativeData(OGRFeatureH, const char *);
+const char CPL_DLL *OGR_F_GetNativeMediaType(OGRFeatureH);
+void CPL_DLL OGR_F_SetNativeMediaType(OGRFeatureH, const char *);
+
+void CPL_DLL OGR_F_FillUnsetWithDefault(OGRFeatureH hFeat, int bNotNullableOnly,
+                                        char **papszOptions);
+int CPL_DLL OGR_F_Validate(OGRFeatureH, int nValidateFlags, int bEmitError);
+
+/* OGRFieldDomain */
+
+void CPL_DLL OGR_FldDomain_Destroy(OGRFieldDomainH);
+const char CPL_DLL *OGR_FldDomain_GetName(OGRFieldDomainH);
+const char CPL_DLL *OGR_FldDomain_GetDescription(OGRFieldDomainH);
+OGRFieldDomainType CPL_DLL OGR_FldDomain_GetDomainType(OGRFieldDomainH);
+OGRFieldType CPL_DLL OGR_FldDomain_GetFieldType(OGRFieldDomainH);
+OGRFieldSubType CPL_DLL OGR_FldDomain_GetFieldSubType(OGRFieldDomainH);
+OGRFieldDomainSplitPolicy CPL_DLL OGR_FldDomain_GetSplitPolicy(OGRFieldDomainH);
+void CPL_DLL OGR_FldDomain_SetSplitPolicy(OGRFieldDomainH,
+                                          OGRFieldDomainSplitPolicy);
+OGRFieldDomainMergePolicy CPL_DLL OGR_FldDomain_GetMergePolicy(OGRFieldDomainH);
+void CPL_DLL OGR_FldDomain_SetMergePolicy(OGRFieldDomainH,
+                                          OGRFieldDomainMergePolicy);
+
+OGRFieldDomainH CPL_DLL OGR_CodedFldDomain_Create(
+    const char *pszName, const char *pszDescription, OGRFieldType eFieldType,
+    OGRFieldSubType eFieldSubType, const OGRCodedValue *enumeration);
+const OGRCodedValue CPL_DLL *OGR_CodedFldDomain_GetEnumeration(OGRFieldDomainH);
+
+OGRFieldDomainH CPL_DLL OGR_RangeFldDomain_Create(
+    const char *pszName, const char *pszDescription, OGRFieldType eFieldType,
+    OGRFieldSubType eFieldSubType, const OGRField *psMin, bool bMinIsInclusive,
+    const OGRField *psMax, bool bMaxIsInclusive);
+const OGRField CPL_DLL *OGR_RangeFldDomain_GetMin(OGRFieldDomainH,
+                                                  bool *pbIsInclusiveOut);
+const OGRField CPL_DLL *OGR_RangeFldDomain_GetMax(OGRFieldDomainH,
+                                                  bool *pbIsInclusiveOut);
+
+OGRFieldDomainH CPL_DLL OGR_GlobFldDomain_Create(const char *pszName,
+                                                 const char *pszDescription,
+                                                 OGRFieldType eFieldType,
+                                                 OGRFieldSubType eFieldSubType,
+                                                 const char *pszGlob);
+const char CPL_DLL *OGR_GlobFldDomain_GetGlob(OGRFieldDomainH);
+
+/* -------------------------------------------------------------------- */
+/*      ogrsf_frmts.h                                                   */
+/* -------------------------------------------------------------------- */
+
+#ifdef DEBUG
+typedef struct OGRLayerHS *OGRLayerH;
+typedef struct OGRDataSourceHS *OGRDataSourceH;
+typedef struct OGRDriverHS *OGRSFDriverH;
+#else
+/** Opaque type for a layer (OGRLayer) */
+typedef void *OGRLayerH;
+/** Opaque type for a OGR datasource (OGRDataSource) */
+typedef void *OGRDataSourceH;
+/** Opaque type for a OGR driver (OGRSFDriver) */
+typedef void *OGRSFDriverH;
+#endif
+
+/* OGRLayer */
+
+const char CPL_DLL *OGR_L_GetName(OGRLayerH);
+OGRwkbGeometryType CPL_DLL OGR_L_GetGeomType(OGRLayerH);
+
+/* Defined in gdal.h to avoid circular dependency with ogr_api.h */
+/* GDALDatasetH CPL_DLL OGR_L_GetDataset(OGRLayerH hLayer); */
+
+/** Result item of OGR_L_GetGeometryTypes */
+typedef struct
+{
+    /** Geometry type */
+    OGRwkbGeometryType eGeomType;
+    /** Number of geometries of type eGeomType */
+    int64_t nCount;
+} OGRGeometryTypeCounter;
+
+/** Flag for OGR_L_GetGeometryTypes() indicating that
+ * OGRGeometryTypeCounter::nCount value is not needed */
+#define OGR_GGT_COUNT_NOT_NEEDED 0x1
+/** Flag for OGR_L_GetGeometryTypes() indicating that iteration might stop as
+ * sooon as 2 distinct geometry types are found. */
+#define OGR_GGT_STOP_IF_MIXED 0x2
+/** Flag for OGR_L_GetGeometryTypes() indicating that a GeometryCollectionZ
+ * whose first subgeometry is a TinZ should be reported as TinZ */
+#define OGR_GGT_GEOMCOLLECTIONZ_TINZ 0x4
+OGRGeometryTypeCounter CPL_DLL *
+OGR_L_GetGeometryTypes(OGRLayerH hLayer, int iGeomField, int nFlags,
+                       int *pnEntryCount, GDALProgressFunc pfnProgress,
+                       void *pProgressData);
+
+OGRGeometryH CPL_DLL OGR_L_GetSpatialFilter(OGRLayerH);
+void CPL_DLL OGR_L_SetSpatialFilter(OGRLayerH, OGRGeometryH);
+void CPL_DLL OGR_L_SetSpatialFilterRect(OGRLayerH, double, double, double,
+                                        double);
+void CPL_DLL OGR_L_SetSpatialFilterEx(OGRLayerH, int iGeomField,
+                                      OGRGeometryH hGeom);
+void CPL_DLL OGR_L_SetSpatialFilterRectEx(OGRLayerH, int iGeomField,
+                                          double dfMinX, double dfMinY,
+                                          double dfMaxX, double dfMaxY);
+OGRErr CPL_DLL OGR_L_SetAttributeFilter(OGRLayerH, const char *);
+void CPL_DLL OGR_L_ResetReading(OGRLayerH);
+OGRFeatureH CPL_DLL OGR_L_GetNextFeature(OGRLayerH) CPL_WARN_UNUSED_RESULT;
+
+/** Conveniency macro to iterate over features of a layer.
+ *
+ * Typical usage is:
+ * \code{.cpp}
+ * OGR_FOR_EACH_FEATURE_BEGIN(hFeat, hLayer)
+ * {
+ *      // Do something, including continue, break;
+ *      // Do not explicitly destroy the feature (unless you use return or goto
+ *      // outside of the loop, in which case use OGR_F_Destroy(hFeat))
+ * }
+ * OGR_FOR_EACH_FEATURE_END(hFeat)
+ * \endcode
+ *
+ * In C++, you might want to use instead range-based loop:
+ * \code{.cpp}
+ * for( auto&& poFeature: poLayer )
+ * {
+ * }
+ * \endcode
+ *
+ * @param hFeat variable name for OGRFeatureH. The variable will be declared
+ *              inside the macro body.
+ * @param hLayer layer to iterate over.
+ *
+ * @since GDAL 2.3
+ */
+#define OGR_FOR_EACH_FEATURE_BEGIN(hFeat, hLayer)                              \
+    {                                                                          \
+        OGRFeatureH hFeat = CPL_NULLPTR;                                       \
+        OGR_L_ResetReading(hLayer);                                            \
+        while (true)                                                           \
+        {                                                                      \
+            if (hFeat)                                                         \
+                OGR_F_Destroy(hFeat);                                          \
+            hFeat = OGR_L_GetNextFeature(hLayer);                              \
+            if (!hFeat)                                                        \
+                break;
+
+/** End of iterator. */
+#define OGR_FOR_EACH_FEATURE_END(hFeat)                                        \
+    }                                                                          \
+    OGR_F_Destroy(hFeat);                                                      \
+    }
+
+/** Data type for a Arrow C stream. Include ogr_recordbatch.h to get the
+ * definition. */
+struct ArrowArrayStream;
+
+bool CPL_DLL OGR_L_GetArrowStream(OGRLayerH hLayer,
+                                  struct ArrowArrayStream *out_stream,
+                                  char **papszOptions);
+
+/** Data type for a Arrow C schema. Include ogr_recordbatch.h to get the
+ * definition. */
+struct ArrowSchema;
+
+bool CPL_DLL OGR_L_IsArrowSchemaSupported(OGRLayerH hLayer,
+                                          const struct ArrowSchema *schema,
+                                          char **papszOptions,
+                                          char **ppszErrorMsg);
+bool CPL_DLL OGR_L_CreateFieldFromArrowSchema(OGRLayerH hLayer,
+                                              const struct ArrowSchema *schema,
+                                              char **papszOptions);
+
+/** Data type for a Arrow C array. Include ogr_recordbatch.h to get the
+ * definition. */
+struct ArrowArray;
+
+bool CPL_DLL OGR_L_WriteArrowBatch(OGRLayerH hLayer,
+                                   const struct ArrowSchema *schema,
+                                   struct ArrowArray *array,
+                                   char **papszOptions);
+
+OGRErr CPL_DLL OGR_L_SetNextByIndex(OGRLayerH, GIntBig);
+OGRFeatureH CPL_DLL OGR_L_GetFeature(OGRLayerH, GIntBig) CPL_WARN_UNUSED_RESULT;
+OGRErr CPL_DLL OGR_L_SetFeature(OGRLayerH, OGRFeatureH) CPL_WARN_UNUSED_RESULT;
+OGRErr CPL_DLL OGR_L_CreateFeature(OGRLayerH,
+                                   OGRFeatureH) CPL_WARN_UNUSED_RESULT;
+OGRErr CPL_DLL OGR_L_DeleteFeature(OGRLayerH, GIntBig) CPL_WARN_UNUSED_RESULT;
+OGRErr CPL_DLL OGR_L_UpsertFeature(OGRLayerH,
+                                   OGRFeatureH) CPL_WARN_UNUSED_RESULT;
+OGRErr CPL_DLL
+OGR_L_UpdateFeature(OGRLayerH, OGRFeatureH, int nUpdatedFieldsCount,
+                    const int *panUpdatedFieldsIdx, int nUpdatedGeomFieldsCount,
+                    const int *panUpdatedGeomFieldsIdx,
+                    bool bUpdateStyleString) CPL_WARN_UNUSED_RESULT;
+OGRFeatureDefnH CPL_DLL OGR_L_GetLayerDefn(OGRLayerH);
+OGRSpatialReferenceH CPL_DLL OGR_L_GetSpatialRef(OGRLayerH);
+OGRSpatialReferenceH CPL_DLL *
+OGR_L_GetSupportedSRSList(OGRLayerH hLayer, int iGeomField, int *pnCount);
+OGRErr CPL_DLL OGR_L_SetActiveSRS(OGRLayerH hLayer, int iGeomField,
+                                  OGRSpatialReferenceH hSRS);
+int CPL_DLL OGR_L_FindFieldIndex(OGRLayerH, const char *, int bExactMatch);
+GIntBig CPL_DLL OGR_L_GetFeatureCount(OGRLayerH, int);
+OGRErr CPL_DLL OGR_L_GetExtent(OGRLayerH, OGREnvelope *, int);
+OGRErr CPL_DLL OGR_L_GetExtentEx(OGRLayerH, int iGeomField,
+                                 OGREnvelope *psExtent, int bForce);
+OGRErr CPL_DLL OGR_L_GetExtent3D(OGRLayerH hLayer, int iGeomField,
+                                 OGREnvelope3D *psExtent3D, int bForce);
+int CPL_DLL OGR_L_TestCapability(OGRLayerH, const char *);
+OGRErr CPL_DLL OGR_L_CreateField(OGRLayerH, OGRFieldDefnH, int);
+OGRErr CPL_DLL OGR_L_CreateGeomField(OGRLayerH hLayer,
+                                     OGRGeomFieldDefnH hFieldDefn, int bForce);
+OGRErr CPL_DLL OGR_L_DeleteField(OGRLayerH, int iField);
+OGRErr CPL_DLL OGR_L_ReorderFields(OGRLayerH, int *panMap);
+OGRErr CPL_DLL OGR_L_ReorderField(OGRLayerH, int iOldFieldPos,
+                                  int iNewFieldPos);
+OGRErr CPL_DLL OGR_L_AlterFieldDefn(OGRLayerH, int iField,
+                                    OGRFieldDefnH hNewFieldDefn, int nFlags);
+OGRErr CPL_DLL OGR_L_AlterGeomFieldDefn(OGRLayerH, int iField,
+                                        OGRGeomFieldDefnH hNewGeomFieldDefn,
+                                        int nFlags);
+OGRErr CPL_DLL OGR_L_StartTransaction(OGRLayerH) CPL_WARN_UNUSED_RESULT;
+OGRErr CPL_DLL OGR_L_CommitTransaction(OGRLayerH) CPL_WARN_UNUSED_RESULT;
+OGRErr CPL_DLL OGR_L_RollbackTransaction(OGRLayerH);
+OGRErr CPL_DLL OGR_L_Rename(OGRLayerH hLayer, const char *pszNewName);
+
+/*! @cond Doxygen_Suppress */
+int CPL_DLL OGR_L_Reference(OGRLayerH);
+int CPL_DLL OGR_L_Dereference(OGRLayerH);
+int CPL_DLL OGR_L_GetRefCount(OGRLayerH);
+/*! @endcond */
+OGRErr CPL_DLL OGR_L_SyncToDisk(OGRLayerH);
+/*! @cond Doxygen_Suppress */
+GIntBig CPL_DLL OGR_L_GetFeaturesRead(OGRLayerH);
+/*! @endcond */
+const char CPL_DLL *OGR_L_GetFIDColumn(OGRLayerH);
+const char CPL_DLL *OGR_L_GetGeometryColumn(OGRLayerH);
+/** Get style table */
+OGRStyleTableH CPL_DLL OGR_L_GetStyleTable(OGRLayerH);
+/** Set style table (and take ownership) */
+void CPL_DLL OGR_L_SetStyleTableDirectly(OGRLayerH, OGRStyleTableH);
+/** Set style table */
+void CPL_DLL OGR_L_SetStyleTable(OGRLayerH, OGRStyleTableH);
+OGRErr CPL_DLL OGR_L_SetIgnoredFields(OGRLayerH, const char **);
+OGRErr CPL_DLL OGR_L_Intersection(OGRLayerH, OGRLayerH, OGRLayerH, char **,
+                                  GDALProgressFunc, void *);
+OGRErr CPL_DLL OGR_L_Union(OGRLayerH, OGRLayerH, OGRLayerH, char **,
+                           GDALProgressFunc, void *);
+OGRErr CPL_DLL OGR_L_SymDifference(OGRLayerH, OGRLayerH, OGRLayerH, char **,
+                                   GDALProgressFunc, void *);
+OGRErr CPL_DLL OGR_L_Identity(OGRLayerH, OGRLayerH, OGRLayerH, char **,
+                              GDALProgressFunc, void *);
+OGRErr CPL_DLL OGR_L_Update(OGRLayerH, OGRLayerH, OGRLayerH, char **,
+                            GDALProgressFunc, void *);
+OGRErr CPL_DLL OGR_L_Clip(OGRLayerH, OGRLayerH, OGRLayerH, char **,
+                          GDALProgressFunc, void *);
+OGRErr CPL_DLL OGR_L_Erase(OGRLayerH, OGRLayerH, OGRLayerH, char **,
+                           GDALProgressFunc, void *);
+
+/* OGRDataSource */
+
+void CPL_DLL OGR_DS_Destroy(OGRDataSourceH);
+const char CPL_DLL *OGR_DS_GetName(OGRDataSourceH);
+int CPL_DLL OGR_DS_GetLayerCount(OGRDataSourceH);
+OGRLayerH CPL_DLL OGR_DS_GetLayer(OGRDataSourceH, int);
+OGRLayerH CPL_DLL OGR_DS_GetLayerByName(OGRDataSourceH, const char *);
+OGRErr CPL_DLL OGR_DS_DeleteLayer(OGRDataSourceH, int);
+OGRSFDriverH CPL_DLL OGR_DS_GetDriver(OGRDataSourceH);
+OGRLayerH CPL_DLL OGR_DS_CreateLayer(OGRDataSourceH, const char *,
+                                     OGRSpatialReferenceH, OGRwkbGeometryType,
+                                     char **);
+OGRLayerH CPL_DLL OGR_DS_CopyLayer(OGRDataSourceH, OGRLayerH, const char *,
+                                   char **);
+int CPL_DLL OGR_DS_TestCapability(OGRDataSourceH, const char *);
+OGRLayerH CPL_DLL OGR_DS_ExecuteSQL(OGRDataSourceH, const char *, OGRGeometryH,
+                                    const char *);
+void CPL_DLL OGR_DS_ReleaseResultSet(OGRDataSourceH, OGRLayerH);
+/*! @cond Doxygen_Suppress */
+int CPL_DLL OGR_DS_Reference(OGRDataSourceH);
+int CPL_DLL OGR_DS_Dereference(OGRDataSourceH);
+int CPL_DLL OGR_DS_GetRefCount(OGRDataSourceH);
+int CPL_DLL OGR_DS_GetSummaryRefCount(OGRDataSourceH);
+/*! @endcond */
+/** Flush pending changes to disk. See GDALDataset::FlushCache() */
+OGRErr CPL_DLL OGR_DS_SyncToDisk(OGRDataSourceH);
+/** Get style table */
+OGRStyleTableH CPL_DLL OGR_DS_GetStyleTable(OGRDataSourceH);
+/** Set style table (and take ownership) */
+void CPL_DLL OGR_DS_SetStyleTableDirectly(OGRDataSourceH, OGRStyleTableH);
+/** Set style table */
+void CPL_DLL OGR_DS_SetStyleTable(OGRDataSourceH, OGRStyleTableH);
+
+/* OGRSFDriver */
+
+const char CPL_DLL *OGR_Dr_GetName(OGRSFDriverH);
+OGRDataSourceH CPL_DLL OGR_Dr_Open(OGRSFDriverH, const char *,
+                                   int) CPL_WARN_UNUSED_RESULT;
+int CPL_DLL OGR_Dr_TestCapability(OGRSFDriverH, const char *);
+OGRDataSourceH CPL_DLL OGR_Dr_CreateDataSource(OGRSFDriverH, const char *,
+                                               char **) CPL_WARN_UNUSED_RESULT;
+OGRDataSourceH CPL_DLL OGR_Dr_CopyDataSource(OGRSFDriverH, OGRDataSourceH,
+                                             const char *,
+                                             char **) CPL_WARN_UNUSED_RESULT;
+OGRErr CPL_DLL OGR_Dr_DeleteDataSource(OGRSFDriverH, const char *);
+
+/* OGRSFDriverRegistrar */
+
+OGRDataSourceH CPL_DLL OGROpen(const char *, int,
+                               OGRSFDriverH *) CPL_WARN_UNUSED_RESULT;
+OGRDataSourceH CPL_DLL OGROpenShared(const char *, int,
+                                     OGRSFDriverH *) CPL_WARN_UNUSED_RESULT;
+OGRErr CPL_DLL OGRReleaseDataSource(OGRDataSourceH);
+/*! @cond Doxygen_Suppress */
+void CPL_DLL OGRRegisterDriver(OGRSFDriverH);
+void CPL_DLL OGRDeregisterDriver(OGRSFDriverH);
+/*! @endcond */
+int CPL_DLL OGRGetDriverCount(void);
+OGRSFDriverH CPL_DLL OGRGetDriver(int);
+OGRSFDriverH CPL_DLL OGRGetDriverByName(const char *);
+/*! @cond Doxygen_Suppress */
+int CPL_DLL OGRGetOpenDSCount(void);
+OGRDataSourceH CPL_DLL OGRGetOpenDS(int iDS);
+/*! @endcond */
+
+void CPL_DLL OGRRegisterAll(void);
+
+/** Clean-up all drivers (including raster ones starting with GDAL 2.0.
+ * See GDALDestroyDriverManager() */
+void CPL_DLL OGRCleanupAll(void);
+
+/* -------------------------------------------------------------------- */
+/*      ogrsf_featurestyle.h                                            */
+/* -------------------------------------------------------------------- */
+
+#ifdef DEBUG
+typedef struct OGRStyleMgrHS *OGRStyleMgrH;
+typedef struct OGRStyleToolHS *OGRStyleToolH;
+#else
+/** Style manager opaque type */
+typedef void *OGRStyleMgrH;
+/** Style tool opaque type */
+typedef void *OGRStyleToolH;
+#endif
+
+/* OGRStyleMgr */
+
+OGRStyleMgrH CPL_DLL OGR_SM_Create(OGRStyleTableH hStyleTable)
+    CPL_WARN_UNUSED_RESULT;
+void CPL_DLL OGR_SM_Destroy(OGRStyleMgrH hSM);
+
+const char CPL_DLL *OGR_SM_InitFromFeature(OGRStyleMgrH hSM, OGRFeatureH hFeat);
+int CPL_DLL OGR_SM_InitStyleString(OGRStyleMgrH hSM,
+                                   const char *pszStyleString);
+int CPL_DLL OGR_SM_GetPartCount(OGRStyleMgrH hSM, const char *pszStyleString);
+OGRStyleToolH CPL_DLL OGR_SM_GetPart(OGRStyleMgrH hSM, int nPartId,
+                                     const char *pszStyleString);
+int CPL_DLL OGR_SM_AddPart(OGRStyleMgrH hSM, OGRStyleToolH hST);
+int CPL_DLL OGR_SM_AddStyle(OGRStyleMgrH hSM, const char *pszStyleName,
+                            const char *pszStyleString);
+
+/* OGRStyleTool */
+
+OGRStyleToolH CPL_DLL OGR_ST_Create(OGRSTClassId eClassId)
+    CPL_WARN_UNUSED_RESULT;
+void CPL_DLL OGR_ST_Destroy(OGRStyleToolH hST);
+
+OGRSTClassId CPL_DLL OGR_ST_GetType(OGRStyleToolH hST);
+
+OGRSTUnitId CPL_DLL OGR_ST_GetUnit(OGRStyleToolH hST);
+void CPL_DLL OGR_ST_SetUnit(OGRStyleToolH hST, OGRSTUnitId eUnit,
+                            double dfGroundPaperScale);
+
+const char CPL_DLL *OGR_ST_GetParamStr(OGRStyleToolH hST, int eParam,
+                                       int *bValueIsNull);
+int CPL_DLL OGR_ST_GetParamNum(OGRStyleToolH hST, int eParam,
+                               int *bValueIsNull);
+double CPL_DLL OGR_ST_GetParamDbl(OGRStyleToolH hST, int eParam,
+                                  int *bValueIsNull);
+void CPL_DLL OGR_ST_SetParamStr(OGRStyleToolH hST, int eParam,
+                                const char *pszValue);
+void CPL_DLL OGR_ST_SetParamNum(OGRStyleToolH hST, int eParam, int nValue);
+void CPL_DLL OGR_ST_SetParamDbl(OGRStyleToolH hST, int eParam, double dfValue);
+const char CPL_DLL *OGR_ST_GetStyleString(OGRStyleToolH hST);
+
+int CPL_DLL OGR_ST_GetRGBFromString(OGRStyleToolH hST, const char *pszColor,
+                                    int *pnRed, int *pnGreen, int *pnBlue,
+                                    int *pnAlpha);
+
+/* OGRStyleTable */
+
+OGRStyleTableH CPL_DLL OGR_STBL_Create(void) CPL_WARN_UNUSED_RESULT;
+void CPL_DLL OGR_STBL_Destroy(OGRStyleTableH hSTBL);
+int CPL_DLL OGR_STBL_AddStyle(OGRStyleTableH hStyleTable, const char *pszName,
+                              const char *pszStyleString);
+int CPL_DLL OGR_STBL_SaveStyleTable(OGRStyleTableH hStyleTable,
+                                    const char *pszFilename);
+int CPL_DLL OGR_STBL_LoadStyleTable(OGRStyleTableH hStyleTable,
+                                    const char *pszFilename);
+const char CPL_DLL *OGR_STBL_Find(OGRStyleTableH hStyleTable,
+                                  const char *pszName);
+void CPL_DLL OGR_STBL_ResetStyleStringReading(OGRStyleTableH hStyleTable);
+const char CPL_DLL *OGR_STBL_GetNextStyle(OGRStyleTableH hStyleTable);
+const char CPL_DLL *OGR_STBL_GetLastStyleName(OGRStyleTableH hStyleTable);
+
+CPL_C_END
+
+#endif /* ndef OGR_API_H_INCLUDED */