/************************************************************************ * This file has been generated automatically from * * * * src/core/processing/qgsprocessingcontext.h * * * * Do not edit manually ! Edit header and run scripts/sipify.pl again * ************************************************************************/ class QgsProcessingContext { %Docstring Contains information about the context in which a processing algorithm is executed. Contextual information includes settings such as the associated project, and expression context. .. versionadded:: 3.0 %End %TypeHeaderCode #include "qgsprocessingcontext.h" %End public: enum Flag { // UseSelectionIfPresent = 1 << 0, }; typedef QFlags Flags; QgsProcessingContext(); %Docstring Constructor for QgsProcessingContext. %End ~QgsProcessingContext(); void copyThreadSafeSettings( const QgsProcessingContext &other ); %Docstring Copies all settings which are safe for use across different threads from ``other`` to this context. %End QgsProcessingContext::Flags flags() const; %Docstring Returns any flags set in the context. .. seealso:: :py:func:`setFlags` %End void setFlags( QgsProcessingContext::Flags flags ); %Docstring Sets ``flags`` for the context. .. seealso:: :py:func:`flags` %End QgsProject *project() const; %Docstring Returns the project in which the algorithm is being executed. .. seealso:: :py:func:`setProject` %End void setProject( QgsProject *project ); %Docstring Sets the ``project`` in which the algorithm will be executed. This also automatically sets the transformContext() to match the project's transform context. .. seealso:: :py:func:`project` %End QgsExpressionContext &expressionContext(); %Docstring Returns the expression context. %End void setExpressionContext( const QgsExpressionContext &context ); %Docstring Sets the expression ``context``. %End QgsCoordinateTransformContext transformContext() const; %Docstring Returns the coordinate transform context. .. seealso:: :py:func:`setTransformContext` %End void setTransformContext( const QgsCoordinateTransformContext &context ); %Docstring Sets the coordinate transform ``context``. Note that setting a project for the context will automatically set the coordinate transform context. .. seealso:: :py:func:`transformContext` %End QgsMapLayerStore *temporaryLayerStore(); %Docstring Returns a reference to the layer store used for storing temporary layers during algorithm execution. %End class LayerDetails { %Docstring Details for layers to load into projects. .. versionadded:: 3.0 %End %TypeHeaderCode #include "qgsprocessingcontext.h" %End public: LayerDetails( const QString &name, QgsProject *project, const QString &outputName = QString(), QgsProcessingUtils::LayerHint layerTypeHint = QgsProcessingUtils::LayerHint::UnknownType ); %Docstring Constructor for LayerDetails. %End LayerDetails(); %Docstring Default constructor %End QString name; QString outputName; QgsProcessingUtils::LayerHint layerTypeHint; QgsProcessingLayerPostProcessorInterface *postProcessor() const; %Docstring Layer post-processor. May be ``None`` if no post-processing is required. .. seealso:: :py:func:`setPostProcessor` .. versionadded:: 3.2 %End void setPostProcessor( QgsProcessingLayerPostProcessorInterface *processor /Transfer/ ); %Docstring Sets the layer post-processor. May be ``None`` if no post-processing is required. Ownership of ``processor`` is transferred. .. seealso:: :py:func:`postProcessor` .. versionadded:: 3.2 %End QgsProject *project; }; QMap< QString, QgsProcessingContext::LayerDetails > layersToLoadOnCompletion() const; %Docstring Returns a map of layers (by ID or datasource) to LayerDetails, to load into the canvas upon completion of the algorithm or model. .. seealso:: :py:func:`setLayersToLoadOnCompletion` .. seealso:: :py:func:`addLayerToLoadOnCompletion` .. seealso:: :py:func:`willLoadLayerOnCompletion` .. seealso:: :py:func:`layerToLoadOnCompletionDetails` %End bool willLoadLayerOnCompletion( const QString &layer ) const; %Docstring Returns ``True`` if the given ``layer`` (by ID or datasource) will be loaded into the current project upon completion of the algorithm or model. .. seealso:: :py:func:`layersToLoadOnCompletion` .. seealso:: :py:func:`setLayersToLoadOnCompletion` .. seealso:: :py:func:`addLayerToLoadOnCompletion` .. seealso:: :py:func:`layerToLoadOnCompletionDetails` .. versionadded:: 3.2 %End void setLayersToLoadOnCompletion( const QMap< QString, QgsProcessingContext::LayerDetails > &layers ); %Docstring Sets the map of ``layers`` (by ID or datasource) to LayerDetails, to load into the canvas upon completion of the algorithm or model. .. seealso:: :py:func:`addLayerToLoadOnCompletion` .. seealso:: :py:func:`layersToLoadOnCompletion` .. seealso:: :py:func:`willLoadLayerOnCompletion` .. seealso:: :py:func:`layerToLoadOnCompletionDetails` %End void addLayerToLoadOnCompletion( const QString &layer, const QgsProcessingContext::LayerDetails &details ); %Docstring Adds a ``layer`` to load (by ID or datasource) into the canvas upon completion of the algorithm or model. The ``details`` parameter dictates the LayerDetails. .. seealso:: :py:func:`setLayersToLoadOnCompletion` .. seealso:: :py:func:`layersToLoadOnCompletion` .. seealso:: :py:func:`willLoadLayerOnCompletion` .. seealso:: :py:func:`layerToLoadOnCompletionDetails` %End QgsProcessingContext::LayerDetails &layerToLoadOnCompletionDetails( const QString &layer ); %Docstring Returns a reference to the details for a given ``layer`` which is loaded on completion of the algorithm or model. .. warning:: First check willLoadLayerOnCompletion(), or calling this method will incorrectly add ``layer`` as a layer to load on completion. .. seealso:: :py:func:`willLoadLayerOnCompletion` .. seealso:: :py:func:`addLayerToLoadOnCompletion` .. seealso:: :py:func:`setLayersToLoadOnCompletion` .. seealso:: :py:func:`layersToLoadOnCompletion` .. versionadded:: 3.2 %End QgsFeatureRequest::InvalidGeometryCheck invalidGeometryCheck() const; %Docstring Returns the behavior used for checking invalid geometries in input layers. .. seealso:: :py:func:`setInvalidGeometryCheck` %End void setInvalidGeometryCheck( QgsFeatureRequest::InvalidGeometryCheck check ); %Docstring Sets the behavior used for checking invalid geometries in input layers. Settings this to anything but QgsFeatureRequest.GeometryNoCheck will also reset the invalidGeometryCallback() to a default implementation. .. seealso:: :py:func:`invalidGeometryCheck` %End void setInvalidGeometryCallback( SIP_PYCALLABLE / AllowNone / ); %Docstring Sets a callback function to use when encountering an invalid geometry and invalidGeometryCheck() is set to GeometryAbortOnInvalid. This function will be called using the feature with invalid geometry as a parameter. .. seealso:: :py:func:`invalidGeometryCallback` .. versionadded:: 3.0 %End %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 void setTransformErrorCallback( SIP_PYCALLABLE / AllowNone / ); %Docstring Sets a callback function to use when encountering a transform error when iterating features. This function will be called using the feature which encountered the transform error as a parameter. .. seealso:: :py:func:`transformErrorCallback` .. versionadded:: 3.0 %End %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 QString defaultEncoding() const; %Docstring Returns the default encoding to use for newly created files. .. seealso:: :py:func:`setDefaultEncoding` %End void setDefaultEncoding( const QString &encoding ); %Docstring Sets the default ``encoding`` to use for newly created files. .. seealso:: :py:func:`defaultEncoding` %End QgsProcessingFeedback *feedback(); %Docstring Returns the associated feedback object. .. seealso:: :py:func:`setFeedback` %End void setFeedback( QgsProcessingFeedback *feedback ); %Docstring Sets an associated ``feedback`` object. This allows context related functions to report feedback and errors to users and processing logs. While ideally this feedback object should outlive the context, only a weak pointer to ``feedback`` is stored and no errors will occur if feedback is deleted before the context. Ownership of ``feedback`` is not transferred. .. seealso:: :py:func:`setFeedback` %End QThread *thread(); %Docstring Returns the thread in which the context lives. .. seealso:: :py:func:`pushToThread` %End void pushToThread( QThread *thread ); %Docstring Pushes the thread affinity for the context (including all layers contained in the temporaryLayerStore()) into another ``thread``. This method is only safe to call when the current thread matches the existing thread affinity for the context (see thread()). .. seealso:: :py:func:`thread` %End void takeResultsFrom( QgsProcessingContext &context ); %Docstring Takes the results from another ``context`` and merges them with the results currently stored in this context. This includes settings like any layers loaded in the temporaryLayerStore() and layersToLoadOnCompletion(). This is only safe to call when both this context and the other ``context`` share the same thread() affinity, and that thread is the current thread. %End QgsMapLayer *getMapLayer( const QString &identifier ); %Docstring Returns a map layer from the context with a matching ``identifier``. This method considers layer IDs, names and sources when matching the ``identifier`` (see :py:func:`QgsProcessingUtils.mapLayerFromString()` for details). Ownership is not transferred and remains with the context. .. seealso:: :py:func:`takeResultLayer` %End QgsMapLayer *takeResultLayer( const QString &id ) /TransferBack/; %Docstring Takes the result map layer with matching ``id`` from the context and transfers ownership of it back to the caller. This method can be used to remove temporary layers which are not required for further processing from a context. .. seealso:: :py:func:`getMapLayer` %End QString preferredVectorFormat() const; %Docstring Returns the preferred vector format to use for vector outputs. This method returns a file extension to use when creating vector outputs (e.g. "shp"). Generally, it is preferable to use the extension associated with a particular parameter, which can be retrieved through :py:func:`QgsProcessingDestinationParameter.defaultFileExtension()` However, in some cases, a specific parameter may not be available to call this method on (e.g. for an algorithm which has only an output folder parameter and which creates multiple output layers in that folder). In this case, the format returned by this function should be used when creating these outputs. It is the algorithm's responsibility to check whether the returned format is acceptable for the algorithm, and to provide an appropriate fallback when the returned format is not usable. .. seealso:: :py:func:`setPreferredVectorFormat` .. seealso:: :py:func:`preferredRasterFormat` .. versionadded:: 3.10 %End void setPreferredVectorFormat( const QString &format ); %Docstring Sets the preferred vector ``format`` to use for vector outputs. This method sets a file extension to use when creating vector outputs (e.g. "shp"). Generally, it is preferable to use the extension associated with a particular parameter, which can be retrieved through :py:func:`QgsProcessingDestinationParameter.defaultFileExtension()` However, in some cases, a specific parameter may not be available to call this method on (e.g. for an algorithm which has only an output folder parameter and which creates multiple output layers in that folder). In this case, the format set by this function will be used when creating these outputs. .. seealso:: :py:func:`preferredVectorFormat` .. seealso:: :py:func:`setPreferredRasterFormat` .. versionadded:: 3.10 %End QString preferredRasterFormat() const; %Docstring Returns the preferred raster format to use for vector outputs. This method returns a file extension to use when creating raster outputs (e.g. "tif"). Generally, it is preferable to use the extension associated with a particular parameter, which can be retrieved through :py:func:`QgsProcessingDestinationParameter.defaultFileExtension()` However, in some cases, a specific parameter may not be available to call this method on (e.g. for an algorithm which has only an output folder parameter and which creates multiple output layers in that folder). In this case, the format returned by this function should be used when creating these outputs. It is the algorithm's responsibility to check whether the returned format is acceptable for the algorithm, and to provide an appropriate fallback when the returned format is not usable. .. seealso:: :py:func:`setPreferredRasterFormat` .. seealso:: :py:func:`preferredVectorFormat` .. versionadded:: 3.10 %End void setPreferredRasterFormat( const QString &format ); %Docstring Sets the preferred raster ``format`` to use for vector outputs. This method sets a file extension to use when creating raster outputs (e.g. "tif"). Generally, it is preferable to use the extension associated with a particular parameter, which can be retrieved through :py:func:`QgsProcessingDestinationParameter.defaultFileExtension()` However, in some cases, a specific parameter may not be available to call this method on (e.g. for an algorithm which has only an output folder parameter and which creates multiple output layers in that folder). In this case, the format set by this function will be used when creating these outputs. .. seealso:: :py:func:`preferredRasterFormat` .. seealso:: :py:func:`setPreferredVectorFormat` .. versionadded:: 3.10 %End private: QgsProcessingContext( const QgsProcessingContext &other ); }; QFlags operator|(QgsProcessingContext::Flag f1, QFlags f2); class QgsProcessingLayerPostProcessorInterface { %Docstring An interface for layer post-processing handlers for execution following a processing algorithm operation. Note that post-processing of a layer will ONLY occur if that layer is set to be loaded into a QGIS project on algorithm completion. See :py:func:`QgsProcessingContext.layersToLoadOnCompletion()` Algorithms that wish to set post-processing steps for generated layers should implement this interface in a separate class (NOT the algorithm class itself!). .. versionadded:: 3.2 %End %TypeHeaderCode #include "qgsprocessingcontext.h" %End public: virtual ~QgsProcessingLayerPostProcessorInterface(); virtual void postProcessLayer( QgsMapLayer *layer, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) = 0; %Docstring Post-processes the specified ``layer``, following successful execution of a processing algorithm. This method always runs in the main thread and can be used to setup renderers, editor widgets, metadata, etc for the given layer. Post-processing classes can utilize settings from the algorithm's ``context`` and report logging messages or errors via the given ``feedback`` object. In the case of an algorithm run as part of a larger model, the post-processing occurs following the completed execution of the entire model. Note that post-processing of a layer will ONLY occur if that layer is set to be loaded into a QGIS project on algorithm completion. See :py:func:`QgsProcessingContext.layersToLoadOnCompletion()` %End }; /************************************************************************ * This file has been generated automatically from * * * * src/core/processing/qgsprocessingcontext.h * * * * Do not edit manually ! Edit header and run scripts/sipify.pl again * ************************************************************************/