qgsprocessingcontext.h

Go to the documentation of this file.

/***************************************************************************
                         qgsprocessingcontext.h
                         ----------------------
    begin                : April 2017
    copyright            : (C) 2017 by Nyall Dawson
    email                : nyall dot dawson 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 QGSPROCESSINGCONTEXT_H
#define QGSPROCESSINGCONTEXT_H
 
#include "qgis_core.h"
#include "qgis.h"
#include "qgsproject.h"
#include "qgsexpressioncontext.h"
#include "qgsprocessingfeedback.h"
#include "qgsprocessingutils.h"
#include "qgsprocessingmodelresult.h"
#include "qgsprocessingmodelconfig.h"
 
#include <QThread>
#include <QPointer>
 
class QgsProcessingLayerPostProcessorInterface;
 
class CORE_EXPORT QgsProcessingContext
{
  public:
 
    enum Flag SIP_ENUM_BASETYPE( IntFlag )
    {
      // For future API flexibility only and to avoid sip issues, remove when real entries are added to flags.
      Unused = 1 << 0, 
    };
    enum Flag SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( Flags, Flag )
 
    QgsProcessingContext();
 
    QgsProcessingContext( const QgsProcessingContext &other ) = delete;
    QgsProcessingContext &operator=( const QgsProcessingContext &other ) = delete;
 
    ~QgsProcessingContext();
 
    void copyThreadSafeSettings( const QgsProcessingContext &other )
    {
      mFlags = other.mFlags;
      mProject = other.mProject;
      mTransformContext = other.mTransformContext;
      mExpressionContext = other.mExpressionContext;
      mExpressionContext.setLoadedLayerStore( &tempLayerStore );
      mInvalidGeometryCallback = other.mInvalidGeometryCallback;
      mUseDefaultInvalidGeometryCallback = other.mUseDefaultInvalidGeometryCallback;
      mInvalidGeometryCheck = other.mInvalidGeometryCheck;
      mTransformErrorCallback = other.mTransformErrorCallback;
      mDefaultEncoding = other.mDefaultEncoding;
      mFeedback = other.mFeedback;
      mPreferredVectorFormat = other.mPreferredVectorFormat;
      mPreferredRasterFormat = other.mPreferredRasterFormat;
      mEllipsoid = other.mEllipsoid;
      mDistanceUnit = other.mDistanceUnit;
      mAreaUnit = other.mAreaUnit;
      mLogLevel = other.mLogLevel;
      mTemporaryFolderOverride = other.mTemporaryFolderOverride;
      mMaximumThreads = other.mMaximumThreads;
      mModelResult = other.mModelResult;
    }
    void copyThreadSafeSettings( const QgsProcessingContext &other ) {…}
 
    QgsProcessingContext::Flags flags() const SIP_HOLDGIL { return mFlags; }
 
    void setFlags( QgsProcessingContext::Flags flags ) SIP_HOLDGIL { mFlags = flags; }
 
    QgsProject *project() const SIP_HOLDGIL { return mProject; }
 
    void setProject( QgsProject *project ) SIP_HOLDGIL
    {
      mProject = project;
      if ( mProject )
      {
        mTransformContext = mProject->transformContext();
        if ( mEllipsoid.isEmpty() )
          mEllipsoid = mProject->ellipsoid();
        if ( mDistanceUnit == Qgis::DistanceUnit::Unknown )
          mDistanceUnit = mProject->distanceUnits();
        if ( mAreaUnit == Qgis::AreaUnit::Unknown )
          mAreaUnit = mProject->areaUnits();
      }
    }
    void setProject( QgsProject *project ) SIP_HOLDGIL {…}
 
    QgsExpressionContext &expressionContext() SIP_HOLDGIL { return mExpressionContext; }
 
    SIP_SKIP const QgsExpressionContext &expressionContext() const { return mExpressionContext; }
 
    void setExpressionContext( const QgsExpressionContext &context );
 
    QgsCoordinateTransformContext transformContext() const SIP_HOLDGIL { return mTransformContext; }
 
    void setTransformContext( const QgsCoordinateTransformContext &context ) SIP_HOLDGIL { mTransformContext = context; }
 
    QString ellipsoid() const SIP_HOLDGIL;
 
    void setEllipsoid( const QString &ellipsoid ) SIP_HOLDGIL;
 
    Qgis::DistanceUnit distanceUnit() const SIP_HOLDGIL;
 
    void setDistanceUnit( Qgis::DistanceUnit unit ) SIP_HOLDGIL;
 
    Qgis::AreaUnit areaUnit() const SIP_HOLDGIL;
 
    void setAreaUnit( Qgis::AreaUnit areaUnit ) SIP_HOLDGIL;
 
    QgsDateTimeRange currentTimeRange() const SIP_HOLDGIL;
 
    void setCurrentTimeRange( const QgsDateTimeRange &currentTimeRange ) SIP_HOLDGIL;
 
    QgsMapLayerStore *temporaryLayerStore() SIP_HOLDGIL { return &tempLayerStore; }
 
    class CORE_EXPORT LayerDetails
    {
      public:
 
        LayerDetails( const QString &name, QgsProject *project, const QString &outputName = QString(), QgsProcessingUtils::LayerHint layerTypeHint = QgsProcessingUtils::LayerHint::UnknownType )
          : name( name )
          , outputName( outputName )
          , layerTypeHint( layerTypeHint )
          , project( project )
        {}
        LayerDetails( const QString &name, QgsProject *project, const QString &outputName = QString(), QgsProcessingUtils::LayerHint layerTypeHint = QgsProcessingUtils::LayerHint::UnknownType ) {…}
 
        LayerDetails() = default;
 
        QString name;
 
        bool forceName = false;
 
        QString outputName;
 
        QString groupName;
 
        int layerSortKey = 0;
 
        QgsProcessingUtils::LayerHint layerTypeHint = QgsProcessingUtils::LayerHint::UnknownType;
 
        QgsProcessingLayerPostProcessorInterface *postProcessor() const;
 
        void setPostProcessor( QgsProcessingLayerPostProcessorInterface *processor SIP_TRANSFER );
 
        void setOutputLayerName( QgsMapLayer *layer ) const;
 
        QgsProject *project = nullptr;
 
      private:
 
        // Ideally a unique_ptr, but cannot be due to use within QMap. Is cleaned up by QgsProcessingContext.
        QgsProcessingLayerPostProcessorInterface *mPostProcessor = nullptr;
 
    };
    class CORE_EXPORT LayerDetails {…};
 
    QMap< QString, QgsProcessingContext::LayerDetails > layersToLoadOnCompletion() const SIP_HOLDGIL
    {
      return mLayersToLoadOnCompletion;
    }
    QMap< QString, QgsProcessingContext::LayerDetails > layersToLoadOnCompletion() const SIP_HOLDGIL {…}
 
    bool willLoadLayerOnCompletion( const QString &layer ) const SIP_HOLDGIL
    {
      return mLayersToLoadOnCompletion.contains( layer );
    }
    bool willLoadLayerOnCompletion( const QString &layer ) const SIP_HOLDGIL {…}
 
    void setLayersToLoadOnCompletion( const QMap< QString, QgsProcessingContext::LayerDetails > &layers ) SIP_HOLDGIL;
 
    void addLayerToLoadOnCompletion( const QString &layer, const QgsProcessingContext::LayerDetails &details ) SIP_HOLDGIL;
 
    QgsProcessingContext::LayerDetails &layerToLoadOnCompletionDetails( const QString &layer ) SIP_HOLDGIL
    {
      return mLayersToLoadOnCompletion[ layer ];
    }
    QgsProcessingContext::LayerDetails &layerToLoadOnCompletionDetails( const QString &layer ) SIP_HOLDGIL {…}
 
    Qgis::InvalidGeometryCheck invalidGeometryCheck() const SIP_HOLDGIL { return mInvalidGeometryCheck; }
 
    void setInvalidGeometryCheck( Qgis::InvalidGeometryCheck check );
 
#ifndef SIP_RUN
    void setInvalidGeometryCallback( const std::function< void( const QgsFeature & ) > &callback ) { mInvalidGeometryCallback = callback; mUseDefaultInvalidGeometryCallback = false; }
#else
    void setInvalidGeometryCallback( SIP_PYCALLABLE / AllowNone / );
    % MethodCode
    Py_BEGIN_ALLOW_THREADS
 
    sipCpp->setInvalidGeometryCallback( [a0]( const QgsFeature &arg )
    {
      SIP_BLOCK_THREADS
      Py_XDECREF( sipCallMethod( NULL, a0, "D", &arg, sipType_QgsFeature, NULL ) );
      SIP_UNBLOCK_THREADS
    } );
 
    Py_END_ALLOW_THREADS
    % End
#endif
 
    SIP_SKIP std::function< void( const QgsFeature & ) > invalidGeometryCallback( QgsFeatureSource *source = nullptr ) const;
 
    SIP_SKIP std::function< void( const QgsFeature & ) > defaultInvalidGeometryCallbackForCheck( Qgis::InvalidGeometryCheck check, QgsFeatureSource *source = nullptr ) const;
 
#ifndef SIP_RUN
    void setTransformErrorCallback( const std::function< void( const QgsFeature & ) > &callback ) { mTransformErrorCallback = callback; }
#else
    void setTransformErrorCallback( SIP_PYCALLABLE / AllowNone / );
    % MethodCode
    Py_BEGIN_ALLOW_THREADS
 
    sipCpp->setTransformErrorCallback( [a0]( const QgsFeature &arg )
    {
      SIP_BLOCK_THREADS
      Py_XDECREF( sipCallMethod( NULL, a0, "D", &arg, sipType_QgsFeature, NULL ) );
      SIP_UNBLOCK_THREADS
    } );
 
    Py_END_ALLOW_THREADS
    % End
#endif
 
    std::function< void( const QgsFeature & ) > transformErrorCallback() const SIP_SKIP { return mTransformErrorCallback; }
 
    QString defaultEncoding() const SIP_HOLDGIL { return mDefaultEncoding; }
 
    void setDefaultEncoding( const QString &encoding ) SIP_HOLDGIL { mDefaultEncoding = encoding; }
 
    QgsProcessingFeedback *feedback() SIP_HOLDGIL { return mFeedback; }
 
    void setFeedback( QgsProcessingFeedback *feedback ) SIP_HOLDGIL { mFeedback = feedback; }
 
    QThread *thread() SIP_HOLDGIL { return tempLayerStore.thread(); }
 
    void pushToThread( QThread *thread )
    {
      // cppcheck-suppress assertWithSideEffect
      Q_ASSERT_X( QThread::currentThread() == QgsProcessingContext::thread(), "QgsProcessingContext::pushToThread", "Cannot push context to another thread unless the current thread matches the existing context thread affinity" );
      tempLayerStore.moveToThread( thread );
    }
    void pushToThread( QThread *thread ) {…}
 
    void takeResultsFrom( QgsProcessingContext &context );
 
    QgsMapLayer *getMapLayer( const QString &identifier );
 
    QgsMapLayer *takeResultLayer( const QString &id ) SIP_TRANSFERBACK;
 
    QString preferredVectorFormat() const SIP_HOLDGIL { return mPreferredVectorFormat; }
 
    void setPreferredVectorFormat( const QString &format ) SIP_HOLDGIL { mPreferredVectorFormat = format; }
 
    QString preferredRasterFormat() const SIP_HOLDGIL { return mPreferredRasterFormat; }
 
    void setPreferredRasterFormat( const QString &format ) SIP_HOLDGIL { mPreferredRasterFormat = format; }
 
    Qgis::ProcessingLogLevel logLevel() const SIP_HOLDGIL;
 
    void setLogLevel( Qgis::ProcessingLogLevel level ) SIP_HOLDGIL;
 
    QString temporaryFolder() const SIP_HOLDGIL;
 
    void setTemporaryFolder( const QString &folder ) SIP_HOLDGIL;
 
    int maximumThreads() const SIP_HOLDGIL;
 
    void setMaximumThreads( int threads ) SIP_HOLDGIL;
 
    QVariantMap exportToMap() const SIP_HOLDGIL;
 
    enum class ProcessArgumentFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      IncludeProjectPath = 1 << 0, 
    };
    enum class ProcessArgumentFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( ProcessArgumentFlags, ProcessArgumentFlag )
 
    
    QStringList asQgisProcessArguments( QgsProcessingContext::ProcessArgumentFlags flags = QgsProcessingContext::ProcessArgumentFlags() ) const;
 
    QgsProcessingModelInitialRunConfig *modelInitialRunConfig() SIP_SKIP;
 
    std::unique_ptr< QgsProcessingModelInitialRunConfig > takeModelInitialRunConfig() SIP_SKIP;
 
    void setModelInitialRunConfig( std::unique_ptr< QgsProcessingModelInitialRunConfig > config ) SIP_SKIP;
 
    QgsProcessingModelResult modelResult() const { return mModelResult; }
 
    QgsProcessingModelResult &modelResult() SIP_SKIP { return mModelResult; }
 
    void clearModelResult();
 
  private:
 
    QgsProcessingContext::Flags mFlags = QgsProcessingContext::Flags();
    QPointer< QgsProject > mProject;
    QgsCoordinateTransformContext mTransformContext;
 
    QString mEllipsoid;
    Qgis::DistanceUnit mDistanceUnit = Qgis::DistanceUnit::Unknown;
    Qgis::AreaUnit mAreaUnit = Qgis::AreaUnit::Unknown;
 
    QgsDateTimeRange mCurrentTimeRange;
 
    QgsMapLayerStore tempLayerStore;
    QgsExpressionContext mExpressionContext;
 
    Qgis::InvalidGeometryCheck mInvalidGeometryCheck = Qgis::InvalidGeometryCheck::NoCheck;
    bool mUseDefaultInvalidGeometryCallback = true;
    std::function< void( const QgsFeature & ) > mInvalidGeometryCallback;
 
    std::function< void( const QgsFeature & ) > mTransformErrorCallback;
    QString mDefaultEncoding;
    QMap< QString, LayerDetails > mLayersToLoadOnCompletion;
 
    QPointer< QgsProcessingFeedback > mFeedback;
 
    QString mPreferredVectorFormat;
    QString mPreferredRasterFormat;
 
    Qgis::ProcessingLogLevel mLogLevel = Qgis::ProcessingLogLevel::DefaultLevel;
 
    QString mTemporaryFolderOverride;
    int mMaximumThreads = QThread::idealThreadCount();
 
    std::unique_ptr< QgsProcessingModelInitialRunConfig > mModelConfig;
    QgsProcessingModelResult mModelResult;
 
#ifdef SIP_RUN
    QgsProcessingContext( const QgsProcessingContext &other );
#endif
};
class CORE_EXPORT QgsProcessingContext {…};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProcessingContext::Flags )
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProcessingContext::ProcessArgumentFlags )
 
 
 
class CORE_EXPORT QgsProcessingLayerPostProcessorInterface
{
  public:
 
    virtual ~QgsProcessingLayerPostProcessorInterface() = default;
 
    virtual void postProcessLayer( QgsMapLayer *layer, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) = 0;
 
};
class CORE_EXPORT QgsProcessingLayerPostProcessorInterface {…};
 
 
#endif // QGSPROCESSINGPARAMETERS_H