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 4: 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
    QgsFeatureIterator *__iter__();
    % MethodCode
    sipRes = sipCpp;
    % End
 
    SIP_PYOBJECT __next__() SIP_TYPEHINT( QgsFeature );
    % MethodCode
    std::unique_ptr< QgsFeature > 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
#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