QGIS API Documentation  2.13.0-Master
qgsfeatureiterator.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsfeatureiterator.cpp
3  ---------------------
4  begin : Juli 2012
5  copyright : (C) 2012 by Martin Dobias
6  email : wonder dot sk at gmail dot com
7  ***************************************************************************
8  * *
9  * This program is free software; you can redistribute it and/or modify *
10  * it under the terms of the GNU General Public License as published by *
11  * the Free Software Foundation; either version 2 of the License, or *
12  * (at your option) any later version. *
13  * *
14  ***************************************************************************/
15 #include "qgsfeatureiterator.h"
16 #include "qgslogger.h"
17 
18 #include "qgsgeometrysimplifier.h"
19 #include "qgssimplifymethod.h"
20 
21 #include "qgsexpressionsorter.h"
22 
24  : mRequest( request )
25  , mClosed( false )
26  , mZombie( false )
27  , refs( 0 )
28  , mFetchedCount( 0 )
29  , mGeometrySimplifier( nullptr )
30  , mLocalSimplification( false )
31  , mUseCachedFeatures( false )
32 {
33 }
34 
36 {
37  delete mGeometrySimplifier;
38 }
39 
41 {
42  bool dataOk = false;
43  if ( mRequest.limit() >= 0 && mFetchedCount >= mRequest.limit() )
44  {
45  return false;
46  }
47 
48  if ( mUseCachedFeatures )
49  {
50  if ( mFeatureIterator != mCachedFeatures.constEnd() )
51  {
52  f = mFeatureIterator->mFeature;
53  ++mFeatureIterator;
54  dataOk = true;
55  }
56  else
57  {
58  dataOk = false;
59  // even the zombie dies at this point...
60  mZombie = false;
61  }
62  }
63  else
64  {
65  switch ( mRequest.filterType() )
66  {
68  dataOk = nextFeatureFilterExpression( f );
69  break;
70 
72  dataOk = nextFeatureFilterFids( f );
73  break;
74 
75  default:
76  dataOk = fetchFeature( f );
77  break;
78  }
79  }
80 
81  // simplify the geometry using the simplifier configured
82  if ( dataOk && mLocalSimplification )
83  {
84  if ( f.constGeometry() )
85  simplify( f );
86  }
87  if ( dataOk )
88  mFetchedCount++;
89 
90  return dataOk;
91 }
92 
94 {
95  while ( fetchFeature( f ) )
96  {
99  return true;
100  }
101  return false;
102 }
103 
105 {
106  while ( fetchFeature( f ) )
107  {
108  if ( mRequest.filterFids().contains( f.id() ) )
109  return true;
110  }
111  return false;
112 }
113 
115 {
116  // Prepare if required the simplification of geometries to fetch:
117  // This code runs here because of 'prepareSimplification()' is virtual and it can be overrided
118  // in inherited iterators who change the default behavior.
119  // It would be better to call this method in the constructor enabling virtual-calls as it is described by example at:
120  // http://www.parashift.com/c%2B%2B-faq-lite/calling-virtuals-from-ctor-idiom.html
121  if ( refs == 0 )
122  {
124 
125  // Should be called as last preparation step since it possibly will already fetch all features
126  setupOrderBy( mRequest.orderBy() );
127  }
128  refs++;
129 }
130 
132 {
133  refs--;
134  if ( !refs )
135  delete this;
136 }
137 
139 {
140  mLocalSimplification = false;
141 
142  delete mGeometrySimplifier;
143  mGeometrySimplifier = nullptr;
144 
145  // setup the simplification of geometries to fetch
146  if ( !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) && simplifyMethod.methodType() != QgsSimplifyMethod::NoSimplification && ( simplifyMethod.forceLocalOptimization() || !providerCanSimplify( simplifyMethod.methodType() ) ) )
147  {
148  mGeometrySimplifier = QgsSimplifyMethod::createGeometrySimplifier( simplifyMethod );
149  mLocalSimplification = nullptr != mGeometrySimplifier;
150  return mLocalSimplification;
151  }
152  return false;
153 }
154 
155 void QgsAbstractFeatureIterator::setupOrderBy( const QList<QgsFeatureRequest::OrderByClause>& orderBys )
156 {
157  // Let the provider try using an efficient order by strategy first
158  if ( !orderBys.isEmpty() && !prepareOrderBy( orderBys ) )
159  {
160  // No success from the provider
161 
162  // Prepare the expressions
163  QList<QgsFeatureRequest::OrderByClause> preparedOrderBys( orderBys );
164  QList<QgsFeatureRequest::OrderByClause>::iterator orderByIt( preparedOrderBys.begin() );
165 
166  QgsExpressionContext* expressionContext( mRequest.expressionContext() );
167  do
168  {
169  orderByIt->expression().prepare( expressionContext );
170  }
171  while ( ++orderByIt != preparedOrderBys.end() );
172 
173  // Fetch all features
174  QgsIndexedFeature indexedFeature;
175  indexedFeature.mIndexes.resize( preparedOrderBys.size() );
176 
177  while ( nextFeature( indexedFeature.mFeature ) )
178  {
179  expressionContext->setFeature( indexedFeature.mFeature );
180  int i = 0;
181  Q_FOREACH ( const QgsFeatureRequest::OrderByClause& orderBy, preparedOrderBys )
182  {
183  indexedFeature.mIndexes.replace( i++, orderBy.expression().evaluate( expressionContext ) );
184  }
185 
186  // We need all features, to ignore the limit for this pre-fetch
187  // keep the fetched count at 0.
188  mFetchedCount = 0;
189  mCachedFeatures.append( indexedFeature );
190  }
191 
192  qSort( mCachedFeatures.begin(), mCachedFeatures.end(), QgsExpressionSorter( preparedOrderBys ) );
193 
194  mFeatureIterator = mCachedFeatures.constBegin();
195  mUseCachedFeatures = true;
196  // The real iterator is closed, we are only serving cached features
197  mZombie = true;
198  }
199 }
200 
201 bool QgsAbstractFeatureIterator::providerCanSimplify( QgsSimplifyMethod::MethodType methodType ) const
202 {
203  Q_UNUSED( methodType )
204  return false;
205 }
206 
207 bool QgsAbstractFeatureIterator::simplify( QgsFeature& feature )
208 {
209  // simplify locally the geometry using the configured simplifier
210  if ( mGeometrySimplifier )
211  {
212  QgsGeometry* geometry = feature.geometry();
213 
214  QGis::GeometryType geometryType = geometry->type();
215  if ( geometryType == QGis::Line || geometryType == QGis::Polygon )
216  return mGeometrySimplifier->simplifyGeometry( geometry );
217  }
218  return false;
219 }
220 
221 bool QgsAbstractFeatureIterator::prepareOrderBy( const QList<QgsFeatureRequest::OrderByClause>& orderBys )
222 {
223  Q_UNUSED( orderBys )
224  return false;
225 }
226 
228 
230 {
231  if ( this != &other )
232  {
233  if ( mIter )
234  mIter->deref();
235  mIter = other.mIter;
236  if ( mIter )
237  mIter->ref();
238  }
239  return *this;
240 }
QgsFeatureId id() const
Get the feature ID for this feature.
Definition: qgsfeature.cpp:65
Wrapper for iterator of features from vector data provider or vector layer.
const QgsSimplifyMethod & simplifyMethod() const
Get simplification method for geometries that will be fetched.
const Flags & flags() const
Filter using feature IDs.
Q_DECL_DEPRECATED QVariant evaluate(const QgsFeature *f)
Evaluate the feature and return the result.
long mFetchedCount
Number of features already fetched by iterator.
virtual bool fetchFeature(QgsFeature &f)=0
If you write a feature iterator for your provider, this is the method you need to implement!! ...
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
QgsAbstractGeometryV2 * geometry() const
Returns the underlying geometry store.
QgsExpressionContext * expressionContext()
Returns the expression context used to evaluate filter expressions.
const QgsFeatureIds & filterFids() const
Get feature IDs that should be fetched.
QGis::GeometryType type() const
Returns type of the geometry as a QGis::GeometryType.
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:76
GeometryType
Definition: qgis.h:111
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:187
virtual bool simplifyGeometry(QgsGeometry *geometry) const =0
Simplifies the specified geometry.
QgsExpression expression() const
The expression.
void append(const T &value)
void resize(int size)
virtual bool nextFeature(QgsFeature &f)
fetch next feature, return true on success
Temporarily used structure to cache order by information.
Internal feature iterator to be implemented within data providers.
bool isEmpty() const
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
virtual bool nextFeatureFilterExpression(QgsFeature &f)
By default, the iterator will fetch all features and check if the feature matches the expression...
bool mZombie
A feature iterator may be closed already but still be serving features from the cache.
This class wraps a request for features to a vector layer (or directly its vector data provider)...
No simplification is applied.
FilterType filterType() const
Return the filter type which is currently set on this request.
void deref()
remove reference, delete if refs == 0
iterator end()
long limit() const
Returns the maximum number of features to request, or -1 if no limit set.
virtual bool nextFeatureFilterFids(QgsFeature &f)
By default, the iterator will fetch all features and check if the id is in the request.
The OrderByClause class represents an order by clause for a QgsFeatureRequest.
bool contains(const T &value) const
QgsFeatureRequest mRequest
A copy of the feature request.
QgsAbstractFeatureIterator * mIter
const QgsGeometry * constGeometry() const
Gets a const pointer to the geometry object associated with this feature.
Definition: qgsfeature.cpp:82
OrderBy orderBy() const
Return a list of order by clauses specified for this feature request.
static QgsAbstractGeometrySimplifier * createGeometrySimplifier(const QgsSimplifyMethod &simplifyMethod)
Creates a geometry simplifier according to specified method.
QVector< QVariant > mIndexes
void replace(int i, const T &value)
This class contains information about how to simplify geometries fetched from a QgsFeatureIterator.
int refs
reference counting (to allow seamless copying of QgsFeatureIterator instances) TODO QGIS3: make this ...
const_iterator constEnd() const
const_iterator constBegin() const
Geometry is not required. It may still be returned if e.g. required for a filter condition.
virtual bool prepareSimplification(const QgsSimplifyMethod &simplifyMethod)
Setup the simplification of geometries to fetch using the specified simplify method.
virtual ~QgsAbstractFeatureIterator()
destructor makes sure that the iterator is closed properly
iterator begin()
QgsAbstractFeatureIterator(const QgsFeatureRequest &request)
base class constructor - stores the iteration parameters
MethodType methodType() const
Gets the simplification type.
bool forceLocalOptimization() const
Gets whether the simplification executes after fetch the geometries from provider, otherwise it executes, when supported, in provider before fetch the geometries.
QgsExpression * filterExpression() const
Returns the filter expression if set.