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 "qgsfeaturerequest.h"
#include "qgsprocessingfeedback.h"
#include "qgsprocessingutils.h"
 
 
#include <QThread>
#include <QPointer>
 
class QgsProcessingLayerPostProcessorInterface;
 
class CORE_EXPORT QgsProcessingContext
{
  public:
 
    enum Flag
    {
      // For future API flexibility only and to avoid sip issues, remove when real entries are added to flags.
      Unused = 1 << 0, 
    };
    Q_DECLARE_FLAGS( Flags, Flag )
 
    
    enum LogLevel
    {
      DefaultLevel = 0, 
      Verbose, 
      ModelDebug, 
    };
 
    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;
    }
 
    QgsProcessingContext::Flags flags() const { return mFlags; }
 
    void setFlags( QgsProcessingContext::Flags flags ) { mFlags = flags; }
 
    QgsProject *project() const { return mProject; }
 
    void setProject( QgsProject *project )
    {
      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();
      }
    }
 
    QgsExpressionContext &expressionContext() { return mExpressionContext; }
 
    SIP_SKIP const QgsExpressionContext &expressionContext() const { return mExpressionContext; }
 
    void setExpressionContext( const QgsExpressionContext &context );
 
    QgsCoordinateTransformContext transformContext() const { return mTransformContext; }
 
    void setTransformContext( const QgsCoordinateTransformContext &context ) { mTransformContext = context; }
 
    QString ellipsoid() const;
 
    void setEllipsoid( const QString &ellipsoid );
 
    Qgis::DistanceUnit distanceUnit() const;
 
    void setDistanceUnit( Qgis::DistanceUnit unit );
 
    Qgis::AreaUnit areaUnit() const;
 
    void setAreaUnit( Qgis::AreaUnit areaUnit );
 
    QgsDateTimeRange currentTimeRange() const;
 
    void setCurrentTimeRange( const QgsDateTimeRange &currentTimeRange );
 
    QgsMapLayerStore *temporaryLayerStore() { 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() = 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;
 
    };
 
    QMap< QString, QgsProcessingContext::LayerDetails > layersToLoadOnCompletion() const
    {
      return mLayersToLoadOnCompletion;
    }
 
    bool willLoadLayerOnCompletion( const QString &layer ) const
    {
      return mLayersToLoadOnCompletion.contains( layer );
    }
 
    void setLayersToLoadOnCompletion( const QMap< QString, QgsProcessingContext::LayerDetails > &layers );
 
    void addLayerToLoadOnCompletion( const QString &layer, const QgsProcessingContext::LayerDetails &details );
 
    QgsProcessingContext::LayerDetails &layerToLoadOnCompletionDetails( const QString &layer )
    {
      return mLayersToLoadOnCompletion[ layer ];
    }
 
    QgsFeatureRequest::InvalidGeometryCheck invalidGeometryCheck() const { return mInvalidGeometryCheck; }
 
    void setInvalidGeometryCheck( QgsFeatureRequest::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( QgsFeatureRequest::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 { return mTransformErrorCallback; } SIP_SKIP
 
    QString defaultEncoding() const { return mDefaultEncoding; }
 
    void setDefaultEncoding( const QString &encoding ) { mDefaultEncoding = encoding; }
 
    QgsProcessingFeedback *feedback() { return mFeedback; }
 
    void setFeedback( QgsProcessingFeedback *feedback ) { mFeedback = feedback; }
 
    QThread *thread() { 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 takeResultsFrom( QgsProcessingContext &context );
 
    QgsMapLayer *getMapLayer( const QString &identifier );
 
    QgsMapLayer *takeResultLayer( const QString &id ) SIP_TRANSFERBACK;
 
    QString preferredVectorFormat() const { return mPreferredVectorFormat; }
 
    void setPreferredVectorFormat( const QString &format ) { mPreferredVectorFormat = format; }
 
    QString preferredRasterFormat() const { return mPreferredRasterFormat; }
 
    void setPreferredRasterFormat( const QString &format ) { mPreferredRasterFormat = format; }
 
    LogLevel logLevel() const;
 
    void setLogLevel( LogLevel level );
 
    QString temporaryFolder() const;
 
    void setTemporaryFolder( const QString &folder );
 
    int maximumThreads() const;
 
    void setMaximumThreads( int threads );
 
    QVariantMap exportToMap() const;
 
    enum class ProcessArgumentFlag : int
    {
      IncludeProjectPath = 1 << 0, 
    };
    Q_DECLARE_FLAGS( ProcessArgumentFlags, ProcessArgumentFlag )
 
    
    QStringList asQgisProcessArguments( QgsProcessingContext::ProcessArgumentFlags flags = QgsProcessingContext::ProcessArgumentFlags() ) const;
 
  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;
 
    QgsFeatureRequest::InvalidGeometryCheck mInvalidGeometryCheck = QgsFeatureRequest::GeometryNoCheck;
    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;
 
    LogLevel mLogLevel = DefaultLevel;
 
    QString mTemporaryFolderOverride;
    int mMaximumThreads = QThread::idealThreadCount();
 
#ifdef SIP_RUN
    QgsProcessingContext( const QgsProcessingContext &other );
#endif
};
 
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;
 
};
 
 
#endif // QGSPROCESSINGPARAMETERS_H