Line data    Source code

       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  OGR
       4             :  * Purpose:  Implements OGRGMLLayer class.
       5             :  * Author:   Frank Warmerdam, warmerdam@pobox.com
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 2002, Frank Warmerdam <warmerdam@pobox.com>
       9             :  * Copyright (c) 2009-2013, Even Rouault <even dot rouault at spatialys.com>
      10             :  *
      11             :  * SPDX-License-Identifier: MIT
      12             :  ****************************************************************************/
      13             : 
      14             : #include "ogr_gml.h"
      15             : #include "gmlutils.h"
      16             : #include "cpl_conv.h"
      17             : #include "cpl_port.h"
      18             : #include "cpl_string.h"
      19             : #include "ogr_p.h"
      20             : #include "ogr_api.h"
      21             : 
      22             : #include <limits>
      23             : 
      24             : /************************************************************************/
      25             : /*                           OGRGMLLayer()                              */
      26             : /************************************************************************/
      27             : 
      28         713 : OGRGMLLayer::OGRGMLLayer(const char *pszName, bool bWriterIn,
      29         713 :                          OGRGMLDataSource *poDSIn)
      30             :     : poFeatureDefn(new OGRFeatureDefn(
      31         713 :           pszName + (STARTS_WITH_CI(pszName, "ogr:") ? 4 : 0))),
      32             :       bWriter(bWriterIn), poDS(poDSIn),
      33         713 :       poFClass(!bWriter ? poDS->GetReader()->GetClass(pszName) : nullptr),
      34             :       // Reader's should get the corresponding GMLFeatureClass and cache it.
      35        1426 :       hCacheSRS(GML_BuildOGRGeometryFromList_CreateCache()),
      36             :       // Compatibility option. Not advertized, because hopefully won't be
      37             :       // needed. Just put here in case.
      38             :       bUseOldFIDFormat(
      39         713 :           CPLTestBool(CPLGetConfigOption("GML_USE_OLD_FID_FORMAT", "FALSE"))),
      40             :       // Must be in synced in OGR_G_CreateFromGML(), OGRGMLLayer::OGRGMLLayer()
      41             :       // and GMLReader::GMLReader().
      42             :       bFaceHoleNegative(
      43        2852 :           CPLTestBool(CPLGetConfigOption("GML_FACE_HOLE_NEGATIVE", "NO")))
      44             : {
      45         713 :     SetDescription(poFeatureDefn->GetName());
      46         713 :     poFeatureDefn->Reference();
      47         713 :     poFeatureDefn->SetGeomType(wkbNone);
      48         713 : }
      49             : 
      50             : /************************************************************************/
      51             : /*                           ~OGRGMLLayer()                           */
      52             : /************************************************************************/
      53             : 
      54        1426 : OGRGMLLayer::~OGRGMLLayer()
      55             : 
      56             : {
      57         713 :     CPLFree(m_pszFIDPrefix);
      58             : 
      59         713 :     if (poFeatureDefn)
      60         713 :         poFeatureDefn->Release();
      61             : 
      62         713 :     GML_BuildOGRGeometryFromList_DestroyCache(hCacheSRS);
      63        1426 : }
      64             : 
      65             : /************************************************************************/
      66             : /*                            ResetReading()                            */
      67             : /************************************************************************/
      68             : 
      69         786 : void OGRGMLLayer::ResetReading()
      70             : 
      71             : {
      72         786 :     if (bWriter)
      73          16 :         return;
      74             : 
      75        1540 :     if (poDS->GetReadMode() == INTERLEAVED_LAYERS ||
      76         770 :         poDS->GetReadMode() == SEQUENTIAL_LAYERS)
      77             :     {
      78             :         // Does the last stored feature belong to our layer ? If so, no
      79             :         // need to reset the reader.
      80         100 :         if (m_iNextGMLId == 0 && poDS->PeekStoredGMLFeature() != nullptr &&
      81           0 :             poDS->PeekStoredGMLFeature()->GetClass() == poFClass)
      82           0 :             return;
      83             : 
      84         100 :         delete poDS->PeekStoredGMLFeature();
      85         100 :         poDS->SetStoredGMLFeature(nullptr);
      86             :     }
      87             : 
      88         770 :     m_iNextGMLId = 0;
      89         770 :     m_oSetFIDs.clear();
      90         770 :     poDS->GetReader()->ResetReading();
      91         770 :     CPLDebug("GML", "ResetReading()");
      92         770 :     if (poDS->GetLayerCount() > 1 && poDS->GetReadMode() == STANDARD)
      93             :     {
      94          78 :         const char *pszElementName = poFClass->GetElementName();
      95          78 :         const char *pszLastPipe = strrchr(pszElementName, '|');
      96          78 :         if (pszLastPipe != nullptr)
      97          33 :             pszElementName = pszLastPipe + 1;
      98          78 :         poDS->GetReader()->SetFilteredClassName(pszElementName);
      99             :     }
     100             : }
     101             : 
     102             : /************************************************************************/
     103             : /*                              Increment()                             */
     104             : /************************************************************************/
     105             : 
     106         755 : static GIntBig Increment(GIntBig nVal)
     107             : {
     108         755 :     if (nVal <= GINTBIG_MAX - 1)
     109         755 :         return nVal + 1;
     110           0 :     return nVal;
     111             : }
     112             : 
     113             : /************************************************************************/
     114             : /*                           GetNextFeature()                           */
     115             : /************************************************************************/
     116             : 
     117         875 : OGRFeature *OGRGMLLayer::GetNextFeature()
     118             : 
     119             : {
     120         875 :     if (bWriter)
     121             :     {
     122          16 :         CPLError(CE_Failure, CPLE_NotSupported,
     123             :                  "Cannot read features when writing a GML file");
     124          16 :         return nullptr;
     125             :     }
     126             : 
     127         859 :     if (poDS->GetLastReadLayer() != this)
     128             :     {
     129         403 :         if (poDS->GetReadMode() != INTERLEAVED_LAYERS)
     130         394 :             ResetReading();
     131         403 :         poDS->SetLastReadLayer(this);
     132             :     }
     133             : 
     134         859 :     const bool bSkipCorruptedFeatures = CPLFetchBool(
     135         859 :         poDS->GetOpenOptions(), "SKIP_CORRUPTED_FEATURES",
     136         859 :         CPLTestBool(CPLGetConfigOption("GML_SKIP_CORRUPTED_FEATURES", "NO")));
     137             : 
     138             :     /* ==================================================================== */
     139             :     /*      Loop till we find and translate a feature meeting all our       */
     140             :     /*      requirements.                                                   */
     141             :     /* ==================================================================== */
     142             :     while (true)
     143             :     {
     144        1733 :         GMLFeature *poGMLFeature = poDS->PeekStoredGMLFeature();
     145        1733 :         if (poGMLFeature != nullptr)
     146             :         {
     147           3 :             poDS->SetStoredGMLFeature(nullptr);
     148             :         }
     149             :         else
     150             :         {
     151        1730 :             poGMLFeature = poDS->GetReader()->NextFeature();
     152        1730 :             if (poGMLFeature == nullptr)
     153         859 :                 return nullptr;
     154             : 
     155             :             // We count reading low level GML features as a feature read for
     156             :             // work checking purposes, though at least we didn't necessary
     157             :             // have to turn it into an OGRFeature.
     158        1590 :             m_nFeaturesRead++;
     159             :         }
     160             : 
     161             :         /* --------------------------------------------------------------------
     162             :          */
     163             :         /*      Is it of the proper feature class? */
     164             :         /* --------------------------------------------------------------------
     165             :          */
     166             : 
     167        1593 :         if (poGMLFeature->GetClass() != poFClass)
     168             :         {
     169        2478 :             if (poDS->GetReadMode() == INTERLEAVED_LAYERS ||
     170        1650 :                 (poDS->GetReadMode() == SEQUENTIAL_LAYERS && m_iNextGMLId != 0))
     171             :             {
     172           4 :                 CPLAssert(poDS->PeekStoredGMLFeature() == nullptr);
     173           4 :                 poDS->SetStoredGMLFeature(poGMLFeature);
     174           4 :                 return nullptr;
     175             :             }
     176             :             else
     177             :             {
     178         824 :                 delete poGMLFeature;
     179         824 :                 continue;
     180             :             }
     181             :         }
     182             : 
     183             :         /* --------------------------------------------------------------------
     184             :          */
     185             :         /*      Extract the fid: */
     186             :         /*      -Assumes the fids are non-negative integers with an optional */
     187             :         /*       prefix */
     188             :         /*      -If a prefix differs from the prefix of the first feature from
     189             :          */
     190             :         /*       the poDS then the fids from the poDS are ignored and are */
     191             :         /*       assigned serially thereafter */
     192             :         /* --------------------------------------------------------------------
     193             :          */
     194         765 :         GIntBig nFID = -1;
     195         765 :         constexpr size_t MAX_FID_DIGIT_COUNT = 20;
     196         765 :         const char *pszGML_FID = poGMLFeature->GetFID();
     197         765 :         if (m_bInvalidFIDFound || pszGML_FID == nullptr || pszGML_FID[0] == 0)
     198             :         {
     199             :             // do nothing
     200             :         }
     201         607 :         else if (m_iNextGMLId == 0)
     202             :         {
     203         315 :             size_t j = 0;
     204         315 :             size_t i = strlen(pszGML_FID);
     205         753 :             while (i > 0 && j < MAX_FID_DIGIT_COUNT)
     206             :             {
     207         753 :                 --i;
     208         753 :                 if (!(pszGML_FID[i] >= '0' && pszGML_FID[i] <= '9'))
     209             :                     break;
     210         443 :                 j++;
     211         443 :                 if (i == 0)
     212             :                 {
     213           5 :                     i = std::numeric_limits<size_t>::max();
     214           5 :                     break;
     215             :                 }
     216             :             }
     217             :             // i points the last character of the fid prefix.
     218         625 :             if (i != std::numeric_limits<size_t>::max() &&
     219         625 :                 j < MAX_FID_DIGIT_COUNT && m_pszFIDPrefix == nullptr)
     220             :             {
     221         246 :                 m_pszFIDPrefix = static_cast<char *>(CPLMalloc(i + 2));
     222         246 :                 memcpy(m_pszFIDPrefix, pszGML_FID, i + 1);
     223         246 :                 m_pszFIDPrefix[i + 1] = '\0';
     224             :             }
     225             :             // m_pszFIDPrefix now contains the prefix or NULL if no prefix is
     226             :             // found.
     227         315 :             if (j < MAX_FID_DIGIT_COUNT)
     228             :             {
     229         315 :                 char *endptr = nullptr;
     230         315 :                 nFID = std::strtoll(
     231         315 :                     pszGML_FID +
     232         315 :                         (i != std::numeric_limits<size_t>::max() ? i + 1 : 0),
     233             :                     &endptr, 10);
     234         315 :                 if (endptr == pszGML_FID + strlen(pszGML_FID))
     235             :                 {
     236         315 :                     if (m_iNextGMLId <= nFID)
     237         315 :                         m_iNextGMLId = Increment(nFID);
     238             :                 }
     239             :                 else
     240             :                 {
     241           0 :                     nFID = -1;
     242             :                 }
     243             :             }
     244             :         }
     245             :         else  // if( iNextGMLId != 0 ).
     246             :         {
     247         292 :             const char *pszFIDPrefix_notnull = m_pszFIDPrefix;
     248         292 :             if (pszFIDPrefix_notnull == nullptr)
     249           9 :                 pszFIDPrefix_notnull = "";
     250         292 :             const size_t nLenPrefix = strlen(pszFIDPrefix_notnull);
     251             : 
     252         292 :             if (strncmp(pszGML_FID, pszFIDPrefix_notnull, nLenPrefix) == 0 &&
     253         287 :                 strlen(pszGML_FID + nLenPrefix) < MAX_FID_DIGIT_COUNT)
     254             :             {
     255         287 :                 char *endptr = nullptr;
     256         287 :                 nFID = std::strtoll(pszGML_FID + nLenPrefix, &endptr, 10);
     257         287 :                 if (endptr == pszGML_FID + strlen(pszGML_FID))
     258             :                 {
     259             :                     // fid with the prefix. Using its numerical part.
     260         285 :                     if (m_iNextGMLId <= nFID)
     261         274 :                         m_iNextGMLId = Increment(nFID);
     262             :                 }
     263             :                 else
     264             :                 {
     265           2 :                     nFID = -1;
     266             :                 }
     267             :             }
     268             :         }
     269             : 
     270         765 :         constexpr size_t MAX_FID_SET_SIZE = 10 * 1000 * 1000;
     271         765 :         if (nFID >= 0 && m_oSetFIDs.size() < MAX_FID_SET_SIZE)
     272             :         {
     273             :             // Make sure FIDs are unique
     274         600 :             if (!cpl::contains(m_oSetFIDs, nFID))
     275         599 :                 m_oSetFIDs.insert(nFID);
     276             :             else
     277             :             {
     278           1 :                 m_oSetFIDs.clear();
     279           1 :                 nFID = -1;
     280             :             }
     281             :         }
     282             : 
     283         765 :         if (nFID < 0)
     284             :         {
     285             :             // fid without the aforementioned prefix or a valid numerical
     286             :             // part.
     287         166 :             m_bInvalidFIDFound = true;
     288         166 :             nFID = m_iNextGMLId;
     289         166 :             m_iNextGMLId = Increment(m_iNextGMLId);
     290             :         }
     291             : 
     292             :         /* --------------------------------------------------------------------
     293             :          */
     294             :         /*      Does it satisfy the spatial query, if there is one? */
     295             :         /* --------------------------------------------------------------------
     296             :          */
     297             : 
     298         765 :         OGRGeometry **papoGeometries = nullptr;
     299         765 :         const CPLXMLNode *const *papsGeometry = poGMLFeature->GetGeometryList();
     300             : 
     301         765 :         const CPLXMLNode *apsGeometries[2] = {nullptr, nullptr};
     302             :         const CPLXMLNode *psBoundedByGeometry =
     303         765 :             poGMLFeature->GetBoundedByGeometry();
     304         765 :         if (psBoundedByGeometry && !(papsGeometry && papsGeometry[0]))
     305             :         {
     306           6 :             apsGeometries[0] = psBoundedByGeometry;
     307           6 :             papsGeometry = apsGeometries;
     308             :         }
     309             : 
     310         765 :         OGRGeometry *poGeom = nullptr;
     311             : 
     312         765 :         if (poFeatureDefn->GetGeomFieldCount() > 1)
     313             :         {
     314         188 :             papoGeometries = static_cast<OGRGeometry **>(CPLCalloc(
     315          94 :                 poFeatureDefn->GetGeomFieldCount(), sizeof(OGRGeometry *)));
     316          94 :             const char *pszSRSName = poDS->GetGlobalSRSName();
     317         301 :             for (int i = 0; i < poFeatureDefn->GetGeomFieldCount(); i++)
     318             :             {
     319         207 :                 const CPLXMLNode *psGeom = poGMLFeature->GetGeometryRef(i);
     320         207 :                 if (psGeom != nullptr)
     321             :                 {
     322         163 :                     const CPLXMLNode *myGeometryList[2] = {psGeom, nullptr};
     323         163 :                     poGeom = GML_BuildOGRGeometryFromList(
     324             :                         myGeometryList, true,
     325         163 :                         poDS->GetInvertAxisOrderIfLatLong(), pszSRSName,
     326         163 :                         poDS->GetConsiderEPSGAsURN(),
     327         163 :                         poDS->GetSwapCoordinates(),
     328         163 :                         poDS->GetSecondaryGeometryOption(), hCacheSRS,
     329         163 :                         bFaceHoleNegative);
     330             : 
     331             :                     // Do geometry type changes if needed to match layer
     332             :                     // geometry type.
     333         163 :                     if (poGeom != nullptr)
     334             :                     {
     335         163 :                         papoGeometries[i] = OGRGeometryFactory::forceTo(
     336             :                             poGeom,
     337         163 :                             poFeatureDefn->GetGeomFieldDefn(i)->GetType());
     338         163 :                         poGeom = nullptr;
     339             :                     }
     340             :                     else
     341             :                     {
     342             :                         // We assume the createFromGML() function would have
     343             :                         // already reported the error.
     344           0 :                         for (int j = 0; j < poFeatureDefn->GetGeomFieldCount();
     345             :                              j++)
     346             :                         {
     347           0 :                             delete papoGeometries[j];
     348             :                         }
     349           0 :                         CPLFree(papoGeometries);
     350           0 :                         delete poGMLFeature;
     351           0 :                         return nullptr;
     352             :                     }
     353             :                 }
     354             :             }
     355             : 
     356           0 :             if (m_poFilterGeom != nullptr && m_iGeomFieldFilter >= 0 &&
     357           0 :                 m_iGeomFieldFilter < poFeatureDefn->GetGeomFieldCount() &&
     358          94 :                 papoGeometries[m_iGeomFieldFilter] &&
     359           0 :                 !FilterGeometry(papoGeometries[m_iGeomFieldFilter]))
     360             :             {
     361           0 :                 for (int j = 0; j < poFeatureDefn->GetGeomFieldCount(); j++)
     362             :                 {
     363           0 :                     delete papoGeometries[j];
     364             :                 }
     365           0 :                 CPLFree(papoGeometries);
     366           0 :                 delete poGMLFeature;
     367           0 :                 continue;
     368             :             }
     369             :         }
     370         671 :         else if (papsGeometry[0] &&
     371         555 :                  strcmp(papsGeometry[0]->pszValue, "null") == 0)
     372             :         {
     373             :             // do nothing
     374             :         }
     375         667 :         else if (papsGeometry[0] != nullptr)
     376             :         {
     377         551 :             const char *pszSRSName = poDS->GetGlobalSRSName();
     378         551 :             CPLPushErrorHandler(CPLQuietErrorHandler);
     379         551 :             poGeom = GML_BuildOGRGeometryFromList(
     380         551 :                 papsGeometry, true, poDS->GetInvertAxisOrderIfLatLong(),
     381         551 :                 pszSRSName, poDS->GetConsiderEPSGAsURN(),
     382         551 :                 poDS->GetSwapCoordinates(), poDS->GetSecondaryGeometryOption(),
     383         551 :                 hCacheSRS, bFaceHoleNegative);
     384         551 :             CPLPopErrorHandler();
     385             : 
     386             :             // Do geometry type changes if needed to match layer geometry type.
     387         551 :             if (poGeom != nullptr)
     388             :             {
     389         547 :                 poGeom = OGRGeometryFactory::forceTo(poGeom, GetGeomType());
     390             :             }
     391             :             else
     392             :             {
     393           4 :                 const CPLString osLastErrorMsg(CPLGetLastErrorMsg());
     394             : 
     395           8 :                 CPLError(
     396             :                     bSkipCorruptedFeatures ? CE_Warning : CE_Failure,
     397             :                     CPLE_AppDefined,
     398             :                     "Geometry of feature " CPL_FRMT_GIB
     399             :                     " %scannot be parsed: %s%s",
     400           4 :                     nFID, pszGML_FID ? CPLSPrintf("%s ", pszGML_FID) : "",
     401             :                     osLastErrorMsg.c_str(),
     402             :                     bSkipCorruptedFeatures
     403             :                         ? ". Skipping to next feature."
     404             :                         : ". You may set the GML_SKIP_CORRUPTED_FEATURES "
     405             :                           "configuration option to YES to skip to the next "
     406             :                           "feature");
     407           4 :                 delete poGMLFeature;
     408           4 :                 if (bSkipCorruptedFeatures)
     409           2 :                     continue;
     410           2 :                 return nullptr;
     411             :             }
     412             : 
     413         547 :             if (m_poFilterGeom != nullptr && !FilterGeometry(poGeom))
     414             :             {
     415          20 :                 delete poGMLFeature;
     416          20 :                 delete poGeom;
     417          20 :                 continue;
     418             :             }
     419             :         }
     420             : 
     421             :         /* --------------------------------------------------------------------
     422             :          */
     423             :         /*      Convert the whole feature into an OGRFeature. */
     424             :         /* --------------------------------------------------------------------
     425             :          */
     426         741 :         int iDstField = 0;
     427         741 :         OGRFeature *poOGRFeature = new OGRFeature(poFeatureDefn);
     428             : 
     429         741 :         poOGRFeature->SetFID(nFID);
     430         741 :         if (poDS->ExposeId())
     431             :         {
     432         633 :             if (pszGML_FID)
     433         590 :                 poOGRFeature->SetField(iDstField, pszGML_FID);
     434         633 :             iDstField++;
     435             :         }
     436             : 
     437         741 :         const int nPropertyCount = poFClass->GetPropertyCount();
     438        3524 :         for (int iField = 0; iField < nPropertyCount; iField++, iDstField++)
     439             :         {
     440             :             const GMLProperty *psGMLProperty =
     441        2783 :                 poGMLFeature->GetProperty(iField);
     442        2783 :             if (psGMLProperty == nullptr || psGMLProperty->nSubProperties == 0)
     443         616 :                 continue;
     444             : 
     445        2167 :             if (EQUAL(psGMLProperty->papszSubProperties[0], OGR_GML_NULL))
     446             :             {
     447           8 :                 poOGRFeature->SetFieldNull(iDstField);
     448           8 :                 continue;
     449             :             }
     450             : 
     451        2159 :             switch (poFClass->GetProperty(iField)->GetType())
     452             :             {
     453         361 :                 case GMLPT_Real:
     454             :                 {
     455         361 :                     poOGRFeature->SetField(
     456             :                         iDstField,
     457         361 :                         CPLAtof(psGMLProperty->papszSubProperties[0]));
     458             :                 }
     459         361 :                 break;
     460             : 
     461          13 :                 case GMLPT_IntegerList:
     462             :                 {
     463          13 :                     const int nCount = psGMLProperty->nSubProperties;
     464             :                     int *panIntList =
     465          13 :                         static_cast<int *>(CPLMalloc(sizeof(int) * nCount));
     466             : 
     467          39 :                     for (int i = 0; i < nCount; i++)
     468          26 :                         panIntList[i] =
     469          26 :                             atoi(psGMLProperty->papszSubProperties[i]);
     470             : 
     471          13 :                     poOGRFeature->SetField(iDstField, nCount, panIntList);
     472          13 :                     CPLFree(panIntList);
     473             :                 }
     474          13 :                 break;
     475             : 
     476           6 :                 case GMLPT_Integer64List:
     477             :                 {
     478           6 :                     const int nCount = psGMLProperty->nSubProperties;
     479             :                     GIntBig *panIntList = static_cast<GIntBig *>(
     480           6 :                         CPLMalloc(sizeof(GIntBig) * nCount));
     481             : 
     482          15 :                     for (int i = 0; i < nCount; i++)
     483          18 :                         panIntList[i] =
     484           9 :                             CPLAtoGIntBig(psGMLProperty->papszSubProperties[i]);
     485             : 
     486           6 :                     poOGRFeature->SetField(iDstField, nCount, panIntList);
     487           6 :                     CPLFree(panIntList);
     488             :                 }
     489           6 :                 break;
     490             : 
     491          25 :                 case GMLPT_RealList:
     492             :                 {
     493          25 :                     const int nCount = psGMLProperty->nSubProperties;
     494             :                     double *padfList = static_cast<double *>(
     495          25 :                         CPLMalloc(sizeof(double) * nCount));
     496             : 
     497          59 :                     for (int i = 0; i < nCount; i++)
     498          68 :                         padfList[i] =
     499          34 :                             CPLAtof(psGMLProperty->papszSubProperties[i]);
     500             : 
     501          25 :                     poOGRFeature->SetField(iDstField, nCount, padfList);
     502          25 :                     CPLFree(padfList);
     503             :                 }
     504          25 :                 break;
     505             : 
     506         106 :                 case GMLPT_StringList:
     507             :                 case GMLPT_FeaturePropertyList:
     508             :                 {
     509         106 :                     poOGRFeature->SetField(iDstField,
     510         106 :                                            psGMLProperty->papszSubProperties);
     511             :                 }
     512         106 :                 break;
     513             : 
     514          46 :                 case GMLPT_Boolean:
     515             :                 {
     516          46 :                     if (strcmp(psGMLProperty->papszSubProperties[0], "true") ==
     517           7 :                             0 ||
     518           7 :                         strcmp(psGMLProperty->papszSubProperties[0], "1") == 0)
     519             :                     {
     520          39 :                         poOGRFeature->SetField(iDstField, 1);
     521             :                     }
     522           7 :                     else if (strcmp(psGMLProperty->papszSubProperties[0],
     523           0 :                                     "false") == 0 ||
     524           0 :                              strcmp(psGMLProperty->papszSubProperties[0],
     525             :                                     "0") == 0)
     526             :                     {
     527           7 :                         poOGRFeature->SetField(iDstField, 0);
     528             :                     }
     529             :                     else
     530             :                     {
     531           0 :                         poOGRFeature->SetField(
     532           0 :                             iDstField, psGMLProperty->papszSubProperties[0]);
     533             :                     }
     534          46 :                     break;
     535             :                 }
     536             : 
     537           3 :                 case GMLPT_BooleanList:
     538             :                 {
     539           3 :                     const int nCount = psGMLProperty->nSubProperties;
     540             :                     int *panIntList =
     541           3 :                         static_cast<int *>(CPLMalloc(sizeof(int) * nCount));
     542             : 
     543           9 :                     for (int i = 0; i < nCount; i++)
     544             :                     {
     545           6 :                         panIntList[i] =
     546           6 :                             (strcmp(psGMLProperty->papszSubProperties[i],
     547           9 :                                     "true") == 0 ||
     548           3 :                              strcmp(psGMLProperty->papszSubProperties[i],
     549             :                                     "1") == 0);
     550             :                     }
     551             : 
     552           3 :                     poOGRFeature->SetField(iDstField, nCount, panIntList);
     553           3 :                     CPLFree(panIntList);
     554           3 :                     break;
     555             :                 }
     556             : 
     557        1599 :                 default:
     558        1599 :                     poOGRFeature->SetField(
     559        1599 :                         iDstField, psGMLProperty->papszSubProperties[0]);
     560        1599 :                     break;
     561             :             }
     562             :         }
     563             : 
     564         741 :         delete poGMLFeature;
     565         741 :         poGMLFeature = nullptr;
     566             : 
     567             :         // Assign the geometry before the attribute filter because
     568             :         // the attribute filter may use a special field like OGR_GEOMETRY.
     569         741 :         if (papoGeometries != nullptr)
     570             :         {
     571         301 :             for (int i = 0; i < poFeatureDefn->GetGeomFieldCount(); i++)
     572             :             {
     573         207 :                 poOGRFeature->SetGeomFieldDirectly(i, papoGeometries[i]);
     574             :             }
     575          94 :             CPLFree(papoGeometries);
     576          94 :             papoGeometries = nullptr;
     577             :         }
     578             :         else
     579             :         {
     580         647 :             poOGRFeature->SetGeometryDirectly(poGeom);
     581             :         }
     582             : 
     583             :         // Assign SRS.
     584        1518 :         for (int i = 0; i < poFeatureDefn->GetGeomFieldCount(); i++)
     585             :         {
     586         777 :             poGeom = poOGRFeature->GetGeomFieldRef(i);
     587         777 :             if (poGeom != nullptr)
     588             :             {
     589             :                 const OGRSpatialReference *poSRS =
     590         690 :                     poFeatureDefn->GetGeomFieldDefn(i)->GetSpatialRef();
     591         690 :                 if (poSRS != nullptr)
     592         147 :                     poGeom->assignSpatialReference(poSRS);
     593             :             }
     594             :         }
     595             : 
     596             :         /* --------------------------------------------------------------------
     597             :          */
     598             :         /*      Test against the attribute query. */
     599             :         /* --------------------------------------------------------------------
     600             :          */
     601         741 :         if (m_poAttrQuery != nullptr && !m_poAttrQuery->Evaluate(poOGRFeature))
     602             :         {
     603          28 :             delete poOGRFeature;
     604          28 :             continue;
     605             :         }
     606             : 
     607             :         // Got the desired feature.
     608         713 :         return poOGRFeature;
     609         874 :     }
     610             : }
     611             : 
     612             : /************************************************************************/
     613             : /*                          GetFeatureCount()                           */
     614             : /************************************************************************/
     615             : 
     616          62 : GIntBig OGRGMLLayer::GetFeatureCount(int bForce)
     617             : 
     618             : {
     619          62 :     if (poFClass == nullptr)
     620           0 :         return 0;
     621             : 
     622          62 :     if (m_poFilterGeom != nullptr || m_poAttrQuery != nullptr)
     623           6 :         return OGRLayer::GetFeatureCount(bForce);
     624             : 
     625             :     // If the schema is read from a .xsd file, we haven't read
     626             :     // the feature count, so compute it now.
     627          56 :     GIntBig nFeatureCount = poFClass->GetFeatureCount();
     628          56 :     if (nFeatureCount < 0)
     629             :     {
     630          26 :         nFeatureCount = OGRLayer::GetFeatureCount(bForce);
     631          26 :         poFClass->SetFeatureCount(nFeatureCount);
     632             :     }
     633             : 
     634          56 :     return nFeatureCount;
     635             : }
     636             : 
     637             : /************************************************************************/
     638             : /*                            IGetExtent()                              */
     639             : /************************************************************************/
     640             : 
     641          10 : OGRErr OGRGMLLayer::IGetExtent(int iGeomField, OGREnvelope *psExtent,
     642             :                                bool bForce)
     643             : 
     644             : {
     645          10 :     if (GetGeomType() == wkbNone)
     646           0 :         return OGRERR_FAILURE;
     647             : 
     648          10 :     double dfXMin = 0.0;
     649          10 :     double dfXMax = 0.0;
     650          10 :     double dfYMin = 0.0;
     651          10 :     double dfYMax = 0.0;
     652          20 :     if (poFClass != nullptr &&
     653          10 :         poFClass->GetExtents(&dfXMin, &dfXMax, &dfYMin, &dfYMax))
     654             :     {
     655           8 :         psExtent->MinX = dfXMin;
     656           8 :         psExtent->MaxX = dfXMax;
     657           8 :         psExtent->MinY = dfYMin;
     658           8 :         psExtent->MaxY = dfYMax;
     659             : 
     660           8 :         return OGRERR_NONE;
     661             :     }
     662             : 
     663           2 :     return OGRLayer::IGetExtent(iGeomField, psExtent, bForce);
     664             : }
     665             : 
     666             : /************************************************************************/
     667             : /*                             GetExtent()                              */
     668             : /************************************************************************/
     669             : 
     670         505 : static void GMLWriteField(OGRGMLDataSource *poDS, VSILFILE *fp,
     671             :                           bool bWriteSpaceIndentation, const char *pszPrefix,
     672             :                           bool bRemoveAppPrefix, OGRFieldDefn *poFieldDefn,
     673             :                           const char *pszVal)
     674             : 
     675             : {
     676         505 :     const char *pszFieldName = poFieldDefn->GetNameRef();
     677             : 
     678         505 :     while (*pszVal == ' ')
     679           0 :         pszVal++;
     680             : 
     681         505 :     if (bWriteSpaceIndentation)
     682         505 :         VSIFPrintfL(fp, "      ");
     683             : 
     684         505 :     if (bRemoveAppPrefix)
     685          60 :         poDS->PrintLine(fp, "<%s>%s</%s>", pszFieldName, pszVal, pszFieldName);
     686             :     else
     687         445 :         poDS->PrintLine(fp, "<%s:%s>%s</%s:%s>", pszPrefix, pszFieldName,
     688             :                         pszVal, pszPrefix, pszFieldName);
     689         505 : }
     690             : 
     691             : /************************************************************************/
     692             : /*                           ICreateFeature()                            */
     693             : /************************************************************************/
     694             : 
     695         266 : OGRErr OGRGMLLayer::ICreateFeature(OGRFeature *poFeature)
     696             : 
     697             : {
     698         266 :     const bool bIsGML3Output = poDS->IsGML3Output();
     699         266 :     VSILFILE *fp = poDS->GetOutputFP();
     700         266 :     const bool bWriteSpaceIndentation = poDS->WriteSpaceIndentation();
     701         266 :     const char *pszPrefix = poDS->GetAppPrefix();
     702         266 :     const bool bRemoveAppPrefix = poDS->RemoveAppPrefix();
     703         266 :     const bool bGMLFeatureCollection = poDS->GMLFeatureCollection();
     704             : 
     705         266 :     if (!bWriter || poDS->HasWriteError())
     706           0 :         return OGRERR_FAILURE;
     707             : 
     708         266 :     poFeature->FillUnsetWithDefault(TRUE, nullptr);
     709         266 :     if (!poFeature->Validate(OGR_F_VAL_ALL & ~OGR_F_VAL_GEOM_TYPE &
     710             :                                  ~OGR_F_VAL_ALLOW_NULL_WHEN_DEFAULT,
     711             :                              TRUE))
     712           2 :         return OGRERR_FAILURE;
     713             : 
     714         264 :     if (bWriteSpaceIndentation)
     715         264 :         VSIFPrintfL(fp, "  ");
     716         264 :     if (bIsGML3Output && !bGMLFeatureCollection)
     717             :     {
     718         220 :         if (bRemoveAppPrefix)
     719          10 :             poDS->PrintLine(fp, "<featureMember>");
     720             :         else
     721         210 :             poDS->PrintLine(fp, "<%s:featureMember>", pszPrefix);
     722             :     }
     723             :     else
     724             :     {
     725          44 :         poDS->PrintLine(fp, "<gml:featureMember>");
     726             :     }
     727             : 
     728         264 :     if (poFeature->GetFID() == OGRNullFID)
     729         251 :         poFeature->SetFID(m_iNextGMLId++);
     730             : 
     731         264 :     if (bWriteSpaceIndentation)
     732         264 :         VSIFPrintfL(fp, "    ");
     733         264 :     VSIFPrintfL(fp, "<");
     734         264 :     if (!bRemoveAppPrefix)
     735         244 :         VSIFPrintfL(fp, "%s:", pszPrefix);
     736             : 
     737         264 :     int nGMLIdIndex = -1;
     738         264 :     if (bIsGML3Output)
     739             :     {
     740         230 :         nGMLIdIndex = poFeatureDefn->GetFieldIndex("gml_id");
     741         230 :         if (nGMLIdIndex >= 0 && poFeature->IsFieldSetAndNotNull(nGMLIdIndex))
     742           3 :             poDS->PrintLine(fp, "%s gml:id=\"%s\">", poFeatureDefn->GetName(),
     743             :                             poFeature->GetFieldAsString(nGMLIdIndex));
     744             :         else
     745         454 :             poDS->PrintLine(fp, "%s gml:id=\"%s." CPL_FRMT_GIB "\">",
     746         227 :                             poFeatureDefn->GetName(), poFeatureDefn->GetName(),
     747             :                             poFeature->GetFID());
     748             :     }
     749             :     else
     750             :     {
     751          34 :         nGMLIdIndex = poFeatureDefn->GetFieldIndex("fid");
     752          34 :         if (bUseOldFIDFormat)
     753             :         {
     754           0 :             poDS->PrintLine(fp, "%s fid=\"F" CPL_FRMT_GIB "\">",
     755           0 :                             poFeatureDefn->GetName(), poFeature->GetFID());
     756             :         }
     757          44 :         else if (nGMLIdIndex >= 0 &&
     758          10 :                  poFeature->IsFieldSetAndNotNull(nGMLIdIndex))
     759             :         {
     760          10 :             poDS->PrintLine(fp, "%s fid=\"%s\">", poFeatureDefn->GetName(),
     761             :                             poFeature->GetFieldAsString(nGMLIdIndex));
     762             :         }
     763             :         else
     764             :         {
     765          48 :             poDS->PrintLine(fp, "%s fid=\"%s." CPL_FRMT_GIB "\">",
     766          24 :                             poFeatureDefn->GetName(), poFeatureDefn->GetName(),
     767             :                             poFeature->GetFID());
     768             :         }
     769             :     }
     770             : 
     771         517 :     for (int iGeomField = 0; iGeomField < poFeatureDefn->GetGeomFieldCount();
     772             :          iGeomField++)
     773             :     {
     774             :         const OGRGeomFieldDefn *poFieldDefn =
     775         253 :             poFeatureDefn->GetGeomFieldDefn(iGeomField);
     776             : 
     777             :         // Write out Geometry - for now it isn't indented properly.
     778             :         // GML geometries don't like very much the concept of empty geometry.
     779         253 :         OGRGeometry *poGeom = poFeature->GetGeomFieldRef(iGeomField);
     780         253 :         if (poGeom != nullptr && !poGeom->IsEmpty())
     781             :         {
     782         215 :             OGREnvelope3D sGeomBounds;
     783             : 
     784         215 :             const int nCoordDimension = poGeom->getCoordinateDimension();
     785             : 
     786         215 :             poGeom->getEnvelope(&sGeomBounds);
     787         215 :             if (poDS->HasWriteGlobalSRS())
     788         211 :                 poDS->GrowExtents(&sGeomBounds, nCoordDimension);
     789             : 
     790         356 :             if (poGeom->getSpatialReference() == nullptr &&
     791         141 :                 poFieldDefn->GetSpatialRef() != nullptr)
     792          18 :                 poGeom->assignSpatialReference(poFieldDefn->GetSpatialRef());
     793             : 
     794         215 :             const auto &oCoordPrec = poFieldDefn->GetCoordinatePrecision();
     795             : 
     796         215 :             if (bIsGML3Output && poDS->WriteFeatureBoundedBy())
     797             :             {
     798         171 :                 bool bCoordSwap = false;
     799             : 
     800             :                 char *pszSRSName =
     801         171 :                     GML_GetSRSName(poGeom->getSpatialReference(),
     802         171 :                                    poDS->GetSRSNameFormat(), &bCoordSwap);
     803         171 :                 char szLowerCorner[75] = {};
     804         171 :                 char szUpperCorner[75] = {};
     805             : 
     806         171 :                 OGRWktOptions coordOpts;
     807             : 
     808         171 :                 if (oCoordPrec.dfXYResolution !=
     809             :                     OGRGeomCoordinatePrecision::UNKNOWN)
     810             :                 {
     811           3 :                     coordOpts.format = OGRWktFormat::F;
     812           3 :                     coordOpts.xyPrecision =
     813           3 :                         OGRGeomCoordinatePrecision::ResolutionToPrecision(
     814           3 :                             oCoordPrec.dfXYResolution);
     815             :                 }
     816         171 :                 if (oCoordPrec.dfZResolution !=
     817             :                     OGRGeomCoordinatePrecision::UNKNOWN)
     818             :                 {
     819           3 :                     coordOpts.format = OGRWktFormat::F;
     820           3 :                     coordOpts.zPrecision =
     821           3 :                         OGRGeomCoordinatePrecision::ResolutionToPrecision(
     822           3 :                             oCoordPrec.dfZResolution);
     823             :                 }
     824             : 
     825         342 :                 std::string wkt;
     826         171 :                 if (bCoordSwap)
     827             :                 {
     828          36 :                     wkt = OGRMakeWktCoordinate(
     829             :                         sGeomBounds.MinY, sGeomBounds.MinX, sGeomBounds.MinZ,
     830          18 :                         nCoordDimension, coordOpts);
     831          18 :                     memcpy(szLowerCorner, wkt.data(), wkt.size() + 1);
     832             : 
     833          36 :                     wkt = OGRMakeWktCoordinate(
     834             :                         sGeomBounds.MaxY, sGeomBounds.MaxX, sGeomBounds.MaxZ,
     835          18 :                         nCoordDimension, coordOpts);
     836          18 :                     memcpy(szUpperCorner, wkt.data(), wkt.size() + 1);
     837             :                 }
     838             :                 else
     839             :                 {
     840         306 :                     wkt = OGRMakeWktCoordinate(
     841             :                         sGeomBounds.MinX, sGeomBounds.MinY, sGeomBounds.MinZ,
     842         153 :                         nCoordDimension, coordOpts);
     843         153 :                     memcpy(szLowerCorner, wkt.data(), wkt.size() + 1);
     844             : 
     845         306 :                     wkt = OGRMakeWktCoordinate(
     846             :                         sGeomBounds.MaxX, sGeomBounds.MaxY, sGeomBounds.MaxZ,
     847         153 :                         nCoordDimension, coordOpts);
     848         153 :                     memcpy(szUpperCorner, wkt.data(), wkt.size() + 1);
     849             :                 }
     850         171 :                 if (bWriteSpaceIndentation)
     851         171 :                     VSIFPrintfL(fp, "      ");
     852         171 :                 poDS->PrintLine(
     853             :                     fp,
     854             :                     "<gml:boundedBy><gml:Envelope%s%s><gml:lowerCorner>%s"
     855             :                     "</gml:lowerCorner><gml:upperCorner>%s</gml:upperCorner>"
     856             :                     "</gml:Envelope></gml:boundedBy>",
     857             :                     (nCoordDimension == 3) ? " srsDimension=\"3\"" : "",
     858             :                     pszSRSName, szLowerCorner, szUpperCorner);
     859         171 :                 CPLFree(pszSRSName);
     860             :             }
     861             : 
     862         215 :             char **papszOptions = nullptr;
     863         215 :             if (bIsGML3Output)
     864             :             {
     865         181 :                 papszOptions = CSLAddString(papszOptions, "FORMAT=GML3");
     866         181 :                 if (poDS->GetSRSNameFormat() == SRSNAME_SHORT)
     867             :                     papszOptions =
     868           1 :                         CSLAddString(papszOptions, "SRSNAME_FORMAT=SHORT");
     869         180 :                 else if (poDS->GetSRSNameFormat() == SRSNAME_OGC_URN)
     870             :                     papszOptions =
     871         167 :                         CSLAddString(papszOptions, "SRSNAME_FORMAT=OGC_URN");
     872          13 :                 else if (poDS->GetSRSNameFormat() == SRSNAME_OGC_URL)
     873             :                     papszOptions =
     874          13 :                         CSLAddString(papszOptions, "SRSNAME_FORMAT=OGC_URL");
     875             :             }
     876         215 :             const char *pszSRSDimensionLoc = poDS->GetSRSDimensionLoc();
     877         215 :             if (pszSRSDimensionLoc != nullptr)
     878           3 :                 papszOptions = CSLSetNameValue(papszOptions, "SRSDIMENSION_LOC",
     879             :                                                pszSRSDimensionLoc);
     880         215 :             if (poDS->IsGML32Output())
     881             :             {
     882         115 :                 if (poFeatureDefn->GetGeomFieldCount() > 1)
     883          18 :                     papszOptions = CSLAddString(
     884             :                         papszOptions, CPLSPrintf("GMLID=%s.%s." CPL_FRMT_GIB,
     885           9 :                                                  poFeatureDefn->GetName(),
     886             :                                                  poFieldDefn->GetNameRef(),
     887             :                                                  poFeature->GetFID()));
     888             :                 else
     889         212 :                     papszOptions = CSLAddString(
     890             :                         papszOptions, CPLSPrintf("GMLID=%s.geom." CPL_FRMT_GIB,
     891         106 :                                                  poFeatureDefn->GetName(),
     892             :                                                  poFeature->GetFID()));
     893             :             }
     894             : 
     895         215 :             if (oCoordPrec.dfXYResolution !=
     896             :                 OGRGeomCoordinatePrecision::UNKNOWN)
     897             :             {
     898           3 :                 papszOptions = CSLAddString(
     899             :                     papszOptions, CPLSPrintf("XY_COORD_RESOLUTION=%g",
     900           3 :                                              oCoordPrec.dfXYResolution));
     901             :             }
     902         215 :             if (oCoordPrec.dfZResolution != OGRGeomCoordinatePrecision::UNKNOWN)
     903             :             {
     904           3 :                 papszOptions = CSLAddString(
     905             :                     papszOptions, CPLSPrintf("Z_COORD_RESOLUTION=%g",
     906           3 :                                              oCoordPrec.dfZResolution));
     907             :             }
     908             : 
     909         215 :             char *pszGeometry = nullptr;
     910         215 :             if (!bIsGML3Output && OGR_GT_IsNonLinear(poGeom->getGeometryType()))
     911             :             {
     912           0 :                 OGRGeometry *poGeomTmp = OGRGeometryFactory::forceTo(
     913           0 :                     poGeom->clone(),
     914           0 :                     OGR_GT_GetLinear(poGeom->getGeometryType()));
     915           0 :                 pszGeometry = poGeomTmp->exportToGML(papszOptions);
     916           0 :                 delete poGeomTmp;
     917             :             }
     918             :             else
     919             :             {
     920         215 :                 if (wkbFlatten(poGeom->getGeometryType()) == wkbTriangle)
     921             :                 {
     922           0 :                     pszGeometry = poGeom->exportToGML(papszOptions);
     923             : 
     924             :                     const char *pszGMLID =
     925           0 :                         poDS->IsGML32Output()
     926           0 :                             ? CPLSPrintf(
     927             :                                   " gml:id=\"%s\"",
     928             :                                   CSLFetchNameValue(papszOptions, "GMLID"))
     929           0 :                             : "";
     930           0 :                     char *pszNewGeom = CPLStrdup(
     931             :                         CPLSPrintf("<gml:TriangulatedSurface%s><gml:patches>%s<"
     932             :                                    "/gml:patches></gml:TriangulatedSurface>",
     933             :                                    pszGMLID, pszGeometry));
     934           0 :                     CPLFree(pszGeometry);
     935           0 :                     pszGeometry = pszNewGeom;
     936             :                 }
     937             :                 else
     938             :                 {
     939         215 :                     pszGeometry = poGeom->exportToGML(papszOptions);
     940             :                 }
     941             :             }
     942         215 :             CSLDestroy(papszOptions);
     943         215 :             if (pszGeometry)
     944             :             {
     945         214 :                 if (bWriteSpaceIndentation)
     946         214 :                     VSIFPrintfL(fp, "      ");
     947         214 :                 if (bRemoveAppPrefix)
     948          20 :                     poDS->PrintLine(fp, "<%s>%s</%s>",
     949             :                                     poFieldDefn->GetNameRef(), pszGeometry,
     950             :                                     poFieldDefn->GetNameRef());
     951             :                 else
     952         194 :                     poDS->PrintLine(fp, "<%s:%s>%s</%s:%s>", pszPrefix,
     953             :                                     poFieldDefn->GetNameRef(), pszGeometry,
     954             :                                     pszPrefix, poFieldDefn->GetNameRef());
     955             :             }
     956             :             else
     957             :             {
     958           1 :                 CPLError(CE_Failure, CPLE_AppDefined,
     959             :                          "Export of geometry to GML failed");
     960             :             }
     961         215 :             CPLFree(pszGeometry);
     962             :         }
     963             :     }
     964             : 
     965             :     // Write all "set" fields.
     966         885 :     for (int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++)
     967             :     {
     968         621 :         if (iField == nGMLIdIndex)
     969          13 :             continue;
     970         608 :         OGRFieldDefn *poFieldDefn = poFeatureDefn->GetFieldDefn(iField);
     971             : 
     972         608 :         if (poFeature->IsFieldNull(iField))
     973             :         {
     974           1 :             const char *pszFieldName = poFieldDefn->GetNameRef();
     975             : 
     976           1 :             if (bWriteSpaceIndentation)
     977           1 :                 VSIFPrintfL(fp, "      ");
     978             : 
     979           1 :             if (bRemoveAppPrefix)
     980           0 :                 poDS->PrintLine(fp, "<%s xsi:nil=\"true\"/>", pszFieldName);
     981             :             else
     982           1 :                 poDS->PrintLine(fp, "<%s:%s xsi:nil=\"true\"/>", pszPrefix,
     983             :                                 pszFieldName);
     984             :         }
     985         607 :         else if (poFeature->IsFieldSet(iField))
     986             :         {
     987         500 :             OGRFieldType eType = poFieldDefn->GetType();
     988         500 :             if (eType == OFTStringList)
     989             :             {
     990           1 :                 char **papszIter = poFeature->GetFieldAsStringList(iField);
     991           3 :                 while (papszIter != nullptr && *papszIter != nullptr)
     992             :                 {
     993           2 :                     char *pszEscaped = OGRGetXML_UTF8_EscapedString(*papszIter);
     994           2 :                     GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
     995             :                                   bRemoveAppPrefix, poFieldDefn, pszEscaped);
     996           2 :                     CPLFree(pszEscaped);
     997             : 
     998           2 :                     papszIter++;
     999             :                 }
    1000             :             }
    1001         499 :             else if (eType == OFTIntegerList)
    1002             :             {
    1003           2 :                 int nCount = 0;
    1004             :                 const int *panVals =
    1005           2 :                     poFeature->GetFieldAsIntegerList(iField, &nCount);
    1006           2 :                 if (poFieldDefn->GetSubType() == OFSTBoolean)
    1007             :                 {
    1008           3 :                     for (int i = 0; i < nCount; i++)
    1009             :                     {
    1010             :                         // 0 and 1 are OK, but the canonical representation is
    1011             :                         // false and true.
    1012           2 :                         GMLWriteField(poDS, fp, bWriteSpaceIndentation,
    1013             :                                       pszPrefix, bRemoveAppPrefix, poFieldDefn,
    1014           2 :                                       panVals[i] ? "true" : "false");
    1015             :                     }
    1016             :                 }
    1017             :                 else
    1018             :                 {
    1019           3 :                     for (int i = 0; i < nCount; i++)
    1020             :                     {
    1021           2 :                         GMLWriteField(poDS, fp, bWriteSpaceIndentation,
    1022             :                                       pszPrefix, bRemoveAppPrefix, poFieldDefn,
    1023           2 :                                       CPLSPrintf("%d", panVals[i]));
    1024             :                     }
    1025             :                 }
    1026             :             }
    1027         497 :             else if (eType == OFTInteger64List)
    1028             :             {
    1029           2 :                 int nCount = 0;
    1030             :                 const GIntBig *panVals =
    1031           2 :                     poFeature->GetFieldAsInteger64List(iField, &nCount);
    1032           2 :                 if (poFieldDefn->GetSubType() == OFSTBoolean)
    1033             :                 {
    1034           0 :                     for (int i = 0; i < nCount; i++)
    1035             :                     {
    1036             :                         // 0 and 1 are OK, but the canonical representation is
    1037             :                         // false and true.
    1038           0 :                         GMLWriteField(poDS, fp, bWriteSpaceIndentation,
    1039             :                                       pszPrefix, bRemoveAppPrefix, poFieldDefn,
    1040           0 :                                       panVals[i] ? "true" : "false");
    1041             :                     }
    1042             :                 }
    1043             :                 else
    1044             :                 {
    1045           5 :                     for (int i = 0; i < nCount; i++)
    1046             :                     {
    1047           3 :                         GMLWriteField(poDS, fp, bWriteSpaceIndentation,
    1048             :                                       pszPrefix, bRemoveAppPrefix, poFieldDefn,
    1049           3 :                                       CPLSPrintf(CPL_FRMT_GIB, panVals[i]));
    1050             :                     }
    1051             :                 }
    1052             :             }
    1053         495 :             else if (eType == OFTRealList)
    1054             :             {
    1055           1 :                 int nCount = 0;
    1056             :                 const double *padfVals =
    1057           1 :                     poFeature->GetFieldAsDoubleList(iField, &nCount);
    1058           3 :                 for (int i = 0; i < nCount; i++)
    1059             :                 {
    1060           2 :                     char szBuffer[80] = {};
    1061           2 :                     CPLsnprintf(szBuffer, sizeof(szBuffer), "%.15g",
    1062           2 :                                 padfVals[i]);
    1063           2 :                     GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
    1064             :                                   bRemoveAppPrefix, poFieldDefn, szBuffer);
    1065             :                 }
    1066             :             }
    1067         625 :             else if ((eType == OFTInteger || eType == OFTInteger64) &&
    1068         131 :                      poFieldDefn->GetSubType() == OFSTBoolean)
    1069             :             {
    1070             :                 // 0 and 1 are OK, but the canonical representation is false and
    1071             :                 // true.
    1072           2 :                 GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
    1073             :                               bRemoveAppPrefix, poFieldDefn,
    1074           2 :                               (poFeature->GetFieldAsInteger(iField)) ? "true"
    1075             :                                                                      : "false");
    1076             :             }
    1077         492 :             else if (eType == OFTDate)
    1078             :             {
    1079          49 :                 const OGRField *poField = poFeature->GetRawFieldRef(iField);
    1080             :                 const char *pszXML =
    1081          98 :                     CPLSPrintf("%04d-%02d-%02d", poField->Date.Year,
    1082          49 :                                poField->Date.Month, poField->Date.Day);
    1083          49 :                 GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
    1084             :                               bRemoveAppPrefix, poFieldDefn, pszXML);
    1085             :             }
    1086         443 :             else if (eType == OFTDateTime)
    1087             :             {
    1088             :                 char *pszXML =
    1089          49 :                     OGRGetXMLDateTime(poFeature->GetRawFieldRef(iField));
    1090          49 :                 GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
    1091             :                               bRemoveAppPrefix, poFieldDefn, pszXML);
    1092          49 :                 CPLFree(pszXML);
    1093             :             }
    1094             :             else
    1095             :             {
    1096         394 :                 const char *pszRaw = poFeature->GetFieldAsString(iField);
    1097             : 
    1098         394 :                 char *pszEscaped = OGRGetXML_UTF8_EscapedString(pszRaw);
    1099             : 
    1100         394 :                 GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
    1101             :                               bRemoveAppPrefix, poFieldDefn, pszEscaped);
    1102         394 :                 CPLFree(pszEscaped);
    1103             :             }
    1104             :         }
    1105             :     }
    1106             : 
    1107         264 :     if (bWriteSpaceIndentation)
    1108         264 :         VSIFPrintfL(fp, "    ");
    1109         264 :     if (bRemoveAppPrefix)
    1110          20 :         poDS->PrintLine(fp, "</%s>", poFeatureDefn->GetName());
    1111             :     else
    1112         244 :         poDS->PrintLine(fp, "</%s:%s>", pszPrefix, poFeatureDefn->GetName());
    1113         264 :     if (bWriteSpaceIndentation)
    1114         264 :         VSIFPrintfL(fp, "  ");
    1115         264 :     if (bIsGML3Output && !bGMLFeatureCollection)
    1116             :     {
    1117         220 :         if (bRemoveAppPrefix)
    1118          10 :             poDS->PrintLine(fp, "</featureMember>");
    1119             :         else
    1120         210 :             poDS->PrintLine(fp, "</%s:featureMember>", pszPrefix);
    1121             :     }
    1122             :     else
    1123             :     {
    1124          44 :         poDS->PrintLine(fp, "</gml:featureMember>");
    1125             :     }
    1126             : 
    1127         264 :     return !poDS->HasWriteError() ? OGRERR_NONE : OGRERR_FAILURE;
    1128             : }
    1129             : 
    1130             : /************************************************************************/
    1131             : /*                           TestCapability()                           */
    1132             : /************************************************************************/
    1133             : 
    1134         342 : int OGRGMLLayer::TestCapability(const char *pszCap) const
    1135             : 
    1136             : {
    1137         342 :     if (EQUAL(pszCap, OLCSequentialWrite))
    1138          19 :         return bWriter;
    1139             : 
    1140         323 :     else if (EQUAL(pszCap, OLCCreateField))
    1141          18 :         return bWriter && m_iNextGMLId == 0;
    1142             : 
    1143         305 :     else if (EQUAL(pszCap, OLCCreateGeomField))
    1144           4 :         return bWriter && m_iNextGMLId == 0;
    1145             : 
    1146         301 :     else if (EQUAL(pszCap, OLCFastGetExtent))
    1147             :     {
    1148           4 :         if (poFClass == nullptr)
    1149           0 :             return FALSE;
    1150             : 
    1151           4 :         double dfXMin = 0.0;
    1152           4 :         double dfXMax = 0.0;
    1153           4 :         double dfYMin = 0.0;
    1154           4 :         double dfYMax = 0.0;
    1155             : 
    1156           4 :         return poFClass->GetExtents(&dfXMin, &dfXMax, &dfYMin, &dfYMax);
    1157             :     }
    1158             : 
    1159         297 :     else if (EQUAL(pszCap, OLCFastFeatureCount))
    1160             :     {
    1161           1 :         if (poFClass == nullptr || m_poFilterGeom != nullptr ||
    1162           1 :             m_poAttrQuery != nullptr)
    1163           0 :             return FALSE;
    1164             : 
    1165           1 :         return poFClass->GetFeatureCount() != -1;
    1166             :     }
    1167             : 
    1168         296 :     else if (EQUAL(pszCap, OLCStringsAsUTF8))
    1169          15 :         return TRUE;
    1170             : 
    1171         281 :     else if (EQUAL(pszCap, OLCCurveGeometries))
    1172         146 :         return poDS->IsGML3Output();
    1173             : 
    1174         135 :     else if (EQUAL(pszCap, OLCZGeometries))
    1175           3 :         return TRUE;
    1176             : 
    1177             :     else
    1178         132 :         return FALSE;
    1179             : }
    1180             : 
    1181             : /************************************************************************/
    1182             : /*                            CreateField()                             */
    1183             : /************************************************************************/
    1184             : 
    1185         181 : OGRErr OGRGMLLayer::CreateField(const OGRFieldDefn *poField, int bApproxOK)
    1186             : 
    1187             : {
    1188         181 :     if (!bWriter || m_iNextGMLId != 0)
    1189           0 :         return OGRERR_FAILURE;
    1190             : 
    1191             :     /* -------------------------------------------------------------------- */
    1192             :     /*      Enforce XML naming semantics on element name.                   */
    1193             :     /* -------------------------------------------------------------------- */
    1194         362 :     OGRFieldDefn oCleanCopy(poField);
    1195         181 :     char *pszName = CPLStrdup(poField->GetNameRef());
    1196         181 :     CPLCleanXMLElementName(pszName);
    1197             : 
    1198         181 :     if (strcmp(pszName, poField->GetNameRef()) != 0)
    1199             :     {
    1200           0 :         if (!bApproxOK)
    1201             :         {
    1202           0 :             CPLFree(pszName);
    1203           0 :             CPLError(CE_Failure, CPLE_AppDefined,
    1204             :                      "Unable to create field with name '%s', it would not\n"
    1205             :                      "be valid as an XML element name.",
    1206             :                      poField->GetNameRef());
    1207           0 :             return OGRERR_FAILURE;
    1208             :         }
    1209             : 
    1210           0 :         oCleanCopy.SetName(pszName);
    1211           0 :         CPLError(CE_Warning, CPLE_AppDefined,
    1212             :                  "Field name '%s' adjusted to '%s' to be a valid\n"
    1213             :                  "XML element name.",
    1214             :                  poField->GetNameRef(), pszName);
    1215             :     }
    1216             : 
    1217         181 :     CPLFree(pszName);
    1218             : 
    1219         181 :     poFeatureDefn->AddFieldDefn(&oCleanCopy);
    1220             : 
    1221         181 :     return OGRERR_NONE;
    1222             : }
    1223             : 
    1224             : /************************************************************************/
    1225             : /*                          CreateGeomField()                           */
    1226             : /************************************************************************/
    1227             : 
    1228          19 : OGRErr OGRGMLLayer::CreateGeomField(const OGRGeomFieldDefn *poField,
    1229             :                                     int bApproxOK)
    1230             : 
    1231             : {
    1232          19 :     if (!bWriter || m_iNextGMLId != 0)
    1233           0 :         return OGRERR_FAILURE;
    1234             : 
    1235             :     /* -------------------------------------------------------------------- */
    1236             :     /*      Enforce XML naming semantics on element name.                   */
    1237             :     /* -------------------------------------------------------------------- */
    1238          38 :     OGRGeomFieldDefn oCleanCopy(poField);
    1239          19 :     const auto poSRSOri = poField->GetSpatialRef();
    1240          19 :     poDS->DeclareNewWriteSRS(poSRSOri);
    1241          19 :     if (poSRSOri)
    1242             :     {
    1243           6 :         auto poSRS = poSRSOri->Clone();
    1244           6 :         poSRS->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
    1245           6 :         oCleanCopy.SetSpatialRef(poSRS);
    1246           6 :         poSRS->Release();
    1247             :     }
    1248          19 :     char *pszName = CPLStrdup(poField->GetNameRef());
    1249          19 :     CPLCleanXMLElementName(pszName);
    1250             : 
    1251          19 :     if (strcmp(pszName, poField->GetNameRef()) != 0)
    1252             :     {
    1253           0 :         if (!bApproxOK)
    1254             :         {
    1255           0 :             CPLFree(pszName);
    1256           0 :             CPLError(CE_Failure, CPLE_AppDefined,
    1257             :                      "Unable to create field with name '%s', it would not\n"
    1258             :                      "be valid as an XML element name.",
    1259             :                      poField->GetNameRef());
    1260           0 :             return OGRERR_FAILURE;
    1261             :         }
    1262             : 
    1263           0 :         oCleanCopy.SetName(pszName);
    1264           0 :         CPLError(CE_Warning, CPLE_AppDefined,
    1265             :                  "Field name '%s' adjusted to '%s' to be a valid\n"
    1266             :                  "XML element name.",
    1267             :                  poField->GetNameRef(), pszName);
    1268             :     }
    1269             : 
    1270          19 :     CPLFree(pszName);
    1271             : 
    1272          19 :     poFeatureDefn->AddGeomFieldDefn(&oCleanCopy);
    1273             : 
    1274          19 :     return OGRERR_NONE;
    1275             : }
    1276             : 
    1277             : /************************************************************************/
    1278             : /*                             GetDataset()                             */
    1279             : /************************************************************************/
    1280             : 
    1281          20 : GDALDataset *OGRGMLLayer::GetDataset()
    1282             : {
    1283          20 :     return poDS;
    1284             : }