qgsfeaturerequest.h

Go to the documentation of this file.

/***************************************************************************
    qgsfeaturerequest.h
    ---------------------
    begin                : Mai 2012
    copyright            : (C) 2012 by Martin Dobias
    email                : wonder dot sk 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 QGSFEATUREREQUEST_H
#define QGSFEATUREREQUEST_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include <QFlags>
#include <QList>
#include <memory>
 
#include "qgis.h"
#include "qgsfeature.h"
#include "qgsrectangle.h"
#include "qgsexpression.h"
#include "qgsexpressioncontext.h"
#include "qgssimplifymethod.h"
#include "qgscoordinatetransformcontext.h"
#include "qgscoordinatereferencesystem.h"
 
 
class CORE_EXPORT QgsFeatureRequest
{
  public:
    enum Flag
    {
      NoFlags            = 0,
      NoGeometry         = 1,  
      SubsetOfAttributes = 2,  
      ExactIntersect     = 4,   
      IgnoreStaticNodesDuringExpressionCompilation = 8, 
      EmbeddedSymbols    = 16,  
    };
    Q_DECLARE_FLAGS( Flags, Flag )
 
    
    enum FilterType
    {
      FilterNone,       
      FilterFid,        
      FilterExpression, 
      FilterFids        
    };
 
    enum InvalidGeometryCheck
    {
      GeometryNoCheck = 0, 
      GeometrySkipInvalid = 1, 
      GeometryAbortOnInvalid = 2, 
    };
 
    class CORE_EXPORT OrderByClause
    {
      public:
 
        OrderByClause( const QString &expression, bool ascending = true );
 
        OrderByClause( const QString &expression, bool ascending, bool nullsfirst );
 
        OrderByClause( const QgsExpression &expression, bool ascending = true );
 
        OrderByClause( const QgsExpression &expression, bool ascending, bool nullsfirst );
 
        QgsExpression expression() const;
 
        bool prepare( QgsExpressionContext *context );
 
        bool ascending() const;
 
        void setAscending( bool ascending );
 
        bool nullsFirst() const;
 
        void setNullsFirst( bool nullsFirst );
 
        QString dump() const;
 
        // friend inline int qHash(const OrderByClause &a) { return qHash(a.mExpression.expression()) ^ qHash(a.mAscending) ^ qHash( a.mNullsFirst); }
 
        bool operator==( const OrderByClause &v ) const
        {
          return mExpression == v.mExpression &&
                 mAscending == v.mAscending &&
                 mNullsFirst == v.mNullsFirst;
        }
 
        bool operator!=( const OrderByClause &v ) const
        {
          return !( v == *this );
        }
 
      private:
        QgsExpression mExpression;
        bool mAscending;
        bool mNullsFirst;
    };
 
 
    class OrderBy : public QList<QgsFeatureRequest::OrderByClause>
    {
      public:
 
        CORE_EXPORT OrderBy();
 
        CORE_EXPORT OrderBy( const QList<QgsFeatureRequest::OrderByClause> &other );
 
        QList<QgsFeatureRequest::OrderByClause> CORE_EXPORT list() const;
 
        void CORE_EXPORT save( QDomElement &elem ) const;
 
        void CORE_EXPORT load( const QDomElement &elem );
 
        QSet<QString> CORE_EXPORT usedAttributes() const;
 
        QSet<int> CORE_EXPORT usedAttributeIndices( const QgsFields &fields ) const;
 
        QString CORE_EXPORT dump() const;
    };
 
    static const QString ALL_ATTRIBUTES;
 
    QgsFeatureRequest();
    explicit QgsFeatureRequest( QgsFeatureId fid );
    explicit QgsFeatureRequest( const QgsFeatureIds &fids );
 
    explicit QgsFeatureRequest( const QgsRectangle &rectangle );
 
    explicit QgsFeatureRequest( const QgsExpression &expr, const QgsExpressionContext &context = QgsExpressionContext() );
    QgsFeatureRequest( const QgsFeatureRequest &rh );
    QgsFeatureRequest &operator=( const QgsFeatureRequest &rh );
 
    ~QgsFeatureRequest();
 
    FilterType filterType() const { return mFilter; }
 
    Qgis::SpatialFilterType spatialFilterType() const { return mSpatialFilter; }
 
    QgsFeatureRequest &setFilterRect( const QgsRectangle &rectangle );
 
    QgsRectangle filterRect() const;
 
    QgsFeatureRequest &setDistanceWithin( const QgsGeometry &geometry, double distance );
 
    QgsGeometry referenceGeometry() const { return mReferenceGeometry; }
 
    std::shared_ptr< QgsGeometryEngine > referenceGeometryEngine() const SIP_SKIP { return mReferenceGeometryEngine; }
 
    double distanceWithin() const { return mDistanceWithin; }
 
    QgsFeatureRequest &setFilterFid( QgsFeatureId fid );
 
    QgsFeatureId filterFid() const { return mFilterFid; }
 
    QgsFeatureRequest &setFilterFids( const QgsFeatureIds &fids );
 
    const QgsFeatureIds &filterFids() const { return mFilterFids; }
 
    QgsFeatureRequest &setInvalidGeometryCheck( InvalidGeometryCheck check );
 
    InvalidGeometryCheck invalidGeometryCheck() const { return mInvalidGeometryFilter; }
 
#ifndef SIP_RUN
    QgsFeatureRequest &setInvalidGeometryCallback( const std::function< void( const QgsFeature & )> &callback );
#else
    QgsFeatureRequest &setInvalidGeometryCallback( SIP_PYCALLABLE / AllowNone / );
    % MethodCode
    Py_BEGIN_ALLOW_THREADS
 
    sipCpp->setInvalidGeometryCallback( [a0]( const QgsFeature &arg )
    {
      SIP_BLOCK_THREADS
      Py_XDECREF( sipCallMethod( NULL, a0, "D", &arg, sipType_QgsFeature, NULL ) );
      SIP_UNBLOCK_THREADS
    } );
 
    sipRes = sipCpp;
 
    Py_END_ALLOW_THREADS
    % End
#endif
 
    std::function< void( const QgsFeature & ) > invalidGeometryCallback() const { return mInvalidGeometryCallback; } SIP_SKIP
 
    QgsFeatureRequest &setFilterExpression( const QString &expression );
 
    QgsExpression *filterExpression() const { return mFilterExpression.get(); }
 
    QgsFeatureRequest &combineFilterExpression( const QString &expression );
 
    QgsExpressionContext *expressionContext() { return &mExpressionContext; }
 
    QgsFeatureRequest &setExpressionContext( const QgsExpressionContext &context );
 
    QgsFeatureRequest &disableFilter() { mFilter = FilterNone; mFilterExpression.reset(); return *this; }
 
    QgsFeatureRequest &addOrderBy( const QString &expression, bool ascending = true );
 
    QgsFeatureRequest &addOrderBy( const QString &expression, bool ascending, bool nullsfirst );
 
    OrderBy orderBy() const;
 
    QgsFeatureRequest &setOrderBy( const OrderBy &orderBy );
 
    QgsFeatureRequest &setLimit( long long limit );
 
#ifndef SIP_RUN
    long long limit() const { return mLimit; }
#else
    long long limit() const;
#endif
 
    QgsFeatureRequest &setFlags( QgsFeatureRequest::Flags flags );
 
    Flags flags() const { return mFlags; }
 
    QgsFeatureRequest &setSubsetOfAttributes( const QgsAttributeList &attrs );
 
    QgsFeatureRequest &setNoAttributes();
 
    QgsAttributeList subsetOfAttributes() const { return mAttrs; }
 
    QgsFeatureRequest &setSubsetOfAttributes( const QStringList &attrNames, const QgsFields &fields );
 
    QgsFeatureRequest &setSubsetOfAttributes( const QSet<QString> &attrNames, const QgsFields &fields );
 
    QgsFeatureRequest &setSimplifyMethod( const QgsSimplifyMethod &simplifyMethod );
 
    const QgsSimplifyMethod &simplifyMethod() const { return mSimplifyMethod; }
 
    QgsCoordinateReferenceSystem destinationCrs() const;
 
    QgsCoordinateTransformContext transformContext() const;
 
    QgsFeatureRequest &setDestinationCrs( const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context );
 
#ifndef SIP_RUN
    QgsFeatureRequest &setTransformErrorCallback( const std::function< void( const QgsFeature & )> &callback );
#else
    QgsFeatureRequest &setTransformErrorCallback( SIP_PYCALLABLE / AllowNone / );
    % MethodCode
    Py_BEGIN_ALLOW_THREADS
 
    sipCpp->setTransformErrorCallback( [a0]( const QgsFeature &arg )
    {
      SIP_BLOCK_THREADS
      Py_XDECREF( sipCallMethod( NULL, a0, "D", &arg, sipType_QgsFeature, NULL ) );
      SIP_UNBLOCK_THREADS
    } );
 
    sipRes = sipCpp;
 
    Py_END_ALLOW_THREADS
    % End
#endif
 
    std::function< void( const QgsFeature & ) > transformErrorCallback() const { return mTransformErrorCallback; } SIP_SKIP
 
 
    bool acceptFeature( const QgsFeature &feature );
 
    Q_DECL_DEPRECATED int connectionTimeout() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QgsFeatureRequest &setConnectionTimeout( int connectionTimeout ) SIP_DEPRECATED;
 
    int timeout() const;
 
    QgsFeatureRequest &setTimeout( int timeout );
 
    bool requestMayBeNested() const;
 
    QgsFeatureRequest &setRequestMayBeNested( bool requestMayBeNested );
 
    void setFeedback( QgsFeedback *feedback );
 
    QgsFeedback *feedback() const;
 
  protected:
 
    FilterType mFilter = FilterNone;
 
    Qgis::SpatialFilterType mSpatialFilter = Qgis::SpatialFilterType::NoFilter;
 
    QgsRectangle mFilterRect;
 
    QgsGeometry mReferenceGeometry;
 
    std::shared_ptr< QgsGeometryEngine > mReferenceGeometryEngine;
 
    double mDistanceWithin = 0;
 
    QgsFeatureId mFilterFid = -1;
    QgsFeatureIds mFilterFids;
    std::unique_ptr< QgsExpression > mFilterExpression;
    QgsExpressionContext mExpressionContext;
    Flags mFlags = Flags();
    QgsAttributeList mAttrs;
    QgsSimplifyMethod mSimplifyMethod;
    long long mLimit = -1;
    OrderBy mOrderBy;
    InvalidGeometryCheck mInvalidGeometryFilter = GeometryNoCheck;
    std::function< void( const QgsFeature & ) > mInvalidGeometryCallback;
    std::function< void( const QgsFeature & ) > mTransformErrorCallback;
    QgsCoordinateReferenceSystem mCrs;
    QgsCoordinateTransformContext mTransformContext;
    int mTimeout = -1;
    int mRequestMayBeNested = false;
    QgsFeedback *mFeedback = nullptr;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsFeatureRequest::Flags )
 
 
class QgsFeatureIterator;
class QgsAbstractFeatureIterator;
 
class CORE_EXPORT QgsAbstractFeatureSource
{
  public:
    virtual ~QgsAbstractFeatureSource();
 
 
    // IMPORTANT -- do NOT remove the /TransferBack/ annotation here -- while it looks completely wrong, it's
    // required for Python data providers to work correctly! Argh!
 
    virtual QgsFeatureIterator getFeatures( const QgsFeatureRequest &request = QgsFeatureRequest() ) = 0 SIP_TRANSFERBACK;
 
    // IMPORTANT -- do NOT remove the /TransferBack/ annotation here -- while it looks completely wrong, it's
    // required for Python data providers to work correctly! Argh!
 
  protected:
    void iteratorOpened( QgsAbstractFeatureIterator *it );
    void iteratorClosed( QgsAbstractFeatureIterator *it );
 
    QSet< QgsAbstractFeatureIterator * > mActiveIterators;
 
    template<typename> friend class QgsAbstractFeatureIteratorFromSource;
};
 
#endif // QGSFEATUREREQUEST_H