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 "qgsfeaturerequest.h"
#include "qgslogger.h"
#include "qgsindexedfeature.h"


class CORE_EXPORT QgsInterruptionChecker
{
  public:
    virtual bool mustStop() const = 0;
};

class CORE_EXPORT QgsAbstractFeatureIterator
{
  public:

    enum CompileStatus
    {
      NoCompilation, 
      PartiallyCompiled, 
      Compiled, 
    };

    QgsAbstractFeatureIterator( const QgsFeatureRequest& request );

    virtual ~QgsAbstractFeatureIterator();

    virtual bool nextFeature( QgsFeature& f );

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

    virtual void setInterruptionChecker( QgsInterruptionChecker* interruptionChecker );

    CompileStatus compileStatus() const { return mCompileStatus; }

  protected:
    virtual bool fetchFeature( QgsFeature& f ) = 0;

    virtual bool nextFeatureFilterExpression( QgsFeature &f );

    virtual bool nextFeatureFilterFids( QgsFeature & f );

    QgsFeatureRequest mRequest;

    bool mClosed;

    bool mZombie;

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

    long mFetchedCount;

    CompileStatus mCompileStatus;

    virtual bool prepareSimplification( const QgsSimplifyMethod& simplifyMethod );

  private:
    bool mUseCachedFeatures;
    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()
    {
      if ( mOwnSource )
        delete mSource;
    }

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

    T* mSource;
    bool mOwnSource;
};

class CORE_EXPORT QgsFeatureIterator
{
  public:
    QgsFeatureIterator();
    QgsFeatureIterator( QgsAbstractFeatureIterator* iter );
    QgsFeatureIterator( const QgsFeatureIterator& fi );
    ~QgsFeatureIterator();

    QgsFeatureIterator& operator=( const QgsFeatureIterator& other );

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

    bool isClosed() const;

    void setInterruptionChecker( QgsInterruptionChecker* interruptionChecker );

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

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

  protected:
    QgsAbstractFeatureIterator* mIter;
};


inline QgsFeatureIterator::QgsFeatureIterator()
    : mIter( nullptr )
{
}

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( QgsInterruptionChecker* interruptionChecker )
{
  if ( mIter )
    mIter->setInterruptionChecker( interruptionChecker );
}

#endif // QGSFEATUREITERATOR_H