Line data    Source code

       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  GML Reader
       4             :  * Purpose:  Declarations for OGR wrapper classes for GML, and GML<->OGR
       5             :  *           translation of geometry.
       6             :  * Author:   Frank Warmerdam, warmerdam@pobox.com
       7             :  *
       8             :  ******************************************************************************
       9             :  * Copyright (c) 2002, Frank Warmerdam
      10             :  * Copyright (c) 2010-2013, Even Rouault <even dot rouault at spatialys.com>
      11             :  *
      12             :  * SPDX-License-Identifier: MIT
      13             :  ****************************************************************************/
      14             : 
      15             : #ifndef OGR_GML_H_INCLUDED
      16             : #define OGR_GML_H_INCLUDED
      17             : 
      18             : #include "ogrsf_frmts.h"
      19             : #include "gmlreader.h"
      20             : #include "gmlutils.h"
      21             : 
      22             : #include <memory>
      23             : #include <vector>
      24             : 
      25             : class OGRGMLDataSource;
      26             : 
      27             : typedef enum
      28             : {
      29             :     STANDARD,
      30             :     SEQUENTIAL_LAYERS,
      31             :     INTERLEAVED_LAYERS
      32             : } ReadMode;
      33             : 
      34             : /************************************************************************/
      35             : /*                            OGRGMLLayer                               */
      36             : /************************************************************************/
      37             : 
      38             : class OGRGMLLayer final : public OGRLayer
      39             : {
      40             :     OGRFeatureDefn *poFeatureDefn;
      41             : 
      42             :     GIntBig iNextGMLId;
      43             :     bool bInvalidFIDFound;
      44             :     char *pszFIDPrefix;
      45             : 
      46             :     bool bWriter;
      47             : 
      48             :     OGRGMLDataSource *poDS;
      49             : 
      50             :     GMLFeatureClass *poFClass;
      51             : 
      52             :     void *hCacheSRS;
      53             : 
      54             :     bool bUseOldFIDFormat;
      55             : 
      56             :     bool bFaceHoleNegative;
      57             : 
      58             :     CPL_DISALLOW_COPY_ASSIGN(OGRGMLLayer)
      59             : 
      60             :   public:
      61             :     OGRGMLLayer(const char *pszName, bool bWriter, OGRGMLDataSource *poDS);
      62             : 
      63             :     virtual ~OGRGMLLayer();
      64             : 
      65             :     GDALDataset *GetDataset() override;
      66             : 
      67             :     void ResetReading() override;
      68             :     OGRFeature *GetNextFeature() override;
      69             : 
      70             :     GIntBig GetFeatureCount(int bForce = TRUE) override;
      71             :     OGRErr GetExtent(OGREnvelope *psExtent, int bForce = TRUE) override;
      72             : 
      73          11 :     virtual OGRErr GetExtent(int iGeomField, OGREnvelope *psExtent,
      74             :                              int bForce) override
      75             :     {
      76          11 :         return OGRLayer::GetExtent(iGeomField, psExtent, bForce);
      77             :     }
      78             : 
      79             :     OGRErr ICreateFeature(OGRFeature *poFeature) override;
      80             : 
      81        7219 :     OGRFeatureDefn *GetLayerDefn() override
      82             :     {
      83        7219 :         return poFeatureDefn;
      84             :     }
      85             : 
      86             :     virtual OGRErr CreateField(const OGRFieldDefn *poField,
      87             :                                int bApproxOK = TRUE) override;
      88             :     virtual OGRErr CreateGeomField(const OGRGeomFieldDefn *poField,
      89             :                                    int bApproxOK = TRUE) override;
      90             : 
      91             :     int TestCapability(const char *) override;
      92             : };
      93             : 
      94             : /************************************************************************/
      95             : /*                           OGRGMLDataSource                           */
      96             : /************************************************************************/
      97             : 
      98             : class OGRGMLDataSource final : public GDALDataset
      99             : {
     100             :     OGRLayer **papoLayers;
     101             :     int nLayers;
     102             : 
     103             :     OGRGMLLayer *TranslateGMLSchema(GMLFeatureClass *);
     104             : 
     105             :     char **papszCreateOptions;
     106             : 
     107             :     // output related parameters
     108             :     VSILFILE *fpOutput;
     109             :     bool bFpOutputIsNonSeekable;
     110             :     bool bFpOutputSingleFile;
     111             :     bool m_bWriteError = false;
     112             :     OGREnvelope3D sBoundingRect{};
     113             :     bool bBBOX3D;
     114             :     int nBoundedByLocation;
     115             : 
     116             :     int nSchemaInsertLocation;
     117             :     bool bIsOutputGML3;
     118             :     bool bIsOutputGML3Deegree; /* if TRUE, then bIsOutputGML3 is also TRUE */
     119             :     bool bIsOutputGML32;       /* if TRUE, then bIsOutputGML3 is also TRUE */
     120             :     OGRGMLSRSNameFormat eSRSNameFormat;
     121             :     bool bWriteSpaceIndentation;
     122             : 
     123             :     //! Whether all geometry fields of all layers have the same SRS (or no SRS at all)
     124             :     bool m_bWriteGlobalSRS = true;
     125             : 
     126             :     //! The global SRS (may be null), that is valid only if m_bWriteGlobalSRS == true
     127             :     std::unique_ptr<OGRSpatialReference> m_poWriteGlobalSRS{};
     128             : 
     129             :     //! Whether at least one geometry field has been created
     130             :     bool m_bWriteGlobalSRSInit = false;
     131             : 
     132             :     // input related parameters.
     133             :     CPLString osFilename{};
     134             :     CPLString osXSDFilename{};
     135             :     bool m_bUnlinkXSDFilename = false;
     136             : 
     137             :     IGMLReader *poReader;
     138             :     bool bOutIsTempFile;
     139             : 
     140             :     void InsertHeader();
     141             : 
     142             :     bool bExposeGMLId;
     143             :     bool bExposeFid;
     144             :     bool bIsWFS;
     145             : 
     146             :     bool bUseGlobalSRSName;
     147             : 
     148             :     bool m_bInvertAxisOrderIfLatLong;
     149             :     bool m_bConsiderEPSGAsURN;
     150             :     GMLSwapCoordinatesEnum m_eSwapCoordinates;
     151             :     bool m_bGetSecondaryGeometryOption;
     152             : 
     153             :     ReadMode eReadMode;
     154             :     GMLFeature *poStoredGMLFeature;
     155             :     OGRGMLLayer *poLastReadLayer;
     156             : 
     157             :     bool bEmptyAsNull;
     158             : 
     159             :     OGRSpatialReference m_oStandaloneGeomSRS{};
     160             :     std::unique_ptr<OGRGeometry> m_poStandaloneGeom{};
     161             : 
     162             :     std::vector<std::string> m_aosGMLExtraElements{};
     163             : 
     164             :     void FindAndParseTopElements(VSILFILE *fp);
     165             :     void SetExtents(double dfMinX, double dfMinY, double dfMaxX, double dfMaxY);
     166             : 
     167             :     void BuildJointClassFromXSD();
     168             :     void BuildJointClassFromScannedSchema();
     169             : 
     170             :     void WriteTopElements();
     171             : 
     172             :     // Analyze the OGR_SCHEMA open options and apply changes to the GML reader, return false in case of a critical error
     173             :     bool DealWithOgrSchemaOpenOption(const GDALOpenInfo *poOpenInfo);
     174             : 
     175             :     CPL_DISALLOW_COPY_ASSIGN(OGRGMLDataSource)
     176             : 
     177             :   public:
     178             :     OGRGMLDataSource();
     179             :     virtual ~OGRGMLDataSource();
     180             : 
     181             :     bool Open(GDALOpenInfo *poOpenInfo);
     182             :     CPLErr Close() override;
     183             :     bool Create(const char *pszFile, char **papszOptions);
     184             : 
     185        1440 :     int GetLayerCount() override
     186             :     {
     187        1440 :         return nLayers;
     188             :     }
     189             : 
     190             :     OGRLayer *GetLayer(int) override;
     191             :     OGRLayer *ICreateLayer(const char *pszName,
     192             :                            const OGRGeomFieldDefn *poGeomFieldDefn,
     193             :                            CSLConstList papszOptions) override;
     194             :     int TestCapability(const char *) override;
     195             : 
     196         266 :     VSILFILE *GetOutputFP() const
     197             :     {
     198         266 :         return fpOutput;
     199             :     }
     200             : 
     201        2831 :     IGMLReader *GetReader() const
     202             :     {
     203        2831 :         return poReader;
     204             :     }
     205             : 
     206             :     void GrowExtents(OGREnvelope3D *psGeomBounds, int nCoordDimension);
     207             : 
     208         703 :     int ExposeId() const
     209             :     {
     210         703 :         return bExposeGMLId || bExposeFid;
     211             :     }
     212             : 
     213             :     void PrintLine(VSILFILE *fp, const char *fmt, ...)
     214             :         CPL_PRINT_FUNC_FORMAT(3, 4);
     215             : 
     216        1778 :     bool IsGML3Output() const
     217             :     {
     218        1778 :         return bIsOutputGML3;
     219             :     }
     220             : 
     221         138 :     bool IsGML3DeegreeOutput() const
     222             :     {
     223         138 :         return bIsOutputGML3Deegree;
     224             :     }
     225             : 
     226         890 :     bool IsGML32Output() const
     227             :     {
     228         890 :         return bIsOutputGML32;
     229             :     }
     230             : 
     231             :     /** Returns whether a writing error has occurred */
     232         530 :     inline bool HasWriteError() const
     233             :     {
     234         530 :         return m_bWriteError;
     235             :     }
     236             : 
     237         575 :     OGRGMLSRSNameFormat GetSRSNameFormat() const
     238             :     {
     239         575 :         return eSRSNameFormat;
     240             :     }
     241             : 
     242         266 :     bool WriteSpaceIndentation() const
     243             :     {
     244         266 :         return bWriteSpaceIndentation;
     245             :     }
     246             : 
     247             :     const char *GetGlobalSRSName();
     248             : 
     249         690 :     bool GetInvertAxisOrderIfLatLong() const
     250             :     {
     251         690 :         return m_bInvertAxisOrderIfLatLong;
     252             :     }
     253             : 
     254         690 :     bool GetConsiderEPSGAsURN() const
     255             :     {
     256         690 :         return m_bConsiderEPSGAsURN;
     257             :     }
     258             : 
     259         690 :     GMLSwapCoordinatesEnum GetSwapCoordinates() const
     260             :     {
     261         690 :         return m_eSwapCoordinates;
     262             :     }
     263             : 
     264         690 :     bool GetSecondaryGeometryOption() const
     265             :     {
     266         690 :         return m_bGetSecondaryGeometryOption;
     267             :     }
     268             : 
     269        3245 :     ReadMode GetReadMode() const
     270             :     {
     271        3245 :         return eReadMode;
     272             :     }
     273             : 
     274         101 :     void SetStoredGMLFeature(GMLFeature *poStoredGMLFeatureIn)
     275             :     {
     276         101 :         poStoredGMLFeature = poStoredGMLFeatureIn;
     277         101 :     }
     278             : 
     279        1658 :     GMLFeature *PeekStoredGMLFeature() const
     280             :     {
     281        1658 :         return poStoredGMLFeature;
     282             :     }
     283             : 
     284         808 :     OGRGMLLayer *GetLastReadLayer() const
     285             :     {
     286         808 :         return poLastReadLayer;
     287             :     }
     288             : 
     289         380 :     void SetLastReadLayer(OGRGMLLayer *poLayer)
     290             :     {
     291         380 :         poLastReadLayer = poLayer;
     292         380 :     }
     293             : 
     294             :     const char *GetAppPrefix() const;
     295             :     bool RemoveAppPrefix() const;
     296             :     bool WriteFeatureBoundedBy() const;
     297             :     const char *GetSRSDimensionLoc() const;
     298             :     bool GMLFeatureCollection() const;
     299             : 
     300             :     void DeclareNewWriteSRS(const OGRSpatialReference *poSRS);
     301             : 
     302         215 :     bool HasWriteGlobalSRS() const
     303             :     {
     304         215 :         return m_bWriteGlobalSRS;
     305             :     }
     306             : 
     307             :     virtual OGRLayer *ExecuteSQL(const char *pszSQLCommand,
     308             :                                  OGRGeometry *poSpatialFilter,
     309             :                                  const char *pszDialect) override;
     310             :     virtual void ReleaseResultSet(OGRLayer *poResultsSet) override;
     311             : 
     312             :     static bool CheckHeader(const char *pszStr);
     313             : };
     314             : 
     315             : #endif /* OGR_GML_H_INCLUDED */