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 "qgsfeature.h"
#include "qgsrectangle.h"
#include "qgsexpression.h"
#include "qgsexpressioncontext.h"
#include "qgssimplifymethod.h"
 
 
 
class CORE_EXPORT QgsFeatureRequest
{
  public:
    enum Flag
    {
      NoFlags            = 0,
      NoGeometry         = 1,  
      SubsetOfAttributes = 2,  
      ExactIntersect     = 4   
    };
    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); }
 
      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 );
 
    FilterType filterType() const { return mFilter; }
 
    QgsFeatureRequest &setFilterRect( const QgsRectangle &rectangle );
 
    const QgsRectangle &filterRect() const { return mFilterRect; }
 
    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 limit );
 
    long limit() const { return mLimit; }
 
    QgsFeatureRequest &setFlags( QgsFeatureRequest::Flags flags );
    const 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 );
 
  protected:
    FilterType mFilter = FilterNone;
    QgsRectangle mFilterRect;
    QgsFeatureId mFilterFid = -1;
    QgsFeatureIds mFilterFids;
    std::unique_ptr< QgsExpression > mFilterExpression;
    QgsExpressionContext mExpressionContext;
    Flags mFlags = Flags();
    QgsAttributeList mAttrs;
    QgsSimplifyMethod mSimplifyMethod;
    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;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsFeatureRequest::Flags )
 
 
class QgsFeatureIterator;
class QgsAbstractFeatureIterator;
 
class CORE_EXPORT QgsAbstractFeatureSource
{
  public:
    virtual ~QgsAbstractFeatureSource();
 
    virtual QgsFeatureIterator getFeatures( const QgsFeatureRequest &request = QgsFeatureRequest() ) = 0;
 
  protected:
    void iteratorOpened( QgsAbstractFeatureIterator *it );
    void iteratorClosed( QgsAbstractFeatureIterator *it );
 
    QSet< QgsAbstractFeatureIterator * > mActiveIterators;
 
    template<typename> friend class QgsAbstractFeatureIteratorFromSource;
};
 
#endif // QGSFEATUREREQUEST_H