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 <QFlags>
#include <QList>

#include "qgsfeature.h"
#include "qgsrectangle.h"
#include "qgsexpression.h"
#include "qgsexpressioncontext.h"
#include "qgssimplifymethod.h"

typedef QList<int> QgsAttributeList;

class CORE_EXPORT QgsFeatureRequest
{
  public:
    enum Flag
    {
      NoFlags            = 0,
      NoGeometry         = 1,  
      SubsetOfAttributes = 2,  
      ExactIntersect     = 4   
    };
    Q_DECLARE_FLAGS( Flags, Flag )

    
    enum FilterType
    {
      FilterNone,       
      FilterRect,       
      FilterFid,        
      FilterExpression, 
      FilterFids        
    };

    class CORE_EXPORT OrderByClause
    {
      public:
        OrderByClause( const QString &expression, bool ascending = true );
        OrderByClause( const QString &expression, bool ascending, bool nullsfirst );

        QgsExpression expression() const;

        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<OrderByClause>
    {
      public:
        CORE_EXPORT OrderBy()
            : QList<OrderByClause>()
        {}

        CORE_EXPORT OrderBy( const QList<OrderByClause>& other );

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

        QString CORE_EXPORT dump() const;
    };

    static const QString AllAttributes;

    QgsFeatureRequest();
    explicit QgsFeatureRequest( QgsFeatureId fid );
    explicit QgsFeatureRequest( const QgsRectangle& rect );
    explicit QgsFeatureRequest( const QgsExpression& expr, const QgsExpressionContext& context = QgsExpressionContext() );
    QgsFeatureRequest( const QgsFeatureRequest& rh );
    QgsFeatureRequest& operator=( const QgsFeatureRequest& rh );

    ~QgsFeatureRequest();

    FilterType filterType() const { if ( mFilter == FilterNone && !mFilterRect.isNull() ) return FilterRect; else return mFilter; }

    QgsFeatureRequest& setFilterRect( const QgsRectangle& rect );

    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& setFilterExpression( const QString& expression );

    QgsExpression* filterExpression() const { return mFilterExpression; }

    QgsFeatureRequest& combineFilterExpression( const QString& expression );

    QgsExpressionContext* expressionContext() { return &mExpressionContext; }

    QgsFeatureRequest& setExpressionContext( const QgsExpressionContext& context );

    QgsFeatureRequest& disableFilter() { mFilter = FilterNone; 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( const QgsFeatureRequest::Flags& flags );
    const Flags& flags() const { return mFlags; }

    QgsFeatureRequest& setSubsetOfAttributes( const QgsAttributeList& attrs );
    QgsAttributeList subsetOfAttributes() const { return mAttrs; }

    QgsFeatureRequest& setSubsetOfAttributes( const QStringList& attrNames, const QgsFields& fields );

    QgsFeatureRequest& setSimplifyMethod( const QgsSimplifyMethod& simplifyMethod );
    const QgsSimplifyMethod& simplifyMethod() const { return mSimplifyMethod; }

    bool acceptFeature( const QgsFeature& feature );

    // TODO: in future
    // void setFilterNativeExpression(con QString& expr);   // using provider's SQL (if supported)

  protected:
    FilterType mFilter;
    QgsRectangle mFilterRect;
    QgsFeatureId mFilterFid;
    QgsFeatureIds mFilterFids;
    QgsExpression* mFilterExpression;
    QgsExpressionContext mExpressionContext;
    Flags mFlags;
    QgsAttributeList mAttrs;
    QgsSimplifyMethod mSimplifyMethod;
    long mLimit;
    OrderBy mOrderBy;
};

Q_DECLARE_OPERATORS_FOR_FLAGS( QgsFeatureRequest::Flags )


class QgsFeatureIterator;
class QgsAbstractFeatureIterator;

class CORE_EXPORT QgsAbstractFeatureSource
{
  public:
    virtual ~QgsAbstractFeatureSource();

    virtual QgsFeatureIterator getFeatures( const QgsFeatureRequest& request ) = 0;

  protected:
    void iteratorOpened( QgsAbstractFeatureIterator* it );
    void iteratorClosed( QgsAbstractFeatureIterator* it );

    QSet< QgsAbstractFeatureIterator* > mActiveIterators;

    template<typename> friend class QgsAbstractFeatureIteratorFromSource;
};

#endif // QGSFEATUREREQUEST_H