Line data    Source code

       1             : /******************************************************************************
       2             :  * $Id$
       3             :  *
       4             :  * Project:  NAS Reader
       5             :  * Purpose:  Private Declarations for OGR NAS Reader code.
       6             :  * Author:   Frank Warmerdam, warmerdam@pobox.com
       7             :  *
       8             :  ******************************************************************************
       9             :  * Copyright (c) 2008, 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 CPL_NASREADERP_H_INCLUDED
      16             : #define CPL_NASREADERP_H_INCLUDED
      17             : 
      18             : #include "xercesc_headers.h"
      19             : #include "ogr_xerces.h"
      20             : 
      21             : #include "gmlreader.h"
      22             : #include "gmlreaderp.h"
      23             : #include "ogr_api.h"
      24             : #include "ogr_geometry.h"
      25             : #include "cpl_string.h"
      26             : #include <list>
      27             : 
      28             : IGMLReader *CreateNASReader();
      29             : 
      30             : class NASReader;
      31             : 
      32             : CPL_C_START
      33             : OGRGeometryH OGR_G_CreateFromGML3(const char *pszGML);
      34             : CPL_C_END
      35             : 
      36             : /************************************************************************/
      37             : /*                              NASHandler                              */
      38             : /************************************************************************/
      39             : class NASHandler final : public DefaultHandler
      40             : {
      41             :     NASReader *m_poReader;
      42             : 
      43             :     char *m_pszCurField;
      44             : 
      45             :     char *m_pszGeometry;
      46             :     int m_nGeomAlloc;
      47             :     int m_nGeomLen;
      48             : 
      49             :     int m_nGeometryDepth;
      50             :     int m_nGeometryPropertyIndex;
      51             :     bool IsGeometryElement(const char *);
      52             : 
      53             :     int m_nDepth;
      54             :     int m_nDepthFeature;
      55             :     bool m_bIgnoreFeature;
      56             : 
      57             :     CPLString m_osDeleteContext;
      58             :     CPLString m_osTypeName;
      59             :     CPLString m_osReplacingFID;
      60             :     CPLString m_osSafeToIgnore;
      61             :     CPLString m_osUpdatePropertyName;
      62             :     CPLString m_osUpdateEnds;
      63             :     CPLString m_osFeatureId;
      64             :     std::list<CPLString> m_UpdateOccasions;
      65             : 
      66             :     CPLString m_osElementName;
      67             :     CPLString m_osCharacters;
      68             : 
      69             :     const Locator *m_Locator;
      70             : 
      71             :     int m_nEntityCounter = 0;
      72             : 
      73             :   public:
      74             :     explicit NASHandler(NASReader *poReader);
      75             :     virtual ~NASHandler();
      76             : 
      77             :     void startElement(const XMLCh *const uri, const XMLCh *const localname,
      78             :                       const XMLCh *const qname,
      79             :                       const Attributes &attrs) override;
      80             :     void endElement(const XMLCh *const uri, const XMLCh *const localname,
      81             :                     const XMLCh *const qname) override;
      82             : #if XERCES_VERSION_MAJOR >= 3
      83             :     void characters(const XMLCh *const chars, const XMLSize_t length) override;
      84             : #else
      85             :     void characters(const XMLCh *const chars, const unsigned int length);
      86             : #endif
      87             : 
      88             :     void fatalError(const SAXParseException &) override;
      89             : 
      90             :     void startEntity(const XMLCh *const name) override;
      91             : 
      92             :     void setDocumentLocator(const Locator *locator) override;
      93             : 
      94             :     CPLString GetAttributes(const Attributes *attr);
      95             : };
      96             : 
      97             : /************************************************************************/
      98             : /*                             GMLReadState                             */
      99             : /************************************************************************/
     100             : 
     101             : // for now, use existing gmlreadstate.
     102             : #ifdef notdef
     103             : class GMLReadState
     104             : {
     105             :     void RebuildPath();
     106             : 
     107             :   public:
     108             :     GMLReadState();
     109             :     ~GMLReadState();
     110             : 
     111             :     void PushPath(const char *pszElement);
     112             :     void PopPath();
     113             : 
     114             :     int MatchPath(const char *pszPathInput);
     115             : 
     116             :     const char *GetPath() const
     117             :     {
     118             :         return m_pszPath;
     119             :     }
     120             : 
     121             :     const char *GetLastComponent() const;
     122             : 
     123             :     GMLFeature *m_poFeature;
     124             :     GMLReadState *m_poParentState;
     125             : 
     126             :     char *m_pszPath;  // element path ... | as separator.
     127             : 
     128             :     int m_nPathLength;
     129             :     char **m_papszPathComponents;
     130             : };
     131             : #endif
     132             : 
     133             : /************************************************************************/
     134             : /*                              NASReader                               */
     135             : /************************************************************************/
     136             : 
     137             : class NASReader final : public IGMLReader
     138             : {
     139             :   private:
     140             :     bool m_bClassListLocked;
     141             : 
     142             :     int m_nClassCount;
     143             :     GMLFeatureClass **m_papoClass;
     144             : 
     145             :     char *m_pszFilename;
     146             : 
     147             :     NASHandler *m_poNASHandler;
     148             :     SAX2XMLReader *m_poSAXReader;
     149             :     bool m_bReadStarted;
     150             :     bool m_bXercesInitialized;
     151             :     XMLPScanToken m_oToFill;
     152             : 
     153             :     GMLReadState *m_poState;
     154             : 
     155             :     GMLFeature *m_poCompleteFeature;
     156             :     VSILFILE *m_fp;
     157             :     InputSource *m_GMLInputSource;
     158             : 
     159             :     bool SetupParser();
     160             :     void CleanupParser();
     161             : 
     162             :     char *m_pszFilteredClassName;
     163             :     bool m_bStopParsing = false;
     164             : 
     165             :   public:
     166             :     NASReader();
     167             :     virtual ~NASReader();
     168             : 
     169           9 :     bool IsClassListLocked() const override
     170             :     {
     171           9 :         return m_bClassListLocked;
     172             :     }
     173             : 
     174           5 :     void SetClassListLocked(bool bFlag) override
     175             :     {
     176           5 :         m_bClassListLocked = bFlag;
     177           5 :     }
     178             : 
     179             :     void SetSourceFile(const char *pszFilename) override;
     180             :     const char *GetSourceFileName() override;
     181             : 
     182          53 :     int GetClassCount() const override
     183             :     {
     184          53 :         return m_nClassCount;
     185             :     }
     186             : 
     187             :     GMLFeatureClass *GetClass(int i) const override;
     188             :     GMLFeatureClass *GetClass(const char *pszName) const override;
     189             : 
     190             :     int AddClass(GMLFeatureClass *poClass) override;
     191             :     void ClearClasses() override;
     192             : 
     193             :     GMLFeature *NextFeature() override;
     194             : 
     195             :     bool LoadClasses(const char *pszFile = nullptr) override;
     196             :     bool SaveClasses(const char *pszFile = nullptr) override;
     197             : 
     198             :     bool PrescanForSchema(bool bGetExtents = true,
     199             :                           bool bOnlyDetectSRS = false) override;
     200             :     bool PrescanForTemplate() override;
     201             :     void ResetReading() override;
     202             : 
     203             :     bool ParseXSD(const char * /* pszFile */)
     204             :     {
     205             :         return false;
     206             :     }
     207             : 
     208             :     bool ResolveXlinks(const char *pszFile, bool *pbOutIsTempFile,
     209             :                        char **papszSkip = nullptr,
     210             :                        const bool bStrict = false) override;
     211             : 
     212             :     bool HugeFileResolver(const char *pszFile, bool bSqliteIsTempFile,
     213             :                           int iSqliteCacheMB) override;
     214             : 
     215             :     // ---
     216             : 
     217        1402 :     GMLReadState *GetState() const
     218             :     {
     219        1402 :         return m_poState;
     220             :     }
     221             : 
     222             :     void PopState();
     223             :     void PushState(GMLReadState *);
     224             : 
     225             :     bool IsFeatureElement(const char *pszElement);
     226             :     bool IsAttributeElement(const char *pszElement, const Attributes &attrs);
     227             : 
     228             :     void PushFeature(const char *pszElement, const Attributes &attrs);
     229             : 
     230             :     void SetFeaturePropertyDirectly(const char *pszElement, char *pszValue);
     231             : 
     232           0 :     void StopParsing()
     233             :     {
     234           0 :         m_bStopParsing = true;
     235           0 :     }
     236             : 
     237           1 :     bool HasStoppedParsing() override
     238             :     {
     239           1 :         return m_bStopParsing;
     240             :     }
     241             : 
     242             :     int GetAttributeElementIndex(const char *pszElement, int nLen,
     243             :                                  const char *pszAttrKey);
     244             :     void DealWithAttributes(const char *pszElement, int nLenName,
     245             :                             const Attributes &attrs);
     246             : 
     247           0 :     virtual const char *GetGlobalSRSName() override
     248             :     {
     249           0 :         return nullptr;
     250             :     }
     251             : 
     252           0 :     virtual bool CanUseGlobalSRSName() override
     253             :     {
     254           0 :         return false;
     255             :     }
     256             : 
     257             :     bool SetFilteredClassName(const char *pszClassName) override;
     258             : 
     259          11 :     const char *GetFilteredClassName() override
     260             :     {
     261          11 :         return m_pszFilteredClassName;
     262             :     }
     263             : 
     264             :     static OGRGeometry *ConvertGeometry(OGRGeometry *);
     265             : };
     266             : 
     267             : #endif /* CPL_NASREADERP_H_INCLUDED */