QGIS API Documentation  3.4.3-Madeira (2f64a3c)
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 
18 #include "qgsprocessingregistry.h"
19 #include "qgsvectorfilewriter.h"
21 
23  : QObject( parent )
24 {
49 }
50 
52 {
53  Q_FOREACH ( QgsProcessingProvider *p, mProviders )
54  {
55  removeProvider( p );
56  }
57 
58  const auto parameterTypes = mParameterTypes.values();
59 
61  {
62  removeParameterType( type );
63  }
64 }
65 
67 {
68  if ( !provider )
69  return false;
70 
71  if ( mProviders.contains( provider->id() ) )
72  {
73  QgsLogger::warning( QStringLiteral( "Duplicate provider %1 registered" ).arg( provider->id() ) );
74  delete provider;
75  return false;
76  }
77 
78  if ( !provider->load() )
79  {
80  QgsLogger::warning( QStringLiteral( "Provider %1 cannot load" ).arg( provider->id() ) );
81  delete provider;
82  return false;
83  }
84 
85  provider->setParent( this );
86  mProviders[ provider->id()] = provider;
87  emit providerAdded( provider->id() );
88  return true;
89 }
90 
92 {
93  if ( !provider )
94  return false;
95 
96  QString id = provider->id();
97 
98  if ( !mProviders.contains( id ) )
99  return false;
100 
101  provider->unload();
102 
103  delete mProviders.take( id );
104  emit providerRemoved( id );
105  return true;
106 }
107 
108 bool QgsProcessingRegistry::removeProvider( const QString &providerId )
109 {
110  QgsProcessingProvider *p = providerById( providerId );
111  return removeProvider( p );
112 }
113 
115 {
116  return mProviders.value( id, nullptr );
117 }
118 
119 QList< const QgsProcessingAlgorithm * > QgsProcessingRegistry::algorithms() const
120 {
121  QList< const QgsProcessingAlgorithm * > algs;
122  QMap<QString, QgsProcessingProvider *>::const_iterator it = mProviders.constBegin();
123  for ( ; it != mProviders.constEnd(); ++it )
124  {
125  algs.append( it.value()->algorithms() );
126  }
127  return algs;
128 }
129 
131 {
132  QMap<QString, QgsProcessingProvider *>::const_iterator it = mProviders.constBegin();
133  for ( ; it != mProviders.constEnd(); ++it )
134  {
135  Q_FOREACH ( const QgsProcessingAlgorithm *alg, it.value()->algorithms() )
136  if ( alg->id() == id )
137  return alg;
138  }
139 
140  // try mapping 'qgis' algs to 'native' algs - this allows us to freely move algorithms
141  // from the python 'qgis' provider to the c++ 'native' provider without breaking API
142  // or existing models
143  if ( id.startsWith( QLatin1String( "qgis:" ) ) )
144  {
145  QString newId = QStringLiteral( "native:" ) + id.mid( 5 );
146  return algorithmById( newId );
147  }
148  return nullptr;
149 }
150 
151 QgsProcessingAlgorithm *QgsProcessingRegistry::createAlgorithmById( const QString &id, const QVariantMap &configuration ) const
152 {
153  const QgsProcessingAlgorithm *alg = algorithmById( id );
154  if ( !alg )
155  return nullptr;
156 
157  std::unique_ptr< QgsProcessingAlgorithm > creation( alg->create( configuration ) );
158  return creation.release();
159 }
160 
162 {
163  if ( !mParameterTypes.contains( type->id() ) )
164  {
165  mParameterTypes.insert( type->id(), type );
166  emit parameterTypeAdded( type );
167  return true;
168  }
169  else
170  {
171  QgsLogger::warning( QStringLiteral( "Duplicate parameter type %1 (\"%2\") registered" ).arg( type->id(), type->name() ) );
172 
173  if ( mParameterTypes.value( type->id() ) != type )
174  delete type;
175 
176  return false;
177  }
178 }
179 
181 {
182  mParameterTypes.remove( type->id() );
183  emit parameterTypeRemoved( type );
184  delete type;
185 }
186 
188 {
189  return mParameterTypes.value( id );
190 }
191 
192 QList<QgsProcessingParameterType *> QgsProcessingRegistry::parameterTypes() const
193 {
194  return mParameterTypes.values();
195 }
A feature sink parameter for Processing algorithms.
A vector layer destination parameter, for specifying the destination path for a vector layer created ...
bool removeProvider(QgsProcessingProvider *provider)
Removes a provider implementation from the registry (the provider object is deleted).
QString id() const
Returns the unique ID for the algorithm, which is a combination of the algorithm provider&#39;s ID and th...
void providerAdded(const QString &id)
Emitted when a provider has been added to the registry.
#define SIP_TRANSFERTHIS
Definition: qgis_sip.h:46
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
QgsProcessingAlgorithm * create(const QVariantMap &configuration=QVariantMap()) const
Creates a copy of the algorithm, ready for execution.
static void warning(const QString &msg)
Goes to qWarning.
Definition: qgslogger.cpp:121
virtual QString id() const =0
A static id for this type which will be used for storing this parameter type.
A folder destination parameter, for specifying the destination path for a folder created by the algor...
void removeParameterType(QgsProcessingParameterType *type)
Unregister a custom parameter type from processing.
A numeric range parameter for processing algorithms.
An expression parameter for processing algorithms.
Abstract base class for processing providers.
const QgsProcessingAlgorithm * algorithmById(const QString &id) const
Finds an algorithm by its ID.
A vector layer or feature source field parameter for processing algorithms.
QgsProcessingParameterType * parameterType(const QString &id) const
Returns the parameter type registered for id.
void parameterTypeAdded(QgsProcessingParameterType *type)
Emitted when a new parameter type has been added to the registry.
A numeric parameter for processing algorithms.
A distance parameter for processing algorithms.
Abstract base class for processing algorithms.
A string parameter for processing algorithms.
bool addParameterType(QgsProcessingParameterType *type)
Register a new parameter type for processing.
QgsProcessingProvider * providerById(const QString &id)
Returns a matching provider by provider ID.
A vector layer parameter for processing algorithms.
A boolean parameter for processing algorithms.
A generic map layer parameter for processing algorithms.
An input file or folder parameter for processing algorithms.
void providerRemoved(const QString &id)
Emitted when a provider is removed from the registry.
A raster layer parameter for processing algorithms.
QList< const QgsProcessingAlgorithm * > algorithms() const
Returns a list of all available algorithms from registered providers.
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
virtual QString id() const =0
Returns the unique provider id, used for identifying the provider.
virtual QString name() const =0
A human readable and translatable short name for this parameter type.
QgsProcessingRegistry(QObject *parent=nullptr)
Constructor for QgsProcessingRegistry.
virtual bool load()
Loads the provider.
QgsProcessingAlgorithm * createAlgorithmById(const QString &id, const QVariantMap &configuration=QVariantMap()) const
Creates a new instance of an algorithm by its ID.
A point parameter for processing algorithms.
bool addProvider(QgsProcessingProvider *provider)
Add a processing provider to the registry.
A table (matrix) parameter for processing algorithms.
A parameter for processing algorithms which accepts multiple map layers.
A crs parameter for processing algorithms.
Makes metadata of processing parameters available.
void parameterTypeRemoved(QgsProcessingParameterType *type)
Emitted when a parameter type has been removed from the registry and is about to be deleted...
An input feature source (such as vector layers) parameter for processing algorithms.
A rectangular map extent parameter for processing algorithms.
QList< QgsProcessingParameterType * > parameterTypes() const
Returns a list with all known parameter types.
An enum based parameter for processing algorithms, allowing for selection from predefined values...
virtual void unload()
Unloads the provider.
A raster band parameter for Processing algorithms.