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