bool QgsSpatiaLiteFeatureIterator::fetchFeature( QgsFeature& feature )
{
if ( mClosed )
return false;
feature.setValid( false );
if ( sqliteStatement == NULL )
{
QgsDebugMsg( "Invalid current SQLite statement" );
close();
return false;
}
if ( !getFeature( sqliteStatement, feature ) )
{
sqlite3_finalize( sqliteStatement );
sqliteStatement = NULL;
close();
return false;
}
feature.setValid( true );
return true;
}
bool QgsCachedFeatureIterator::fetchFeature( QgsFeature &f )
{
f.setValid( false );
if ( mClosed )
return false;
while ( mFeatureIdIterator != mFeatureIds.constEnd() )
{
if ( !mVectorLayerCache->mCache.contains( *mFeatureIdIterator ) )
{
++mFeatureIdIterator;
continue;
}
f = QgsFeature( *mVectorLayerCache->mCache[*mFeatureIdIterator]->feature() );
++mFeatureIdIterator;
if ( mRequest.acceptFeature( f ) )
{
f.setValid( true );
geometryToDestinationCrs( f, mTransform );
return true;
}
}
close();
return false;
}
bool QgsPostgresFeatureIterator::fetchFeature( QgsFeature& feature )
{
feature.setValid( false );
if ( mClosed )
return false;
if ( mFeatureQueue.empty() )
{
QString fetch = QString( "FETCH FORWARD %1 FROM %2" ).arg( mFeatureQueueSize ).arg( mCursorName );
QgsDebugMsgLevel( QString( "fetching %1 features." ).arg( mFeatureQueueSize ), 4 );
if ( mConn->PQsendQuery( fetch ) == 0 ) // fetch features asynchronously
{
QgsMessageLog::logMessage( QObject::tr( "Fetching from cursor %1 failed\nDatabase error: %2" ).arg( mCursorName, mConn->PQerrorMessage() ), QObject::tr( "PostGIS" ) );
}
QgsPostgresResult queryResult;
for ( ;; )
{
queryResult = mConn->PQgetResult();
if ( !queryResult.result() )
break;
if ( queryResult.PQresultStatus() != PGRES_TUPLES_OK )
{
QgsMessageLog::logMessage( QObject::tr( "Fetching from cursor %1 failed\nDatabase error: %2" ).arg( mCursorName, mConn->PQerrorMessage() ), QObject::tr( "PostGIS" ) );
break;
}
int rows = queryResult.PQntuples();
if ( rows == 0 )
continue;
for ( int row = 0; row < rows; row++ )
{
mFeatureQueue.enqueue( QgsFeature() );
getFeature( queryResult, row, mFeatureQueue.back() );
} // for each row in queue
}
}
if ( mFeatureQueue.empty() )
{
QgsDebugMsg( QString( "Finished after %1 features" ).arg( mFetched ) );
close();
mSource->mShared->ensureFeaturesCountedAtLeast( mFetched );
return false;
}
feature = mFeatureQueue.dequeue();
mFetched++;
feature.setValid( true );
feature.setFields( mSource->mFields ); // allow name-based attribute lookups
return true;
}
bool QgsOgrFeatureIterator::fetchFeatureWithId( QgsFeatureId id, QgsFeature &feature ) const
{
feature.setValid( false );
gdal::ogr_feature_unique_ptr fet;
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(2,2,0)
if ( !QgsOgrProviderUtils::canDriverShareSameDatasetAmongLayers( mSource->mDriverName ) )
{
OGRLayerH nextFeatureBelongingLayer;
bool found = false;
// First pass: try to read from the last feature, in the hope the dataset
// returns them in increasing feature id number (and as we use a std::set
// for mFilterFids, we get them in increasing number by the iterator)
// Second pass: reset before reading
for ( int passNumber = 0; passNumber < 2; passNumber++ )
{
while ( fet.reset( GDALDatasetGetNextFeature(
mConn->ds, &nextFeatureBelongingLayer, nullptr, nullptr, nullptr ) ), fet )
{
if ( nextFeatureBelongingLayer == mOgrLayer )
{
if ( OGR_F_GetFID( fet.get() ) == FID_TO_NUMBER( id ) )
{
found = true;
break;
}
}
}
if ( found || passNumber == 1 )
{
break;
}
GDALDatasetResetReading( mConn->ds );
}
if ( !found )
{
return false;
}
}
else
#endif
{
fet.reset( OGR_L_GetFeature( mOgrLayer, FID_TO_NUMBER( id ) ) );
}
if ( !fet )
{
return false;
}
if ( !readFeature( std::move( fet ), feature ) )
return false;
feature.setValid( true );
geometryToDestinationCrs( feature, mTransform );
return true;
}
bool QgsOgrFeatureIterator::fetchFeatureWithId( QgsFeatureId id, QgsFeature& feature ) const
{
feature.setValid( false );
OGRFeatureH fet = OGR_L_GetFeature( ogrLayer, FID_TO_NUMBER( id ) );
if ( !fet )
{
return false;
}
if ( readFeature( fet, feature ) )
OGR_F_Destroy( fet );
feature.setValid( true );
return true;
}
bool QgsOgrFeatureIterator::fetchFeature( QgsFeature& feature )
{
feature.setValid( false );
if ( mClosed || !ogrLayer )
return false;
if ( mRequest.filterType() == QgsFeatureRequest::FilterFid )
{
bool result = fetchFeatureWithId( mRequest.filterFid(), feature );
close(); // the feature has been read or was not found: we have finished here
return result;
}
else if ( mRequest.filterType() == QgsFeatureRequest::FilterFids )
{
while ( mFilterFidsIt != mFilterFids.constEnd() )
{
QgsFeatureId nextId = *mFilterFidsIt;
mFilterFidsIt++;
if ( fetchFeatureWithId( nextId, feature ) )
return true;
}
close();
return false;
}
OGRFeatureH fet;
while (( fet = OGR_L_GetNextFeature( ogrLayer ) ) )
{
if ( !readFeature( fet, feature ) )
continue;
else
OGR_F_Destroy( fet );
if ( !mRequest.filterRect().isNull() && !feature.hasGeometry() )
continue;
// we have a feature, end this cycle
feature.setValid( true );
return true;
} // while
close();
return false;
}
void QgsVectorLayerFeatureIterator::useAddedFeature( const QgsFeature& src, QgsFeature& f )
{
f.setFeatureId( src.id() );
f.setValid( true );
f.setFields( &L->mUpdatedFields );
if ( src.geometry() && !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) )
{
f.setGeometry( *src.geometry() );
// simplify the edited geometry using its simplifier configured
if ( mEditGeometrySimplifier )
{
QgsGeometry* geometry = f.geometry();
QGis::GeometryType geometryType = geometry->type();
if ( geometryType == QGis::Line || geometryType == QGis::Polygon ) mEditGeometrySimplifier->simplifyGeometry( geometry );
}
}
// TODO[MD]: if subset set just some attributes
f.setAttributes( src.attributes() );
if ( !mFetchJoinInfo.isEmpty() )
addJoinedAttributes( f );
}
void QgsVectorLayerFeatureIterator::useChangedAttributeFeature( QgsFeatureId fid, const QgsGeometry& geom, QgsFeature& f )
{
f.setFeatureId( fid );
f.setValid( true );
f.setFields( &L->mUpdatedFields );
if ( !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) )
f.setGeometry( geom );
bool subsetAttrs = ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes );
if ( !subsetAttrs || ( subsetAttrs && mRequest.subsetOfAttributes().count() > 0 ) )
{
// retrieve attributes from provider
QgsFeature tmp;
//mDataProvider->featureAtId( fid, tmp, false, mFetchProvAttributes );
QgsFeatureRequest request;
request.setFilterFid( fid ).setFlags( QgsFeatureRequest::NoGeometry ).setSubsetOfAttributes( mProviderRequest.subsetOfAttributes() );
QgsFeatureIterator fi = L->dataProvider()->getFeatures( request );
if ( fi.nextFeature( tmp ) )
{
updateChangedAttributes( tmp );
f.setAttributes( tmp.attributes() );
}
}
if ( !mFetchJoinInfo.isEmpty() )
addJoinedAttributes( f );
}
bool QgsGrassFeatureIterator::fetchFeature( QgsFeature& feature )
{
QgsDebugMsgLevel( "entered", 3 );
if ( mClosed )
{
return false;
}
if ( mCanceled )
{
QgsDebugMsg( "iterator is canceled -> close" );
close();
return false;
}
feature.setValid( false );
// TODO: locking each feature is too expensive. What happens with map structures if lines are
// written/rewritten/deleted? Can be read simultaneously?
mSource->mLayer->map()->lockReadWrite(); // locks only in editing mode
bool filterById = mRequest.filterType() == QgsFeatureRequest::FilterFid;
int cat = 0;
int type = 0;
int lid = 0;
QgsFeatureId featureId = 0;
QgsAbstractGeometryV2 *oldGeometry = 0;
#ifdef QGISDEBUG
if ( mSource->mEditing )
{
QgsDebugMsgLevel( "newLids:", 3 );
foreach ( int oldLid, mSource->mLayer->map()->newLids().keys() )
{
QgsDebugMsgLevel( QString( "%1 -> %2" ).arg( oldLid ).arg( mSource->mLayer->map()->newLids().value( oldLid ) ), 3 );
}
}
bool QgsOgrFeatureIterator::fetchFeature( QgsFeature& feature )
{
feature.setValid( false );
if ( mClosed )
return false;
if ( !P->mRelevantFieldsForNextFeature )
ensureRelevantFields();
if ( mRequest.filterType() == QgsFeatureRequest::FilterFid )
{
OGRFeatureH fet = OGR_L_GetFeature( ogrLayer, FID_TO_NUMBER( mRequest.filterFid() ) );
if ( !fet )
{
close();
return false;
}
if ( readFeature( fet, feature ) )
OGR_F_Destroy( fet );
feature.setValid( true );
close(); // the feature has been read: we have finished here
return true;
}
OGRFeatureH fet;
while (( fet = OGR_L_GetNextFeature( ogrLayer ) ) )
{
if ( !readFeature( fet, feature ) )
continue;
// we have a feature, end this cycle
feature.setValid( true );
OGR_F_Destroy( fet );
return true;
} // while
QgsDebugMsg( "Feature is null" );
close();
return false;
}
bool QgsGPXFeatureIterator::fetchFeature( QgsFeature& feature )
{
feature.setValid( false );
if ( mClosed )
return false;
if ( mRequest.filterType() == QgsFeatureRequest::FilterFid )
{
bool res = readFid( feature );
close();
return res;
}
if ( mSource->mFeatureType == QgsGPXProvider::WaypointType )
{
// go through the list of waypoints and return the first one that is in
// the bounds rectangle
for ( ; mWptIter != mSource->data->waypointsEnd(); ++mWptIter )
{
if ( readWaypoint( *mWptIter, feature ) )
{
++mWptIter;
return true;
}
}
}
else if ( mSource->mFeatureType == QgsGPXProvider::RouteType )
{
// go through the routes and return the first one that is in the bounds
// rectangle
for ( ; mRteIter != mSource->data->routesEnd(); ++mRteIter )
{
if ( readRoute( *mRteIter, feature ) )
{
++mRteIter;
return true;
}
}
}
else if ( mSource->mFeatureType == QgsGPXProvider::TrackType )
{
// go through the tracks and return the first one that is in the bounds
// rectangle
for ( ; mTrkIter != mSource->data->tracksEnd(); ++mTrkIter )
{
if ( readTrack( *mTrkIter, feature ) )
{
++mTrkIter;
return true;
}
}
}
close();
return false;
}
bool QgsOgrFeatureIterator::fetchFeature( QgsFeature& feature )
{
feature.setValid( false );
if ( mClosed )
return false;
if ( mRequest.filterType() == QgsFeatureRequest::FilterFid )
{
OGRFeatureH fet = OGR_L_GetFeature( ogrLayer, FID_TO_NUMBER( mRequest.filterFid() ) );
if ( !fet )
{
close();
return false;
}
if ( readFeature( fet, feature ) )
OGR_F_Destroy( fet );
feature.setValid( true );
close(); // the feature has been read: we have finished here
return true;
}
OGRFeatureH fet;
while (( fet = OGR_L_GetNextFeature( ogrLayer ) ) )
{
if ( !readFeature( fet, feature ) )
continue;
if ( !mRequest.filterRect().isNull() && !feature.constGeometry() )
continue;
// we have a feature, end this cycle
feature.setValid( true );
OGR_F_Destroy( fet );
return true;
} // while
close();
return false;
}
bool QgsMssqlFeatureIterator::fetchFeature( QgsFeature& feature )
{
feature.setValid( false );
if ( !mQuery )
return false;
if ( !mQuery->isActive() )
{
QgsDebugMsg( "Read attempt on inactive query" );
return false;
}
if ( mQuery->next() )
{
feature.initAttributes( mSource->mFields.count() );
feature.setFields( &mSource->mFields ); // allow name-based attribute lookups
for ( int i = 0; i < mAttributesToFetch.count(); i++ )
{
QVariant v = mQuery->value( i );
feature.setAttribute( mAttributesToFetch[i], mQuery->value( i ) );
}
if ( mFidCol >= 0 )
{
feature.setFeatureId( mQuery->value( mFidCol ).toLongLong() );
}
if ( mGeometryCol >= 0 )
{
QByteArray ar = mQuery->value( mGeometryCol ).toByteArray();
unsigned char* wkb = mParser.ParseSqlGeometry(( unsigned char* )ar.data(), ar.size() );
if ( wkb )
{
feature.setGeometryAndOwnership( wkb, mParser.GetWkbLen() );
}
}
feature.setValid( true );
return true;
}
return false;
}
bool QgsMemoryFeatureIterator::nextFeatureTraverseAll( QgsFeature &feature )
{
bool hasFeature = false;
// option 2: traversing the whole layer
while ( mSelectIterator != mSource->mFeatures.constEnd() )
{
if ( mFilterRect.isNull() )
{
// selection rect empty => using all features
hasFeature = true;
}
else
{
if ( mRequest.flags() & QgsFeatureRequest::ExactIntersect )
{
// using exact test when checking for intersection
if ( mSelectIterator->hasGeometry() && mSelectRectEngine->intersects( mSelectIterator->geometry().constGet() ) )
hasFeature = true;
}
else
{
// check just bounding box against rect when not using intersection
if ( mSelectIterator->hasGeometry() && mSelectIterator->geometry().boundingBox().intersects( mFilterRect ) )
hasFeature = true;
}
}
if ( mSubsetExpression )
{
mSource->mExpressionContext.setFeature( *mSelectIterator );
if ( !mSubsetExpression->evaluate( &mSource->mExpressionContext ).toBool() )
hasFeature = false;
}
if ( hasFeature )
break;
++mSelectIterator;
}
// copy feature
if ( hasFeature )
{
feature = mSelectIterator.value();
++mSelectIterator;
feature.setValid( true );
feature.setFields( mSource->mFields ); // allow name-based attribute lookups
geometryToDestinationCrs( feature, mTransform );
}
else
close();
return hasFeature;
}
bool QgsMemoryFeatureIterator::fetchFeature( QgsFeature& feature )
{
feature.setValid( false );
if ( mClosed )
return false;
if ( mUsingFeatureIdList )
return nextFeatureUsingList( feature );
else
return nextFeatureTraverseAll( feature );
}
bool QgsVectorLayerFeatureIterator::nextFeature( QgsFeature& f )
{
f.setValid( false );
if ( mClosed )
return false;
if ( mRequest.filterType() == QgsFeatureRequest::FilterFid )
{
if ( mFetchedFid )
return false;
bool res = nextFeatureFid( f );
mFetchedFid = true;
return res;
}
if ( mRequest.filterType() == QgsFeatureRequest::FilterRect )
{
if ( fetchNextChangedGeomFeature( f ) )
return true;
// no more changed geometries
}
if ( fetchNextAddedFeature( f ) )
return true;
// no more added features
while ( mProviderIterator.nextFeature( f ) )
{
if ( mFetchConsidered.contains( f.id() ) )
continue;
// TODO[MD]: just one resize of attributes
f.setFields( &L->mUpdatedFields );
// update attributes
updateChangedAttributes( f );
if ( !mFetchJoinInfo.isEmpty() )
addJoinedAttributes( f );
// update geometry
if ( !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) )
updateFeatureGeometry( f );
return true;
}
close();
return false;
}
bool QgsOgrFeatureIterator::checkFeature( gdal::ogr_feature_unique_ptr &fet, QgsFeature &feature )
{
if ( !readFeature( std::move( fet ), feature ) )
return false;
if ( !mFilterRect.isNull() && ( !feature.hasGeometry() || feature.geometry().isEmpty() ) )
return false;
// we have a feature, end this cycle
feature.setValid( true );
geometryToDestinationCrs( feature, mTransform );
return true;
}
bool QgsDelimitedTextFeatureIterator::nextFeature( QgsFeature& feature )
{
// before we do anything else, assume that there's something wrong with
// the feature
feature.setValid( false );
if ( mClosed )
return false;
bool gotFeature = P->nextFeature( feature, P->mFile, mRequest );
if ( ! gotFeature ) close();
return gotFeature;
}
QgsFeature QgsOgrUtils::readOgrFeature( OGRFeatureH ogrFet, const QgsFields& fields, QTextCodec* encoding )
{
QgsFeature feature;
if ( !ogrFet )
{
feature.setValid( false );
return feature;
}
feature.setFeatureId( OGR_F_GetFID( ogrFet ) );
feature.setValid( true );
if ( !readOgrFeatureGeometry( ogrFet, feature ) )
{
feature.setValid( false );
}
if ( !readOgrFeatureAttributes( ogrFet, fields, feature, encoding ) )
{
feature.setValid( false );
}
return feature;
}
void QgsVectorLayerFeatureIterator::useAddedFeature( const QgsFeature& src, QgsFeature& f )
{
f.setFeatureId( src.id() );
f.setValid( true );
f.setFields( &L->mUpdatedFields );
if ( src.geometry() && !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) )
f.setGeometry( *src.geometry() );
// TODO[MD]: if subset set just some attributes
f.setAttributes( src.attributes() );
if ( !mFetchJoinInfo.isEmpty() )
addJoinedAttributes( f );
}
bool QgsMemoryFeatureIterator::nextFeatureTraverseAll( QgsFeature& feature )
{
bool hasFeature = false;
// option 2: traversing the whole layer
while ( mSelectIterator != P->mFeatures.end() )
{
if ( mRequest.filterType() != QgsFeatureRequest::FilterRect )
{
// selection rect empty => using all features
hasFeature = true;
}
else
{
if ( mRequest.flags() & QgsFeatureRequest::ExactIntersect )
{
// using exact test when checking for intersection
if ( mSelectIterator->geometry()->intersects( mSelectRectGeom ) )
hasFeature = true;
}
else
{
// check just bounding box against rect when not using intersection
if ( mSelectIterator->geometry()->boundingBox().intersects( mRequest.filterRect() ) )
hasFeature = true;
}
}
if ( hasFeature )
break;
mSelectIterator++;
}
// copy feature
if ( hasFeature )
{
feature = mSelectIterator.value();
mSelectIterator++;
feature.setValid( true );
feature.setFields( &P->mFields ); // allow name-based attribute lookups
}
else
close();
return hasFeature;
}
bool QgsDelimitedTextFeatureIterator::fetchFeature( QgsFeature& feature )
{
// before we do anything else, assume that there's something wrong with
// the feature
feature.setValid( false );
if ( mClosed )
return false;
bool gotFeature = false;
if ( mMode == FileScan )
{
gotFeature = nextFeatureInternal( feature );
}
else
{
while ( ! gotFeature )
{
qint64 fid = -1;
if ( mMode == FeatureIds )
{
if ( mNextId < mFeatureIds.size() )
{
fid = mFeatureIds[mNextId];
}
}
else if ( mNextId < mSource->mSubsetIndex.size() )
{
fid = mSource->mSubsetIndex[mNextId];
}
if ( fid < 0 ) break;
mNextId++;
gotFeature = ( setNextFeatureId( fid ) && nextFeatureInternal( feature ) );
}
}
// CC: 2013-05-08: What is the intent of rewind/close. The following
// line from previous implementation means that we cannot rewind the iterator
// after reading last record? Is this correct? This line can be removed if
// not.
if ( ! gotFeature ) close();
return gotFeature;
}
void QgsVectorLayerDiagramProvider::drawLabel( QgsRenderContext &context, pal::LabelPosition *label ) const
{
#if 1 // XXX strk
// features are pre-rotated but not scaled/translated,
// so we only disable rotation here. Ideally, they'd be
// also pre-scaled/translated, as suggested here:
// https://issues.qgis.org/issues/11856
QgsMapToPixel xform = context.mapToPixel();
xform.setMapRotation( 0, 0, 0 );
#else
const QgsMapToPixel &xform = context.mapToPixel();
#endif
QgsDiagramLabelFeature *dlf = dynamic_cast<QgsDiagramLabelFeature *>( label->getFeaturePart()->feature() );
QgsFeature feature;
feature.setFields( mFields );
feature.setValid( true );
feature.setId( label->getFeaturePart()->featureId() );
feature.setAttributes( dlf->attributes() );
context.expressionContext().setFeature( feature );
//calculate top-left point for diagram
//first, calculate the centroid of the label (accounts for PAL creating
//rotated labels when we do not want to draw the diagrams rotated)
double centerX = 0;
double centerY = 0;
for ( int i = 0; i < 4; ++i )
{
centerX += label->getX( i );
centerY += label->getY( i );
}
QgsPointXY outPt( centerX / 4.0, centerY / 4.0 );
//then, calculate the top left point for the diagram with this center position
QgsPointXY centerPt = xform.transform( outPt.x() - label->getWidth() / 2,
outPt.y() - label->getHeight() / 2 );
mSettings.renderer()->renderDiagram( feature, context, centerPt.toQPointF(), mSettings.dataDefinedProperties() );
//insert into label search tree to manipulate position interactively
mEngine->results()->mLabelSearchTree->insertLabel( label, label->getFeaturePart()->featureId(), mLayerId, QString(), QFont(), true, false );
}
void QgsWFSFeatureIterator::copyFeature( const QgsFeature* f, QgsFeature& feature, bool fetchGeometry )
{
Q_UNUSED( fetchGeometry );
if ( !f )
{
return;
}
//copy the geometry
const QgsGeometry* geometry = f->constGeometry();
if ( geometry && fetchGeometry )
{
const unsigned char *geom = geometry->asWkb();
int geomSize = geometry->wkbSize();
unsigned char* copiedGeom = new unsigned char[geomSize];
memcpy( copiedGeom, geom, geomSize );
QgsGeometry *g = new QgsGeometry();
g->fromWkb( copiedGeom, geomSize );
feature.setGeometry( g );
}
else
{
feature.setGeometry( nullptr );
}
//and the attributes
feature.initAttributes( mSource->mFields.size() );
for ( int i = 0; i < mSource->mFields.size(); i++ )
{
const QVariant &v = f->attributes().value( i );
if ( v.type() != mSource->mFields.at( i ).type() )
feature.setAttribute( i, QgsVectorDataProvider::convertValue( mSource->mFields.at( i ).type(), v.toString() ) );
else
feature.setAttribute( i, v );
}
//id and valid
feature.setValid( true );
feature.setFeatureId( f->id() );
feature.setFields( mSource->mFields ); // allow name-based attribute lookups
}
void QgsVectorLayerFeatureIterator::useChangedAttributeFeature( QgsFeatureId fid, const QgsGeometry& geom, QgsFeature& f )
{
f.setFeatureId( fid );
f.setValid( true );
f.setFields( &L->mUpdatedFields );
if ( !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) )
{
f.setGeometry( geom );
// simplify the edited geometry using its simplifier configured
if ( mEditGeometrySimplifier )
{
QgsGeometry* geometry = f.geometry();
QGis::GeometryType geometryType = geometry->type();
if ( geometryType == QGis::Line || geometryType == QGis::Polygon ) mEditGeometrySimplifier->simplifyGeometry( geometry );
}
}
bool subsetAttrs = ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes );
if ( !subsetAttrs || ( subsetAttrs && mRequest.subsetOfAttributes().count() > 0 ) )
{
// retrieve attributes from provider
QgsFeature tmp;
//mDataProvider->featureAtId( fid, tmp, false, mFetchProvAttributes );
QgsFeatureRequest request;
request.setFilterFid( fid ).setFlags( QgsFeatureRequest::NoGeometry );
if ( subsetAttrs )
{
request.setSubsetOfAttributes( mProviderRequest.subsetOfAttributes() );
}
QgsFeatureIterator fi = L->dataProvider()->getFeatures( request );
if ( fi.nextFeature( tmp ) )
{
updateChangedAttributes( tmp );
f.setAttributes( tmp.attributes() );
}
}
if ( !mFetchJoinInfo.isEmpty() )
addJoinedAttributes( f );
}
bool QgsGPXFeatureIterator::readRoute( const QgsRoute &rte, QgsFeature &feature )
{
if ( rte.points.isEmpty() )
return false;
QgsGeometry *geometry = readRouteGeometry( rte );
if ( !mFilterRect.isNull() )
{
if ( ( rte.xMax < mFilterRect.xMinimum() ) || ( rte.xMin > mFilterRect.xMaximum() ) ||
( rte.yMax < mFilterRect.yMinimum() ) || ( rte.yMin > mFilterRect.yMaximum() ) )
{
delete geometry;
return false;
}
if ( !geometry->intersects( mFilterRect ) ) //use geos for precise intersection test
{
delete geometry;
return false;
}
}
if ( !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) )
{
feature.setGeometry( *geometry );
delete geometry;
}
else
{
delete geometry;
}
feature.setId( rte.id );
feature.setValid( true );
feature.setFields( mSource->mFields ); // allow name-based attribute lookups
feature.initAttributes( mSource->mFields.count() );
readAttributes( feature, rte );
return true;
}
bool QgsGPXFeatureIterator::readTrack( const QgsTrack &trk, QgsFeature &feature )
{
//QgsDebugMsg( QString( "GPX feature track segments: %1" ).arg( trk.segments.size() ) );
QgsGeometry *geometry = readTrackGeometry( trk );
if ( !mFilterRect.isNull() )
{
if ( ( trk.xMax < mFilterRect.xMinimum() ) || ( trk.xMin > mFilterRect.xMaximum() ) ||
( trk.yMax < mFilterRect.yMinimum() ) || ( trk.yMin > mFilterRect.yMaximum() ) )
{
delete geometry;
return false;
}
if ( !geometry->intersects( mFilterRect ) ) //use geos for precise intersection test
{
delete geometry;
return false;
}
}
if ( !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) )
{
feature.setGeometry( *geometry );
delete geometry;
}
else
{
delete geometry;
}
feature.setId( trk.id );
feature.setValid( true );
feature.setFields( mSource->mFields ); // allow name-based attribute lookups
feature.initAttributes( mSource->mFields.count() );
readAttributes( feature, trk );
return true;
}
bool
QgsSqlAnywhereFeatureIterator::nextFeature( QgsFeature& feature )
{
if ( mClosed )
return false;
feature.setValid( false );
if ( !P->isValid() )
{
SaDebugMsg( "Read attempt on an invalid SQL Anywhere data source" );
return false;
}
if ( mStmt == NULL || !mStmt->isValid() )
{
SaDebugMsg( "nextFeature() called with invalid cursor()" );
return false;
}
return nextFeature( feature, mStmt );
}
bool QgsGPXFeatureIterator::readRoute( const QgsRoute& rte, QgsFeature& feature )
{
if ( rte.points.size() == 0 )
return false;
QgsGeometry* theGeometry = readRouteGeometry( rte );
if ( mRequest.filterType() == QgsFeatureRequest::FilterRect )
{
const QgsRectangle& rect = mRequest.filterRect();
if (( rte.xMax < rect.xMinimum() ) || ( rte.xMin > rect.xMaximum() ) ||
( rte.yMax < rect.yMinimum() ) || ( rte.yMin > rect.yMaximum() ) )
return false;
if ( !theGeometry->intersects( rect ) ) //use geos for precise intersection test
{
delete theGeometry;
return false;
}
}
if ( !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) )
{
feature.setGeometry( theGeometry );
}
else
{
delete theGeometry;
}
feature.setFeatureId( rte.id );
feature.setValid( true );
feature.setFields( &mSource->mFields ); // allow name-based attribute lookups
feature.initAttributes( mSource->mFields.count() );
readAttributes( feature, rte );
return true;
}
bool QgsGPXFeatureIterator::readWaypoint( const QgsWaypoint& wpt, QgsFeature& feature )
{
if ( mRequest.filterType() == QgsFeatureRequest::FilterRect )
{
const QgsRectangle& rect = mRequest.filterRect();
if ( ! rect.contains( QgsPoint( wpt.lon, wpt.lat ) ) )
return false;
}
// some wkb voodoo
if ( !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) )
{
feature.setGeometry( readWaypointGeometry( wpt ) );
}
feature.setFeatureId( wpt.id );
feature.setValid( true );
feature.setFields( &mSource->mFields ); // allow name-based attribute lookups
feature.initAttributes( mSource->mFields.count() );
readAttributes( feature, wpt );
return true;
}
