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;

    enum class RequestToSourceCrsResult : int
    {
      Success,                             
      DistanceWithinMustBeCheckedManually, 
    };
 
  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 );

    RequestToSourceCrsResult updateRequestToSourceCrs( QgsFeatureRequest &request, const QgsCoordinateTransform &transform ) const SIP_THROW( QgsCsException );

    QgsFeatureRequest mRequest;

    bool mClosed = false;

    bool mZombie = false;
 
    // TODO QGIS 5: make this private

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

    long 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
    // clang-format off
    QgsFeatureIterator *__iter__();
    % MethodCode
    sipRes = sipCpp;
    % End
 
    SIP_PYOBJECT __next__() SIP_TYPEHINT( QgsFeature );
    % MethodCode
    auto f = std::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
// clang-format on
#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();

    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