LCOV - code coverage report
Current view: top level - ogr - ogr_p.h (source / functions) Hit Total Coverage
Test: gdal_filtered.info Lines: 31 31 100.0 %
Date: 2025-07-09 17:50:03 Functions: 8 8 100.0 %

          Line data    Source code
       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  OpenGIS Simple Features Reference Implementation
       4             :  * Purpose:  Some private helper functions and stuff for OGR implementation.
       5             :  * Author:   Frank Warmerdam, warmerdam@pobox.com
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 1999, Frank Warmerdam
       9             :  * Copyright (c) 2008-2014, Even Rouault <even dot rouault at spatialys.com>
      10             :  *
      11             :  * SPDX-License-Identifier: MIT
      12             :  ****************************************************************************/
      13             : 
      14             : #ifndef OGR_P_H_INCLUDED
      15             : #define OGR_P_H_INCLUDED
      16             : 
      17             : /* -------------------------------------------------------------------- */
      18             : /*      Include the common portability library ... lets us do lots      */
      19             : /*      of stuff easily.                                                */
      20             : /* -------------------------------------------------------------------- */
      21             : 
      22             : #include "cpl_string.h"
      23             : #include "cpl_conv.h"
      24             : #include "cpl_minixml.h"
      25             : 
      26             : #include "ogr_core.h"
      27             : 
      28             : #include <limits>
      29             : #include <string_view>
      30             : 
      31             : class OGRGeometry;
      32             : class OGRFieldDefn;
      33             : 
      34             : /* A default name for the default geometry column, instead of '' */
      35             : #define OGR_GEOMETRY_DEFAULT_NON_EMPTY_NAME "_ogr_geometry_"
      36             : 
      37             : #ifdef CPL_MSB
      38             : #define OGR_SWAP(x) (x == wkbNDR)
      39             : #else
      40             : #define OGR_SWAP(x) (x == wkbXDR)
      41             : #endif
      42             : 
      43             : /* PostGIS 1.X has non standard codes for the following geometry types */
      44             : #define POSTGIS15_CURVEPOLYGON 13 /* instead of 10 */
      45             : #define POSTGIS15_MULTICURVE 14   /* instead of 11 */
      46             : #define POSTGIS15_MULTISURFACE 15 /* instead of 12 */
      47             : 
      48             : /* Has been deprecated. Can only be used in very specific circumstances */
      49             : #ifdef GDAL_COMPILATION
      50             : #define wkb25DBitInternalUse 0x80000000
      51             : #endif
      52             : 
      53             : /* -------------------------------------------------------------------- */
      54             : /*      helper function for parsing well known text format vector objects.*/
      55             : /* -------------------------------------------------------------------- */
      56             : 
      57             : #ifdef OGR_GEOMETRY_H_INCLUDED
      58             : #define OGR_WKT_TOKEN_MAX 64
      59             : 
      60             : const char CPL_DLL *OGRWktReadToken(const char *pszInput, char *pszToken);
      61             : 
      62             : const char CPL_DLL *OGRWktReadPoints(const char *pszInput,
      63             :                                      OGRRawPoint **ppaoPoints, double **ppadfZ,
      64             :                                      int *pnMaxPoints, int *pnReadPoints);
      65             : 
      66             : const char CPL_DLL *
      67             : OGRWktReadPointsM(const char *pszInput, OGRRawPoint **ppaoPoints,
      68             :                   double **ppadfZ, double **ppadfM,
      69             :                   int *flags, /* geometry flags, are we expecting Z, M, or both;
      70             :                                  may change due to input */
      71             :                   int *pnMaxPoints, int *pnReadPoints);
      72             : 
      73             : void CPL_DLL OGRMakeWktCoordinate(char *, double, double, double, int);
      74             : std::string CPL_DLL OGRMakeWktCoordinate(double, double, double, int,
      75             :                                          const OGRWktOptions &opts);
      76             : void CPL_DLL OGRMakeWktCoordinateM(char *, double, double, double, double,
      77             :                                    OGRBoolean, OGRBoolean);
      78             : std::string CPL_DLL OGRMakeWktCoordinateM(double, double, double, double,
      79             :                                           OGRBoolean, OGRBoolean,
      80             :                                           const OGRWktOptions &opts);
      81             : 
      82             : #endif
      83             : 
      84             : void CPL_DLL OGRFormatDouble(char *pszBuffer, int nBufferLen, double dfVal,
      85             :                              char chDecimalSep, int nPrecision = 15,
      86             :                              char chConversionSpecifier = 'f');
      87             : 
      88             : #ifdef OGR_GEOMETRY_H_INCLUDED
      89             : std::string CPL_DLL OGRFormatDouble(double val, const OGRWktOptions &opts,
      90             :                                     int nDimIdx);
      91             : #endif
      92             : 
      93             : int OGRFormatFloat(char *pszBuffer, int nBufferLen, float fVal, int nPrecision,
      94             :                    char chConversionSpecifier);
      95             : 
      96             : /* -------------------------------------------------------------------- */
      97             : /*      Date-time parsing and processing functions                      */
      98             : /* -------------------------------------------------------------------- */
      99             : 
     100             : /* Internal use by OGR drivers only, CPL_DLL is just there in case */
     101             : /* they are compiled as plugins  */
     102             : 
     103             : int CPL_DLL OGRTimezoneToTZFlag(const char *pszTZ,
     104             :                                 bool bEmitErrorIfUnhandledFormat);
     105             : std::string CPL_DLL OGRTZFlagToTimezone(int nTZFlag,
     106             :                                         const char *pszUTCRepresentation);
     107             : 
     108             : int CPL_DLL OGRGetDayOfWeek(int day, int month, int year);
     109             : int CPL_DLL OGRParseXMLDateTime(const char *pszXMLDateTime, OGRField *psField);
     110             : int CPL_DLL OGRParseRFC822DateTime(const char *pszRFC822DateTime,
     111             :                                    OGRField *psField);
     112             : char CPL_DLL *OGRGetRFC822DateTime(const OGRField *psField);
     113             : char CPL_DLL *OGRGetXMLDateTime(const OGRField *psField);
     114             : char CPL_DLL *OGRGetXMLDateTime(const OGRField *psField,
     115             :                                 bool bAlwaysMillisecond);
     116             : // 30 = strlen("YYYY-MM-DDThh:mm:ss.sss+hh:mm") + 1
     117             : #define OGR_SIZEOF_ISO8601_DATETIME_BUFFER 30
     118             : int CPL_DLL
     119             : OGRGetISO8601DateTime(const OGRField *psField, bool bAlwaysMillisecond,
     120             :                       char szBuffer[OGR_SIZEOF_ISO8601_DATETIME_BUFFER]);
     121             : 
     122             : /** Precision of formatting */
     123             : enum class OGRISO8601Precision
     124             : {
     125             :     /** Automated mode: millisecond included if non zero, otherwise truncated at second */
     126             :     AUTO,
     127             :     /** Always include millisecond */
     128             :     MILLISECOND,
     129             :     /** Always include second, but no millisecond */
     130             :     SECOND,
     131             :     /** Always include minute, but no second */
     132             :     MINUTE
     133             : };
     134             : 
     135             : /** Configuration of the ISO8601 formatting output */
     136             : struct OGRISO8601Format
     137             : {
     138             :     /** Precision of formatting */
     139             :     OGRISO8601Precision ePrecision;
     140             : };
     141             : 
     142             : int CPL_DLL
     143             : OGRGetISO8601DateTime(const OGRField *psField, const OGRISO8601Format &sFormat,
     144             :                       char szBuffer[OGR_SIZEOF_ISO8601_DATETIME_BUFFER]);
     145             : char CPL_DLL *OGRGetXML_UTF8_EscapedString(const char *pszString);
     146             : 
     147             : #ifdef GDAL_COMPILATION
     148             : bool CPL_DLL OGRParseDateTimeYYYYMMDDTHHMMZ(std::string_view sInput,
     149             :                                             OGRField *psField);
     150             : bool CPL_DLL OGRParseDateTimeYYYYMMDDTHHMMSSZ(std::string_view sInput,
     151             :                                               OGRField *psField);
     152             : bool CPL_DLL OGRParseDateTimeYYYYMMDDTHHMMSSsssZ(std::string_view sInput,
     153             :                                                  OGRField *psField);
     154             : #endif
     155             : 
     156             : int OGRCompareDate(const OGRField *psFirstTuple,
     157             :                    const OGRField *psSecondTuple); /* used by ogr_gensql.cpp and
     158             :                                                       ogrfeaturequery.cpp */
     159             : 
     160             : /* General utility option processing. */
     161             : int CPL_DLL OGRGeneralCmdLineProcessor(int nArgc, char ***ppapszArgv,
     162             :                                        int nOptions);
     163             : 
     164             : /************************************************************************/
     165             : /*     Support for special attributes (feature query and selection)     */
     166             : /************************************************************************/
     167             : #define SPF_FID 0
     168             : #define SPF_OGR_GEOMETRY 1
     169             : #define SPF_OGR_STYLE 2
     170             : #define SPF_OGR_GEOM_WKT 3
     171             : #define SPF_OGR_GEOM_AREA 4
     172             : #define SPECIAL_FIELD_COUNT 5
     173             : 
     174             : extern const char *const SpecialFieldNames[SPECIAL_FIELD_COUNT];
     175             : 
     176             : /************************************************************************/
     177             : /*     Some SRS related stuff, search in SRS data files.                */
     178             : /************************************************************************/
     179             : 
     180             : OGRErr CPL_DLL OSRGetEllipsoidInfo(int, char **, double *, double *);
     181             : 
     182             : /* Fast atof function */
     183             : double OGRFastAtof(const char *pszStr);
     184             : 
     185             : OGRErr CPL_DLL OGRCheckPermutation(const int *panPermutation, int nSize);
     186             : 
     187             : /* GML related */
     188             : 
     189             : OGRGeometry CPL_DLL *GML2OGRGeometry_XMLNode(
     190             :     const CPLXMLNode *psNode, int nPseudoBoolGetSecondaryGeometryOption,
     191             :     int nRecLevel = 0, int nSRSDimension = 0, bool bIgnoreGSG = false,
     192             :     bool bOrientation = true, bool bFaceHoleNegative = false,
     193             :     const char *pszId = nullptr);
     194             : 
     195             : /************************************************************************/
     196             : /*                        PostGIS EWKB encoding                         */
     197             : /************************************************************************/
     198             : 
     199             : OGRGeometry CPL_DLL *OGRGeometryFromEWKB(GByte *pabyWKB, int nLength,
     200             :                                          int *pnSRID, int bIsPostGIS1_EWKB);
     201             : OGRGeometry CPL_DLL *OGRGeometryFromHexEWKB(const char *pszBytea, int *pnSRID,
     202             :                                             int bIsPostGIS1_EWKB);
     203             : char CPL_DLL *OGRGeometryToHexEWKB(OGRGeometry *poGeometry, int nSRSId,
     204             :                                    int nPostGISMajor, int nPostGISMinor);
     205             : 
     206             : /************************************************************************/
     207             : /*                        WKB Type Handling encoding                    */
     208             : /************************************************************************/
     209             : 
     210             : OGRErr CPL_DLL OGRReadWKBGeometryType(const unsigned char *pabyData,
     211             :                                       OGRwkbVariant wkbVariant,
     212             :                                       OGRwkbGeometryType *eGeometryType);
     213             : 
     214             : /************************************************************************/
     215             : /*                        WKT Type Handling encoding                    */
     216             : /************************************************************************/
     217             : 
     218             : OGRErr CPL_DLL OGRReadWKTGeometryType(const char *pszWKT,
     219             :                                       OGRwkbGeometryType *peGeometryType);
     220             : 
     221             : /************************************************************************/
     222             : /*                            Other                                     */
     223             : /************************************************************************/
     224             : 
     225             : void CPL_DLL OGRUpdateFieldType(OGRFieldDefn *poFDefn, OGRFieldType eNewType,
     226             :                                 OGRFieldSubType eNewSubType);
     227             : 
     228             : /************************************************************************/
     229             : /*                         OGRRoundValueIEEE754()                       */
     230             : /************************************************************************/
     231             : 
     232             : /** Set to zero least significants bits of a double precision floating-point
     233             :  * number (passed as an integer), taking into account a desired bit precision.
     234             :  *
     235             :  * @param nVal Integer representation of a IEEE754 double-precision number.
     236             :  * @param nBitsPrecision Desired precision (number of bits after integral part)
     237             :  * @return quantized nVal.
     238             :  * @since GDAL 3.9
     239             :  */
     240             : inline uint64_t OGRRoundValueIEEE754(uint64_t nVal,
     241             :                                      int nBitsPrecision) CPL_WARN_UNUSED_RESULT;
     242             : 
     243         104 : inline uint64_t OGRRoundValueIEEE754(uint64_t nVal, int nBitsPrecision)
     244             : {
     245         104 :     constexpr int MANTISSA_SIZE = std::numeric_limits<double>::digits - 1;
     246         104 :     constexpr int MAX_EXPONENT = std::numeric_limits<double>::max_exponent;
     247             : #if __cplusplus >= 201703L
     248             :     static_assert(MANTISSA_SIZE == 52);
     249             :     static_assert(MAX_EXPONENT == 1024);
     250             : #endif
     251             :     // Extract the binary exponent from the IEEE754 representation
     252         104 :     const int nExponent =
     253         104 :         ((nVal >> MANTISSA_SIZE) & (2 * MAX_EXPONENT - 1)) - (MAX_EXPONENT - 1);
     254             :     // Add 1 to round-up and the desired precision
     255         104 :     const int nBitsRequired = 1 + nExponent + nBitsPrecision;
     256             :     // Compute number of nullified bits
     257         104 :     int nNullifiedBits = MANTISSA_SIZE - nBitsRequired;
     258             :     // this will also capture NaN and Inf since nExponent = 1023,
     259             :     // and thus nNullifiedBits < 0
     260         104 :     if (nNullifiedBits <= 0)
     261           2 :         return nVal;
     262         102 :     if (nNullifiedBits >= MANTISSA_SIZE)
     263           2 :         nNullifiedBits = MANTISSA_SIZE;
     264         102 :     nVal >>= nNullifiedBits;
     265         102 :     nVal <<= nNullifiedBits;
     266         102 :     return nVal;
     267             : }
     268             : 
     269             : /************************************************************************/
     270             : /*                   OGRRoundCoordinatesIEEE754XYValues()               */
     271             : /************************************************************************/
     272             : 
     273             : /** Quantize XY values.
     274             :  *
     275             :  * @since GDAL 3.9
     276             :  */
     277             : template <int SPACING>
     278      673282 : inline void OGRRoundCoordinatesIEEE754XYValues(int nBitsPrecision,
     279             :                                                GByte *pabyBase, size_t nPoints)
     280             : {
     281             :     // Note: we use SPACING as template for improved code generation.
     282             : 
     283      673282 :     if (nBitsPrecision != INT_MIN)
     284             :     {
     285          42 :         for (size_t i = 0; i < nPoints; i++)
     286             :         {
     287             :             uint64_t nVal;
     288             : 
     289          29 :             memcpy(&nVal, pabyBase + SPACING * i, sizeof(uint64_t));
     290          29 :             nVal = OGRRoundValueIEEE754(nVal, nBitsPrecision);
     291          29 :             memcpy(pabyBase + SPACING * i, &nVal, sizeof(uint64_t));
     292             : 
     293          29 :             memcpy(&nVal, pabyBase + sizeof(uint64_t) + SPACING * i,
     294             :                    sizeof(uint64_t));
     295          29 :             nVal = OGRRoundValueIEEE754(nVal, nBitsPrecision);
     296          29 :             memcpy(pabyBase + sizeof(uint64_t) + SPACING * i, &nVal,
     297             :                    sizeof(uint64_t));
     298             :         }
     299             :     }
     300      673282 : }
     301             : 
     302             : /************************************************************************/
     303             : /*                     OGRRoundCoordinatesIEEE754()                     */
     304             : /************************************************************************/
     305             : 
     306             : /** Quantize Z or M values.
     307             :  *
     308             :  * @since GDAL 3.9
     309             :  */
     310             : template <int SPACING>
     311      215510 : inline void OGRRoundCoordinatesIEEE754(int nBitsPrecision, GByte *pabyBase,
     312             :                                        size_t nPoints)
     313             : {
     314      215510 :     if (nBitsPrecision != INT_MIN)
     315             :     {
     316          52 :         for (size_t i = 0; i < nPoints; i++)
     317             :         {
     318             :             uint64_t nVal;
     319             : 
     320          34 :             memcpy(&nVal, pabyBase + SPACING * i, sizeof(uint64_t));
     321          34 :             nVal = OGRRoundValueIEEE754(nVal, nBitsPrecision);
     322          34 :             memcpy(pabyBase + SPACING * i, &nVal, sizeof(uint64_t));
     323             :         }
     324             :     }
     325      215510 : }
     326             : 
     327             : /* -------------------------------------------------------------------- */
     328             : /*      helper functions for string escaping.                           */
     329             : /* -------------------------------------------------------------------- */
     330             : 
     331             : /** Replace all occurrences of ch by it repeated twice.
     332             :  * Typically used for SQL string literal or identifier escaping.
     333             :  */
     334             : std::string CPL_DLL OGRDuplicateCharacter(const std::string &osStr, char ch);
     335             : 
     336             : #endif /* ndef OGR_P_H_INCLUDED */

Generated by: LCOV version 1.14