qgsfeatureiterator.h

Go to the documentation of this file.

/***************************************************************************
    qgsfeatureiterator.h
    ---------------------
    begin                : Juli 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 QGSFEATUREITERATOR_H
#define QGSFEATUREITERATOR_H

#include "qgis_core.h"
#include "qgsfeaturerequest.h"
#include "qgsindexedfeature.h"

class QgsFeedback;

class CORE_EXPORT QgsAbstractFeatureIterator
{
  public:

    enum CompileStatus
    {
      NoCompilation, 
      PartiallyCompiled, 
      Compiled, 
    };

    QgsAbstractFeatureIterator( const QgsFeatureRequest &request );

    virtual ~QgsAbstractFeatureIterator() = default;

    virtual bool nextFeature( QgsFeature &f );

    virtual bool rewind() = 0;
    virtual bool close() = 0;

    virtual void setInterruptionChecker( QgsFeedback *interruptionChecker ) SIP_SKIP;

    CompileStatus compileStatus() const { return mCompileStatus; }

    virtual bool isValid() const
    {
      return mValid;
    }

    bool compileFailed() const;

  protected:

    virtual bool fetchFeature( QgsFeature &f ) = 0;

    virtual bool nextFeatureFilterExpression( QgsFeature &f );

    virtual bool nextFeatureFilterFids( QgsFeature &f );

    void geometryToDestinationCrs( QgsFeature &feature, const QgsCoordinateTransform &transform ) const;


    QgsRectangle filterRectToSourceCrs( const QgsCoordinateTransform &transform ) const SIP_THROW( QgsCsException );

    QgsFeatureRequest mRequest;

    bool mClosed = false;

    bool mZombie = false;

    int refs = 0;
    void ref();
    void deref();
    friend class QgsFeatureIterator;

    long mFetchedCount = 0;

    CompileStatus mCompileStatus = NoCompilation;

    bool mCompileFailed = false;

    virtual bool prepareSimplification( const QgsSimplifyMethod &simplifyMethod );

    bool mValid = true;

  private:
    bool mUseCachedFeatures = false;
    QList<QgsIndexedFeature> mCachedFeatures;
    QList<QgsIndexedFeature>::ConstIterator mFeatureIterator;

    virtual bool providerCanSimplify( QgsSimplifyMethod::MethodType methodType ) const;

    virtual bool prepareOrderBy( const QList<QgsFeatureRequest::OrderByClause> &orderBys );

    void setupOrderBy( const QList<QgsFeatureRequest::OrderByClause> &orderBys );
};


template<typename T>
class QgsAbstractFeatureIteratorFromSource : public QgsAbstractFeatureIterator
{
  public:
    QgsAbstractFeatureIteratorFromSource( T *source, bool ownSource, const QgsFeatureRequest &request )
      : QgsAbstractFeatureIterator( request )
      , mSource( source )
      , mOwnSource( ownSource )
    {
      mSource->iteratorOpened( this );
    }

    ~QgsAbstractFeatureIteratorFromSource() override
    {
      if ( mOwnSource )
        delete mSource;
    }

  protected:
    void iteratorClosed() { mSource->iteratorClosed( this ); }

    T *mSource = nullptr;
    bool mOwnSource;
};


class CORE_EXPORT QgsFeatureIterator
{
  public:

#ifdef SIP_RUN
    QgsFeatureIterator *__iter__();
    % MethodCode
    sipRes = sipCpp;
    % End

    SIP_PYOBJECT __next__() SIP_TYPEHINT( QgsFeature );
    % MethodCode
    std::unique_ptr< QgsFeature > f = qgis::make_unique< QgsFeature >();
    bool result = false;
    Py_BEGIN_ALLOW_THREADS
    result = ( sipCpp->nextFeature( *f ) );
    Py_END_ALLOW_THREADS
    if ( result )
      sipRes = sipConvertFromType( f.release(), sipType_QgsFeature, Py_None );
    else
    {
      PyErr_SetString( PyExc_StopIteration, "" );
    }
    % End
#endif

    QgsFeatureIterator() = default;
    QgsFeatureIterator( QgsAbstractFeatureIterator *iter SIP_TRANSFER );
    QgsFeatureIterator( const QgsFeatureIterator &fi );
    ~QgsFeatureIterator();

    QgsFeatureIterator &operator=( const QgsFeatureIterator &other );

    bool nextFeature( QgsFeature &f );
    bool rewind();
    bool close();

    virtual bool isValid() const;

    bool isClosed() const;

    void setInterruptionChecker( QgsFeedback *interruptionChecker ) SIP_SKIP;

    QgsAbstractFeatureIterator::CompileStatus compileStatus() const { return mIter->compileStatus(); }

    bool compileFailed() const { return mIter->compileFailed(); }

    friend bool operator== ( const QgsFeatureIterator &fi1, const QgsFeatureIterator &fi2 ) SIP_SKIP;
    friend bool operator!= ( const QgsFeatureIterator &fi1, const QgsFeatureIterator &fi2 ) SIP_SKIP;

  protected:
    QgsAbstractFeatureIterator *mIter = nullptr;


};

#ifndef SIP_RUN

inline QgsFeatureIterator::QgsFeatureIterator( QgsAbstractFeatureIterator *iter )
  : mIter( iter )
{
  if ( iter )
    iter->ref();
}

inline QgsFeatureIterator::QgsFeatureIterator( const QgsFeatureIterator &fi )
  : mIter( fi.mIter )
{
  if ( mIter )
    mIter->ref();
}

inline QgsFeatureIterator::~QgsFeatureIterator()
{
  if ( mIter )
    mIter->deref();
}

inline bool QgsFeatureIterator::nextFeature( QgsFeature &f )
{
  return mIter ? mIter->nextFeature( f ) : false;
}

inline bool QgsFeatureIterator::rewind()
{
  if ( mIter )
    mIter->mFetchedCount = 0;

  return mIter ? mIter->rewind() : false;
}

inline bool QgsFeatureIterator::close()
{
  if ( mIter )
    mIter->mFetchedCount = 0;

  return mIter ? mIter->close() : false;
}

inline bool QgsFeatureIterator::isClosed() const
{
  return mIter ? mIter->mClosed && !mIter->mZombie : true;
}

inline bool operator== ( const QgsFeatureIterator &fi1, const QgsFeatureIterator &fi2 )
{
  return fi1.mIter == fi2.mIter;
}

inline bool operator!= ( const QgsFeatureIterator &fi1, const QgsFeatureIterator &fi2 )
{
  return !( fi1 == fi2 );
}

inline void QgsFeatureIterator::setInterruptionChecker( QgsFeedback *interruptionChecker )
{
  if ( mIter )
    mIter->setInterruptionChecker( interruptionChecker );
}

#endif

#endif // QGSFEATUREITERATOR_H