ogr_core.h

Go to the documentation of this file.

/******************************************************************************
 *
 * Project:  OpenGIS Simple Features Reference Implementation
 * Purpose:  Define some core portability services for cross-platform OGR code.
 * Author:   Frank Warmerdam, warmerdam@pobox.com
 *
 ******************************************************************************
 * Copyright (c) 1999, Frank Warmerdam
 * Copyright (c) 2007-2014, Even Rouault <even dot rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/
 
#ifndef OGR_CORE_H_INCLUDED
#define OGR_CORE_H_INCLUDED
 
#include "cpl_port.h"
#if defined(GDAL_COMPILATION)
#define DO_NOT_DEFINE_GDAL_DATE_NAME
#endif
#include "gdal_version.h"
 
#if defined(__cplusplus) && !defined(CPL_SUPRESS_CPLUSPLUS)
 
extern "C++"
{
#if !defined(DOXYGEN_SKIP)
#include <cmath>
#include <limits>
#endif
 
    class OGREnvelope3D;
 
    class CPL_DLL OGREnvelope
    {
      public:
        OGREnvelope()
            : MinX(std::numeric_limits<double>::infinity()),
              MaxX(-std::numeric_limits<double>::infinity()),
              MinY(std::numeric_limits<double>::infinity()),
              MaxY(-std::numeric_limits<double>::infinity())
        {
        }
 
        OGREnvelope(const OGREnvelope &oOther)
            : MinX(oOther.MinX), MaxX(oOther.MaxX), MinY(oOther.MinY),
              MaxY(oOther.MaxY)
        {
        }
 
        OGREnvelope &operator=(const OGREnvelope &) = default;
 
        double MinX;
 
        double MaxX;
 
        double MinY;
 
        double MaxY;
 
#ifdef HAVE_GCC_DIAGNOSTIC_PUSH
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
        int IsInit() const
        {
            return MinX != std::numeric_limits<double>::infinity();
        }
 
#ifdef HAVE_GCC_DIAGNOSTIC_PUSH
#pragma GCC diagnostic pop
#endif
 
        void Merge(OGREnvelope const &sOther)
        {
            MinX = MIN(MinX, sOther.MinX);
            MaxX = MAX(MaxX, sOther.MaxX);
            MinY = MIN(MinY, sOther.MinY);
            MaxY = MAX(MaxY, sOther.MaxY);
        }
 
        void Merge(double dfX, double dfY)
        {
            MinX = MIN(MinX, dfX);
            MaxX = MAX(MaxX, dfX);
            MinY = MIN(MinY, dfY);
            MaxY = MAX(MaxY, dfY);
        }
 
        void Intersect(OGREnvelope const &sOther)
        {
            if (Intersects(sOther))
            {
                if (IsInit())
                {
                    MinX = MAX(MinX, sOther.MinX);
                    MaxX = MIN(MaxX, sOther.MaxX);
                    MinY = MAX(MinY, sOther.MinY);
                    MaxY = MIN(MaxY, sOther.MaxY);
                }
                else
                {
                    MinX = sOther.MinX;
                    MaxX = sOther.MaxX;
                    MinY = sOther.MinY;
                    MaxY = sOther.MaxY;
                }
            }
            else
            {
                *this = OGREnvelope();
            }
        }
 
        int Intersects(OGREnvelope const &other) const
        {
            return MinX <= other.MaxX && MaxX >= other.MinX &&
                   MinY <= other.MaxY && MaxY >= other.MinY;
        }
 
        int Contains(OGREnvelope const &other) const
        {
            return MinX <= other.MinX && MinY <= other.MinY &&
                   MaxX >= other.MaxX && MaxY >= other.MaxY;
        }
 
        bool operator==(const OGREnvelope &other) const
        {
#ifdef HAVE_GCC_DIAGNOSTIC_PUSH
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
            return MinX == other.MinX && MinY == other.MinY &&
                   MaxX == other.MaxX && MaxY == other.MaxY;
 
#ifdef HAVE_GCC_DIAGNOSTIC_PUSH
#pragma GCC diagnostic pop
#endif
        }
 
        bool operator!=(const OGREnvelope &other) const
        {
            return !(*this == other);
        }
    };
 
}  // extern "C++"
 
#else
typedef struct
{
    double MinX;
    double MaxX;
    double MinY;
    double MaxY;
} OGREnvelope;
#endif
 
#if defined(__cplusplus) && !defined(CPL_SUPRESS_CPLUSPLUS)
 
extern "C++"
{
 
    class CPL_DLL OGREnvelope3D : public OGREnvelope
    {
      public:
        OGREnvelope3D()
            : OGREnvelope(), MinZ(std::numeric_limits<double>::infinity()),
              MaxZ(-std::numeric_limits<double>::infinity())
        {
        }
 
        OGREnvelope3D(const OGREnvelope3D &oOther)
            : OGREnvelope(oOther), MinZ(oOther.MinZ), MaxZ(oOther.MaxZ)
        {
        }
 
        OGREnvelope3D &operator=(const OGREnvelope3D &) = default;
 
        bool Is3D() const
        {
            return std::isfinite(MinZ) && std::isfinite(MaxZ);
        }
 
        double MinZ;
 
        double MaxZ;
 
#ifdef HAVE_GCC_DIAGNOSTIC_PUSH
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
        int IsInit() const
        {
            return MinX != std::numeric_limits<double>::infinity();
        }
#ifdef HAVE_GCC_DIAGNOSTIC_PUSH
#pragma GCC diagnostic pop
#endif
 
        void Merge(OGREnvelope3D const &sOther)
        {
            MinX = MIN(MinX, sOther.MinX);
            MaxX = MAX(MaxX, sOther.MaxX);
            MinY = MIN(MinY, sOther.MinY);
            MaxY = MAX(MaxY, sOther.MaxY);
            MinZ = MIN(MinZ, sOther.MinZ);
            MaxZ = MAX(MaxZ, sOther.MaxZ);
        }
 
        void Merge(OGREnvelope const &sOther)
        {
            MinX = MIN(MinX, sOther.MinX);
            MaxX = MAX(MaxX, sOther.MaxX);
            MinY = MIN(MinY, sOther.MinY);
            MaxY = MAX(MaxY, sOther.MaxY);
        }
 
        void Merge(double dfX, double dfY, double dfZ)
        {
            MinX = MIN(MinX, dfX);
            MaxX = MAX(MaxX, dfX);
            MinY = MIN(MinY, dfY);
            MaxY = MAX(MaxY, dfY);
            MinZ = MIN(MinZ, dfZ);
            MaxZ = MAX(MaxZ, dfZ);
        }
 
        void Intersect(OGREnvelope3D const &sOther)
        {
            if (Intersects(sOther))
            {
                if (IsInit())
                {
                    MinX = MAX(MinX, sOther.MinX);
                    MaxX = MIN(MaxX, sOther.MaxX);
                    MinY = MAX(MinY, sOther.MinY);
                    MaxY = MIN(MaxY, sOther.MaxY);
                    MinZ = MAX(MinZ, sOther.MinZ);
                    MaxZ = MIN(MaxZ, sOther.MaxZ);
                }
                else
                {
                    MinX = sOther.MinX;
                    MaxX = sOther.MaxX;
                    MinY = sOther.MinY;
                    MaxY = sOther.MaxY;
                    MinZ = sOther.MinZ;
                    MaxZ = sOther.MaxZ;
                }
            }
            else
            {
                *this = OGREnvelope3D();
            }
        }
 
        int Intersects(OGREnvelope3D const &other) const
        {
            return MinX <= other.MaxX && MaxX >= other.MinX &&
                   MinY <= other.MaxY && MaxY >= other.MinY &&
                   MinZ <= other.MaxZ && MaxZ >= other.MinZ;
        }
 
        int Contains(OGREnvelope3D const &other) const
        {
            return MinX <= other.MinX && MinY <= other.MinY &&
                   MaxX >= other.MaxX && MaxY >= other.MaxY &&
                   MinZ <= other.MinZ && MaxZ >= other.MaxZ;
        }
    };
 
}  // extern "C++"
 
#else
typedef struct
{
    double MinX;
    double MaxX;
    double MinY;
    double MaxY;
    double MinZ;
    double MaxZ;
} OGREnvelope3D;
#endif
 
CPL_C_START
 
void CPL_DLL *OGRMalloc(size_t) CPL_WARN_DEPRECATED("Use CPLMalloc instead.");
void CPL_DLL *OGRCalloc(size_t, size_t)
    CPL_WARN_DEPRECATED("Use CPLCalloc instead.");
void CPL_DLL *OGRRealloc(void *, size_t)
    CPL_WARN_DEPRECATED("Use CPLRealloc instead.");
char CPL_DLL *OGRStrdup(const char *)
    CPL_WARN_DEPRECATED("Use CPLStrdup instead.");
void CPL_DLL OGRFree(void *) CPL_WARN_DEPRECATED("Use CPLFree instead.");
#ifdef STRICT_OGRERR_TYPE
typedef enum
{
    OGRERR_NONE,                      
    OGRERR_NOT_ENOUGH_DATA,           
    OGRERR_NOT_ENOUGH_MEMORY,         
    OGRERR_UNSUPPORTED_GEOMETRY_TYPE, 
    OGRERR_UNSUPPORTED_OPERATION,     
    OGRERR_CORRUPT_DATA,              
    OGRERR_FAILURE,                   
    OGRERR_UNSUPPORTED_SRS,           
    OGRERR_INVALID_HANDLE,            
    OGRERR_NON_EXISTING_FEATURE 
} OGRErr;
#else
typedef int OGRErr;
 
#define OGRERR_NONE 0              
#define OGRERR_NOT_ENOUGH_DATA 1   
#define OGRERR_NOT_ENOUGH_MEMORY 2 
#define OGRERR_UNSUPPORTED_GEOMETRY_TYPE 3 
#define OGRERR_UNSUPPORTED_OPERATION 4     
#define OGRERR_CORRUPT_DATA 5              
#define OGRERR_FAILURE 6                   
#define OGRERR_UNSUPPORTED_SRS 7           
#define OGRERR_INVALID_HANDLE 8            
#define OGRERR_NON_EXISTING_FEATURE                                            \
    9 
#endif
 
typedef int OGRBoolean;
 
/* -------------------------------------------------------------------- */
/*      ogr_geometry.h related definitions.                             */
/* -------------------------------------------------------------------- */
 
#if defined(HAVE_GCC_DIAGNOSTIC_PUSH) && __STDC_VERSION__ < 202311L
/* wkbPoint25D and friends cause warnings with -Wpedantic prior to C23. */
/* Cf https://github.com/OSGeo/gdal/issues/2322 */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
#endif
 
typedef enum
{
    wkbUnknown = 0, 
    wkbPoint = 1,      
    wkbLineString = 2, 
    wkbPolygon = 3,    
    wkbMultiPoint = 4, 
    wkbMultiLineString =
        5,               
    wkbMultiPolygon = 6, 
    wkbGeometryCollection = 7, 
    wkbCircularString = 8, 
    wkbCompoundCurve = 9, 
    wkbCurvePolygon = 10, 
    wkbMultiCurve = 11,   
    wkbMultiSurface = 12, 
    wkbCurve =
        13, 
    wkbSurface =
        14, 
    wkbPolyhedralSurface =
        15,      
    wkbTIN = 16, 
    wkbTriangle = 17, 
    wkbNone = 100,       
    wkbLinearRing = 101, 
    wkbCircularStringZ = 1008, 
    wkbCompoundCurveZ = 1009, 
    wkbCurvePolygonZ = 1010,  
    wkbMultiCurveZ = 1011,    
    wkbMultiSurfaceZ = 1012,  
    wkbCurveZ = 1013,   
    wkbSurfaceZ = 1014, 
    wkbPolyhedralSurfaceZ = 1015, 
    wkbTINZ = 1016,               
    wkbTriangleZ = 1017,          
    wkbPointM = 2001,              
    wkbLineStringM = 2002,         
    wkbPolygonM = 2003,            
    wkbMultiPointM = 2004,         
    wkbMultiLineStringM = 2005,    
    wkbMultiPolygonM = 2006,       
    wkbGeometryCollectionM = 2007, 
    wkbCircularStringM = 2008,     
    wkbCompoundCurveM = 2009,      
    wkbCurvePolygonM = 2010,       
    wkbMultiCurveM = 2011,         
    wkbMultiSurfaceM = 2012,       
    wkbCurveM = 2013,              
    wkbSurfaceM = 2014,            
    wkbPolyhedralSurfaceM = 2015,  
    wkbTINM = 2016,                
    wkbTriangleM = 2017,           
    wkbPointZM = 3001,              
    wkbLineStringZM = 3002,         
    wkbPolygonZM = 3003,            
    wkbMultiPointZM = 3004,         
    wkbMultiLineStringZM = 3005,    
    wkbMultiPolygonZM = 3006,       
    wkbGeometryCollectionZM = 3007, 
    wkbCircularStringZM = 3008,     
    wkbCompoundCurveZM = 3009,      
    wkbCurvePolygonZM = 3010,       
    wkbMultiCurveZM = 3011,         
    wkbMultiSurfaceZM = 3012,       
    wkbCurveZM = 3013,              
    wkbSurfaceZM = 3014,            
    wkbPolyhedralSurfaceZM = 3015,  
    wkbTINZM = 3016,                
    wkbTriangleZM = 3017,           
#if defined(DOXYGEN_SKIP)
    // Sphinx doesn't like 0x8000000x constants
    wkbPoint25D = -2147483647,             
    wkbLineString25D = -2147483646,        
    wkbPolygon25D = -2147483645,           
    wkbMultiPoint25D = -2147483644,        
    wkbMultiLineString25D = -2147483643,   
    wkbMultiPolygon25D = -2147483642,      
    wkbGeometryCollection25D = -2147483641 
#else
    wkbPoint25D = 0x80000001,             
    wkbLineString25D = 0x80000002,        
    wkbPolygon25D = 0x80000003,           
    wkbMultiPoint25D = 0x80000004,        
    wkbMultiLineString25D = 0x80000005,   
    wkbMultiPolygon25D = 0x80000006,      
    wkbGeometryCollection25D = 0x80000007 
#endif
} OGRwkbGeometryType;
 
#if defined(HAVE_GCC_DIAGNOSTIC_PUSH) && __STDC_VERSION__ < 202311L
#pragma GCC diagnostic pop
#endif
 
/* clang-format off */
/* clang-format on */
 
typedef enum
{
    wkbVariantOldOgc, 
    wkbVariantIso, 
    wkbVariantPostGIS1 
} OGRwkbVariant;
 
#ifndef GDAL_COMPILATION
#define wkb25DBit 0x80000000
#endif
 
#ifndef __cplusplus
#define wkbFlatten(x) OGR_GT_Flatten((OGRwkbGeometryType)(x))
#else
#define wkbFlatten(x) OGR_GT_Flatten(static_cast<OGRwkbGeometryType>(x))
#endif
 
#define wkbHasZ(x) (OGR_GT_HasZ(x) != 0)
 
#define wkbSetZ(x) OGR_GT_SetZ(x)
 
#define wkbHasM(x) (OGR_GT_HasM(x) != 0)
 
#define wkbSetM(x) OGR_GT_SetM(x)
 
#ifndef DOXYGEN_SKIP
#define ogrZMarker 0x21125711
#endif
 
const char CPL_DLL *OGRGeometryTypeToName(OGRwkbGeometryType eType);
OGRwkbGeometryType CPL_DLL OGRMergeGeometryTypes(OGRwkbGeometryType eMain,
                                                 OGRwkbGeometryType eExtra);
OGRwkbGeometryType CPL_DLL OGRMergeGeometryTypesEx(OGRwkbGeometryType eMain,
                                                   OGRwkbGeometryType eExtra,
                                                   int bAllowPromotingToCurves);
OGRwkbGeometryType CPL_DLL OGR_GT_Flatten(OGRwkbGeometryType eType);
OGRwkbGeometryType CPL_DLL OGR_GT_SetZ(OGRwkbGeometryType eType);
OGRwkbGeometryType CPL_DLL OGR_GT_SetM(OGRwkbGeometryType eType);
OGRwkbGeometryType CPL_DLL OGR_GT_SetModifier(OGRwkbGeometryType eType,
                                              int bSetZ, int bSetM);
int CPL_DLL OGR_GT_HasZ(OGRwkbGeometryType eType);
int CPL_DLL OGR_GT_HasM(OGRwkbGeometryType eType);
int CPL_DLL OGR_GT_IsSubClassOf(OGRwkbGeometryType eType,
                                OGRwkbGeometryType eSuperType);
int CPL_DLL OGR_GT_IsCurve(OGRwkbGeometryType);
int CPL_DLL OGR_GT_IsSurface(OGRwkbGeometryType);
int CPL_DLL OGR_GT_IsNonLinear(OGRwkbGeometryType);
OGRwkbGeometryType CPL_DLL OGR_GT_GetCollection(OGRwkbGeometryType eType);
OGRwkbGeometryType CPL_DLL OGR_GT_GetSingle(OGRwkbGeometryType eType);
OGRwkbGeometryType CPL_DLL OGR_GT_GetCurve(OGRwkbGeometryType eType);
OGRwkbGeometryType CPL_DLL OGR_GT_GetLinear(OGRwkbGeometryType eType);
 
typedef enum
{
    wkbXDR = 0, 
    wkbNDR = 1  
} OGRwkbByteOrder;
 
#ifndef DOXYGEN_SKIP
 
#ifndef NO_HACK_FOR_IBM_DB2_V72
#define HACK_FOR_IBM_DB2_V72
#endif
 
#ifdef HACK_FOR_IBM_DB2_V72
#define DB2_V72_FIX_BYTE_ORDER(x) ((((x)&0x31) == (x)) ? ((x)&0x1) : (x))
#define DB2_V72_UNFIX_BYTE_ORDER(x)                                            \
    CPL_STATIC_CAST(unsigned char, OGRGeometry::bGenerate_DB2_V72_BYTE_ORDER   \
                                       ? ((x) | 0x30)                          \
                                       : (x))
#else
#define DB2_V72_FIX_BYTE_ORDER(x) (x)
#define DB2_V72_UNFIX_BYTE_ORDER(x) (x)
#endif
 
#endif /* #ifndef DOXYGEN_SKIP */
 
#define ALTER_NAME_FLAG 0x1
 
#define ALTER_TYPE_FLAG 0x2
 
#define ALTER_WIDTH_PRECISION_FLAG 0x4
 
#define ALTER_NULLABLE_FLAG 0x8
 
#define ALTER_DEFAULT_FLAG 0x10
 
#define ALTER_UNIQUE_FLAG 0x20
 
#define ALTER_DOMAIN_FLAG 0x40
 
#define ALTER_ALTERNATIVE_NAME_FLAG 0x80
 
#define ALTER_COMMENT_FLAG 0x100
 
#define ALTER_ALL_FLAG                                                         \
    (ALTER_NAME_FLAG | ALTER_TYPE_FLAG | ALTER_WIDTH_PRECISION_FLAG |          \
     ALTER_NULLABLE_FLAG | ALTER_DEFAULT_FLAG | ALTER_UNIQUE_FLAG |            \
     ALTER_DOMAIN_FLAG | ALTER_ALTERNATIVE_NAME_FLAG | ALTER_COMMENT_FLAG)
 
#define ALTER_GEOM_FIELD_DEFN_NAME_FLAG 0x1000
 
#define ALTER_GEOM_FIELD_DEFN_TYPE_FLAG 0x2000
 
#define ALTER_GEOM_FIELD_DEFN_NULLABLE_FLAG 0x4000
 
#define ALTER_GEOM_FIELD_DEFN_SRS_FLAG 0x8000
 
#define ALTER_GEOM_FIELD_DEFN_SRS_COORD_EPOCH_FLAG 0x10000
 
#define ALTER_GEOM_FIELD_DEFN_ALL_FLAG                                         \
    (ALTER_GEOM_FIELD_DEFN_NAME_FLAG | ALTER_GEOM_FIELD_DEFN_TYPE_FLAG |       \
     ALTER_GEOM_FIELD_DEFN_NULLABLE_FLAG | ALTER_GEOM_FIELD_DEFN_SRS_FLAG |    \
     ALTER_GEOM_FIELD_DEFN_SRS_COORD_EPOCH_FLAG)
 
#define OGR_F_VAL_NULL 0x00000001
 
#define OGR_F_VAL_GEOM_TYPE 0x00000002
 
#define OGR_F_VAL_WIDTH 0x00000004
 
#define OGR_F_VAL_ALLOW_NULL_WHEN_DEFAULT 0x00000008
 
#define OGR_F_VAL_ALLOW_DIFFERENT_GEOM_DIM 0x00000010
 
#define OGR_F_VAL_ALL (0x7FFFFFFF & ~OGR_F_VAL_ALLOW_DIFFERENT_GEOM_DIM)
 
/************************************************************************/
/*                  ogr_feature.h related definitions.                  */
/************************************************************************/
 
typedef enum
{
    OFTMaxType = 13
} OGRFieldType;
 
typedef enum
{
    OFSTBoolean = 1,
    OFSTInt16 = 2,
    OFSTFloat32 = 3,
    OFSTJSON = 4,
    OFSTUUID = 5,
    OFSTMaxSubType = 5
} OGRFieldSubType;
 
typedef enum
{
    OJUndefined = 0,
    OJLeft = 1,
    OJRight = 2
} OGRJustification;
 
#define OGRNullFID -1
 
/* Special value for an unknown field type. This should only be used
 * while reading a file. At the end of file any unknown types should
 * be set to OFTString.
 */
#define OGRUnknownType static_cast<OGRFieldType>(-1)
#define OGRUnsetMarker -21121
 
#define OGRNullMarker -21122
 
#define OGR_TZFLAG_UNKNOWN 0
 
#define OGR_TZFLAG_LOCALTIME 1
 
#define OGR_TZFLAG_MIXED_TZ 2
 
#define OGR_TZFLAG_UTC 100
 
/************************************************************************/
/*                               OGRField                               */
/************************************************************************/
 
typedef union
{
    int Integer;
    GIntBig Integer64;
    double Real;
    char *String;
 
    struct
    {
        int nCount;
        int *paList;
    } IntegerList;
 
    struct
    {
        int nCount;
        GIntBig *paList;
    } Integer64List;
 
    struct
    {
        int nCount;
        double *paList;
    } RealList;
 
    struct
    {
        int nCount;
        char **paList;
    } StringList;
 
    struct
    {
        int nCount;
        GByte *paData;
    } Binary;
 
    struct
    {
        int nMarker1;
        int nMarker2;
        int nMarker3;
    } Set;
 
    struct
    {
        GInt16 Year;
        GByte Month;
        GByte Day;
        GByte Hour;
        GByte Minute;
        GByte TZFlag;   /* 0=unknown, 1=localtime(ambiguous),
                           100=GMT, 104=GMT+1, 80=GMT-5, etc */
        GByte Reserved; /* must be set to 0 */
        float Second; /* with millisecond accuracy. at the end of the structure,
                         so as to keep it 12 bytes on 32 bit */
    } Date;
 
} OGRField;
 
int CPL_DLL OGR_GET_MS(float fSec);
 
#define OGRPARSEDATE_OPTION_LAX 1
 
int CPL_DLL OGRParseDate(const char *pszInput, OGRField *psOutput,
                         int nOptions);
 
/* -------------------------------------------------------------------- */
/*      Constants from ogrsf_frmts.h for capabilities.                  */
/* -------------------------------------------------------------------- */
#define OLCRandomRead "RandomRead" 
#define OLCSequentialWrite                                                     \
    "SequentialWrite" 
#define OLCRandomWrite "RandomWrite" 
#define OLCFastSpatialFilter                                                   \
    "FastSpatialFilter" 
#define OLCFastFeatureCount                                                    \
    "FastFeatureCount" 
#define OLCFastGetExtent                                                       \
    "FastGetExtent" 
#define OLCFastGetExtent3D                                                     \
    "FastGetExtent3D" 
#define OLCCreateField                                                         \
    "CreateField" 
#define OLCDeleteField                                                         \
    "DeleteField" 
#define OLCReorderFields                                                       \
    "ReorderFields" 
#define OLCAlterFieldDefn                                                      \
    "AlterFieldDefn" 
#define OLCAlterGeomFieldDefn                                                  \
    "AlterGeomFieldDefn" 
#define OLCTransactions                                                        \
    "Transactions" 
#define OLCDeleteFeature                                                       \
    "DeleteFeature" 
#define OLCUpsertFeature                                                       \
    "UpsertFeature" 
#define OLCUpdateFeature                                                       \
    "UpdateFeature" 
#define OLCFastSetNextByIndex                                                  \
    "FastSetNextByIndex" 
#define OLCStringsAsUTF8                                                       \
    "StringsAsUTF8" 
#define OLCIgnoreFields                                                        \
    "IgnoreFields" 
#define OLCCreateGeomField                                                     \
    "CreateGeomField" 
#define OLCCurveGeometries                                                     \
    "CurveGeometries" 
#define OLCMeasuredGeometries                                                  \
    "MeasuredGeometries" 
#define OLCZGeometries                                                         \
    "ZGeometries" 
#define OLCRename                                                              \
    "Rename" 
#define OLCFastGetArrowStream                                                  \
    "FastGetArrowStream" 
#define OLCFastWriteArrowBatch                                                 \
    "FastWriteArrowBatch" 
#define ODsCCreateLayer                                                        \
    "CreateLayer" 
#define ODsCDeleteLayer                                                        \
    "DeleteLayer" 
/* Reserved:                   "RenameLayer" */
#define ODsCCreateGeomFieldAfterCreateLayer                                    \
    "CreateGeomFieldAfterCreateLayer" 
#define ODsCCurveGeometries                                                    \
    "CurveGeometries" 
#define ODsCTransactions                                                       \
    "Transactions" 
#define ODsCEmulatedTransactions                                               \
    "EmulatedTransactions" 
#define ODsCMeasuredGeometries                                                 \
    "MeasuredGeometries" 
#define ODsCZGeometries                                                        \
    "ZGeometries" 
#define ODsCRandomLayerRead                                                    \
    "RandomLayerRead" 
/* Note the unfortunate trailing space at the end of the string */
#define ODsCRandomLayerWrite                                                   \
    "RandomLayerWrite " 
#define ODsCAddFieldDomain                                                     \
    "AddFieldDomain" 
#define ODsCDeleteFieldDomain                                                  \
    "DeleteFieldDomain" 
#define ODsCUpdateFieldDomain                                                  \
    "UpdateFieldDomain" 
#define ODrCCreateDataSource                                                   \
    "CreateDataSource" 
#define ODrCDeleteDataSource                                                   \
    "DeleteDataSource" 
/* -------------------------------------------------------------------- */
/*      Layer metadata items.                                           */
/* -------------------------------------------------------------------- */
#define OLMD_FID64 "OLMD_FID64"
 
/************************************************************************/
/*                  ogr_featurestyle.h related definitions.             */
/************************************************************************/
 
typedef enum ogr_style_tool_class_id
{
    OGRSTCNone = 0,   
    OGRSTCPen = 1,    
    OGRSTCBrush = 2,  
    OGRSTCSymbol = 3, 
    OGRSTCLabel = 4,  
    OGRSTCVector = 5  
} OGRSTClassId;
 
typedef enum ogr_style_tool_units_id
{
    OGRSTUGround = 0, 
    OGRSTUPixel = 1,  
    OGRSTUPoints = 2, 
    OGRSTUMM = 3,     
    OGRSTUCM = 4,     
    OGRSTUInches = 5  
} OGRSTUnitId;
 
typedef enum ogr_style_tool_param_pen_id
{
    OGRSTPenColor = 0,     
    OGRSTPenWidth = 1,     
    OGRSTPenPattern = 2,   
    OGRSTPenId = 3,        
    OGRSTPenPerOffset = 4, 
    OGRSTPenCap = 5,       
    OGRSTPenJoin = 6,      
    OGRSTPenPriority = 7,  
#ifndef DOXYGEN_SKIP
    OGRSTPenLast = 8
#endif
} OGRSTPenParam;
 
typedef enum ogr_style_tool_param_brush_id
{
    OGRSTBrushFColor = 0,   
    OGRSTBrushBColor = 1,   
    OGRSTBrushId = 2,       
    OGRSTBrushAngle = 3,    
    OGRSTBrushSize = 4,     
    OGRSTBrushDx = 5,       
    OGRSTBrushDy = 6,       
    OGRSTBrushPriority = 7, 
#ifndef DOXYGEN_SKIP
    OGRSTBrushLast = 8
#endif
 
} OGRSTBrushParam;
 
typedef enum ogr_style_tool_param_symbol_id
{
    OGRSTSymbolId = 0,        
    OGRSTSymbolAngle = 1,     
    OGRSTSymbolColor = 2,     
    OGRSTSymbolSize = 3,      
    OGRSTSymbolDx = 4,        
    OGRSTSymbolDy = 5,        
    OGRSTSymbolStep = 6,      
    OGRSTSymbolPerp = 7,      
    OGRSTSymbolOffset = 8,    
    OGRSTSymbolPriority = 9,  
    OGRSTSymbolFontName = 10, 
    OGRSTSymbolOColor = 11,   
#ifndef DOXYGEN_SKIP
    OGRSTSymbolLast = 12
#endif
} OGRSTSymbolParam;
 
typedef enum ogr_style_tool_param_label_id
{
    OGRSTLabelFontName = 0,   
    OGRSTLabelSize = 1,       
    OGRSTLabelTextString = 2, 
    OGRSTLabelAngle = 3,      
    OGRSTLabelFColor = 4,     
    OGRSTLabelBColor = 5,     
    OGRSTLabelPlacement = 6,  
    OGRSTLabelAnchor = 7,     
    OGRSTLabelDx = 8,         
    OGRSTLabelDy = 9,         
    OGRSTLabelPerp = 10,      
    OGRSTLabelBold = 11,      
    OGRSTLabelItalic = 12,    
    OGRSTLabelUnderline = 13, 
    OGRSTLabelPriority = 14,  
    OGRSTLabelStrikeout = 15, 
    OGRSTLabelStretch = 16,   
    OGRSTLabelAdjHor = 17,    
    OGRSTLabelAdjVert = 18,   
    OGRSTLabelHColor = 19,    
    OGRSTLabelOColor = 20,    
#ifndef DOXYGEN_SKIP
    OGRSTLabelLast = 21
#endif
} OGRSTLabelParam;
 
/* -------------------------------------------------------------------- */
/*                          Field domains                               */
/* -------------------------------------------------------------------- */
 
typedef struct
{
    char *pszCode;
 
    char *pszValue;
} OGRCodedValue;
 
typedef enum
{
    OFDT_CODED,
    OFDT_RANGE,
    OFDT_GLOB
} OGRFieldDomainType;
 
typedef enum
{
    OFDSP_DEFAULT_VALUE,
    OFDSP_DUPLICATE,
    OFDSP_GEOMETRY_RATIO
} OGRFieldDomainSplitPolicy;
 
typedef enum
{
    OFDMP_DEFAULT_VALUE,
    OFDMP_SUM,
    OFDMP_GEOMETRY_WEIGHTED
} OGRFieldDomainMergePolicy;
 
/* ------------------------------------------------------------------- */
/*                        Version checking                             */
/* -------------------------------------------------------------------- */
 
#ifndef DOXYGEN_SKIP
 
/* Note to developers : please keep this section in sync with gdal.h */
 
#ifndef GDAL_VERSION_INFO_DEFINED
#define GDAL_VERSION_INFO_DEFINED
const char CPL_DLL *CPL_STDCALL GDALVersionInfo(const char *);
#endif
 
#ifndef GDAL_CHECK_VERSION
 
int CPL_DLL CPL_STDCALL GDALCheckVersion(int nVersionMajor, int nVersionMinor,
                                         const char *pszCallingComponentName);
 
#define GDAL_CHECK_VERSION(pszCallingComponentName)                            \
    GDALCheckVersion(GDAL_VERSION_MAJOR, GDAL_VERSION_MINOR,                   \
                     pszCallingComponentName)
 
#endif
 
#endif /* #ifndef DOXYGEN_SKIP */
 
CPL_C_END
 
#endif /* ndef OGR_CORE_H_INCLUDED */