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 <expat.h>
#include "qgis.h"
#include "qgsapplication.h"
#include "qgscoordinatereferencesystem.h"
#include "qgsdataprovider.h"
#include "qgsfeature.h"
#include "qgsfield.h"
#include "qgslogger.h"
#include "qgspoint.h"
#include "qgsrectangle.h"
#include "qgswkbptr.h"

#include <QPair>
#include <QByteArray>
#include <QDomElement>
#include <QStringList>
#include <QStack>
#include <QVector>

#include <string>

class CORE_EXPORT QgsGmlStreamingParser
{
  public:

    typedef QPair<QgsFeature*, QString> QgsGmlFeaturePtrGmlIdPair;

    class LayerProperties
    {
      public:
        LayerProperties() {}

        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();

    bool processData( const QByteArray& data, bool atEnd, QString& errorMsg );

    bool processData( const QByteArray& data, bool atEnd );

    QVector<QgsGmlFeaturePtrGmlIdPair> getAndStealReadyFeatures();

    int getEPSGCode() const { return mEpsg; }

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

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

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

    int pointsFromString( QList<QgsPoint>& points, const QString& coordString ) const;
    int getPointWKB( QgsWkbPtr &wkbPtr, const QgsPoint& ) const;
    int getLineWKB( QgsWkbPtr &wkbPtr, const QList<QgsPoint>& lineCoordinates ) const;
    int getRingWKB( QgsWkbPtr &wkbPtr, const QList<QgsPoint>& 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;
    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;
    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;
    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;
    AxisOrientationLogic mAxisOrientationLogic;
    bool mInvertAxisOrientationRequest;
    bool mInvertAxisOrientation;
    int mNumberReturned;
    int mNumberMatched;
    std::string mGeometryString;
    bool mFoundUnhandledGeometryElement;
};


class CORE_EXPORT QgsGml : public QObject
{
    Q_OBJECT
  public:
    QgsGml(
      const QString& typeName,
      const QString& geometryAttribute,
      const QgsFields & fields );

    ~QgsGml();

    int getFeatures( const QString& uri,
                     QGis::WkbType* wkbType,
                     QgsRectangle* extent = nullptr,
                     const QString& userName = QString(),
                     const QString& password = QString(),
                     const QString& authcfg = QString() );

    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;

  private slots:

    void setFinished();

    void handleProgressEvent( qint64 progress, qint64 totalSteps );

  signals:
    void dataReadProgress( int progress );
    void totalStepsUpdate( int totalSteps );
    //also emit signal with progress and totalSteps together (this is better for the status message)
    void dataProgressAndSteps( int progress, int 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