"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "src/providers/wfs/qgswfsfeatureiterator.cpp" between
QGIS-final-3_10_11.tar.gz and QGIS-final-3_10_12.tar.gz

About: QGIS (Quantum GIS) is a Geographic Information System that supports vector, raster, and database formats. Long-term release (3.10.x series).

qgswfsfeatureiterator.cpp  (QGIS-final-3_10_11)	:	qgswfsfeatureiterator.cpp  (QGIS-final-3_10_12)
skipping to change at line 36		skipping to change at line 36
#include "qgswfsconstants.h"		#include "qgswfsconstants.h"
#include "qgswfsfeatureiterator.h"		#include "qgswfsfeatureiterator.h"
#include "qgswfsprovider.h"		#include "qgswfsprovider.h"
#include "qgswfsshareddata.h"		#include "qgswfsshareddata.h"
#include "qgswfsutils.h"		#include "qgswfsutils.h"
#include "qgslogger.h"		#include "qgslogger.h"
#include "qgssettings.h"		#include "qgssettings.h"
#include "qgsexception.h"		#include "qgsexception.h"
#include "qgsfeedback.h"		#include "qgsfeedback.h"
#include "qgssqliteutils.h"		#include "qgssqliteutils.h"
		#include "qgsnetworkaccessmanager.h"
#include <algorithm>		#include <algorithm>
#include <QDir>		#include <QDir>
#include <QProgressDialog>		#include <QProgressDialog>
#include <QTimer>		#include <QTimer>
#include <QStyle>		#include <QStyle>
#include <sqlite3.h>		#include <sqlite3.h>
QgsWFSFeatureHitsAsyncRequest::QgsWFSFeatureHitsAsyncRequest( QgsWFSDataSourceUR I &uri )		QgsWFSFeatureHitsAsyncRequest::QgsWFSFeatureHitsAsyncRequest( QgsWFSDataSourceUR I &uri )
skipping to change at line 87		skipping to change at line 88
emit gotHitsResponse();		emit gotHitsResponse();
}		}
QString QgsWFSFeatureHitsAsyncRequest::errorMessageWithReason( const QString &re ason )		QString QgsWFSFeatureHitsAsyncRequest::errorMessageWithReason( const QString &re ason )
{		{
return tr( "Download of feature count failed: %1" ).arg( reason );		return tr( "Download of feature count failed: %1" ).arg( reason );
}		}
// -------------------------		// -------------------------
QgsWFSFeatureDownloader::QgsWFSFeatureDownloader( QgsWFSSharedData *shared )		QgsWFSFeatureDownloader::QgsWFSFeatureDownloader( QgsWFSSharedData *shared, bool requestMadeFromMainThread )
: QgsWfsRequest( shared->mURI )		: QgsWfsRequest( shared->mURI )
, mShared( shared )		, mShared( shared )
, mStop( false )		, mStop( false )
, mProgressDialogShowImmediately( false )		, mProgressDialogShowImmediately( false )
, mPageSize( shared->mPageSize )		, mPageSize( shared->mPageSize )
, mRemoveNSPrefix( false )		, mRemoveNSPrefix( false )
, mNumberMatched( -1 )		, mNumberMatched( -1 )
, mFeatureHitsAsyncRequest( shared->mURI )		, mFeatureHitsAsyncRequest( shared->mURI )
, mTotalDownloadedFeatureCount( 0 )		, mTotalDownloadedFeatureCount( 0 )
{		{
// Needed because used by a signal		// Needed because used by a signal
qRegisterMetaType< QVector<QgsWFSFeatureGmlIdPair> >( "QVector<QgsWFSFeatureGm lIdPair>" );		qRegisterMetaType< QVector<QgsWFSFeatureGmlIdPair> >( "QVector<QgsWFSFeatureGm lIdPair>" );
		if ( requestMadeFromMainThread )
		{
		auto emitResumeMainThread = [this]()
		{
		emit resumeMainThread();
		};
		connect( QgsNetworkAccessManager::instance(), &QgsNetworkAccessManager::auth
		RequestOccurred,
		this, emitResumeMainThread, Qt::DirectConnection );
		connect( QgsNetworkAccessManager::instance(), &QgsNetworkAccessManager::prox
		yAuthenticationRequired,
		this, emitResumeMainThread, Qt::DirectConnection );
		#ifndef QT_NO_SSL
		connect( QgsNetworkAccessManager::instance(), &QgsNetworkAccessManager::sslE
		rrorsOccurred,
		this, emitResumeMainThread, Qt::DirectConnection );
		#endif
		}
}		}
QgsWFSFeatureDownloader::~QgsWFSFeatureDownloader()		QgsWFSFeatureDownloader::~QgsWFSFeatureDownloader()
{		{
stop();		stop();
if ( mProgressDialog )		if ( mProgressDialog )
mProgressDialog->deleteLater();		mProgressDialog->deleteLater();
if ( mTimer )		if ( mTimer )
mTimer->deleteLater();		mTimer->deleteLater();
skipping to change at line 896		skipping to change at line 913
mFeatureHitsAsyncRequest.abort();		mFeatureHitsAsyncRequest.abort();
}		}
QString QgsWFSFeatureDownloader::errorMessageWithReason( const QString &reason )		QString QgsWFSFeatureDownloader::errorMessageWithReason( const QString &reason )
{		{
return tr( "Download of features failed: %1" ).arg( reason );		return tr( "Download of features failed: %1" ).arg( reason );
}		}
QgsWFSThreadedFeatureDownloader::QgsWFSThreadedFeatureDownloader( QgsWFSSharedDa ta *shared )		QgsWFSThreadedFeatureDownloader::QgsWFSThreadedFeatureDownloader( QgsWFSSharedDa ta *shared )
: mShared( shared )		: mShared( shared )
		, mRequestMadeFromMainThread( QThread::currentThread() == QApplication::instan ce()->thread() )
{		{
}		}
QgsWFSThreadedFeatureDownloader::~QgsWFSThreadedFeatureDownloader()		QgsWFSThreadedFeatureDownloader::~QgsWFSThreadedFeatureDownloader()
{		{
stop();		stop();
}		}
void QgsWFSThreadedFeatureDownloader::stop()		void QgsWFSThreadedFeatureDownloader::stop()
{		{
skipping to change at line 929		skipping to change at line 947
QMutexLocker locker( &mWaitMutex );		QMutexLocker locker( &mWaitMutex );
while ( !mDownloader )		while ( !mDownloader )
{		{
mWaitCond.wait( &mWaitMutex );		mWaitCond.wait( &mWaitMutex );
}		}
}		}
void QgsWFSThreadedFeatureDownloader::run()		void QgsWFSThreadedFeatureDownloader::run()
{		{
// We need to construct it in the run() method (i.e. in the new thread)		// We need to construct it in the run() method (i.e. in the new thread)
mDownloader = new QgsWFSFeatureDownloader( mShared );		mDownloader = new QgsWFSFeatureDownloader( mShared, mRequestMadeFromMainThread );
{		{
QMutexLocker locker( &mWaitMutex );		QMutexLocker locker( &mWaitMutex );
mWaitCond.wakeOne();		mWaitCond.wakeOne();
}		}
mDownloader->run( true, /* serialize features */		mDownloader->run( true, /* serialize features */
mShared->requestLimit() /* user max features */ );		mShared->requestLimit() /* user max features */ );
}		}
// -------------------------		// -------------------------
skipping to change at line 1135		skipping to change at line 1153
void QgsWFSFeatureIterator::connectSignals( QgsWFSFeatureDownloader *downloader )		void QgsWFSFeatureIterator::connectSignals( QgsWFSFeatureDownloader *downloader )
{		{
// We want to run the slot for that signal in the same thread as the sender		// We want to run the slot for that signal in the same thread as the sender
// so as to avoid the list of features to accumulate without control in		// so as to avoid the list of features to accumulate without control in
// memory		// memory
connect( downloader, static_cast<void ( QgsWFSFeatureDownloader::* )( QVector< QgsWFSFeatureGmlIdPair> )>( &QgsWFSFeatureDownloader::featureReceived ),		connect( downloader, static_cast<void ( QgsWFSFeatureDownloader::* )( QVector< QgsWFSFeatureGmlIdPair> )>( &QgsWFSFeatureDownloader::featureReceived ),
this, &QgsWFSFeatureIterator::featureReceivedSynchronous, Qt::DirectC onnection );		this, &QgsWFSFeatureIterator::featureReceivedSynchronous, Qt::DirectC onnection );
connect( downloader, &QgsWFSFeatureDownloader::endOfDownload,		connect( downloader, &QgsWFSFeatureDownloader::endOfDownload,
this, &QgsWFSFeatureIterator::endOfDownloadSynchronous, Qt::DirectCon nection );		this, &QgsWFSFeatureIterator::endOfDownloadSynchronous, Qt::DirectCon nection );
		connect( downloader, &QgsWFSFeatureDownloader::resumeMainThread,
		this, &QgsWFSFeatureIterator::resumeMainThreadSynchronous, Qt::Direct
		Connection );
}		}
void QgsWFSFeatureIterator::endOfDownloadSynchronous( bool )		void QgsWFSFeatureIterator::endOfDownloadSynchronous( bool )
{		{
// Wake up waiting loop		// Wake up waiting loop
QMutexLocker locker( &mMutex );		QMutexLocker locker( &mMutex );
mDownloadFinished = true;		mDownloadFinished = true;
mWaitCond.wakeOne();		mWaitCond.wakeOne();
}		}
		void QgsWFSFeatureIterator::resumeMainThreadSynchronous()
		{
		// Wake up waiting loop
		QMutexLocker locker( &mMutex );
		mProcessEvents = true;
		mWaitCond.wakeOne();
		}
void QgsWFSFeatureIterator::setInterruptionChecker( QgsFeedback *interruptionChe cker )		void QgsWFSFeatureIterator::setInterruptionChecker( QgsFeedback *interruptionChe cker )
{		{
mInterruptionChecker = interruptionChecker;		mInterruptionChecker = interruptionChecker;
}		}
// This method will serialize the receive feature list, first into memory, and		// This method will serialize the receive feature list, first into memory, and
// if it goes above a given threshold, on disk		// if it goes above a given threshold, on disk
void QgsWFSFeatureIterator::featureReceivedSynchronous( const QVector<QgsWFSFeat ureGmlIdPair> &list )		void QgsWFSFeatureIterator::featureReceivedSynchronous( const QVector<QgsWFSFeat ureGmlIdPair> &list )
{		{
QgsDebugMsgLevel( QStringLiteral( "QgsWFSFeatureIterator::featureReceivedSynch ronous %1 features" ).arg( list.size() ), 4 );		QgsDebugMsgLevel( QStringLiteral( "QgsWFSFeatureIterator::featureReceivedSynch ronous %1 features" ).arg( list.size() ), 4 );
skipping to change at line 1270		skipping to change at line 1299
if ( stmt.step() == SQLITE_ROW )		if ( stmt.step() == SQLITE_ROW )
{		{
f.setId( stmt.columnAsInt64( 0 ) );		f.setId( stmt.columnAsInt64( 0 ) );
Q_ASSERT( stmt.step() != SQLITE_ROW );		Q_ASSERT( stmt.step() != SQLITE_ROW );
}		}
}		}
return true;		return true;
}		}
		const bool requestMadeFromMainThread = QThread::currentThread() == QApplicatio
		n::instance()->thread();
// Second step is to wait for features to be notified by the downloader		// Second step is to wait for features to be notified by the downloader
while ( true )		while ( true )
{		{
{		{
QMutexLocker locker( &mMutex );		QMutexLocker locker( &mMutex );
mNewFeaturesReceived = false;		mNewFeaturesReceived = false;
}		}
// Initialize a reader stream if there's a writer stream available		// Initialize a reader stream if there's a writer stream available
if ( !mReaderStream )		if ( !mReaderStream )
skipping to change at line 1403		skipping to change at line 1434
const int timeout = ( requestTimeout > 0 ) ?		const int timeout = ( requestTimeout > 0 ) ?
std::min( requestTimeout - timeRequestTimeout.elapsed( ), delayCheckInterruption ) :		std::min( requestTimeout - timeRequestTimeout.elapsed( ), delayCheckInterruption ) :
delayCheckInterruption;		delayCheckInterruption;
if ( timeout < 0 )		if ( timeout < 0 )
{		{
mTimeoutOrInterruptionOccurred = true;		mTimeoutOrInterruptionOccurred = true;
mDownloadFinished = true;		mDownloadFinished = true;
break;		break;
}		}
mWaitCond.wait( &mMutex, timeout );		mWaitCond.wait( &mMutex, timeout );
		if ( requestMadeFromMainThread && mProcessEvents )
		{
		QgsApplication::instance()->processEvents();
		mProcessEvents = false;
		}
if ( mInterruptionChecker && mInterruptionChecker->isCanceled() )		if ( mInterruptionChecker && mInterruptionChecker->isCanceled() )
{		{
mTimeoutOrInterruptionOccurred = true;		mTimeoutOrInterruptionOccurred = true;
mDownloadFinished = true;		mDownloadFinished = true;
break;		break;
}		}
}		}
}		}
}		}
End of changes. 9 change blocks.
2 lines changed or deleted		43 lines changed or added

---