qgsgml.h

Go to the documentation of this file.

/***************************************************************************
    qgsgml.h
    ---------------------
    begin                : February 2013
    copyright            : (C) 2013 by Radim Blazek
    email                : radim dot blazek at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef QGSGML_H
#define QGSGML_H
 
#include "qgis_core.h"
#include <expat.h>
#include "qgis_sip.h"
#include "qgsfields.h"
#include "qgsrectangle.h"
#include "qgswkbptr.h"
#include "qgsfeature.h"
 
#include <QPair>
#include <QByteArray>
#include <QDomElement>
#include <QStringList>
#include <QStack>
#include <QVector>
 
#include <string>
 
#ifndef SIP_RUN
#include <nlohmann/json.hpp>
#endif
 
class QgsCoordinateReferenceSystem;
class QTextCodec;
 
#ifndef SIP_RUN
 
class CORE_EXPORT QgsGmlStreamingParser
{
  public:
 
    typedef QPair<QgsFeature *, QString> QgsGmlFeaturePtrGmlIdPair;
 
    class LayerProperties
    {
      public:
 
        LayerProperties() = default;
 
        QString mName;
        QString mGeometryAttribute;
    };
 
    typedef enum
    {
      Honour_EPSG_if_urn,
      Honour_EPSG,
      Ignore_EPSG,
    } AxisOrientationLogic;
 
    QgsGmlStreamingParser( const QString &typeName,
                           const QString &geometryAttribute,
                           const QgsFields &fields,
                           AxisOrientationLogic axisOrientationLogic = Honour_EPSG_if_urn,
                           bool invertAxisOrientation = false );
 
    QgsGmlStreamingParser( const QList<LayerProperties> &layerProperties,
                           const QgsFields &fields,
                           const QMap< QString, QPair<QString, QString> > &fieldNameToSrcLayerNameFieldNameMap,
                           AxisOrientationLogic axisOrientationLogic = Honour_EPSG_if_urn,
                           bool invertAxisOrientation = false );
    ~QgsGmlStreamingParser();
 
    QgsGmlStreamingParser( const QgsGmlStreamingParser &other ) = delete;
    QgsGmlStreamingParser &operator=( const QgsGmlStreamingParser &other ) = delete;
 
    void setFieldsXPath(
      const QMap<QString, QPair<QString, bool>> &fieldNameToSrcLayerNameFieldNameMap,
      const QMap<QString, QString> &namespacePrefixToURIMap );
 
    bool processData( const QByteArray &data, bool atEnd, QString &errorMsg );
 
    bool processData( const QByteArray &data, bool atEnd );
 
    QVector<QgsGmlFeaturePtrGmlIdPair> getAndStealReadyFeatures();
 
    int getEPSGCode() const { return mEpsg; }
 
    QString srsName() const { return mSrsName; }
 
    const QgsRectangle &layerExtent() const { return mLayerExtent; }
 
    Qgis::WkbType wkbType() const { return mWkbType; }
 
    int numberMatched() const { return mNumberMatched; }
 
    int numberReturned() const { return mNumberReturned; }
 
    bool isException() const { return mIsException; }
 
    QString exceptionText() const { return mExceptionText; }
 
    bool isTruncatedResponse() const { return mTruncatedResponse; }
 
  private:
 
    enum ParseMode
    {
      None,
      BoundingBox,
      Null,
      Envelope,
      LowerCorner,
      UpperCorner,
      Feature,  // feature element containing attrs and geo (inside gml:featureMember)
      Attribute,
      Tuple, // wfs:Tuple of a join layer
      FeatureTuple,
      AttributeTuple,
      Geometry,
      Coordinate,
      PosList,
      MultiPoint,
      MultiLine,
      MultiPolygon,
      ExceptionReport,
      ExceptionText
    };
 
    void startElement( const XML_Char *el, const XML_Char **attr );
    void endElement( const XML_Char *el );
    void characters( const XML_Char *chars, int len );
    static void start( void *data, const XML_Char *el, const XML_Char **attr )
    {
      static_cast<QgsGmlStreamingParser *>( data )->startElement( el, attr );
    }
    static void end( void *data, const XML_Char *el )
    {
      static_cast<QgsGmlStreamingParser *>( data )->endElement( el );
    }
    static void chars( void *data, const XML_Char *chars, int len )
    {
      static_cast<QgsGmlStreamingParser *>( data )->characters( chars, len );
    }
 
    // Add mStringCash to the current json object
    void addStringContentToJson();
 
    // Set current feature attribute
    void setAttribute( const QString &name, const QString &value );
 
    //helper routines
 
    int readEpsgFromAttribute( int &epsgNr, const XML_Char **attr );
 
    QString readAttribute( const QString &attributeName, const XML_Char **attr ) const;
    bool createBBoxFromCoordinateString( QgsRectangle &bb, const QString &coordString ) const;
 
    int pointsFromCoordinateString( QList<QgsPoint> &points, const QString &coordString, int *dimension = nullptr ) const;
 
    int pointsFromPosListString( QList<QgsPoint> &points, const QString &coordString, int dimension ) const;
 
    int pointsFromString( QList<QgsPoint> &points, const QString &coordString, int *dimension = nullptr ) const;
    int getPointWKB( QByteArray &wkbPtr, const QgsPoint &, int dimension ) const;
    int getLineWKB( QByteArray &wkbPtr, const QList<QgsPoint> &lineCoordinates, int dimension ) const;
    int getRingWKB( QByteArray &wkbPtr, const QList<QgsPoint> &ringCoordinates, int dimension ) const;
 
    int createMultiLineFromFragments();
    int createMultiPointFromFragments();
    int createPolygonFromFragments();
    int createMultiPolygonFromFragments();
    int totalWKBFragmentSize() const;
 
    ParseMode modeStackTop() { return mParseModeStack.isEmpty() ? None : mParseModeStack.top(); }
 
    ParseMode modeStackPop() { return mParseModeStack.isEmpty() ? None : mParseModeStack.pop(); }
 
    void createParser( const QByteArray &encoding = QByteArray() );
 
    XML_Parser mParser = nullptr;
 
    QVector<QgsGmlFeaturePtrGmlIdPair> mFeatureList;
 
    QList<LayerProperties> mLayerProperties;
    QMap< QString, LayerProperties > mMapTypeNameToProperties;
 
    QString mTypeName;
    QByteArray mTypeNameBA;
    const char *mTypeNamePtr = nullptr;
    size_t mTypeNameUTF8Len;
 
    Qgis::WkbType mWkbType;
 
    //results are members such that handler routines are able to manipulate them
 
    QString mGeometryAttribute;
    QByteArray mGeometryAttributeBA;
    const char *mGeometryAttributePtr = nullptr;
    size_t mGeometryAttributeUTF8Len;
 
    QgsFields mFields;
    QMap<QString, QPair<int, QgsField> > mThematicAttributes;
    QMap<QString, QPair<QString, bool>> mMapXPathToFieldNameAndIsNestedContent;
    QMap<QString, QString> mMapNamespaceURIToNamespacePrefix;
 
    bool mIsException;
    QString mExceptionText;
    bool mTruncatedResponse;
    int mParseDepth;
    int mFeatureTupleDepth;
    QString mCurrentTypename; 
    QStack<ParseMode> mParseModeStack;
    QString mCurrentXPathWithinFeature;
    QString mStringCash;
    QgsFeature *mCurrentFeature = nullptr;
    QVector<QVariant> mCurrentAttributes; //attributes of current feature
    QString mCurrentFeatureId;
    int mFeatureCount;
    QByteArray mCurrentWKB;
    QgsRectangle mCurrentExtent;
    bool mBoundedByNullFound;
 
    QList< QList< QByteArray > > mCurrentWKBFragments;
    QString mAttributeName;
    int mAttributeDepth = -1;
    bool mAttributeValIsNested = false;
    QMap< QString, QString > mMapFieldNameToJSONContent;
    nlohmann::json mAttributeJson;
    QStack<nlohmann::json *> mAttributeJsonCurrentStack;
    char mEndian;
    QString mCoordinateSeparator;
    QString mTupleSeparator;
    QStack<int> mDimensionStack;
    int mDimension;
    ParseMode mCoorMode;
    int mEpsg;
    QString mSrsName;
    QgsRectangle mLayerExtent;
    QString mGMLNameSpaceURI;
    const char *mGMLNameSpaceURIPtr = nullptr;
    AxisOrientationLogic mAxisOrientationLogic;
    bool mInvertAxisOrientationRequest;
    bool mInvertAxisOrientation;
    int mNumberReturned;
    int mNumberMatched;
    std::string mGeometryString;
    bool mFoundUnhandledGeometryElement;
    QTextCodec *mCodec = nullptr;
};
 
#endif
 
class CORE_EXPORT QgsGml : public QObject
{
    Q_OBJECT
  public:
    QgsGml(
      const QString &typeName,
      const QString &geometryAttribute,
      const QgsFields &fields );
 
    int getFeatures( const QString &uri,
                     Qgis::WkbType *wkbType,
                     QgsRectangle *extent = nullptr,
                     const QString &userName = QString(),
                     const QString &password = QString(),
                     const QString &authcfg = QString() ) SIP_PYNAME( getFeaturesUri );
 
    int getFeatures( const QByteArray &data, Qgis::WkbType *wkbType, QgsRectangle *extent = nullptr );
 
    QMap<QgsFeatureId, QgsFeature * > featuresMap() const { return mFeatures; }
 
    QMap<QgsFeatureId, QString > idsMap() const { return mIdMap; }
 
    QgsCoordinateReferenceSystem crs() const;
 
  signals:
 
    void dataReadProgress( int progress );
 
    void totalStepsUpdate( int totalSteps );
 
    void dataProgressAndSteps( int progress, int totalSteps );
 
  private slots:
 
    void setFinished();
 
    void handleProgressEvent( qint64 progress, qint64 totalSteps );
 
  private:
 
    void calculateExtentFromFeatures();
 
    void fillMapsFromParser();
 
    QgsGmlStreamingParser mParser;
 
    QString mTypeName;
 
    bool mFinished;
 
    //QMap<QgsFeatureId, QgsFeature* > &mFeatures;
    QMap<QgsFeatureId, QgsFeature * > mFeatures;
    //QMap<QString, QMap<QgsFeatureId, QgsFeature* > > mFeatures;
 
    //QMap<QgsFeatureId, QString > &mIdMap;
    QMap<QgsFeatureId, QString > mIdMap;
    //QMap<QString, QMap<QgsFeatureId, QString > > mIdMap;
 
    QgsRectangle mExtent;
};
 
#endif