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 <memory>
 
#include "qgis.h"
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgscoordinatereferencesystem.h"
#include "qgscoordinatetransform.h"
#include "qgscoordinatetransformcontext.h"
#include "qgsexpression.h"
#include "qgsexpressioncontext.h"
#include "qgsfeature.h"
#include "qgsrectangle.h"
#include "qgssimplifymethod.h"
 
#include <QFlags>
#include <QList>

class CORE_EXPORT QgsFeatureRequest
{
  public:

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

        CORE_EXPORT bool operator==( const OrderBy &v ) const;

        CORE_EXPORT bool operator!=( const OrderBy &v ) const;

        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 );
    SIP_SKIP QgsFeatureRequest( QgsFeatureRequest &&rh );
    QgsFeatureRequest &operator=( const QgsFeatureRequest &rh );
    QgsFeatureRequest &operator=( QgsFeatureRequest &&rh );

    bool compare( const QgsFeatureRequest &other ) const;
 
    ~QgsFeatureRequest();

    Qgis::FeatureRequestFilterType 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( Qgis::InvalidGeometryCheck check );

    Qgis::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 SIP_SKIP { return mInvalidGeometryCallback; }

    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 = Qgis::FeatureRequestFilterType::NoFilter; 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( Qgis::FeatureRequestFlags flags );

    Qgis::FeatureRequestFlags 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; }

    QgsCoordinateTransform coordinateTransform() const;

    QgsCoordinateReferenceSystem destinationCrs() const;

    QgsCoordinateTransformContext transformContext() const;

    QgsCoordinateTransform calculateTransform( const QgsCoordinateReferenceSystem &sourceCrs ) const;

    QgsFeatureRequest &setCoordinateTransform( const QgsCoordinateTransform &transform );

    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 SIP_SKIP { return mTransformErrorCallback; }
 

    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:

    Qgis::FeatureRequestFilterType mFilter = Qgis::FeatureRequestFilterType::NoFilter;

    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;
    Qgis::FeatureRequestFlags mFlags;
    QgsAttributeList mAttrs;
    QgsSimplifyMethod mSimplifyMethod;
    long long mLimit = -1;
    OrderBy mOrderBy;
    Qgis::InvalidGeometryCheck mInvalidGeometryFilter = Qgis::InvalidGeometryCheck::NoCheck;
    std::function< void( const QgsFeature & ) > mInvalidGeometryCallback;
    std::function< void( const QgsFeature & ) > mTransformErrorCallback;
    QgsCoordinateTransform mTransform;
    QgsCoordinateReferenceSystem mCrs;
    QgsCoordinateTransformContext mTransformContext;
    int mTimeout = -1;
    int mRequestMayBeNested = false;
    QgsFeedback *mFeedback = nullptr;
};
 
 
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