ogr_core.h

Go to the documentation of this file.

/******************************************************************************
 * $Id: ogr_core.h 3b0c26d57528326c074a9c82890e737e2d516a7d 2022-02-23 14:39:49Z Andrew C Aitchison $
 *
 * 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>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ****************************************************************************/
 
#ifndef OGR_CORE_H_INCLUDED
#define OGR_CORE_H_INCLUDED
 
#include "cpl_port.h"
#if defined(GDAL_COMPILATION)
#define DO_NOT_DEFINE_GDAL_RELEASE_DATE_AND_GDAL_RELEASE_NAME
#endif
#include "gdal_version.h"

 
#if defined(__cplusplus) && !defined(CPL_SUPRESS_CPLUSPLUS)
 
extern "C++"
{
#if !defined(DOXYGEN_SKIP)
#include <limits>
#endif

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;

    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( 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.                             */
/* -------------------------------------------------------------------- */

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;

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_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_ALL_FLAG             (ALTER_NAME_FLAG | ALTER_TYPE_FLAG | ALTER_WIDTH_PRECISION_FLAG | ALTER_NULLABLE_FLAG | ALTER_DEFAULT_FLAG | ALTER_UNIQUE_FLAG | ALTER_DOMAIN_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
{                   OFTInteger = 0,                 OFTIntegerList = 1,        OFTReal = 2,                        OFTRealList = 3,                  OFTString = 4,                       OFTStringList = 5,                             OFTWideString = 6,                             OFTWideStringList = 7,                        OFTBinary = 8,                                   OFTDate = 9,                                   OFTTime = 10,                          OFTDateTime = 11,                   OFTInteger64 = 12,                 OFTInteger64List = 13,
                                                OFTMaxType = 13
} OGRFieldType;

typedef enum
{        OFSTNone = 0,
                                                        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
 
/************************************************************************/
/*                               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;
 
#ifdef __cplusplus
inline int OGR_GET_MS(float fSec) {
  if( CPLIsNan(fSec) ) return 0;
  if( fSec >= 999 ) return 999;
  if( fSec <= 0 ) return 0;
  const float fValue = (fSec - static_cast<int>(fSec)) * 1000 + 0.5f;
  return static_cast<int>(fValue);
}
#endif  // __cplusplus
 
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 OLCCreateField         "CreateField"        
#define OLCDeleteField         "DeleteField"        
#define OLCReorderFields       "ReorderFields"      
#define OLCAlterFieldDefn      "AlterFieldDefn"     
#define OLCTransactions        "Transactions"       
#define OLCDeleteFeature       "DeleteFeature"      
#define OLCFastSetNextByIndex  "FastSetNextByIndex" 
#define OLCStringsAsUTF8       "StringsAsUTF8"      
#define OLCIgnoreFields        "IgnoreFields"       
#define OLCCreateGeomField     "CreateGeomField"    
#define OLCCurveGeometries     "CurveGeometries"    
#define OLCMeasuredGeometries  "MeasuredGeometries" 
 
#define ODsCCreateLayer        "CreateLayer"        
#define ODsCDeleteLayer        "DeleteLayer"        
#define ODsCCreateGeomFieldAfterCreateLayer   "CreateGeomFieldAfterCreateLayer" 
#define ODsCCurveGeometries    "CurveGeometries"    
#define ODsCTransactions       "Transactions"       
#define ODsCEmulatedTransactions "EmulatedTransactions" 
#define ODsCMeasuredGeometries "MeasuredGeometries"     
#define ODsCRandomLayerRead     "RandomLayerRead"   
/* Note the unfortunate trailing space at the end of the string */
#define ODsCRandomLayerWrite    "RandomLayerWrite " 
#define ODsCAddFieldDomain     "AddFieldDomain"    
 
#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 */