QGIS API Documentation 3.37.0-Master (df6056bf1be)
Loading...
Searching...
No Matches
qgsprocessingregistry.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsprocessingregistry.cpp
3 --------------------------
4 begin : December 2016
5 copyright : (C) 2016 by Nyall Dawson
6 email : nyall dot dawson at gmail dot com
7 ***************************************************************************/
8
9/***************************************************************************
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 ***************************************************************************/
17
19#include "qgsvectorfilewriter.h"
28
30 : QObject( parent )
31{
70 addParameterType( new QgsProcessingParameterTypeVectorTileWriterLayers() );
71 addParameterType( new QgsProcessingParameterTypeFieldMapping() );
72 addParameterType( new QgsProcessingParameterTypeAggregate() );
73 addParameterType( new QgsProcessingParameterTypeTinInputLayers() );
74 addParameterType( new QgsProcessingParameterTypeDxfLayers() );
75 addParameterType( new QgsProcessingParameterTypeMeshDatasetGroups() );
76 addParameterType( new QgsProcessingParameterTypeMeshDatasetTime() );
82 addParameterType( new QgsProcessingParameterTypeAlignRasterLayers() );
83}
84
86{
87 const auto constMProviders = mProviders;
88 for ( QgsProcessingProvider *p : constMProviders )
89 {
90 removeProvider( p );
91 }
92
93 const auto parameterTypes = mParameterTypes.values();
94
96 {
97 removeParameterType( type );
98 }
99}
100
102{
103 if ( !provider )
104 return false;
105
106 if ( providerById( provider->id() ) )
107 {
108 QgsLogger::warning( QStringLiteral( "Duplicate provider %1 registered" ).arg( provider->id() ) );
109 delete provider;
110 return false;
111 }
112
113 if ( !provider->load() )
114 {
115 QgsLogger::warning( QStringLiteral( "Provider %1 cannot load" ).arg( provider->id() ) );
116 delete provider;
117 return false;
118 }
119
120 provider->setParent( this );
121 mProviders[ provider->id()] = provider;
122
123 mCachedInformation.clear();
124 connect( provider, &QgsProcessingProvider::algorithmsLoaded, this, [this]
125 {
126 mCachedInformation.clear();
127 } );
128
129 emit providerAdded( provider->id() );
130 return true;
131}
132
134{
135 if ( !provider )
136 return false;
137
138 const QString id = provider->id();
139
140 if ( !mProviders.contains( id ) )
141 return false;
142
143 provider->unload();
144
145 delete mProviders.take( id );
146
147 mCachedInformation.clear();
148
149 emit providerRemoved( id );
150 return true;
151}
152
153bool QgsProcessingRegistry::removeProvider( const QString &providerId )
154{
155 QgsProcessingProvider *p = providerById( providerId );
156 return removeProvider( p );
157}
158
160{
161 auto it = mProviders.constFind( id );
162 if ( it != mProviders.constEnd() )
163 return it.value();
164
165 // transparently map old references to "grass7" provider to "grass" provider
166 if ( id.compare( QLatin1String( "grass7" ), Qt::CaseInsensitive ) == 0 )
167 return providerById( QStringLiteral( "grass" ) );
168
169 return nullptr;
170}
171
172QList< const QgsProcessingAlgorithm * > QgsProcessingRegistry::algorithms() const
173{
174 QList< const QgsProcessingAlgorithm * > algs;
175 QMap<QString, QgsProcessingProvider *>::const_iterator it = mProviders.constBegin();
176 for ( ; it != mProviders.constEnd(); ++it )
177 {
178 algs.append( it.value()->algorithms() );
179 }
180 return algs;
181}
182
184{
185 const auto it = mCachedInformation.constFind( id );
186 if ( it != mCachedInformation.constEnd() )
187 return *it;
188
191 {
193 info.icon = algorithm->icon();
194 }
195 mCachedInformation.insert( id, info );
196 return info;
197}
198
200{
201 if ( constId.isEmpty() )
202 return nullptr;
203
204 // allow mapping of algorithm via registered algorithm aliases
205 const QString id = mAlgorithmAliases.value( constId, constId );
206
207 // try to match just the one target provider, if we can determine it from the id easily
208 static thread_local QRegularExpression reSplitProviderId( QStringLiteral( "^(.*?):(.*)$" ) );
209 const QRegularExpressionMatch match = reSplitProviderId.match( id );
210 if ( match.hasMatch() )
211 {
212 if ( QgsProcessingProvider *provider = providerById( match.captured( 1 ) ) )
213 {
214 if ( const QgsProcessingAlgorithm *algorithm = provider->algorithm( match.captured( 2 ) ) )
215 return algorithm;
216 }
217
218 // try mapping 'qgis' algs to 'native' algs - this allows us to freely move algorithms
219 // from the python 'qgis' provider to the c++ 'native' provider without breaking API
220 // or existing models
221 if ( match.captured( 1 ) == QLatin1String( "qgis" ) )
222 {
223 const QString algorithmName = id.mid( 5 );
224 if ( QgsProcessingProvider *provider = mProviders.value( QStringLiteral( "native" ) ) )
225 {
226 if ( const QgsProcessingAlgorithm *algorithm = provider->algorithm( algorithmName ) )
227 return algorithm;
228 }
229 }
230 }
231
232 // slow: iterate through ALL providers to find a match
233 QMap<QString, QgsProcessingProvider *>::const_iterator it = mProviders.constBegin();
234 for ( ; it != mProviders.constEnd(); ++it )
235 {
236 const QList< const QgsProcessingAlgorithm * > algorithms = it.value()->algorithms();
237 for ( const QgsProcessingAlgorithm *alg : algorithms )
238 if ( alg->id() == id )
239 return alg;
240 }
241
242 return nullptr;
243}
244
245QgsProcessingAlgorithm *QgsProcessingRegistry::createAlgorithmById( const QString &id, const QVariantMap &configuration ) const
246{
247 const QgsProcessingAlgorithm *alg = algorithmById( id );
248 if ( !alg )
249 return nullptr;
250
251 std::unique_ptr< QgsProcessingAlgorithm > creation( alg->create( configuration ) );
252 return creation.release();
253}
254
255void QgsProcessingRegistry::addAlgorithmAlias( const QString &aliasId, const QString &actualId )
256{
257 mAlgorithmAliases.insert( aliasId, actualId );
258}
259
261{
262 if ( !mParameterTypes.contains( type->id() ) )
263 {
264 mParameterTypes.insert( type->id(), type );
265 emit parameterTypeAdded( type );
266 return true;
267 }
268 else
269 {
270 QgsLogger::warning( QStringLiteral( "Duplicate parameter type %1 (\"%2\") registered" ).arg( type->id(), type->name() ) );
271
272 if ( mParameterTypes.value( type->id() ) != type )
273 delete type;
274
275 return false;
276 }
277}
278
280{
281 mParameterTypes.remove( type->id() );
282 emit parameterTypeRemoved( type );
283 delete type;
284}
285
287{
288 return mParameterTypes.value( id );
289}
290
291QList<QgsProcessingParameterType *> QgsProcessingRegistry::parameterTypes() const
292{
293 return mParameterTypes.values();
294}
static void warning(const QString &msg)
Goes to qWarning.
Contains basic properties for a Processing algorithm.
QString displayName
Algorithm display name.
Abstract base class for processing algorithms.
virtual QIcon icon() const
Returns an icon for the algorithm.
virtual QString displayName() const =0
Returns the translated algorithm name, which should be used for any user-visible display of the algor...
QgsProcessingAlgorithm * create(const QVariantMap &configuration=QVariantMap()) const
Creates a copy of the algorithm, ready for execution.
An annotation layer parameter for processing algorithms.
A authentication configuration parameter for processing algorithms.
A raster band parameter for Processing algorithms.
A boolean parameter for processing algorithms.
A color parameter for Processing algorithms.
A coordinate operation parameter for Processing algorithms.
A crs parameter for processing algorithms.
A database schema name parameter for processing algorithms.
A database table name parameter for processing algorithms.
A datetime parameter for processing algorithms.
A distance parameter for processing algorithms.
A duration parameter for processing algorithms.
An enum based parameter for processing algorithms, allowing for selection from predefined values.
An expression parameter for processing algorithms.
A rectangular map extent parameter for processing algorithms.
A feature sink parameter for Processing algorithms.
An input feature source (such as vector layers) parameter for processing algorithms.
A vector layer or feature source field parameter for processing algorithms.
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
An input file or folder parameter for processing algorithms.
A folder destination parameter, for specifying the destination path for a folder created by the algor...
A geometry parameter for processing algorithms.
A print layout item parameter for Processing algorithms.
A print layout parameter for Processing algorithms.
A generic map layer parameter for processing algorithms.
A map theme parameter for Processing algorithms.
A table (matrix) parameter for processing algorithms.
A mesh layer parameter for processing algorithms.
A parameter for processing algorithms which accepts multiple map layers.
A numeric parameter for processing algorithms.
A point cloud layer attribute parameter for Processing algorithms.
A pointcloud layer destination parameter, for specifying the destination path for a point cloud layer...
A point cloud layer parameter for processing algorithms.
A point parameter for processing algorithms.
A provider connection name parameter for processing algorithms.
A numeric range parameter for processing algorithms.
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
A raster layer parameter for processing algorithms.
A scale parameter for processing algorithms.
A string parameter for processing algorithms.
A vector layer destination parameter, for specifying the destination path for a vector layer created ...
A vector layer parameter for processing algorithms.
A vector tile layer destination parameter, for specifying the destination path for a vector tile laye...
Makes metadata of processing parameters available.
virtual QString name() const =0
A human readable and translatable short name for this parameter type.
virtual QString id() const =0
A static id for this type which will be used for storing this parameter type.
Abstract base class for processing providers.
void algorithmsLoaded()
Emitted when the provider has loaded (or refreshed) its list of available algorithms.
virtual void unload()
Unloads the provider.
virtual QString id() const =0
Returns the unique provider id, used for identifying the provider.
virtual bool load()
Loads the provider.
void removeParameterType(QgsProcessingParameterType *type)
Unregister a custom parameter type from processing.
void parameterTypeAdded(QgsProcessingParameterType *type)
Emitted when a new parameter type has been added to the registry.
QgsProcessingAlgorithm * createAlgorithmById(const QString &id, const QVariantMap &configuration=QVariantMap()) const
Creates a new instance of an algorithm by its ID.
void parameterTypeRemoved(QgsProcessingParameterType *type)
Emitted when a parameter type has been removed from the registry and is about to be deleted.
QgsProcessingAlgorithmInformation algorithmInformation(const QString &id) const
Returns basic algorithm information for the algorithm with matching ID.
QList< const QgsProcessingAlgorithm * > algorithms() const
Returns a list of all available algorithms from registered providers.
QgsProcessingParameterType * parameterType(const QString &id) const
Returns the parameter type registered for id.
bool removeProvider(QgsProcessingProvider *provider)
Removes a provider implementation from the registry (the provider object is deleted).
bool addParameterType(QgsProcessingParameterType *type)
Register a new parameter type for processing.
QgsProcessingRegistry(QObject *parent=nullptr)
Constructor for QgsProcessingRegistry.
const QgsProcessingAlgorithm * algorithmById(const QString &id) const
Finds an algorithm by its ID.
QgsProcessingProvider * providerById(const QString &id) const
Returns a matching provider by provider ID.
void providerAdded(const QString &id)
Emitted when a provider has been added to the registry.
QList< QgsProcessingParameterType * > parameterTypes() const
Returns a list with all known parameter types.
bool addProvider(QgsProcessingProvider *provider)
Add a processing provider to the registry.
void providerRemoved(const QString &id)
Emitted when a provider is removed from the registry.
void addAlgorithmAlias(const QString &aliasId, const QString &actualId)
Adds a new alias to an existing algorithm.
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into allowing algorithms to be written in pure substantial changes are required in order to port existing x Processing algorithms for QGIS x The most significant changes are outlined not GeoAlgorithm For algorithms which operate on features one by consider subclassing the QgsProcessingFeatureBasedAlgorithm class This class allows much of the boilerplate code for looping over features from a vector layer to be bypassed and instead requires implementation of a processFeature method Ensure that your algorithm(or algorithm 's parent class) implements the new pure virtual createInstance(self) call
#define SIP_TRANSFERTHIS
Definition qgis_sip.h:53