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.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>

class QgsCoordinateReferenceSystem;

#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> > &mapFieldNameToSrcLayerNameFieldName,
                           AxisOrientationLogic axisOrientationLogic = Honour_EPSG_if_urn,
                           bool invertAxisOrientation = false );
    ~QgsGmlStreamingParser();

    QgsGmlStreamingParser( const QgsGmlStreamingParser &other ) = delete;
    QgsGmlStreamingParser &operator=( const QgsGmlStreamingParser &other ) = delete;

    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; }

    QgsWkbTypes::Type 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 );
    }

    // 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<QgsPointXY> &points, const QString &coordString ) const;

    int pointsFromPosListString( QList<QgsPointXY> &points, const QString &coordString, int dimension ) const;

    int pointsFromString( QList<QgsPointXY> &points, const QString &coordString ) const;
    int getPointWKB( QgsWkbPtr &wkbPtr, const QgsPointXY & ) const;
    int getLineWKB( QgsWkbPtr &wkbPtr, const QList<QgsPointXY> &lineCoordinates ) const;
    int getRingWKB( QgsWkbPtr &wkbPtr, const QList<QgsPointXY> &ringCoordinates ) 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(); }

    XML_Parser mParser;

    QVector<QgsGmlFeaturePtrGmlIdPair> mFeatureList;

    QList<LayerProperties> mLayerProperties;
    QMap< QString, LayerProperties > mMapTypeNameToProperties;

    QString mTypeName;
    QByteArray mTypeNameBA;
    const char *mTypeNamePtr = nullptr;
    size_t mTypeNameUTF8Len;

    QgsWkbTypes::Type 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;

    bool mIsException;
    QString mExceptionText;
    bool mTruncatedResponse;
    int mParseDepth;
    int mFeatureTupleDepth;
    QString mCurrentTypename; 
    QStack<ParseMode> mParseModeStack;
    QString mStringCash;
    QgsFeature *mCurrentFeature = nullptr;
    QVector<QVariant> mCurrentAttributes; //attributes of current feature
    QString mCurrentFeatureId;
    int mFeatureCount;
    QgsWkbPtr mCurrentWKB;
    QgsRectangle mCurrentExtent;
    bool mBoundedByNullFound;

    QList< QList<QgsWkbPtr> > mCurrentWKBFragments;
    QString mAttributeName;
    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;
};

#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,
                     QgsWkbTypes::Type *wkbType,
                     QgsRectangle *extent = nullptr,
                     const QString &userName = QString(),
                     const QString &password = QString(),
                     const QString &authcfg = QString() ) SIP_PYNAME( getFeaturesUri );

    int getFeatures( const QByteArray &data, QgsWkbTypes::Type *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