Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgsprocessingparameters.h
3 : : -------------------------
4 : : begin : April 2017
5 : : copyright : (C) 2017 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 : : #ifndef QGSPROCESSINGPARAMETERS_H
19 : : #define QGSPROCESSINGPARAMETERS_H
20 : :
21 : : #include "qgis_core.h"
22 : : #include "qgis.h"
23 : : #include "qgsprocessing.h"
24 : : #include "qgsproperty.h"
25 : : #include "qgscoordinatereferencesystem.h"
26 : : #include "qgsfeaturesource.h"
27 : : #include "qgsprocessingutils.h"
28 : : #include "qgsfilefiltergenerator.h"
29 : : #include "qgsremappingproxyfeaturesink.h"
30 : : #include <QMap>
31 : : #include <limits>
32 : :
33 : : class QgsProcessingContext;
34 : : class QgsProcessingAlgorithm;
35 : : class QgsRasterLayer;
36 : : class QgsMeshLayer;
37 : : class QgsVectorLayer;
38 : : class QgsFeatureSink;
39 : : class QgsProcessingFeatureSource;
40 : : class QgsProcessingOutputDefinition;
41 : : class QgsProcessingFeedback;
42 : : class QgsProcessingProvider;
43 : : class QgsPrintLayout;
44 : : class QgsLayoutItem;
45 : :
46 : : /**
47 : : * \class QgsProcessingFeatureSourceDefinition
48 : : * \ingroup core
49 : : *
50 : : * \brief Encapsulates settings relating to a feature source input to a processing algorithm.
51 : : *
52 : : * \since QGIS 3.0
53 : : */
54 : :
55 : 0 : class CORE_EXPORT QgsProcessingFeatureSourceDefinition
56 : : {
57 : : public:
58 : :
59 : : /**
60 : : * Flags which control source behavior.
61 : : * \since QGIS 3.14
62 : : */
63 : : enum Flag
64 : : {
65 : : FlagOverrideDefaultGeometryCheck = 1 << 0, //!< If set, the default geometry check method (as dictated by QgsProcessingContext) will be overridden for this source
66 : : FlagCreateIndividualOutputPerInputFeature = 1 << 1, //!< If set, every feature processed from this source will be placed into its own individually created output destination. Support for this flag depends on how an algorithm is executed.
67 : : };
68 : : Q_DECLARE_FLAGS( Flags, Flag )
69 : :
70 : : /**
71 : : * Constructor for QgsProcessingFeatureSourceDefinition, accepting a static string \a source.
72 : : *
73 : : * If \a selectedFeaturesOnly is TRUE, then only selected features from the source will be used.
74 : : *
75 : : * The optional \a featureLimit can be set to a value > 0 to place a hard limit on the maximum number
76 : : * of features which will be read from the source.
77 : : *
78 : : * The \a flags argument can be used to specify flags which dictate the source behavior.
79 : : *
80 : : * If the QgsProcessingFeatureSourceDefinition::Flag::FlagOverrideDefaultGeometryCheck is set in \a flags, then the value of \a geometryCheck will override
81 : : * the default geometry check method (as dictated by QgsProcessingContext) for this source.
82 : : */
83 : 0 : QgsProcessingFeatureSourceDefinition( const QString &source = QString(), bool selectedFeaturesOnly = false, long long featureLimit = -1,
84 : : QgsProcessingFeatureSourceDefinition::Flags flags = QgsProcessingFeatureSourceDefinition::Flags(), QgsFeatureRequest::InvalidGeometryCheck geometryCheck = QgsFeatureRequest::GeometryAbortOnInvalid )
85 : 0 : : source( QgsProperty::fromValue( source ) )
86 : 0 : , selectedFeaturesOnly( selectedFeaturesOnly )
87 : 0 : , featureLimit( featureLimit )
88 : 0 : , flags( flags )
89 : 0 : , geometryCheck( geometryCheck )
90 : 0 : {}
91 : :
92 : : /**
93 : : * Constructor for QgsProcessingFeatureSourceDefinition, accepting a QgsProperty source.
94 : : *
95 : : * If \a selectedFeaturesOnly is TRUE, then only selected features from the source will be used.
96 : : *
97 : : * The optional \a featureLimit can be set to a value > 0 to place a hard limit on the maximum number
98 : : * of features which will be read from the source.
99 : : *
100 : : * The \a flags argument can be used to specify flags which dictate the source behavior.
101 : : *
102 : : * If the QgsProcessingFeatureSourceDefinition::Flag::FlagOverrideDefaultGeometryCheck is set in \a flags, then the value of \a geometryCheck will override
103 : : * the default geometry check method (as dictated by QgsProcessingContext) for this source.
104 : : */
105 : : QgsProcessingFeatureSourceDefinition( const QgsProperty &source, bool selectedFeaturesOnly = false, long long featureLimit = -1,
106 : : QgsProcessingFeatureSourceDefinition::Flags flags = QgsProcessingFeatureSourceDefinition::Flags(), QgsFeatureRequest::InvalidGeometryCheck geometryCheck = QgsFeatureRequest::GeometryAbortOnInvalid )
107 : : : source( source )
108 : : , selectedFeaturesOnly( selectedFeaturesOnly )
109 : : , featureLimit( featureLimit )
110 : : , flags( flags )
111 : : , geometryCheck( geometryCheck )
112 : : {}
113 : :
114 : : /**
115 : : * Source definition. Usually a static property set to a source layer's ID or file name.
116 : : */
117 : : QgsProperty source;
118 : :
119 : : /**
120 : : * TRUE if only selected features in the source should be used by algorithms.
121 : : */
122 : : bool selectedFeaturesOnly;
123 : :
124 : : /**
125 : : * If set to a value > 0, places a limit on the maximum number of features which will be
126 : : * read from the source.
127 : : *
128 : : * \since QGIS 3.14
129 : : */
130 : : long long featureLimit = -1;
131 : :
132 : : /**
133 : : * Flags which dictate source behavior.
134 : : *
135 : : * \since QGIS 3.14
136 : : */
137 : : Flags flags = Flags();
138 : :
139 : : /**
140 : : * Geometry check method to apply to this source. This setting is only
141 : : * utilized if the QgsProcessingFeatureSourceDefinition::Flag::FlagCreateIndividualOutputPerInputFeature is
142 : : * set in QgsProcessingFeatureSourceDefinition::flags.
143 : : *
144 : : * \see overrideDefaultGeometryCheck
145 : : * \since QGIS 3.14
146 : : */
147 : : QgsFeatureRequest::InvalidGeometryCheck geometryCheck = QgsFeatureRequest::GeometryAbortOnInvalid;
148 : :
149 : : /**
150 : : * Saves this source definition to a QVariantMap, wrapped in a QVariant.
151 : : * You can use QgsXmlUtils::writeVariant to save it to an XML document.
152 : : * \see loadVariant()
153 : : * \since QGIS 3.14
154 : : */
155 : : QVariant toVariant() const;
156 : :
157 : : /**
158 : : * Loads this source definition from a QVariantMap, wrapped in a QVariant.
159 : : * You can use QgsXmlUtils::readVariant to load it from an XML document.
160 : : * \see toVariant()
161 : : * \since QGIS 3.14
162 : : */
163 : : bool loadVariant( const QVariantMap &map );
164 : :
165 : 0 : bool operator==( const QgsProcessingFeatureSourceDefinition &other ) const
166 : : {
167 : 0 : return source == other.source
168 : 0 : && selectedFeaturesOnly == other.selectedFeaturesOnly
169 : 0 : && featureLimit == other.featureLimit
170 : 0 : && flags == other.flags
171 : 0 : && geometryCheck == other.geometryCheck;
172 : : }
173 : :
174 : : bool operator!=( const QgsProcessingFeatureSourceDefinition &other ) const
175 : : {
176 : : return !( *this == other );
177 : : }
178 : :
179 : : //! Allows direct construction of QVariants.
180 : 0 : operator QVariant() const
181 : : {
182 : 0 : return QVariant::fromValue( *this );
183 : : }
184 : :
185 : : };
186 : :
187 : 10 : Q_DECLARE_METATYPE( QgsProcessingFeatureSourceDefinition )
188 : : Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProcessingFeatureSourceDefinition::Flags )
189 : :
190 : : /**
191 : : * \class QgsProcessingOutputLayerDefinition
192 : : * \ingroup core
193 : : *
194 : : * \brief Encapsulates settings relating to a feature sink or output raster layer for a processing algorithm.
195 : : *
196 : : * \since QGIS 3.0
197 : : */
198 : :
199 : 0 : class CORE_EXPORT QgsProcessingOutputLayerDefinition
200 : : {
201 : : public:
202 : :
203 : : /**
204 : : * Constructor for QgsProcessingOutputLayerDefinition, accepting a static sink/layer string.
205 : : * The \a destinationProject parameter can be set to a QgsProject instance in which
206 : : * to automatically load the resulting sink/layer after completing processing.
207 : : */
208 : 0 : QgsProcessingOutputLayerDefinition( const QString &sink = QString(), QgsProject *destinationProject = nullptr )
209 : 0 : : sink( QgsProperty::fromValue( sink ) )
210 : 0 : , destinationProject( destinationProject )
211 : 0 : {}
212 : :
213 : : /**
214 : : * Constructor for QgsProcessingOutputLayerDefinition, accepting a QgsProperty sink/layer.
215 : : * The \a destinationProject parameter can be set to a QgsProject instance in which
216 : : * to automatically load the resulting sink/layer after completing processing.
217 : : */
218 : : QgsProcessingOutputLayerDefinition( const QgsProperty &sink, QgsProject *destinationProject = nullptr )
219 : : : sink( sink )
220 : : , destinationProject( destinationProject )
221 : : {}
222 : :
223 : : /**
224 : : * Sink/layer definition. Usually a static property set to the destination file name for the sink's layer.
225 : : */
226 : : QgsProperty sink;
227 : :
228 : : /**
229 : : * Destination project. Can be set to a QgsProject instance in which
230 : : * to automatically load the resulting sink/layer after completing processing.
231 : : * The default behavior is not to load the result into any project (NULLPTR).
232 : : */
233 : : QgsProject *destinationProject = nullptr;
234 : :
235 : : /**
236 : : * Name to use for sink if it's to be loaded into a destination project.
237 : : */
238 : : QString destinationName;
239 : :
240 : : /**
241 : : * Map of optional sink/layer creation options, which
242 : : * are passed to the underlying provider when creating new layers. Known options also
243 : : * include 'fileEncoding', which is used to specify a file encoding to use for created
244 : : * files.
245 : : */
246 : : QVariantMap createOptions;
247 : :
248 : : /**
249 : : * Returns TRUE if the output uses a remapping definition.
250 : : *
251 : : * \see remappingDefinition()
252 : : * \since QGIS 3.14
253 : : */
254 : 0 : bool useRemapping() const { return mUseRemapping; }
255 : :
256 : : /**
257 : : * Returns the output remapping definition, if useRemapping() is TRUE.
258 : : *
259 : : * \see useRemapping()
260 : : * \see setRemappingDefinition()
261 : : * \since QGIS 3.14
262 : : */
263 : 0 : QgsRemappingSinkDefinition remappingDefinition() const { return mRemappingDefinition; }
264 : :
265 : : /**
266 : : * Sets the remapping \a definition to use when adding features to the output layer.
267 : : *
268 : : * Calling this method will set useRemapping() to TRUE.
269 : : *
270 : : * \see remappingDefinition()
271 : : * \see useRemapping()
272 : : *
273 : : * \since QGIS 3.14
274 : : */
275 : : void setRemappingDefinition( const QgsRemappingSinkDefinition &definition );
276 : :
277 : : /**
278 : : * Saves this output layer definition to a QVariantMap, wrapped in a QVariant.
279 : : * You can use QgsXmlUtils::writeVariant to save it to an XML document.
280 : : * \see loadVariant()
281 : : * \since QGIS 3.2
282 : : */
283 : : QVariant toVariant() const;
284 : :
285 : : /**
286 : : * Loads this output layer definition from a QVariantMap, wrapped in a QVariant.
287 : : * You can use QgsXmlUtils::readVariant to load it from an XML document.
288 : : * \see toVariant()
289 : : * \since QGIS 3.2
290 : : */
291 : : bool loadVariant( const QVariantMap &map );
292 : :
293 : : //! Allows direct construction of QVariants.
294 : 0 : operator QVariant() const
295 : : {
296 : 0 : return QVariant::fromValue( *this );
297 : : }
298 : :
299 : : bool operator==( const QgsProcessingOutputLayerDefinition &other ) const;
300 : : bool operator!=( const QgsProcessingOutputLayerDefinition &other ) const;
301 : :
302 : : private:
303 : :
304 : 0 : bool mUseRemapping = false;
305 : : QgsRemappingSinkDefinition mRemappingDefinition;
306 : :
307 : : };
308 : :
309 : 5 : Q_DECLARE_METATYPE( QgsProcessingOutputLayerDefinition )
310 : :
311 : :
312 : :
313 : :
314 : : //
315 : : // Parameter definitions
316 : : //
317 : :
318 : : /**
319 : : * \class QgsProcessingParameterDefinition
320 : : * \ingroup core
321 : : *
322 : : * \brief Base class for the definition of processing parameters.
323 : : *
324 : : * Parameter definitions encapsulate properties regarding the behavior of parameters,
325 : : * their acceptable ranges, defaults, etc.
326 : : *
327 : : * \since QGIS 3.0
328 : : */
329 : :
330 : 0 : class CORE_EXPORT QgsProcessingParameterDefinition
331 : : {
332 : :
333 : : #ifdef SIP_RUN
334 : : % TypeHeaderCode
335 : : #include "qgsprocessingparameteraggregate.h"
336 : : #include "qgsprocessingparameterdxflayers.h"
337 : : #include "qgsprocessingparameterfieldmap.h"
338 : : #include "qgsprocessingparametertininputlayers.h"
339 : : #include "qgsprocessingparametervectortilewriterlayers.h"
340 : : #include "qgsprocessingparametermeshdataset.h"
341 : : % End
342 : : SIP_CONVERT_TO_SUBCLASS_CODE
343 : : if ( sipCpp->type() == QgsProcessingParameterBoolean::typeName() )
344 : : sipType = sipType_QgsProcessingParameterBoolean;
345 : : else if ( sipCpp->type() == QgsProcessingParameterCrs::typeName() )
346 : : sipType = sipType_QgsProcessingParameterCrs;
347 : : else if ( sipCpp->type() == QgsProcessingParameterMapLayer::typeName() )
348 : : sipType = sipType_QgsProcessingParameterMapLayer;
349 : : else if ( sipCpp->type() == QgsProcessingParameterExtent::typeName() )
350 : : sipType = sipType_QgsProcessingParameterExtent;
351 : : else if ( sipCpp->type() == QgsProcessingParameterPoint::typeName() )
352 : : sipType = sipType_QgsProcessingParameterPoint;
353 : : else if ( sipCpp->type() == QgsProcessingParameterGeometry::typeName() )
354 : : sipType = sipType_QgsProcessingParameterGeometry;
355 : : else if ( sipCpp->type() == QgsProcessingParameterFile::typeName() )
356 : : sipType = sipType_QgsProcessingParameterFile;
357 : : else if ( sipCpp->type() == QgsProcessingParameterMatrix::typeName() )
358 : : sipType = sipType_QgsProcessingParameterMatrix;
359 : : else if ( sipCpp->type() == QgsProcessingParameterMultipleLayers::typeName() )
360 : : sipType = sipType_QgsProcessingParameterMultipleLayers;
361 : : else if ( sipCpp->type() == QgsProcessingParameterNumber::typeName() )
362 : : sipType = sipType_QgsProcessingParameterNumber;
363 : : else if ( sipCpp->type() == QgsProcessingParameterDistance::typeName() )
364 : : sipType = sipType_QgsProcessingParameterDistance;
365 : : else if ( sipCpp->type() == QgsProcessingParameterScale::typeName() )
366 : : sipType = sipType_QgsProcessingParameterScale;
367 : : else if ( sipCpp->type() == QgsProcessingParameterRange::typeName() )
368 : : sipType = sipType_QgsProcessingParameterRange;
369 : : else if ( sipCpp->type() == QgsProcessingParameterRasterLayer::typeName() )
370 : : sipType = sipType_QgsProcessingParameterRasterLayer;
371 : : else if ( sipCpp->type() == QgsProcessingParameterMeshLayer::typeName() )
372 : : sipType = sipType_QgsProcessingParameterMeshLayer;
373 : : else if ( sipCpp->type() == QgsProcessingParameterEnum::typeName() )
374 : : sipType = sipType_QgsProcessingParameterEnum;
375 : : else if ( sipCpp->type() == QgsProcessingParameterString::typeName() )
376 : : sipType = sipType_QgsProcessingParameterString;
377 : : else if ( sipCpp->type() == QgsProcessingParameterExpression::typeName() )
378 : : sipType = sipType_QgsProcessingParameterExpression;
379 : : else if ( sipCpp->type() == QgsProcessingParameterAuthConfig::typeName() )
380 : : sipType = sipType_QgsProcessingParameterAuthConfig;
381 : : else if ( sipCpp->type() == QgsProcessingParameterVectorLayer::typeName() )
382 : : sipType = sipType_QgsProcessingParameterVectorLayer;
383 : : else if ( sipCpp->type() == QgsProcessingParameterField::typeName() )
384 : : sipType = sipType_QgsProcessingParameterField;
385 : : else if ( sipCpp->type() == QgsProcessingParameterFeatureSource::typeName() )
386 : : sipType = sipType_QgsProcessingParameterFeatureSource;
387 : : else if ( sipCpp->type() == QgsProcessingParameterFeatureSink::typeName() )
388 : : sipType = sipType_QgsProcessingParameterFeatureSink;
389 : : else if ( sipCpp->type() == QgsProcessingParameterVectorDestination::typeName() )
390 : : sipType = sipType_QgsProcessingParameterVectorDestination;
391 : : else if ( sipCpp->type() == QgsProcessingParameterRasterDestination::typeName() )
392 : : sipType = sipType_QgsProcessingParameterRasterDestination;
393 : : else if ( sipCpp->type() == QgsProcessingParameterFileDestination::typeName() )
394 : : sipType = sipType_QgsProcessingParameterFileDestination;
395 : : else if ( sipCpp->type() == QgsProcessingParameterFolderDestination::typeName() )
396 : : sipType = sipType_QgsProcessingParameterFolderDestination;
397 : : else if ( sipCpp->type() == QgsProcessingParameterBand::typeName() )
398 : : sipType = sipType_QgsProcessingParameterBand;
399 : : else if ( sipCpp->type() == QgsProcessingParameterLayout::typeName() )
400 : : sipType = sipType_QgsProcessingParameterLayout;
401 : : else if ( sipCpp->type() == QgsProcessingParameterLayoutItem::typeName() )
402 : : sipType = sipType_QgsProcessingParameterLayoutItem;
403 : : else if ( sipCpp->type() == QgsProcessingParameterColor::typeName() )
404 : : sipType = sipType_QgsProcessingParameterColor;
405 : : else if ( sipCpp->type() == QgsProcessingParameterCoordinateOperation::typeName() )
406 : : sipType = sipType_QgsProcessingParameterCoordinateOperation;
407 : : else if ( sipCpp->type() == QgsProcessingParameterMapTheme::typeName() )
408 : : sipType = sipType_QgsProcessingParameterMapTheme;
409 : : else if ( sipCpp->type() == QgsProcessingParameterDateTime::typeName() )
410 : : sipType = sipType_QgsProcessingParameterDateTime;
411 : : else if ( sipCpp->type() == QgsProcessingParameterProviderConnection::typeName() )
412 : : sipType = sipType_QgsProcessingParameterProviderConnection;
413 : : else if ( sipCpp->type() == QgsProcessingParameterDatabaseSchema::typeName() )
414 : : sipType = sipType_QgsProcessingParameterDatabaseSchema;
415 : : else if ( sipCpp->type() == QgsProcessingParameterDatabaseTable::typeName() )
416 : : sipType = sipType_QgsProcessingParameterDatabaseTable;
417 : : else if ( sipCpp->type() == QgsProcessingParameterFieldMapping::typeName() )
418 : : sipType = sipType_QgsProcessingParameterFieldMapping;
419 : : else if ( sipCpp->type() == QgsProcessingParameterTinInputLayers::typeName() )
420 : : sipType = sipType_QgsProcessingParameterTinInputLayers;
421 : : else if ( sipCpp->type() == QgsProcessingParameterVectorTileWriterLayers::typeName() )
422 : : sipType = sipType_QgsProcessingParameterVectorTileWriterLayers;
423 : : else if ( sipCpp->type() == QgsProcessingParameterDxfLayers::typeName() )
424 : : sipType = sipType_QgsProcessingParameterDxfLayers;
425 : : else if ( sipCpp->type() == QgsProcessingParameterMeshDatasetGroups::typeName() )
426 : : sipType = sipType_QgsProcessingParameterMeshDatasetGroups;
427 : : else if ( sipCpp->type() == QgsProcessingParameterMeshDatasetTime::typeName() )
428 : : sipType = sipType_QgsProcessingParameterMeshDatasetTime;
429 : : else
430 : : sipType = nullptr;
431 : : SIP_END
432 : : #endif
433 : :
434 : : public:
435 : :
436 : : //! Parameter flags
437 : : enum Flag
438 : : {
439 : : FlagAdvanced = 1 << 1, //!< Parameter is an advanced parameter which should be hidden from users by default
440 : : FlagHidden = 1 << 2, //!< Parameter is hidden and should not be shown to users
441 : : FlagOptional = 1 << 3, //!< Parameter is optional
442 : : FlagIsModelOutput = 1 << 4, //!< Destination parameter is final output. The parameter name will be used.
443 : : };
444 : : Q_DECLARE_FLAGS( Flags, Flag )
445 : :
446 : : /**
447 : : * Constructor for QgsProcessingParameterDefinition.
448 : : */
449 : : QgsProcessingParameterDefinition( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
450 : : bool optional = false, const QString &help = QString() );
451 : :
452 : 5 : virtual ~QgsProcessingParameterDefinition() = default;
453 : :
454 : : /**
455 : : * Creates a clone of the parameter definition.
456 : : */
457 : : virtual QgsProcessingParameterDefinition *clone() const = 0 SIP_FACTORY;
458 : :
459 : : /**
460 : : * Unique parameter type name.
461 : : */
462 : : virtual QString type() const = 0;
463 : :
464 : : /**
465 : : * Returns TRUE if this parameter represents a file or layer destination, e.g. parameters
466 : : * which are used for the destination for layers output by an algorithm will return
467 : : * TRUE.
468 : : */
469 : 0 : virtual bool isDestination() const { return false; }
470 : :
471 : : /**
472 : : * Returns the name of the parameter. This is the internal identifier by which
473 : : * algorithms access this parameter.
474 : : * \see setName()
475 : : */
476 : 0 : QString name() const { return mName; }
477 : :
478 : : /**
479 : : * Sets the \a name of the parameter. This is the internal identifier by which
480 : : * algorithms access this parameter.
481 : : * \see name()
482 : : */
483 : 0 : void setName( const QString &name ) { mName = name; }
484 : :
485 : : /**
486 : : * Returns the description for the parameter. This is the user-visible string
487 : : * used to identify this parameter.
488 : : * \see setDescription()
489 : : */
490 : 0 : QString description() const { return mDescription; }
491 : :
492 : : /**
493 : : * Sets the \a description for the parameter. This is the user-visible string
494 : : * used to identify this parameter.
495 : : * \see description()
496 : : */
497 : 0 : void setDescription( const QString &description ) { mDescription = description; }
498 : :
499 : : /**
500 : : * Returns the help for the parameter.
501 : : *
502 : : * This is a descriptive (possibly lengthy), translated string explaining
503 : : * the parameter's behavior and use in depth.
504 : : *
505 : : * \see setHelp()
506 : : * \since QGIS 3.16
507 : : */
508 : 0 : QString help() const { return mHelp; }
509 : :
510 : : /**
511 : : * Sets the \a help for the parameter.
512 : : *
513 : : * The \a help string should be a descriptive, translated string explaining
514 : : * the parameter's behavior and use in depth.
515 : : *
516 : : * \see help()
517 : : * \since QGIS 3.16
518 : : */
519 : 0 : void setHelp( const QString &help ) { mHelp = help; }
520 : :
521 : : /**
522 : : * Returns the default value for the parameter.
523 : : * \see setDefaultValue()
524 : : * \see defaultValueForGui()
525 : : * \see guiDefaultValueOverride()
526 : : */
527 : 0 : QVariant defaultValue() const { return mDefault; }
528 : :
529 : : /**
530 : : * Sets the default \a value for the parameter. Caller takes responsibility
531 : : * to ensure that \a value is a valid input for the parameter subclass.
532 : : * \see defaultValue()
533 : : * \see setGuiDefaultValueOverride()
534 : : */
535 : 0 : void setDefaultValue( const QVariant &value ) { mDefault = value; }
536 : :
537 : : /**
538 : : * Returns the default value to use in the GUI for the parameter.
539 : : *
540 : : * Usually this will return an invalid variant, which indicates that the standard defaultValue()
541 : : * will be used in the GUI.
542 : : *
543 : : * \see defaultValue()
544 : : * \see setGuiDefaultValueOverride()
545 : : * \see defaultValueForGui()
546 : : *
547 : : * \since QGIS 3.18
548 : : */
549 : : QVariant guiDefaultValueOverride() const { return mGuiDefault; }
550 : :
551 : : /**
552 : : * Sets the default \a value to use for the parameter in GUI widgets. Caller takes responsibility
553 : : * to ensure that \a value is a valid input for the parameter subclass.
554 : : *
555 : : * Usually the guiDefaultValueOverride() is a invalid variant, which indicates that the standard defaultValue()
556 : : * should be used in the GUI. In cases where it is decided that a previous default value was inappropriate,
557 : : * setting a non-invalid default GUI value can be used to change the default value for the parameter shown
558 : : * to users when running algorithms without changing the actual defaultValue() and potentially breaking
559 : : * third party scripts.
560 : : *
561 : : * \see guiDefaultValueOverride()
562 : : * \see setDefaultValue()
563 : : *
564 : : * \since QGIS 3.18
565 : : */
566 : : void setGuiDefaultValueOverride( const QVariant &value ) { mGuiDefault = value; }
567 : :
568 : : /**
569 : : * Returns the default value to use for the parameter in a GUI.
570 : : *
571 : : * This will be the parameter's defaultValue(), unless a guiDefaultValueOverride() is set to
572 : : * override that.
573 : : *
574 : : * \since QGIS 3.18
575 : : */
576 : : QVariant defaultValueForGui() const { return mGuiDefault.isValid() ? mGuiDefault : mDefault; }
577 : :
578 : : /**
579 : : * Returns any flags associated with the parameter.
580 : : * \see setFlags()
581 : : */
582 : 0 : Flags flags() const { return mFlags; }
583 : :
584 : : /**
585 : : * Sets the \a flags associated with the parameter.
586 : : * \see flags()
587 : : */
588 : 0 : void setFlags( Flags flags ) { mFlags = flags; }
589 : :
590 : : /**
591 : : * Checks whether the specified \a input value is acceptable for the
592 : : * parameter. Returns TRUE if the value can be accepted.
593 : : * The optional \a context parameter can be specified to allow a more stringent
594 : : * check to be performed, capable of checking for the presence of required
595 : : * layers and other factors within the context.
596 : : */
597 : : virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const;
598 : :
599 : : /**
600 : : * Returns a string version of the parameter input \a value, which is suitable for use as an input
601 : : * parameter value when running an algorithm directly from a Python command.
602 : : */
603 : : virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
604 : :
605 : : /**
606 : : * Returns a Python comment explaining a parameter \a value, or an empty string if no comment is required.
607 : : *
608 : : * \since QGIS 3.20
609 : : */
610 : : virtual QString valueAsPythonComment( const QVariant &value, QgsProcessingContext &context ) const;
611 : :
612 : : /**
613 : : * Returns the parameter definition encoded in a string which can be used within a
614 : : * Processing script.
615 : : */
616 : : virtual QString asScriptCode() const;
617 : :
618 : : /**
619 : : * Returns the parameter definition as a Python command which can be used within a
620 : : * Python Processing script.
621 : : *
622 : : * The \a outputType argument specifies the desired output format for the Python string,
623 : : * i.e. the intended end use of the generated Python code.
624 : : *
625 : : * \since QGIS 3.6
626 : : */
627 : : virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
628 : :
629 : : /**
630 : : * Saves this parameter to a QVariantMap. Subclasses should ensure that they call the base class
631 : : * method and then extend the result with additional properties.
632 : : * \see fromVariantMap()
633 : : */
634 : : virtual QVariantMap toVariantMap() const;
635 : :
636 : : /**
637 : : * Restores this parameter to a QVariantMap. Subclasses should ensure that they call the base class
638 : : * method.
639 : : * \see toVariantMap()
640 : : */
641 : : virtual bool fromVariantMap( const QVariantMap &map );
642 : :
643 : : /**
644 : : * Returns the parameter's freeform metadata. This is mostly used by parameter widget wrappers
645 : : * in order to customize their appearance and behavior.
646 : : * \see setMetadata()
647 : : * \note not available in Python bindings.
648 : : */
649 : : SIP_SKIP QVariantMap metadata() const { return mMetadata; }
650 : :
651 : : /**
652 : : * Returns the parameter's freeform metadata. This is mostly used by parameter widget wrappers
653 : : * in order to customize their appearance and behavior.
654 : : * \see setMetadata()
655 : : */
656 : : QVariantMap &metadata() { return mMetadata; }
657 : :
658 : : /**
659 : : * Sets the parameter's freeform \a metadata. This is mostly used by parameter widget wrappers
660 : : * in order to customize their appearance and behavior.
661 : : * \see metadata()
662 : : */
663 : 0 : void setMetadata( const QVariantMap &metadata ) { mMetadata = metadata; }
664 : :
665 : : /**
666 : : * Returns a list of other parameter names on which this parameter is dependent (e.g.
667 : : * field parameters which depend on a parent layer parameter).
668 : : */
669 : 0 : virtual QStringList dependsOnOtherParameters() const { return QStringList(); }
670 : :
671 : : /**
672 : : * Returns a pointer to the algorithm which owns this parameter. May be NULLPTR
673 : : * for non-owned parameters.
674 : : * \see provider()
675 : : */
676 : : QgsProcessingAlgorithm *algorithm() const;
677 : :
678 : : /**
679 : : * Returns a pointer to the provider for the algorithm which owns this parameter. May be NULLPTR
680 : : * for non-owned parameters or algorithms.
681 : : * \see algorithm()
682 : : */
683 : : QgsProcessingProvider *provider() const;
684 : :
685 : : /**
686 : : * Returns a formatted tooltip for use with the parameter, which gives helpful information
687 : : * like parameter description, ID, and extra content like default values (depending on parameter type).
688 : : */
689 : : virtual QString toolTip() const;
690 : :
691 : : /**
692 : : * Returns TRUE if the parameter supports is dynamic, and can support data-defined values
693 : : * (i.e. QgsProperty based values).
694 : : * \see setIsDynamic()
695 : : * \see dynamicPropertyDefinition()
696 : : * \see dynamicLayerParameterName()
697 : : */
698 : : bool isDynamic() const { return mIsDynamic; }
699 : :
700 : : /**
701 : : * Sets whether the parameter is \a dynamic, and can support data-defined values
702 : : * (i.e. QgsProperty based values).
703 : : * \see isDynamic()
704 : : * \see setDynamicPropertyDefinition()
705 : : * \see setDynamicLayerParameterName()
706 : : */
707 : 0 : void setIsDynamic( bool dynamic ) { mIsDynamic = dynamic; }
708 : :
709 : : /**
710 : : * Returns the property definition for dynamic properties.
711 : : * \see isDynamic()
712 : : * \see setDynamicPropertyDefinition()
713 : : * \see dynamicLayerParameterName()
714 : : */
715 : : QgsPropertyDefinition dynamicPropertyDefinition() const { return mPropertyDefinition; }
716 : :
717 : : /**
718 : : * Sets the property \a definition for dynamic properties.
719 : : * \see isDynamic()
720 : : * \see dynamicPropertyDefinition()
721 : : * \see setDynamicLayerParameterName()
722 : : */
723 : 0 : void setDynamicPropertyDefinition( const QgsPropertyDefinition &definition ) { mPropertyDefinition = definition; }
724 : :
725 : : /**
726 : : * Returns the name of the parameter for a layer linked to a dynamic parameter, or an empty string if this is not set.
727 : : *
728 : : * Dynamic parameters (see isDynamic()) can have an optional vector layer parameter linked to them,
729 : : * which indicates which layer the fields and values will be available from when evaluating
730 : : * the dynamic parameter.
731 : : *
732 : : * \see setDynamicLayerParameterName()
733 : : * \see isDynamic()
734 : : * \see dynamicPropertyDefinition()
735 : : */
736 : : QString dynamicLayerParameterName() const { return mDynamicLayerParameterName; }
737 : :
738 : : /**
739 : : * Sets the \a name for the parameter for a layer linked to a dynamic parameter, or an empty string if this is not set.
740 : : *
741 : : * Dynamic parameters (see isDynamic()) can have an optional vector layer parameter linked to them,
742 : : * which indicates which layer the fields and values will be available from when evaluating
743 : : * the dynamic parameter.
744 : : *
745 : : * \see dynamicLayerParameterName()
746 : : * \see isDynamic()
747 : : * \see setDynamicPropertyDefinition()
748 : : */
749 : 0 : void setDynamicLayerParameterName( const QString &name ) { mDynamicLayerParameterName = name; }
750 : :
751 : : /**
752 : : * Returns a list of additional expression context variables which are available for use when evaluating
753 : : * this parameter.
754 : : *
755 : : * The additional variables will be added to the variables exposed from the usual expression
756 : : * context available to the parameter. They can be used to expose variables which are ONLY available
757 : : * to this parameter.
758 : : *
759 : : * The returned list should contain the variable names only, without the usual "@" prefix.
760 : : *
761 : : * \see setAdditionalExpressionContextVariables()
762 : : * \since QGIS 3.8
763 : : */
764 : : QStringList additionalExpressionContextVariables() const { return mAdditionalExpressionVariables; }
765 : :
766 : : /**
767 : : * Sets a list of additional expression context \a variables which are available for use when evaluating
768 : : * this parameter.
769 : : *
770 : : * The additional variables will be added to the variables exposed from the usual expression
771 : : * context available to the parameter. They can be used to expose variables which are ONLY available
772 : : * to this parameter.
773 : : *
774 : : * The \a variables list should contain the variable names only, without the usual "@" prefix.
775 : : *
776 : : * \note Specifying variables via this method is for metadata purposes only. It is the algorithm's responsibility
777 : : * to correctly set the value of these additional variables in all expression context used when evaluating the parameter,
778 : : * in whichever way is appropriate for that particular variable.
779 : : *
780 : : * \see additionalExpressionContextVariables()
781 : : * \since QGIS 3.8
782 : : */
783 : : void setAdditionalExpressionContextVariables( const QStringList &variables ) { mAdditionalExpressionVariables = variables; }
784 : :
785 : : protected:
786 : :
787 : : //! Parameter name
788 : : QString mName;
789 : :
790 : : //! Parameter description
791 : : QString mDescription;
792 : :
793 : : //! Parameter help
794 : : QString mHelp;
795 : :
796 : : //! Default value for parameter
797 : : QVariant mDefault;
798 : :
799 : : //! Default value for parameter in GUI
800 : : QVariant mGuiDefault;
801 : :
802 : : //! Parameter flags
803 : : Flags mFlags;
804 : :
805 : : //! Freeform metadata for parameter. Mostly used by widget wrappers to customize their appearance and behavior.
806 : : QVariantMap mMetadata;
807 : :
808 : : //! Pointer to algorithm which owns this parameter
809 : : QgsProcessingAlgorithm *mAlgorithm = nullptr;
810 : :
811 : : //! True for dynamic parameters, which can have data-defined (QgsProperty) based values
812 : : bool mIsDynamic = false;
813 : :
814 : : //! Data defined property definition
815 : : QgsPropertyDefinition mPropertyDefinition;
816 : :
817 : : //! Linked vector layer parameter name for dynamic properties
818 : : QString mDynamicLayerParameterName;
819 : :
820 : : //! Additional expression context variables exposed for use by this parameter
821 : : QStringList mAdditionalExpressionVariables;
822 : :
823 : : // To allow access to mAlgorithm. We don't want a public setter for this!
824 : : friend class QgsProcessingAlgorithm;
825 : :
826 : : };
827 : :
828 : : Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProcessingParameterDefinition::Flags )
829 : :
830 : : //! List of processing parameters
831 : : typedef QList< const QgsProcessingParameterDefinition * > QgsProcessingParameterDefinitions;
832 : :
833 : : /**
834 : : * \class QgsProcessingParameters
835 : : * \ingroup core
836 : : *
837 : : * \brief A collection of utilities for working with parameters when running a processing algorithm.
838 : : *
839 : : * Parameters are stored in a QVariantMap and referenced by a unique string key.
840 : : * The QVariants in parameters are not usually accessed
841 : : * directly, and instead the high level API provided through QgsProcessingParameters
842 : : * parameterAsString(), parameterAsDouble() are used instead.
843 : : *
844 : : * Parameters are evaluated using a provided QgsProcessingContext, allowing
845 : : * the evaluation to understand available map layers and expression contexts
846 : : * (for expression based parameters).
847 : : *
848 : : * \since QGIS 3.0
849 : : */
850 : :
851 : : class CORE_EXPORT QgsProcessingParameters
852 : : {
853 : :
854 : : public:
855 : :
856 : : /**
857 : : * Returns TRUE if the parameter with matching \a name is a dynamic parameter, and must
858 : : * be evaluated once for every input feature processed.
859 : : */
860 : : static bool isDynamic( const QVariantMap ¶meters, const QString &name );
861 : :
862 : : /**
863 : : * Evaluates the parameter with matching \a definition to a static string value.
864 : : */
865 : : static QString parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
866 : :
867 : : /**
868 : : * Evaluates the parameter with matching \a definition and \a value to a static string value.
869 : : * \since QGIS 3.4
870 : : */
871 : : static QString parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
872 : :
873 : : /**
874 : : * Evaluates the parameter with matching \a definition to an expression.
875 : : */
876 : : static QString parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
877 : :
878 : : /**
879 : : * Evaluates the parameter with matching \a definitionand \a value to an expression.
880 : : * \since QGIS 3.4
881 : : */
882 : : static QString parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
883 : :
884 : : /**
885 : : * Evaluates the parameter with matching \a definition to a static double value.
886 : : */
887 : : static double parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
888 : :
889 : : /**
890 : : * Evaluates the parameter with matching \a definition and \a value to a static double value.
891 : : * \since QGIS 3.4
892 : : */
893 : : static double parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
894 : :
895 : : /**
896 : : * Evaluates the parameter with matching \a definition to a static integer value.
897 : : */
898 : : static int parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
899 : :
900 : : /**
901 : : * Evaluates the parameter with matching \a definition and \a value to a static integer value.
902 : : * \since QGIS 3.4
903 : : */
904 : : static int parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
905 : :
906 : : /**
907 : : * Evaluates the parameter with matching \a definition to a list of integer values.
908 : : * \since QGIS 3.4
909 : : */
910 : : static QList<int> parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
911 : :
912 : : /**
913 : : * Evaluates the parameter with matching \a definition and \a value to a list of integer values.
914 : : * \since QGIS 3.4
915 : : */
916 : : static QList<int> parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
917 : :
918 : : /**
919 : : * Evaluates the parameter with matching \a definition to a static datetime value.
920 : : *
921 : : * \see parameterAsDate()
922 : : * \see parameterAsTime()
923 : : *
924 : : * \since QGIS 3.14
925 : : */
926 : : static QDateTime parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
927 : :
928 : : /**
929 : : * Evaluates the parameter with matching \a definition and \a value to a static datetime value.
930 : : *
931 : : * \see parameterAsDate()
932 : : * \see parameterAsTime()
933 : : *
934 : : * \since QGIS 3.14
935 : : */
936 : : static QDateTime parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
937 : :
938 : : /**
939 : : * Evaluates the parameter with matching \a definition to a static date value.
940 : : *
941 : : * \see parameterAsDateTime()
942 : : * \see parameterAsTime()
943 : : *
944 : : * \since QGIS 3.14
945 : : */
946 : : static QDate parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
947 : :
948 : : /**
949 : : * Evaluates the parameter with matching \a definition and \a value to a static date value.
950 : : *
951 : : * \see parameterAsDateTime()
952 : : * \see parameterAsTime()
953 : : *
954 : : * \since QGIS 3.14
955 : : */
956 : : static QDate parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
957 : :
958 : : /**
959 : : * Evaluates the parameter with matching \a definition to a static time value.
960 : : *
961 : : * \see parameterAsDateTime()
962 : : * \see parameterAsDate()
963 : : *
964 : : * \since QGIS 3.14
965 : : */
966 : : static QTime parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
967 : :
968 : : /**
969 : : * Evaluates the parameter with matching \a definition and \a value to a static time value.
970 : : *
971 : : * \see parameterAsDateTime()
972 : : * \see parameterAsDate()
973 : : *
974 : : * \since QGIS 3.14
975 : : */
976 : : static QTime parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
977 : :
978 : : /**
979 : : * Evaluates the parameter with matching \a definition to a enum value.
980 : : */
981 : : static int parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
982 : :
983 : : /**
984 : : * Evaluates the parameter with matching \a definition and \a value to a enum value.
985 : : * \since QGIS 3.4
986 : : */
987 : : static int parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
988 : :
989 : : /**
990 : : * Evaluates the parameter with matching \a definition to list of enum values.
991 : : */
992 : : static QList<int> parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
993 : :
994 : : /**
995 : : * Evaluates the parameter with matching \a definition and \a value to list of enum values.
996 : : * \since QGIS 3.4
997 : : */
998 : : static QList<int> parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
999 : :
1000 : : /**
1001 : : * Evaluates the parameter with matching \a definition to a static enum string.
1002 : : * \since QGIS 3.18
1003 : : */
1004 : : static QString parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
1005 : :
1006 : : /**
1007 : : * Evaluates the parameter with matching \a definition and \a value to a static enum string.
1008 : : * \since QGIS 3.18
1009 : : */
1010 : : static QString parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1011 : :
1012 : : /**
1013 : : * Evaluates the parameter with matching \a definition to list of static enum strings.
1014 : : * \since QGIS 3.18
1015 : : */
1016 : : static QStringList parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
1017 : :
1018 : : /**
1019 : : * Evaluates the parameter with matching \a definition and \a value to list of static enum strings.
1020 : : * \since QGIS 3.18
1021 : : */
1022 : : static QStringList parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1023 : :
1024 : : /**
1025 : : * Evaluates the parameter with matching \a definition to a static boolean value.
1026 : : */
1027 : : static bool parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
1028 : :
1029 : : /**
1030 : : * Evaluates the parameter with matching \a definition to a static boolean value.
1031 : : *
1032 : : * \since QGIS 3.8
1033 : : */
1034 : : static bool parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
1035 : :
1036 : : /**
1037 : : * Evaluates the parameter with matching \a definition and \a value to a static boolean value.
1038 : : * \since QGIS 3.4
1039 : : */
1040 : : static bool parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1041 : :
1042 : : /**
1043 : : * Evaluates the parameter with matching \a definition and \a value to a static boolean value.
1044 : : * \since QGIS 3.8
1045 : : */
1046 : : static bool parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1047 : :
1048 : : /**
1049 : : * Evaluates the parameter with matching \a definition to a feature sink.
1050 : : *
1051 : : * The \a fields, \a geometryType and \a crs parameters dictate the properties
1052 : : * of the resulting feature sink.
1053 : : *
1054 : : * Sinks will either be taken from \a context's active project, or created from external
1055 : : * providers and stored temporarily in the \a context. The \a destinationIdentifier
1056 : : * argument will be set to a string which can be used to retrieve the layer corresponding
1057 : : * to the sink, e.g. via calling QgsProcessingUtils::mapLayerFromString().
1058 : : *
1059 : : * The \a createOptions argument is used to pass on creation options such as layer name.
1060 : : *
1061 : : * The \a datasourceOptions and \a layerOptions arguments is used to pass on GDAL-specific format driver options.
1062 : : *
1063 : : * This function creates a new object and the caller takes responsibility for deleting the returned object.
1064 : : */
1065 : : static QgsFeatureSink *parameterAsSink( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters,
1066 : : const QgsFields &fields, QgsWkbTypes::Type geometryType, const QgsCoordinateReferenceSystem &crs,
1067 : : QgsProcessingContext &context, QString &destinationIdentifier SIP_OUT, QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(), const QVariantMap &createOptions = QVariantMap(), const QStringList &datasourceOptions = QStringList(), const QStringList &layerOptions = QStringList() ) SIP_FACTORY;
1068 : :
1069 : : /**
1070 : : * Evaluates the parameter with matching \a definition and \a value to a feature sink.
1071 : : *
1072 : : * The \a fields, \a geometryType and \a crs parameters dictate the properties
1073 : : * of the resulting feature sink.
1074 : : *
1075 : : * Sinks will either be taken from \a context's active project, or created from external
1076 : : * providers and stored temporarily in the \a context. The \a destinationIdentifier
1077 : : * argument will be set to a string which can be used to retrieve the layer corresponding
1078 : : * to the sink, e.g. via calling QgsProcessingUtils::mapLayerFromString().
1079 : : *
1080 : : * The \a createOptions argument is used to pass on creation options such as layer name.
1081 : : *
1082 : : * The \a datasourceOptions and \a layerOptions arguments is used to pass on GDAL-specific format driver options.
1083 : : *
1084 : : * This function creates a new object and the caller takes responsibility for deleting the returned object.
1085 : : * \throws QgsProcessingException
1086 : : * \since QGIS 3.4
1087 : : */
1088 : : static QgsFeatureSink *parameterAsSink( const QgsProcessingParameterDefinition *definition, const QVariant &value,
1089 : : const QgsFields &fields, QgsWkbTypes::Type geometryType, const QgsCoordinateReferenceSystem &crs,
1090 : : QgsProcessingContext &context, QString &destinationIdentifier SIP_OUT, QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(), const QVariantMap &createOptions = QVariantMap(), const QStringList &datasourceOptions = QStringList(), const QStringList &layerOptions = QStringList() ) SIP_THROW( QgsProcessingException ) SIP_FACTORY;
1091 : :
1092 : : /**
1093 : : * Evaluates the parameter with matching \a definition to a feature source.
1094 : : *
1095 : : * Sources will either be taken from \a context's active project, or loaded from external
1096 : : * sources and stored temporarily in the \a context.
1097 : : *
1098 : : * This function creates a new object and the caller takes responsibility for deleting the returned object.
1099 : : */
1100 : : static QgsProcessingFeatureSource *parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context ) SIP_FACTORY;
1101 : :
1102 : : /**
1103 : : * Evaluates the parameter with matching \a definition and \a value to a feature source.
1104 : : *
1105 : : * Sources will either be taken from \a context's active project, or loaded from external
1106 : : * sources and stored temporarily in the \a context.
1107 : : *
1108 : : * This function creates a new object and the caller takes responsibility for deleting the returned object.
1109 : : *
1110 : : * \since QGIS 3.4
1111 : : */
1112 : : static QgsProcessingFeatureSource *parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) SIP_FACTORY;
1113 : :
1114 : : /**
1115 : : * Evaluates the parameter with matching \a definition to a source vector layer file path of compatible format.
1116 : : *
1117 : : * If the parameter is evaluated to an existing layer, and that layer is not of the format listed in the
1118 : : * \a compatibleFormats argument, then the layer will first be exported to a compatible format
1119 : : * in a temporary location. The function will then return the path to that temporary file.
1120 : : *
1121 : : * \a compatibleFormats should consist entirely of lowercase file extensions, e.g. 'shp'.
1122 : : *
1123 : : * The \a preferredFormat argument is used to specify to desired file extension to use when a temporary
1124 : : * layer export is required. This defaults to shapefiles, because shapefiles are the future (don't believe the geopackage hype!).
1125 : : *
1126 : : * When an algorithm is capable of handling multi-layer input files (such as Geopackage), it is preferable
1127 : : * to use parameterAsCompatibleSourceLayerPathAndLayerName() which may avoid conversion in more situations.
1128 : : */
1129 : : static QString parameterAsCompatibleSourceLayerPath( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters,
1130 : : QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat = QString( "shp" ), QgsProcessingFeedback *feedback = nullptr );
1131 : :
1132 : : /**
1133 : : * Evaluates the parameter with matching \a definition to a source vector layer file path and layer name of compatible format.
1134 : : *
1135 : : * If the parameter is evaluated to an existing layer, and that layer is not of the format listed in the
1136 : : * \a compatibleFormats argument, then the layer will first be exported to a compatible format
1137 : : * in a temporary location. The function will then return the path to that temporary file.
1138 : : *
1139 : : * \a compatibleFormats should consist entirely of lowercase file extensions, e.g. 'shp'.
1140 : : *
1141 : : * The \a preferredFormat argument is used to specify to desired file extension to use when a temporary
1142 : : * layer export is required. This defaults to shapefiles, because shapefiles are the future (don't believe the geopackage hype!).
1143 : : *
1144 : : * This method should be preferred over parameterAsCompatibleSourceLayerPath() when an algorithm is able
1145 : : * to correctly handle files with multiple layers. Unlike parameterAsCompatibleSourceLayerPath(), it will not force
1146 : : * a conversion in this case and will return the target layer name in the \a layerName argument.
1147 : : *
1148 : : * \param definition associated parameter definition
1149 : : * \param parameters input parameter value map
1150 : : * \param context processing context
1151 : : * \param compatibleFormats a list of lowercase file extensions compatible with the algorithm
1152 : : * \param preferredFormat preferred format extension to use if conversion if required
1153 : : * \param feedback feedback object
1154 : : * \param layerName will be set to the target layer name for multi-layer sources (e.g. Geopackage)
1155 : : *
1156 : : * \returns path to source layer, or nearly converted compatible layer
1157 : : *
1158 : : * \see parameterAsCompatibleSourceLayerPath()
1159 : : * \since QGIS 3.10
1160 : : */
1161 : : static QString parameterAsCompatibleSourceLayerPathAndLayerName( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters,
1162 : : QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat = QString( "shp" ), QgsProcessingFeedback *feedback = nullptr, QString *layerName SIP_OUT = nullptr );
1163 : :
1164 : : /**
1165 : : * Evaluates the parameter with matching \a definition to a map layer.
1166 : : *
1167 : : * Layers will either be taken from \a context's active project, or loaded from external
1168 : : * sources and stored temporarily in the \a context. In either case, callers do not
1169 : : * need to handle deletion of the returned layer.
1170 : : */
1171 : : static QgsMapLayer *parameterAsLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingUtils::LayerHint layerHint = QgsProcessingUtils::LayerHint::UnknownType );
1172 : :
1173 : : /**
1174 : : * Evaluates the parameter with matching \a definition and \a value to a map layer.
1175 : : *
1176 : : * Layers will either be taken from \a context's active project, or loaded from external
1177 : : * sources and stored temporarily in the \a context. In either case, callers do not
1178 : : * need to handle deletion of the returned layer.
1179 : : *
1180 : : * \since QGIS 3.4
1181 : : */
1182 : : static QgsMapLayer *parameterAsLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessingUtils::LayerHint layerHint = QgsProcessingUtils::LayerHint::UnknownType );
1183 : :
1184 : : /**
1185 : : * Evaluates the parameter with matching \a definition to a raster layer.
1186 : : *
1187 : : * Layers will either be taken from \a context's active project, or loaded from external
1188 : : * sources and stored temporarily in the \a context. In either case, callers do not
1189 : : * need to handle deletion of the returned layer.
1190 : : */
1191 : : static QgsRasterLayer *parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1192 : :
1193 : : /**
1194 : : * Evaluates the parameter with matching \a definition and \a value to a raster layer.
1195 : : *
1196 : : * Layers will either be taken from \a context's active project, or loaded from external
1197 : : * sources and stored temporarily in the \a context. In either case, callers do not
1198 : : * need to handle deletion of the returned layer.
1199 : : *
1200 : : * \since QGIS 3.4
1201 : : */
1202 : : static QgsRasterLayer *parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1203 : :
1204 : : /**
1205 : : * Evaluates the parameter with matching \a definition to a output layer destination.
1206 : : */
1207 : : static QString parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1208 : :
1209 : : /**
1210 : : * Evaluates the parameter with matching \a definition and \a value to a output layer destination.
1211 : : * \since QGIS 3.4
1212 : : */
1213 : : static QString parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1214 : :
1215 : : /**
1216 : : * Evaluates the parameter with matching \a definition to a file based output destination.
1217 : : */
1218 : : static QString parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1219 : :
1220 : : /**
1221 : : * Evaluates the parameter with matching \a definition and \a value to a file based output destination.
1222 : : * \since QGIS 3.4
1223 : : */
1224 : : static QString parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1225 : :
1226 : : /**
1227 : : * Evaluates the parameter with matching \a definition to a vector layer.
1228 : : *
1229 : : * Layers will either be taken from \a context's active project, or loaded from external
1230 : : * sources and stored temporarily in the \a context. In either case, callers do not
1231 : : * need to handle deletion of the returned layer.
1232 : : */
1233 : : static QgsVectorLayer *parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1234 : :
1235 : : /**
1236 : : * Evaluates the parameter with matching \a definition and \a value to a vector layer.
1237 : : *
1238 : : * Layers will either be taken from \a context's active project, or loaded from external
1239 : : * sources and stored temporarily in the \a context. In either case, callers do not
1240 : : * need to handle deletion of the returned layer.
1241 : : *
1242 : : * \since QGIS 3.4
1243 : : */
1244 : : static QgsVectorLayer *parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1245 : :
1246 : : /**
1247 : : * Evaluates the parameter with matching \a definition and \a value to a mesh layer.
1248 : : *
1249 : : * Layers will either be taken from \a context's active project, or loaded from external
1250 : : * sources and stored temporarily in the \a context. In either case, callers do not
1251 : : * need to handle deletion of the returned layer.
1252 : : *
1253 : : * \since QGIS 3.6
1254 : : */
1255 : : static QgsMeshLayer *parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1256 : :
1257 : : /**
1258 : : * Evaluates the parameter with matching \a definition and \a value to a mesh layer.
1259 : : *
1260 : : * Layers will either be taken from \a context's active project, or loaded from external
1261 : : * sources and stored temporarily in the \a context. In either case, callers do not
1262 : : * need to handle deletion of the returned layer.
1263 : : *
1264 : : * \since QGIS 3.6
1265 : : */
1266 : : static QgsMeshLayer *parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1267 : :
1268 : :
1269 : : /**
1270 : : * Evaluates the parameter with matching \a definition to a coordinate reference system.
1271 : : */
1272 : : static QgsCoordinateReferenceSystem parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1273 : :
1274 : : /**
1275 : : * Evaluates the parameter with matching \a definition and \a value to a coordinate reference system.
1276 : : * \since QGIS 3.4
1277 : : */
1278 : : static QgsCoordinateReferenceSystem parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1279 : :
1280 : : /**
1281 : : * Evaluates the parameter with matching \a definition to a rectangular extent.
1282 : : *
1283 : : * If \a crs is set, and the original coordinate reference system of the parameter can be determined, then the extent will be automatically
1284 : : * reprojected so that it is in the specified \a crs. In this case the extent of the reproject rectangle will be returned.
1285 : : *
1286 : : * \see parameterAsExtentGeometry()
1287 : : * \see parameterAsExtentCrs()
1288 : : */
1289 : : static QgsRectangle parameterAsExtent( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context,
1290 : : const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1291 : :
1292 : : /**
1293 : : * Evaluates the parameter with matching \a definition and \a value to a rectangular extent.
1294 : : *
1295 : : * If \a crs is set, and the original coordinate reference system of the parameter can be determined, then the extent will be automatically
1296 : : * reprojected so that it is in the specified \a crs. In this case the extent of the reproject rectangle will be returned.
1297 : : *
1298 : : * \see parameterAsExtentGeometry()
1299 : : * \see parameterAsExtentCrs()
1300 : : *
1301 : : * \since QGIS 3.4
1302 : : */
1303 : : static QgsRectangle parameterAsExtent( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context,
1304 : : const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1305 : :
1306 : : /**
1307 : : * Evaluates the parameter with matching \a definition to a rectangular extent, and returns a geometry covering this extent.
1308 : : *
1309 : : * If \a crs is set, and the original coordinate reference system of the parameter can be determined, then the extent will be automatically
1310 : : * reprojected so that it is in the specified \a crs. Unlike parameterAsExtent(), the reprojected rectangle returned by this function
1311 : : * will no longer be a rectangle itself (i.e. this method returns the geometry of the actual reprojected rectangle, while parameterAsExtent() returns
1312 : : * just the extent of the reprojected rectangle).
1313 : : *
1314 : : * \see parameterAsExtent()
1315 : : * \see parameterAsExtentCrs()
1316 : : */
1317 : : static QgsGeometry parameterAsExtentGeometry( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context,
1318 : : const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1319 : :
1320 : : /**
1321 : : * Returns the coordinate reference system associated with an extent parameter value.
1322 : : *
1323 : : * \see parameterAsExtent()
1324 : : */
1325 : : static QgsCoordinateReferenceSystem parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1326 : :
1327 : : /**
1328 : : * Returns the coordinate reference system associated with an extent parameter value.
1329 : : *
1330 : : * \see parameterAsExtent()
1331 : : */
1332 : : static QgsCoordinateReferenceSystem parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1333 : :
1334 : :
1335 : : /**
1336 : : * Evaluates the parameter with matching \a definition to a point.
1337 : : *
1338 : : * If \a crs is set then the point will be automatically reprojected so that it is in the specified \a crs.
1339 : : *
1340 : : * \see parameterAsPointCrs()
1341 : : */
1342 : : static QgsPointXY parameterAsPoint( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context,
1343 : : const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1344 : :
1345 : : /**
1346 : : * Evaluates the parameter with matching \a definition and \a value to a point.
1347 : : *
1348 : : * If \a crs is set then the point will be automatically reprojected so that it is in the specified \a crs.
1349 : : *
1350 : : * \see parameterAsPointCrs()
1351 : : * \since QGIS 3.4
1352 : : */
1353 : : static QgsPointXY parameterAsPoint( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context,
1354 : : const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1355 : :
1356 : : /**
1357 : : * Returns the coordinate reference system associated with an point parameter value.
1358 : : *
1359 : : * \see parameterAsPoint()
1360 : : */
1361 : : static QgsCoordinateReferenceSystem parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1362 : :
1363 : : /**
1364 : : * Returns the coordinate reference system associated with an point parameter value.
1365 : : *
1366 : : * \see parameterAsPoint()
1367 : : * \since QGIS 3.8
1368 : : */
1369 : : static QgsCoordinateReferenceSystem parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1370 : :
1371 : : /**
1372 : : * Evaluates the parameter with matching \a definition to a geometry.
1373 : : *
1374 : : * \since QGIS 3.16
1375 : : */
1376 : : static QgsGeometry parameterAsGeometry( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1377 : :
1378 : : /**
1379 : : * Evaluates the parameter with matching \a definition and \a value to a geometry.
1380 : : *
1381 : : * \since QGIS 3.16
1382 : : */
1383 : : static QgsGeometry parameterAsGeometry( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1384 : :
1385 : : /**
1386 : : * Returns the coordinate reference system associated with a geometry parameter value.
1387 : : *
1388 : : * \see parameterAsGeometry()
1389 : : * \since QGIS 3.16
1390 : : */
1391 : : static QgsCoordinateReferenceSystem parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1392 : :
1393 : : /**
1394 : : * Returns the coordinate reference system associated with an point parameter value.
1395 : : *
1396 : : * \see parameterAsGeometry()
1397 : : * \since QGIS 3.16
1398 : : */
1399 : : static QgsCoordinateReferenceSystem parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1400 : :
1401 : : /**
1402 : : * Evaluates the parameter with matching \a definition to a file/folder name.
1403 : : */
1404 : : static QString parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1405 : :
1406 : : /**
1407 : : * Evaluates the parameter with matching \a definition and \a value to a file/folder name.
1408 : : * \since QGIS 3.4
1409 : : */
1410 : : static QString parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1411 : :
1412 : : /**
1413 : : * Evaluates the parameter with matching \a definition to a matrix/table of values.
1414 : : * Tables are collapsed to a 1 dimensional list.
1415 : : */
1416 : : static QVariantList parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1417 : :
1418 : : /**
1419 : : * Evaluates the parameter with matching \a definition and \a value to a matrix/table of values.
1420 : : * Tables are collapsed to a 1 dimensional list.
1421 : : * \since QGIS 3.4
1422 : : */
1423 : : static QVariantList parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1424 : :
1425 : : /**
1426 : : * Evaluates the parameter with matching \a definition to a list of map layers.
1427 : : */
1428 : : static QList< QgsMapLayer *> parameterAsLayerList( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1429 : :
1430 : : /**
1431 : : * Evaluates the parameter with matching \a definition and \a value to a list of map layers.
1432 : : * \since QGIS 3.4
1433 : : */
1434 : : static QList< QgsMapLayer *> parameterAsLayerList( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1435 : :
1436 : : /**
1437 : : * Evaluates the parameter with matching \a definition to a list of files (for QgsProcessingParameterMultipleLayers in QgsProcessing:TypeFile mode).
1438 : : *
1439 : : * \since QGIS 3.10
1440 : : */
1441 : : static QStringList parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1442 : :
1443 : : /**
1444 : : * Evaluates the parameter with matching \a definition to a list of files (for QgsProcessingParameterMultipleLayers in QgsProcessing:TypeFile mode).
1445 : : *
1446 : : * \since QGIS 3.10
1447 : : */
1448 : : static QStringList parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1449 : :
1450 : : /**
1451 : : * Evaluates the parameter with matching \a definition to a range of values.
1452 : : */
1453 : : static QList<double> parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1454 : :
1455 : : /**
1456 : : * Evaluates the parameter with matching \a definition and \a value to a range of values.
1457 : : * \since QGIS 3.4
1458 : : */
1459 : : static QList<double> parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1460 : :
1461 : : /**
1462 : : * Evaluates the parameter with matching \a definition to a list of fields.
1463 : : */
1464 : : static QStringList parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1465 : :
1466 : : /**
1467 : : * Evaluates the parameter with matching \a definition and \a value to a list of fields.
1468 : : * \since QGIS 3.4
1469 : : */
1470 : : static QStringList parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1471 : :
1472 : : /**
1473 : : * Evaluates the parameter with matching \a definition to a print layout.
1474 : : *
1475 : : * \warning This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
1476 : : * implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
1477 : : *
1478 : : * \since QGIS 3.8
1479 : : */
1480 : : static QgsPrintLayout *parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1481 : :
1482 : : /**
1483 : : * Evaluates the parameter with matching \a definition and \a value to a print layout.
1484 : : *
1485 : : * \warning This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
1486 : : * implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
1487 : : *
1488 : : * \since QGIS 3.8
1489 : : */
1490 : : static QgsPrintLayout *parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1491 : :
1492 : : /**
1493 : : * Evaluates the parameter with matching \a definition to a print layout item, taken from the specified \a layout.
1494 : : *
1495 : : * \warning This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
1496 : : * implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
1497 : : *
1498 : : * \since QGIS 3.8
1499 : : */
1500 : : static QgsLayoutItem *parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context, QgsPrintLayout *layout );
1501 : :
1502 : : /**
1503 : : * Evaluates the parameter with matching \a definition and \a value to a print layout, taken from the specified \a layout.
1504 : : *
1505 : : * \warning This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
1506 : : * implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
1507 : : *
1508 : : * \since QGIS 3.8
1509 : : */
1510 : : static QgsLayoutItem *parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsPrintLayout *layout );
1511 : :
1512 : : /**
1513 : : * Returns the color associated with an point parameter value, or an invalid color if the parameter was not set.
1514 : : *
1515 : : * \since QGIS 3.10
1516 : : */
1517 : : static QColor parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1518 : :
1519 : : /**
1520 : : * Returns the color associated with an color parameter value, or an invalid color if the parameter was not set.
1521 : : *
1522 : : * \since QGIS 3.10
1523 : : */
1524 : : static QColor parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1525 : :
1526 : : /**
1527 : : * Evaluates the parameter with matching \a definition to a connection name string.
1528 : : *
1529 : : * \since QGIS 3.14
1530 : : */
1531 : : static QString parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
1532 : :
1533 : : /**
1534 : : * Evaluates the parameter with matching \a definition and \a value to a connection name string.
1535 : : *
1536 : : * \since QGIS 3.14
1537 : : */
1538 : : static QString parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1539 : :
1540 : : /**
1541 : : * Evaluates the parameter with matching \a definition to a database schema name.
1542 : : *
1543 : : * \since QGIS 3.14
1544 : : */
1545 : : static QString parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
1546 : :
1547 : : /**
1548 : : * Evaluates the parameter with matching \a definition and \a value to a database schema name.
1549 : : *
1550 : : * \since QGIS 3.14
1551 : : */
1552 : : static QString parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1553 : :
1554 : : /**
1555 : : * Evaluates the parameter with matching \a definition to a database table name.
1556 : : *
1557 : : * \since QGIS 3.14
1558 : : */
1559 : : static QString parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
1560 : :
1561 : : /**
1562 : : * Evaluates the parameter with matching \a definition and \a value to a database table name.
1563 : : *
1564 : : * \since QGIS 3.14
1565 : : */
1566 : : static QString parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1567 : :
1568 : : /**
1569 : : * Creates a new QgsProcessingParameterDefinition using the configuration from a
1570 : : * supplied variant \a map.
1571 : : * The caller takes responsibility for deleting the returned object.
1572 : : */
1573 : : static QgsProcessingParameterDefinition *parameterFromVariantMap( const QVariantMap &map ) SIP_FACTORY;
1574 : :
1575 : : /**
1576 : : * Creates an autogenerated parameter description from a parameter \a name.
1577 : : */
1578 : : static QString descriptionFromName( const QString &name );
1579 : :
1580 : : /**
1581 : : * Creates a new QgsProcessingParameterDefinition using the configuration from a
1582 : : * supplied script \a code string.
1583 : : * The caller takes responsibility for deleting the returned object.
1584 : : */
1585 : : static QgsProcessingParameterDefinition *parameterFromScriptCode( const QString &code ) SIP_FACTORY;
1586 : :
1587 : : private:
1588 : :
1589 : : static bool parseScriptCodeParameterOptions( const QString &code, bool &isOptional, QString &name, QString &type, QString &definition );
1590 : : };
1591 : :
1592 : :
1593 : :
1594 : : /**
1595 : : * \class QgsProcessingParameterBoolean
1596 : : * \ingroup core
1597 : : * \brief A boolean parameter for processing algorithms.
1598 : : * \since QGIS 3.0
1599 : : */
1600 : 0 : class CORE_EXPORT QgsProcessingParameterBoolean : public QgsProcessingParameterDefinition
1601 : : {
1602 : : public:
1603 : :
1604 : : /**
1605 : : * Constructor for QgsProcessingParameterBoolean.
1606 : : */
1607 : : QgsProcessingParameterBoolean( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
1608 : : bool optional = false );
1609 : :
1610 : : /**
1611 : : * Returns the type name for the parameter class.
1612 : : */
1613 : 0 : static QString typeName() { return QStringLiteral( "boolean" ); }
1614 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1615 : 0 : QString type() const override { return typeName(); }
1616 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
1617 : : QString asScriptCode() const override;
1618 : :
1619 : : /**
1620 : : * Creates a new parameter using the definition from a script code.
1621 : : */
1622 : : static QgsProcessingParameterBoolean *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
1623 : : };
1624 : :
1625 : : /**
1626 : : * \class QgsProcessingParameterCrs
1627 : : * \ingroup core
1628 : : * \brief A coordinate reference system parameter for processing algorithms.
1629 : : * \since QGIS 3.0
1630 : : */
1631 : 0 : class CORE_EXPORT QgsProcessingParameterCrs : public QgsProcessingParameterDefinition
1632 : : {
1633 : : public:
1634 : :
1635 : : /**
1636 : : * Constructor for QgsProcessingParameterCrs.
1637 : : */
1638 : : QgsProcessingParameterCrs( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
1639 : : bool optional = false );
1640 : :
1641 : : /**
1642 : : * Returns the type name for the parameter class.
1643 : : */
1644 : 0 : static QString typeName() { return QStringLiteral( "crs" ); }
1645 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1646 : 0 : QString type() const override { return typeName(); }
1647 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
1648 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
1649 : :
1650 : : /**
1651 : : * Creates a new parameter using the definition from a script code.
1652 : : */
1653 : : static QgsProcessingParameterCrs *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
1654 : :
1655 : : };
1656 : :
1657 : : /**
1658 : : * \class QgsProcessingParameterExtent
1659 : : * \ingroup core
1660 : : * \brief A rectangular map extent parameter for processing algorithms.
1661 : : * \since QGIS 3.0
1662 : : */
1663 : 0 : class CORE_EXPORT QgsProcessingParameterExtent : public QgsProcessingParameterDefinition
1664 : : {
1665 : : public:
1666 : :
1667 : : /**
1668 : : * Constructor for QgsProcessingParameterExtent.
1669 : : */
1670 : : QgsProcessingParameterExtent( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
1671 : : bool optional = false );
1672 : :
1673 : : /**
1674 : : * Returns the type name for the parameter class.
1675 : : */
1676 : 0 : static QString typeName() { return QStringLiteral( "extent" ); }
1677 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1678 : 0 : QString type() const override { return typeName(); }
1679 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
1680 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
1681 : :
1682 : : /**
1683 : : * Creates a new parameter using the definition from a script code.
1684 : : */
1685 : : static QgsProcessingParameterExtent *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
1686 : :
1687 : : };
1688 : :
1689 : :
1690 : : /**
1691 : : * \class QgsProcessingParameterPoint
1692 : : * \ingroup core
1693 : : * \brief A point parameter for processing algorithms.
1694 : : * \since QGIS 3.0
1695 : : */
1696 : 0 : class CORE_EXPORT QgsProcessingParameterPoint : public QgsProcessingParameterDefinition
1697 : : {
1698 : : public:
1699 : :
1700 : : /**
1701 : : * Constructor for QgsProcessingParameterPoint.
1702 : : */
1703 : : QgsProcessingParameterPoint( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
1704 : : bool optional = false );
1705 : :
1706 : : /**
1707 : : * Returns the type name for the parameter class.
1708 : : */
1709 : 0 : static QString typeName() { return QStringLiteral( "point" ); }
1710 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1711 : 0 : QString type() const override { return typeName(); }
1712 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
1713 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
1714 : :
1715 : : /**
1716 : : * Creates a new parameter using the definition from a script code.
1717 : : */
1718 : : static QgsProcessingParameterPoint *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
1719 : :
1720 : : };
1721 : :
1722 : : /**
1723 : : * \class QgsProcessingParameterGeometry
1724 : : * \ingroup core
1725 : : * \brief A geometry parameter for processing algorithms.
1726 : : * \since QGIS 3.16
1727 : : */
1728 : 0 : class CORE_EXPORT QgsProcessingParameterGeometry : public QgsProcessingParameterDefinition
1729 : : {
1730 : : public:
1731 : :
1732 : : /**
1733 : : * Constructor for QgsProcessingParameterGeometry.
1734 : : *
1735 : : * The \a geometryTypes argument allows for specifying a list of geometry types (see QgsWkbTypes::GeometryType) acceptable for this
1736 : : * parameter. Passing a empty list will allow for any type of geometry.
1737 : : * The \a allowMultiPart argument allows specifying a multi part geometry
1738 : : */
1739 : : QgsProcessingParameterGeometry( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false, const QList< int > &geometryTypes = QList< int >(), bool allowMultipart = true );
1740 : :
1741 : : /**
1742 : : * Returns the type name for the parameter class.
1743 : : */
1744 : 0 : static QString typeName() { return QStringLiteral( "geometry" ); }
1745 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1746 : 0 : QString type() const override { return typeName(); }
1747 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
1748 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
1749 : : QString asScriptCode() const override;
1750 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
1751 : : QVariantMap toVariantMap() const override;
1752 : : bool fromVariantMap( const QVariantMap &map ) override;
1753 : :
1754 : : /**
1755 : : * Returns the parameter allowed geometries, as a list of QgsWkbTypes::GeometryType values.
1756 : : * \see setGeometryTypes()
1757 : : */
1758 : : QList<int> geometryTypes() const { return mGeomTypes; }
1759 : :
1760 : : /**
1761 : : * Sets the allowed \a geometryTypes, as a list of QgsWkbTypes::GeometryType values.
1762 : : * \see geometryTypes()
1763 : : */
1764 : : void setGeometryTypes( const QList<int> &geometryTypes ) { mGeomTypes = geometryTypes; }
1765 : :
1766 : : /**
1767 : : * Returns the parameter allow multipart geometries.
1768 : : * \see setAllowMultipart()
1769 : : */
1770 : : bool allowMultipart() const { return mAllowMultipart; }
1771 : :
1772 : : /**
1773 : : * Sets the allow multipart geometries
1774 : : * \see allowMultipart()
1775 : : */
1776 : : void setAllowMultipart( bool allowMultipart ) { mAllowMultipart = allowMultipart; }
1777 : :
1778 : :
1779 : :
1780 : : /**
1781 : : * Creates a new parameter using the definition from a script code.
1782 : : */
1783 : : static QgsProcessingParameterGeometry *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
1784 : :
1785 : : private:
1786 : :
1787 : : QList<int> mGeomTypes;
1788 : : bool mAllowMultipart;
1789 : :
1790 : : };
1791 : :
1792 : : /**
1793 : : * \class QgsProcessingParameterFile
1794 : : * \ingroup core
1795 : : * \brief An input file or folder parameter for processing algorithms.
1796 : : * \since QGIS 3.0
1797 : : */
1798 : 0 : class CORE_EXPORT QgsProcessingParameterFile : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
1799 : : {
1800 : : public:
1801 : :
1802 : : //! Parameter behavior
1803 : : enum Behavior
1804 : : {
1805 : : File = 0, //!< Parameter is a single file
1806 : : Folder, //!< Parameter is a folder
1807 : : };
1808 : :
1809 : : /**
1810 : : * Constructor for QgsProcessingParameterFile.
1811 : : *
1812 : : * The \a extension argument allows for specifying a file extension associated with the parameter (e.g. "html"). Use \a fileFilter
1813 : : * for a more flexible approach which allows for multiple file extensions. Only one of \a extension or \a fileFilter should be specified,
1814 : : * if both are specified then \a fileFilter takes precedence.
1815 : : */
1816 : : QgsProcessingParameterFile( const QString &name, const QString &description = QString(), Behavior behavior = File, const QString &extension = QString(), const QVariant &defaultValue = QVariant(),
1817 : : bool optional = false, const QString &fileFilter = QString() );
1818 : :
1819 : : /**
1820 : : * Returns the type name for the parameter class.
1821 : : */
1822 : 0 : static QString typeName() { return QStringLiteral( "file" ); }
1823 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1824 : 0 : QString type() const override { return typeName(); }
1825 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
1826 : : QString asScriptCode() const override;
1827 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
1828 : : QString createFileFilter() const override;
1829 : :
1830 : : /**
1831 : : * Returns the parameter behavior (e.g. File or Folder).
1832 : : * \see setBehavior()
1833 : : */
1834 : : Behavior behavior() const { return mBehavior; }
1835 : :
1836 : : /**
1837 : : * Sets the parameter \a behavior (e.g. File or Folder).
1838 : : * \see behavior()
1839 : : */
1840 : : void setBehavior( Behavior behavior ) { mBehavior = behavior; }
1841 : :
1842 : : /**
1843 : : * Returns any specified file extension for the parameter.
1844 : : *
1845 : : * \note See fileFilter() for a more flexible approach.
1846 : : *
1847 : : * \see setExtension()
1848 : : */
1849 : : QString extension() const { return mExtension; }
1850 : :
1851 : : /**
1852 : : * Sets a file \a extension for the parameter.
1853 : : *
1854 : : * Calling this method resets any existing fileFilter().
1855 : : *
1856 : : * \note See setFileFilter() for a more flexible approach.
1857 : : *
1858 : : * \see extension()
1859 : : */
1860 : : void setExtension( const QString &extension );
1861 : :
1862 : : /**
1863 : : * Returns the file filter string for file destinations compatible with this parameter.
1864 : : * \see setFileFilter()
1865 : : * \see extension()
1866 : : * \since QGIS 3.10
1867 : : */
1868 : : QString fileFilter() const;
1869 : :
1870 : : /**
1871 : : * Sets the file \a filter string for file destinations compatible with this parameter.
1872 : : *
1873 : : * Calling this method resets any existing extension() setting.
1874 : : *
1875 : : * \see fileFilter()
1876 : : * \see setExtension()
1877 : : * \since QGIS 3.10
1878 : : */
1879 : : void setFileFilter( const QString &filter );
1880 : :
1881 : : QVariantMap toVariantMap() const override;
1882 : : bool fromVariantMap( const QVariantMap &map ) override;
1883 : :
1884 : : /**
1885 : : * Creates a new parameter using the definition from a script code.
1886 : : */
1887 : : static QgsProcessingParameterFile *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition, Behavior behavior = File ) SIP_FACTORY;
1888 : :
1889 : : private:
1890 : :
1891 : : Behavior mBehavior = File;
1892 : : QString mExtension;
1893 : : QString mFileFilter;
1894 : : };
1895 : :
1896 : : /**
1897 : : * \class QgsProcessingParameterMatrix
1898 : : * \ingroup core
1899 : : * \brief A table (matrix) parameter for processing algorithms.
1900 : : * \since QGIS 3.0
1901 : : */
1902 : 0 : class CORE_EXPORT QgsProcessingParameterMatrix : public QgsProcessingParameterDefinition
1903 : : {
1904 : : public:
1905 : :
1906 : : /**
1907 : : * Constructor for QgsProcessingParameterMatrix.
1908 : : */
1909 : : QgsProcessingParameterMatrix( const QString &name, const QString &description = QString(), int numberRows = 3,
1910 : : bool hasFixedNumberRows = false, const QStringList &headers = QStringList(),
1911 : : const QVariant &defaultValue = QVariant(),
1912 : : bool optional = false );
1913 : :
1914 : : /**
1915 : : * Returns the type name for the parameter class.
1916 : : */
1917 : 0 : static QString typeName() { return QStringLiteral( "matrix" ); }
1918 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1919 : 0 : QString type() const override { return typeName(); }
1920 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
1921 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
1922 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
1923 : :
1924 : : /**
1925 : : * Returns a list of column headers (if set).
1926 : : * \see setHeaders()
1927 : : */
1928 : : QStringList headers() const;
1929 : :
1930 : : /**
1931 : : * Sets the list of column \a headers.
1932 : : * \see headers()
1933 : : */
1934 : : void setHeaders( const QStringList &headers );
1935 : :
1936 : : /**
1937 : : * Returns the fixed number of rows in the table. This parameter only has an
1938 : : * effect if hasFixedNumberRows() is TRUE.
1939 : : * \see setNumberRows()
1940 : : * \see setHasFixedNumberRows()
1941 : : */
1942 : : int numberRows() const;
1943 : :
1944 : : /**
1945 : : * Sets the fixed number of \a rows in the table. This parameter only has an
1946 : : * effect if hasFixedNumberRows() is TRUE.
1947 : : * \see numberRows()
1948 : : * \see setHasFixedNumberRows()
1949 : : */
1950 : : void setNumberRows( int rows );
1951 : :
1952 : : /**
1953 : : * Returns whether the table has a fixed number of rows.
1954 : : * \see numberRows()
1955 : : * \see setHasFixedNumberRows()
1956 : : */
1957 : : bool hasFixedNumberRows() const;
1958 : :
1959 : : /**
1960 : : * Sets whether the table has a fixed number of rows.
1961 : : * \see setNumberRows()
1962 : : * \see hasFixedNumberRows()
1963 : : */
1964 : : void setHasFixedNumberRows( bool hasFixedNumberRows );
1965 : :
1966 : : QVariantMap toVariantMap() const override;
1967 : : bool fromVariantMap( const QVariantMap &map ) override;
1968 : :
1969 : : /**
1970 : : * Creates a new parameter using the definition from a script code.
1971 : : */
1972 : : static QgsProcessingParameterMatrix *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
1973 : :
1974 : : private:
1975 : :
1976 : : QStringList mHeaders;
1977 : : int mNumberRows = 3;
1978 : : bool mFixedNumberRows = false;
1979 : :
1980 : : };
1981 : :
1982 : : /**
1983 : : * \class QgsProcessingParameterMultipleLayers
1984 : : * \ingroup core
1985 : : * \brief A parameter for processing algorithms which accepts multiple map layers.
1986 : : * \since QGIS 3.0
1987 : : */
1988 : 0 : class CORE_EXPORT QgsProcessingParameterMultipleLayers : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
1989 : : {
1990 : : public:
1991 : :
1992 : : /**
1993 : : * Constructor for QgsProcessingParameterMultipleLayers.
1994 : : */
1995 : : QgsProcessingParameterMultipleLayers( const QString &name, const QString &description = QString(), QgsProcessing::SourceType layerType = QgsProcessing::TypeVectorAnyGeometry,
1996 : : const QVariant &defaultValue = QVariant(),
1997 : : bool optional = false );
1998 : :
1999 : : /**
2000 : : * Returns the type name for the parameter class.
2001 : : */
2002 : 0 : static QString typeName() { return QStringLiteral( "multilayer" ); }
2003 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2004 : 0 : QString type() const override { return typeName(); }
2005 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2006 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2007 : : QString asScriptCode() const override;
2008 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2009 : : QString createFileFilter() const override;
2010 : :
2011 : : /**
2012 : : * Returns the layer type for layers acceptable by the parameter.
2013 : : * \see setLayerType()
2014 : : */
2015 : : QgsProcessing::SourceType layerType() const;
2016 : :
2017 : : /**
2018 : : * Sets the layer \a type for layers acceptable by the parameter.
2019 : : * \see layerType()
2020 : : */
2021 : : void setLayerType( QgsProcessing::SourceType type );
2022 : :
2023 : : /**
2024 : : * Returns the minimum number of layers required for the parameter. If the return value is < 1
2025 : : * then the parameter accepts any number of layers.
2026 : : * \see setMinimumNumberInputs()
2027 : : */
2028 : : int minimumNumberInputs() const;
2029 : :
2030 : : /**
2031 : : * Sets the \a minimum number of layers required for the parameter. The minimum must be >= 1
2032 : : * if the parameter is not optional.
2033 : : * \see minimumNumberInputs()
2034 : : */
2035 : : void setMinimumNumberInputs( int minimum );
2036 : :
2037 : : QVariantMap toVariantMap() const override;
2038 : : bool fromVariantMap( const QVariantMap &map ) override;
2039 : :
2040 : : /**
2041 : : * Creates a new parameter using the definition from a script code.
2042 : : */
2043 : : static QgsProcessingParameterMultipleLayers *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2044 : :
2045 : : private:
2046 : :
2047 : : QgsProcessing::SourceType mLayerType = QgsProcessing::TypeVectorAnyGeometry;
2048 : : int mMinimumNumberInputs = 0;
2049 : :
2050 : : };
2051 : :
2052 : : /**
2053 : : * \class QgsProcessingParameterNumber
2054 : : * \ingroup core
2055 : : * \brief A numeric parameter for processing algorithms.
2056 : : *
2057 : : * For numeric parameters with a dataType() of Double, the number of decimals places
2058 : : * shown in the parameter's widget can be specified by setting the parameter's metadata. For example:
2059 : : *
2060 : : * \code{.py}
2061 : : * param = QgsProcessingParameterNumber( 'VAL', 'Threshold', type=QgsProcessingParameterNumber.Double)
2062 : : * # only show two decimal places in parameter's widgets, not 6:
2063 : : * param.setMetadata( {'widget_wrapper':
2064 : : * { 'decimals': 2 }
2065 : : * })
2066 : : * \endcode
2067 : : *
2068 : : * \since QGIS 3.0
2069 : : */
2070 : 0 : class CORE_EXPORT QgsProcessingParameterNumber : public QgsProcessingParameterDefinition
2071 : : {
2072 : : public:
2073 : :
2074 : : //! Numeric data type
2075 : : enum Type
2076 : : {
2077 : : Integer, //!< Integer values
2078 : : Double, //!< Double/float values
2079 : : };
2080 : :
2081 : : /**
2082 : : * Constructor for QgsProcessingParameterNumber.
2083 : : */
2084 : : explicit QgsProcessingParameterNumber( const QString &name, const QString &description = QString(),
2085 : : Type type = Integer,
2086 : : const QVariant &defaultValue = QVariant(),
2087 : : bool optional = false,
2088 : : double minValue = std::numeric_limits<double>::lowest() + 1,
2089 : : double maxValue = std::numeric_limits<double>::max()
2090 : : );
2091 : :
2092 : : /**
2093 : : * Returns the type name for the parameter class.
2094 : : */
2095 : 0 : static QString typeName() { return QStringLiteral( "number" ); }
2096 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2097 : 0 : QString type() const override { return typeName(); }
2098 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2099 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2100 : : QString toolTip() const override;
2101 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2102 : :
2103 : : /**
2104 : : * Returns the minimum value acceptable by the parameter.
2105 : : * \see setMinimum()
2106 : : */
2107 : : double minimum() const;
2108 : :
2109 : : /**
2110 : : * Sets the \a minimum value acceptable by the parameter.
2111 : : * \see minimum()
2112 : : */
2113 : : void setMinimum( double minimum );
2114 : :
2115 : : /**
2116 : : * Returns the maximum value acceptable by the parameter.
2117 : : * \see setMaximum()
2118 : : */
2119 : : double maximum() const;
2120 : :
2121 : : /**
2122 : : * Sets the \a maximum value acceptable by the parameter.
2123 : : * \see maximum()
2124 : : */
2125 : : void setMaximum( double maximum );
2126 : :
2127 : : /**
2128 : : * Returns the acceptable data type for the parameter.
2129 : : * \see setDataType()
2130 : : */
2131 : : Type dataType() const;
2132 : :
2133 : : /**
2134 : : * Sets the acceptable data \a type for the parameter.
2135 : : * \see dataType()
2136 : : */
2137 : : void setDataType( Type type );
2138 : :
2139 : : QVariantMap toVariantMap() const override;
2140 : : bool fromVariantMap( const QVariantMap &map ) override;
2141 : :
2142 : : /**
2143 : : * Creates a new parameter using the definition from a script code.
2144 : : */
2145 : : static QgsProcessingParameterNumber *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2146 : :
2147 : : private:
2148 : :
2149 : : double mMin = std::numeric_limits<double>::lowest() + 1;
2150 : : double mMax = std::numeric_limits<double>::max();
2151 : : Type mDataType = Integer;
2152 : : };
2153 : :
2154 : : /**
2155 : : * \class QgsProcessingParameterDistance
2156 : : * \ingroup core
2157 : : * \brief A double numeric parameter for distance values. Linked to a source layer or CRS parameter
2158 : : * to determine what units the distance values are in.
2159 : : *
2160 : : * The number of decimals places shown in a distance parameter's widget can be specified by
2161 : : * setting the parameter's metadata. For example:
2162 : : *
2163 : : * \code{.py}
2164 : : * param = QgsProcessingParameterDistance( 'VAL', 'Threshold')
2165 : : * # only show two decimal places in parameter's widgets, not 6:
2166 : : * param.setMetadata( {'widget_wrapper':
2167 : : * { 'decimals': 2 }
2168 : : * })
2169 : : * \endcode
2170 : : *
2171 : : * \since QGIS 3.2
2172 : : */
2173 : 0 : class CORE_EXPORT QgsProcessingParameterDistance : public QgsProcessingParameterNumber
2174 : : {
2175 : : public:
2176 : :
2177 : : /**
2178 : : * Constructor for QgsProcessingParameterDistance.
2179 : : */
2180 : : explicit QgsProcessingParameterDistance( const QString &name, const QString &description = QString(),
2181 : : const QVariant &defaultValue = QVariant(),
2182 : : const QString &parentParameterName = QString(),
2183 : : bool optional = false,
2184 : : double minValue = std::numeric_limits<double>::lowest() + 1,
2185 : : double maxValue = std::numeric_limits<double>::max() );
2186 : :
2187 : : /**
2188 : : * Returns the type name for the parameter class.
2189 : : */
2190 : 0 : static QString typeName() { return QStringLiteral( "distance" ); }
2191 : :
2192 : : QgsProcessingParameterDistance *clone() const override SIP_FACTORY;
2193 : :
2194 : : QString type() const override;
2195 : : QStringList dependsOnOtherParameters() const override;
2196 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2197 : :
2198 : : /**
2199 : : * Returns the name of the parent parameter, or an empty string if this is not set.
2200 : : * \see setParentParameterName()
2201 : : */
2202 : : QString parentParameterName() const;
2203 : :
2204 : : /**
2205 : : * Sets the name of the parent layer parameter. Use an empty string if this is not required.
2206 : : * \see parentParameterName()
2207 : : */
2208 : : void setParentParameterName( const QString &parentParameterName );
2209 : :
2210 : : /**
2211 : : * Returns the default distance unit for the parameter.
2212 : : *
2213 : : * \see setDefaultUnit()
2214 : : * \since QGIS 3.4.3
2215 : : */
2216 : : QgsUnitTypes::DistanceUnit defaultUnit() const { return mDefaultUnit; }
2217 : :
2218 : : /**
2219 : : * Sets the default distance \a unit for the parameter.
2220 : : *
2221 : : * \see defaultUnit()
2222 : : * \since QGIS 3.4.3
2223 : : */
2224 : 0 : void setDefaultUnit( QgsUnitTypes::DistanceUnit unit ) { mDefaultUnit = unit; }
2225 : :
2226 : : QVariantMap toVariantMap() const override;
2227 : : bool fromVariantMap( const QVariantMap &map ) override;
2228 : :
2229 : : private:
2230 : :
2231 : : QString mParentParameterName;
2232 : : QgsUnitTypes::DistanceUnit mDefaultUnit = QgsUnitTypes::DistanceUnknownUnit;
2233 : :
2234 : : };
2235 : :
2236 : : /**
2237 : : * \class QgsProcessingParameterScale
2238 : : * \ingroup core
2239 : : * \brief A double numeric parameter for map scale values.
2240 : : *
2241 : : * QgsProcessingParameterScale should be evaluated by calling QgsProcessingAlgorithm::parameterAsDouble(),
2242 : : * which will return a numeric value representing the scale denominator.
2243 : : *
2244 : : * \since QGIS 3.8
2245 : : */
2246 : 0 : class CORE_EXPORT QgsProcessingParameterScale : public QgsProcessingParameterNumber
2247 : : {
2248 : : public:
2249 : :
2250 : : /**
2251 : : * Constructor for QgsProcessingParameterScale.
2252 : : */
2253 : : explicit QgsProcessingParameterScale( const QString &name, const QString &description = QString(),
2254 : : const QVariant &defaultValue = QVariant(),
2255 : : bool optional = false );
2256 : :
2257 : : /**
2258 : : * Returns the type name for the parameter class.
2259 : : */
2260 : 0 : static QString typeName() { return QStringLiteral( "scale" ); }
2261 : :
2262 : : QgsProcessingParameterScale *clone() const override SIP_FACTORY;
2263 : :
2264 : : QString type() const override;
2265 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2266 : :
2267 : : /**
2268 : : * Creates a new parameter using the definition from a script code.
2269 : : */
2270 : : static QgsProcessingParameterScale *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2271 : :
2272 : : };
2273 : :
2274 : : /**
2275 : : * \class QgsProcessingParameterRange
2276 : : * \ingroup core
2277 : : * \brief A numeric range parameter for processing algorithms.
2278 : : * \since QGIS 3.0
2279 : : */
2280 : 0 : class CORE_EXPORT QgsProcessingParameterRange : public QgsProcessingParameterDefinition
2281 : : {
2282 : : public:
2283 : :
2284 : : /**
2285 : : * Constructor for QgsProcessingParameterRange.
2286 : : */
2287 : : QgsProcessingParameterRange( const QString &name, const QString &description = QString(),
2288 : : QgsProcessingParameterNumber::Type type = QgsProcessingParameterNumber::Integer,
2289 : : const QVariant &defaultValue = QVariant(),
2290 : : bool optional = false );
2291 : :
2292 : : /**
2293 : : * Returns the type name for the parameter class.
2294 : : */
2295 : 0 : static QString typeName() { return QStringLiteral( "range" ); }
2296 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2297 : 0 : QString type() const override { return typeName(); }
2298 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2299 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2300 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2301 : :
2302 : : /**
2303 : : * Returns the acceptable data type for the range.
2304 : : * \see setDataType()
2305 : : */
2306 : : QgsProcessingParameterNumber::Type dataType() const;
2307 : :
2308 : : /**
2309 : : * Sets the acceptable data \a type for the range.
2310 : : * \see dataType()
2311 : : */
2312 : : void setDataType( QgsProcessingParameterNumber::Type dataType );
2313 : :
2314 : : QVariantMap toVariantMap() const override;
2315 : : bool fromVariantMap( const QVariantMap &map ) override;
2316 : :
2317 : : /**
2318 : : * Creates a new parameter using the definition from a script code.
2319 : : */
2320 : : static QgsProcessingParameterRange *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2321 : :
2322 : : private:
2323 : :
2324 : : QgsProcessingParameterNumber::Type mDataType = QgsProcessingParameterNumber::Integer;
2325 : : };
2326 : :
2327 : : /**
2328 : : * \class QgsProcessingParameterRasterLayer
2329 : : * \ingroup core
2330 : : * \brief A raster layer parameter for processing algorithms.
2331 : : * \since QGIS 3.0
2332 : : */
2333 : 0 : class CORE_EXPORT QgsProcessingParameterRasterLayer : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
2334 : : {
2335 : : public:
2336 : :
2337 : : /**
2338 : : * Constructor for QgsProcessingParameterRasterLayer.
2339 : : */
2340 : : QgsProcessingParameterRasterLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2341 : : bool optional = false );
2342 : :
2343 : : /**
2344 : : * Returns the type name for the parameter class.
2345 : : */
2346 : 0 : static QString typeName() { return QStringLiteral( "raster" ); }
2347 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2348 : 0 : QString type() const override { return typeName(); }
2349 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2350 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2351 : : QString createFileFilter() const override;
2352 : :
2353 : : /**
2354 : : * Creates a new parameter using the definition from a script code.
2355 : : */
2356 : : static QgsProcessingParameterRasterLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2357 : :
2358 : : };
2359 : :
2360 : : /**
2361 : : * \class QgsProcessingParameterEnum
2362 : : * \ingroup core
2363 : : * \brief An enum based parameter for processing algorithms, allowing for selection from predefined values.
2364 : : * \since QGIS 3.0
2365 : : */
2366 : 10 : class CORE_EXPORT QgsProcessingParameterEnum : public QgsProcessingParameterDefinition
2367 : : {
2368 : : public:
2369 : :
2370 : : /**
2371 : : * Constructor for QgsProcessingParameterEnum.
2372 : : */
2373 : : QgsProcessingParameterEnum( const QString &name, const QString &description = QString(), const QStringList &options = QStringList(),
2374 : : bool allowMultiple = false,
2375 : : const QVariant &defaultValue = QVariant(),
2376 : : bool optional = false,
2377 : : bool usesStaticStrings = false );
2378 : :
2379 : : /**
2380 : : * Returns the type name for the parameter class.
2381 : : */
2382 : 0 : static QString typeName() { return QStringLiteral( "enum" ); }
2383 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2384 : 0 : QString type() const override { return typeName(); }
2385 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2386 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2387 : : QString valueAsPythonComment( const QVariant &value, QgsProcessingContext &context ) const override;
2388 : : QString asScriptCode() const override;
2389 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2390 : :
2391 : : /**
2392 : : * Returns the list of acceptable options for the parameter.
2393 : : * \see setOptions()
2394 : : */
2395 : : QStringList options() const;
2396 : :
2397 : : /**
2398 : : * Sets the list of acceptable \a options for the parameter.
2399 : : * \see options()
2400 : : */
2401 : : void setOptions( const QStringList &options );
2402 : :
2403 : : /**
2404 : : * Returns TRUE if the parameter allows multiple selected values.
2405 : : * \see setAllowMultiple()
2406 : : */
2407 : : bool allowMultiple() const;
2408 : :
2409 : : /**
2410 : : * Sets whether the parameter allows multiple selected values.
2411 : : * \see allowMultiple()
2412 : : */
2413 : : void setAllowMultiple( bool allowMultiple );
2414 : :
2415 : : /**
2416 : : * Returns TRUE if the parameter uses static (non-translated) string
2417 : : * values for its enumeration choice list.
2418 : : * \see setUsesStaticStrings()
2419 : : * \since QGIS 3.18
2420 : : */
2421 : : bool usesStaticStrings() const;
2422 : :
2423 : : /**
2424 : : * Sets whether the parameter uses static (non-translated) string
2425 : : * values for its enumeration choice list.
2426 : : * \see usesStaticStrings()
2427 : : * \since QGIS 3.18
2428 : : */
2429 : : void setUsesStaticStrings( bool usesStaticStrings );
2430 : :
2431 : : QVariantMap toVariantMap() const override;
2432 : : bool fromVariantMap( const QVariantMap &map ) override;
2433 : :
2434 : : /**
2435 : : * Creates a new parameter using the definition from a script code.
2436 : : */
2437 : : static QgsProcessingParameterEnum *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2438 : :
2439 : : private:
2440 : :
2441 : : QStringList mOptions;
2442 : : bool mAllowMultiple = false;
2443 : : bool mUsesStaticStrings = false;
2444 : : };
2445 : :
2446 : : /**
2447 : : * \class QgsProcessingParameterString
2448 : : * \ingroup core
2449 : : * \brief A string parameter for processing algorithms.
2450 : : * \since QGIS 3.0
2451 : : */
2452 : 0 : class CORE_EXPORT QgsProcessingParameterString : public QgsProcessingParameterDefinition
2453 : : {
2454 : : public:
2455 : :
2456 : : /**
2457 : : * Constructor for QgsProcessingParameterString.
2458 : : */
2459 : : QgsProcessingParameterString( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2460 : : bool multiLine = false,
2461 : : bool optional = false );
2462 : :
2463 : : /**
2464 : : * Returns the type name for the parameter class.
2465 : : */
2466 : 0 : static QString typeName() { return QStringLiteral( "string" ); }
2467 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2468 : 0 : QString type() const override { return typeName(); }
2469 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2470 : : QString asScriptCode() const override;
2471 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2472 : :
2473 : : /**
2474 : : * Returns TRUE if the parameter allows multiline strings.
2475 : : * \see setMultiLine()
2476 : : */
2477 : : bool multiLine() const;
2478 : :
2479 : : /**
2480 : : * Sets whether the parameter allows multiline strings.
2481 : : * \see multiLine()
2482 : : */
2483 : : void setMultiLine( bool multiLine );
2484 : :
2485 : : QVariantMap toVariantMap() const override;
2486 : : bool fromVariantMap( const QVariantMap &map ) override;
2487 : :
2488 : : /**
2489 : : * Creates a new parameter using the definition from a script code.
2490 : : */
2491 : : static QgsProcessingParameterString *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2492 : :
2493 : : private:
2494 : :
2495 : : bool mMultiLine = false;
2496 : :
2497 : : };
2498 : :
2499 : :
2500 : : /**
2501 : : * \class QgsProcessingParameterAuthConfig
2502 : : * \ingroup core
2503 : : * \brief A string parameter for authentication configuration ID values.
2504 : : *
2505 : : * This parameter allows for users to select from available authentication configurations,
2506 : : * or create new authentication configurations as required.
2507 : : *
2508 : : * QgsProcessingParameterAuthConfig should be evaluated by calling QgsProcessingAlgorithm::parameterAsString().
2509 : : *
2510 : : * \since QGIS 3.6
2511 : : */
2512 : 0 : class CORE_EXPORT QgsProcessingParameterAuthConfig : public QgsProcessingParameterDefinition
2513 : : {
2514 : : public:
2515 : :
2516 : : /**
2517 : : * Constructor for QgsProcessingParameterAuthConfig.
2518 : : */
2519 : : QgsProcessingParameterAuthConfig( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2520 : : bool optional = false );
2521 : :
2522 : : /**
2523 : : * Returns the type name for the parameter class.
2524 : : */
2525 : 0 : static QString typeName() { return QStringLiteral( "authcfg" ); }
2526 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2527 : 0 : QString type() const override { return typeName(); }
2528 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2529 : : QString asScriptCode() const override;
2530 : :
2531 : : /**
2532 : : * Creates a new parameter using the definition from a script code.
2533 : : */
2534 : : static QgsProcessingParameterAuthConfig *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2535 : :
2536 : : };
2537 : :
2538 : : /**
2539 : : * \class QgsProcessingParameterExpression
2540 : : * \ingroup core
2541 : : * \brief An expression parameter for processing algorithms.
2542 : : * \since QGIS 3.0
2543 : : */
2544 : 0 : class CORE_EXPORT QgsProcessingParameterExpression : public QgsProcessingParameterDefinition
2545 : : {
2546 : : public:
2547 : :
2548 : : /**
2549 : : * Constructor for QgsProcessingParameterExpression.
2550 : : */
2551 : : QgsProcessingParameterExpression( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2552 : : const QString &parentLayerParameterName = QString(),
2553 : : bool optional = false );
2554 : :
2555 : : /**
2556 : : * Returns the type name for the parameter class.
2557 : : */
2558 : 0 : static QString typeName() { return QStringLiteral( "expression" ); }
2559 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2560 : 0 : QString type() const override { return typeName(); }
2561 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2562 : : QStringList dependsOnOtherParameters() const override;
2563 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2564 : :
2565 : : /**
2566 : : * Returns the name of the parent layer parameter, or an empty string if this is not set.
2567 : : * \see setParentLayerParameterName()
2568 : : */
2569 : : QString parentLayerParameterName() const;
2570 : :
2571 : : /**
2572 : : * Sets the name of the parent layer parameter. Use an empty string if this is not required.
2573 : : * \see parentLayerParameterName()
2574 : : */
2575 : : void setParentLayerParameterName( const QString &parentLayerParameterName );
2576 : :
2577 : : QVariantMap toVariantMap() const override;
2578 : : bool fromVariantMap( const QVariantMap &map ) override;
2579 : :
2580 : : /**
2581 : : * Creates a new parameter using the definition from a script code.
2582 : : */
2583 : : static QgsProcessingParameterExpression *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2584 : :
2585 : : private:
2586 : :
2587 : : QString mParentLayerParameterName;
2588 : :
2589 : : };
2590 : :
2591 : :
2592 : : /**
2593 : : * \class QgsProcessingParameterLimitedDataTypes
2594 : : * \ingroup core
2595 : : * \brief Can be inherited by parameters which require limits to their acceptable data types.
2596 : : * \since QGIS 3.0
2597 : : */
2598 : 0 : class CORE_EXPORT QgsProcessingParameterLimitedDataTypes
2599 : : {
2600 : : public:
2601 : :
2602 : : /**
2603 : : * Constructor for QgsProcessingParameterLimitedDataTypes, with a list of acceptable data \a types.
2604 : : */
2605 : : QgsProcessingParameterLimitedDataTypes( const QList< int > &types = QList< int >() );
2606 : :
2607 : : /**
2608 : : * Returns the geometry types for sources acceptable by the parameter.
2609 : : * \see setDataTypes()
2610 : : */
2611 : : QList< int > dataTypes() const;
2612 : :
2613 : : /**
2614 : : * Sets the geometry \a types for sources acceptable by the parameter.
2615 : : * \see dataTypes()
2616 : : */
2617 : : void setDataTypes( const QList< int > &types );
2618 : :
2619 : : protected:
2620 : :
2621 : : //! List of acceptable data types for the parameter
2622 : : QList< int > mDataTypes;
2623 : : };
2624 : :
2625 : : /**
2626 : : * \class QgsProcessingParameterVectorLayer
2627 : : * \ingroup core
2628 : : * \brief A vector layer (with or without geometry) parameter for processing algorithms. Consider using
2629 : : * the more versatile QgsProcessingParameterFeatureSource wherever possible.
2630 : : * \since QGIS 3.0
2631 : : */
2632 : 0 : class CORE_EXPORT QgsProcessingParameterVectorLayer : public QgsProcessingParameterDefinition, public QgsProcessingParameterLimitedDataTypes, public QgsFileFilterGenerator
2633 : : {
2634 : : public:
2635 : :
2636 : : /**
2637 : : * Constructor for QgsProcessingParameterVectorLayer.
2638 : : */
2639 : : QgsProcessingParameterVectorLayer( const QString &name,
2640 : : const QString &description = QString(),
2641 : : const QList< int > &types = QList< int >(),
2642 : : const QVariant &defaultValue = QVariant(),
2643 : : bool optional = false );
2644 : :
2645 : : /**
2646 : : * Returns the type name for the parameter class.
2647 : : */
2648 : 0 : static QString typeName() { return QStringLiteral( "vector" ); }
2649 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2650 : 0 : QString type() const override { return typeName(); }
2651 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2652 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2653 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2654 : : QString createFileFilter() const override;
2655 : :
2656 : : QVariantMap toVariantMap() const override;
2657 : : bool fromVariantMap( const QVariantMap &map ) override;
2658 : :
2659 : : /**
2660 : : * Creates a new parameter using the definition from a script code.
2661 : : */
2662 : : static QgsProcessingParameterVectorLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2663 : :
2664 : : };
2665 : :
2666 : : /**
2667 : : * \class QgsProcessingParameterMeshLayer
2668 : : * \ingroup core
2669 : : * \brief A mesh layer parameter for processing algorithms.
2670 : : * \since QGIS 3.6
2671 : : */
2672 : 0 : class CORE_EXPORT QgsProcessingParameterMeshLayer : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
2673 : : {
2674 : : public:
2675 : :
2676 : : /**
2677 : : * Constructor for QgsProcessingParameterMeshLayer.
2678 : : */
2679 : : QgsProcessingParameterMeshLayer( const QString &name,
2680 : : const QString &description = QString(),
2681 : : const QVariant &defaultValue = QVariant(),
2682 : : bool optional = false );
2683 : :
2684 : : /**
2685 : : * Returns the type name for the parameter class.
2686 : : */
2687 : 0 : static QString typeName() { return QStringLiteral( "mesh" ); }
2688 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2689 : 0 : QString type() const override { return typeName(); }
2690 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2691 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2692 : : QString createFileFilter() const override;
2693 : :
2694 : : /**
2695 : : * Creates a new parameter using the definition from a script code.
2696 : : */
2697 : : static QgsProcessingParameterMeshLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2698 : : };
2699 : :
2700 : : /**
2701 : : * \class QgsProcessingParameterMapLayer
2702 : : * \ingroup core
2703 : : * \brief A map layer parameter for processing algorithms.
2704 : : * \since QGIS 3.0
2705 : : */
2706 : 0 : class CORE_EXPORT QgsProcessingParameterMapLayer : public QgsProcessingParameterDefinition, public QgsProcessingParameterLimitedDataTypes, public QgsFileFilterGenerator
2707 : : {
2708 : : public:
2709 : :
2710 : : /**
2711 : : * Constructor for QgsProcessingParameterMapLayer.
2712 : : */
2713 : : QgsProcessingParameterMapLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2714 : : bool optional = false,
2715 : : const QList< int > &types = QList< int >() );
2716 : :
2717 : : /**
2718 : : * Returns the type name for the parameter class.
2719 : : */
2720 : 0 : static QString typeName() { return QStringLiteral( "layer" ); }
2721 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2722 : 0 : QString type() const override { return typeName(); }
2723 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2724 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2725 : : QString asScriptCode() const override;
2726 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2727 : : QString createFileFilter() const override;
2728 : :
2729 : : QVariantMap toVariantMap() const override;
2730 : : bool fromVariantMap( const QVariantMap &map ) override;
2731 : :
2732 : : /**
2733 : : * Creates a new parameter using the definition from a script code.
2734 : : */
2735 : : static QgsProcessingParameterMapLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2736 : :
2737 : : };
2738 : :
2739 : : /**
2740 : : * \class QgsProcessingParameterField
2741 : : * \ingroup core
2742 : : * \brief A vector layer or feature source field parameter for processing algorithms.
2743 : : * \since QGIS 3.0
2744 : : */
2745 : 0 : class CORE_EXPORT QgsProcessingParameterField : public QgsProcessingParameterDefinition
2746 : : {
2747 : : public:
2748 : :
2749 : : //! Field data types
2750 : : enum DataType
2751 : : {
2752 : : Any = -1, //!< Accepts any field
2753 : : Numeric = 0, //!< Accepts numeric fields
2754 : : String = 1, //!< Accepts string fields
2755 : : DateTime = 2 //!< Accepts datetime fields
2756 : : };
2757 : :
2758 : : /**
2759 : : * Constructor for QgsProcessingParameterField.
2760 : : */
2761 : : QgsProcessingParameterField( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2762 : : const QString &parentLayerParameterName = QString(),
2763 : : DataType type = Any,
2764 : : bool allowMultiple = false,
2765 : : bool optional = false,
2766 : : bool defaultToAllFields = false );
2767 : :
2768 : : /**
2769 : : * Returns the type name for the parameter class.
2770 : : */
2771 : 0 : static QString typeName() { return QStringLiteral( "field" ); }
2772 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2773 : 0 : QString type() const override { return typeName(); }
2774 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2775 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2776 : : QString asScriptCode() const override;
2777 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2778 : : QStringList dependsOnOtherParameters() const override;
2779 : :
2780 : : /**
2781 : : * Returns the name of the parent layer parameter, or an empty string if this is not set.
2782 : : * \see setParentLayerParameterName()
2783 : : */
2784 : : QString parentLayerParameterName() const;
2785 : :
2786 : : /**
2787 : : * Sets the name of the parent layer parameter. Use an empty string if this is not required.
2788 : : * \see parentLayerParameterName()
2789 : : */
2790 : : void setParentLayerParameterName( const QString &parentLayerParameterName );
2791 : :
2792 : : /**
2793 : : * Returns the acceptable data type for the field.
2794 : : * \see setDataType()
2795 : : */
2796 : : DataType dataType() const;
2797 : :
2798 : : /**
2799 : : * Sets the acceptable data \a type for the field.
2800 : : * \see dataType()
2801 : : */
2802 : : void setDataType( DataType type );
2803 : :
2804 : : /**
2805 : : * Returns whether multiple field selections are permitted.
2806 : : * \see setAllowMultiple()
2807 : : */
2808 : : bool allowMultiple() const;
2809 : :
2810 : : /**
2811 : : * Sets whether multiple field selections are permitted.
2812 : : * \see allowMultiple()
2813 : : */
2814 : : void setAllowMultiple( bool allowMultiple );
2815 : :
2816 : : /**
2817 : : * Returns whether a parameter which allows multiple selections (see allowMultiple()) should automatically
2818 : : * select all fields as the default value.
2819 : : *
2820 : : * If TRUE, this will override any existing defaultValue() set on the parameter.
2821 : : *
2822 : : * \see setDefaultToAllFields()
2823 : : * \since QGIS 3.12
2824 : : */
2825 : : bool defaultToAllFields() const;
2826 : :
2827 : : /**
2828 : : * Sets whether a parameter which allows multiple selections (see allowMultiple()) should automatically
2829 : : * select all fields as the default value.
2830 : : *
2831 : : * If TRUE, this will override any existing defaultValue() set on the parameter.
2832 : : *
2833 : : * \see defaultToAllFields()
2834 : : * \since QGIS 3.12
2835 : : */
2836 : : void setDefaultToAllFields( bool enabled );
2837 : :
2838 : : QVariantMap toVariantMap() const override;
2839 : : bool fromVariantMap( const QVariantMap &map ) override;
2840 : :
2841 : : /**
2842 : : * Creates a new parameter using the definition from a script code.
2843 : : */
2844 : : static QgsProcessingParameterField *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2845 : :
2846 : : private:
2847 : :
2848 : : QString mParentLayerParameterName;
2849 : : DataType mDataType = Any;
2850 : : bool mAllowMultiple = false;
2851 : : bool mDefaultToAllFields = false;
2852 : :
2853 : : };
2854 : :
2855 : :
2856 : : /**
2857 : : * \class QgsProcessingParameterFeatureSource
2858 : : * \ingroup core
2859 : : * \brief An input feature source (such as vector layers) parameter for processing algorithms.
2860 : : * \since QGIS 3.0
2861 : : */
2862 : 0 : class CORE_EXPORT QgsProcessingParameterFeatureSource : public QgsProcessingParameterDefinition, public QgsProcessingParameterLimitedDataTypes, public QgsFileFilterGenerator
2863 : : {
2864 : : public:
2865 : :
2866 : : /**
2867 : : * Constructor for QgsProcessingParameterFeatureSource.
2868 : : */
2869 : : QgsProcessingParameterFeatureSource( const QString &name, const QString &description = QString(),
2870 : : const QList< int > &types = QList< int >(),
2871 : : const QVariant &defaultValue = QVariant(), bool optional = false );
2872 : :
2873 : : /**
2874 : : * Returns the type name for the parameter class.
2875 : : */
2876 : 0 : static QString typeName() { return QStringLiteral( "source" ); }
2877 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2878 : 0 : QString type() const override { return typeName(); }
2879 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2880 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2881 : : QString asScriptCode() const override;
2882 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2883 : : QString createFileFilter() const override;
2884 : :
2885 : : QVariantMap toVariantMap() const override;
2886 : : bool fromVariantMap( const QVariantMap &map ) override;
2887 : :
2888 : : /**
2889 : : * Creates a new parameter using the definition from a script code.
2890 : : */
2891 : : static QgsProcessingParameterFeatureSource *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2892 : :
2893 : : };
2894 : :
2895 : : /**
2896 : : * \class QgsProcessingDestinationParameter
2897 : : * \ingroup core
2898 : : * \brief Base class for all parameter definitions which represent file or layer destinations, e.g. parameters
2899 : : * which are used for the destination for layers output by an algorithm.
2900 : : * \since QGIS 3.0
2901 : : */
2902 : 0 : class CORE_EXPORT QgsProcessingDestinationParameter : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
2903 : : {
2904 : : public:
2905 : :
2906 : : /**
2907 : : * Constructor for QgsProcessingDestinationParameter.
2908 : : *
2909 : : * If \a createByDefault is FALSE and the parameter is \a optional, then the destination
2910 : : * output will not be created by default.
2911 : : */
2912 : : QgsProcessingDestinationParameter( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2913 : : bool optional = false, bool createByDefault = true );
2914 : :
2915 : 0 : bool isDestination() const override { return true; }
2916 : : QVariantMap toVariantMap() const override;
2917 : : bool fromVariantMap( const QVariantMap &map ) override;
2918 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2919 : : QString createFileFilter() const override;
2920 : :
2921 : : /**
2922 : : * Returns a new QgsProcessingOutputDefinition corresponding to the definition of the destination
2923 : : * parameter.
2924 : : */
2925 : : virtual QgsProcessingOutputDefinition *toOutputDefinition() const = 0 SIP_FACTORY;
2926 : :
2927 : : /**
2928 : : * Returns TRUE if the destination parameter supports non filed-based outputs,
2929 : : * such as memory layers or direct database outputs.
2930 : : * \see setSupportsNonFileBasedOutput()
2931 : : */
2932 : 0 : bool supportsNonFileBasedOutput() const { return mSupportsNonFileBasedOutputs; }
2933 : :
2934 : : /**
2935 : : * Sets whether the destination parameter supports non filed-based outputs,
2936 : : * such as memory layers or direct database outputs.
2937 : : * \see supportsNonFileBasedOutput()
2938 : : */
2939 : 0 : void setSupportsNonFileBasedOutput( bool supportsNonFileBasedOutput ) { mSupportsNonFileBasedOutputs = supportsNonFileBasedOutput; }
2940 : :
2941 : : /**
2942 : : * Returns the default file extension for destination file paths
2943 : : * associated with this parameter.
2944 : : */
2945 : : virtual QString defaultFileExtension() const = 0;
2946 : :
2947 : : /**
2948 : : * Generates a temporary destination value for this parameter. The returned
2949 : : * value will be a file path or QGIS data provider URI suitable for
2950 : : * temporary storage of created layers and files.
2951 : : */
2952 : : virtual QString generateTemporaryDestination() const;
2953 : :
2954 : : /**
2955 : : * Tests whether a \a value is a supported value for this parameter.
2956 : : *
2957 : : * Will return FALSE when a \a value with an unsupported file extension is specified. The default implementation
2958 : : * calls QgsProcessingProvider::isSupportedOutputValue() to test compatibility.
2959 : : *
2960 : : * \param value value to test
2961 : : * \param context Processing context
2962 : : * \param error will be set to a descriptive error string
2963 : : *
2964 : : * \returns TRUE if \a value is supported.
2965 : : *
2966 : : * \since QGIS 3.14
2967 : : */
2968 : : virtual bool isSupportedOutputValue( const QVariant &value, QgsProcessingContext &context, QString &error SIP_OUT ) const;
2969 : :
2970 : : /**
2971 : : * Returns TRUE if the destination should be created by default. For optional parameters,
2972 : : * a return value of FALSE indicates that the destination should not be created by default.
2973 : : * \see setCreateByDefault()
2974 : : */
2975 : : bool createByDefault() const;
2976 : :
2977 : : /**
2978 : : * Sets whether the destination should be created by default. For optional parameters,
2979 : : * a value of FALSE indicates that the destination should not be created by default.
2980 : : * \see createByDefault()
2981 : : */
2982 : : void setCreateByDefault( bool createByDefault );
2983 : :
2984 : : protected:
2985 : :
2986 : : /**
2987 : : * Original (source) provider which this parameter has been derived from.
2988 : : * In the case of destination parameters which are part of model algorithms, this
2989 : : * will reflect the child algorithm's provider which actually generates the
2990 : : * parameter, as opposed to the provider which this parameter belongs to (i.e.
2991 : : * the model provider)
2992 : : * \since QGIS 3.2
2993 : : */
2994 : 0 : QgsProcessingProvider *originalProvider() const { return mOriginalProvider; }
2995 : :
2996 : : private:
2997 : :
2998 : : /**
2999 : : * Original (source) provider which this parameter has been derived from.
3000 : : * In the case of destination parameters which are part of model algorithms, this
3001 : : * will reflect the child algorithm's provider which actually generates the
3002 : : * parameter, as opposed to the provider which this parameter belongs to (i.e.
3003 : : * the model provider)
3004 : : */
3005 : : QgsProcessingProvider *mOriginalProvider = nullptr;
3006 : :
3007 : : bool mSupportsNonFileBasedOutputs = true;
3008 : : bool mCreateByDefault = true;
3009 : :
3010 : : friend class QgsProcessingModelAlgorithm;
3011 : : friend class TestQgsProcessing;
3012 : : };
3013 : :
3014 : :
3015 : : /**
3016 : : * \class QgsProcessingParameterFeatureSink
3017 : : * \ingroup core
3018 : : * \brief A feature sink output for processing algorithms.
3019 : : *
3020 : : * A parameter which represents the destination feature sink for features created by an algorithm.
3021 : : * \since QGIS 3.0
3022 : : */
3023 : 0 : class CORE_EXPORT QgsProcessingParameterFeatureSink : public QgsProcessingDestinationParameter
3024 : : {
3025 : : public:
3026 : :
3027 : : /**
3028 : : * Constructor for QgsProcessingParameterFeatureSink.
3029 : : *
3030 : : * If \a createByDefault is FALSE and the parameter is \a optional, then this destination
3031 : : * output will not be created by default.
3032 : : */
3033 : : QgsProcessingParameterFeatureSink( const QString &name, const QString &description = QString(), QgsProcessing::SourceType type = QgsProcessing::TypeVectorAnyGeometry, const QVariant &defaultValue = QVariant(),
3034 : : bool optional = false, bool createByDefault = true, bool supportsAppend = false );
3035 : :
3036 : : /**
3037 : : * Returns the type name for the parameter class.
3038 : : */
3039 : 0 : static QString typeName() { return QStringLiteral( "sink" ); }
3040 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3041 : 0 : QString type() const override { return typeName(); }
3042 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3043 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3044 : : QString asScriptCode() const override;
3045 : : QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
3046 : : QString defaultFileExtension() const override;
3047 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3048 : : QString createFileFilter() const override;
3049 : :
3050 : : /**
3051 : : * Returns a list of the vector format file extensions supported by this parameter.
3052 : : * \see defaultFileExtension()
3053 : : * \since QGIS 3.2
3054 : : */
3055 : : virtual QStringList supportedOutputVectorLayerExtensions() const;
3056 : :
3057 : : /**
3058 : : * Returns the layer type for sinks associated with the parameter.
3059 : : * \see setDataType()
3060 : : */
3061 : : QgsProcessing::SourceType dataType() const;
3062 : :
3063 : : /**
3064 : : * Returns TRUE if sink is likely to include geometries. In cases were presence of geometry
3065 : : * cannot be reliably determined in advance, this method will default to returning TRUE.
3066 : : */
3067 : : bool hasGeometry() const;
3068 : :
3069 : : /**
3070 : : * Sets the layer \a type for the sinks associated with the parameter.
3071 : : * \see dataType()
3072 : : */
3073 : : void setDataType( QgsProcessing::SourceType type );
3074 : :
3075 : : /**
3076 : : * Returns TRUE if the sink supports appending features to an existing table.
3077 : : *
3078 : : * A sink only supports appending if the algorithm implements QgsProcessingAlgorithm::sinkProperties for the sink parameter.
3079 : : *
3080 : : * \see setSupportsAppend()
3081 : : * \since QGIS 3.14
3082 : : */
3083 : : bool supportsAppend() const;
3084 : :
3085 : : /**
3086 : : * Sets whether the sink supports appending features to an existing table.
3087 : : *
3088 : : * \warning A sink only supports appending if the algorithm implements QgsProcessingAlgorithm::sinkProperties for the sink parameter.
3089 : : *
3090 : : * \see supportsAppend()
3091 : : * \since QGIS 3.14
3092 : : */
3093 : : void setSupportsAppend( bool supportsAppend );
3094 : :
3095 : : QVariantMap toVariantMap() const override;
3096 : : bool fromVariantMap( const QVariantMap &map ) override;
3097 : : QString generateTemporaryDestination() const override;
3098 : :
3099 : : /**
3100 : : * Creates a new parameter using the definition from a script code.
3101 : : */
3102 : : static QgsProcessingParameterFeatureSink *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3103 : :
3104 : : private:
3105 : :
3106 : : QgsProcessing::SourceType mDataType = QgsProcessing::TypeVectorAnyGeometry;
3107 : : bool mSupportsAppend = false;
3108 : : };
3109 : :
3110 : :
3111 : : /**
3112 : : * \class QgsProcessingParameterVectorDestination
3113 : : * \ingroup core
3114 : : * \brief A vector layer destination parameter, for specifying the destination path for a vector layer
3115 : : * created by the algorithm.
3116 : : *
3117 : : * \note Consider using the more flexible QgsProcessingParameterFeatureSink wherever
3118 : : * possible.
3119 : : * \since QGIS 3.0
3120 : : */
3121 : 0 : class CORE_EXPORT QgsProcessingParameterVectorDestination : public QgsProcessingDestinationParameter
3122 : : {
3123 : : public:
3124 : :
3125 : : /**
3126 : : * Constructor for QgsProcessingParameterVectorDestination.
3127 : : *
3128 : : * If \a createByDefault is FALSE and the parameter is \a optional, then this destination
3129 : : * output will not be created by default.
3130 : : */
3131 : : QgsProcessingParameterVectorDestination( const QString &name, const QString &description = QString(), QgsProcessing::SourceType type = QgsProcessing::TypeVectorAnyGeometry, const QVariant &defaultValue = QVariant(),
3132 : : bool optional = false, bool createByDefault = true );
3133 : :
3134 : : /**
3135 : : * Returns the type name for the parameter class.
3136 : : */
3137 : 0 : static QString typeName() { return QStringLiteral( "vectorDestination" ); }
3138 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3139 : 0 : QString type() const override { return typeName(); }
3140 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3141 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3142 : : QString asScriptCode() const override;
3143 : : QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
3144 : : QString defaultFileExtension() const override;
3145 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3146 : : QString createFileFilter() const override;
3147 : :
3148 : : /**
3149 : : * Returns a list of the vector format file extensions supported by this parameter.
3150 : : * \see defaultFileExtension()
3151 : : * \since QGIS 3.2
3152 : : */
3153 : : virtual QStringList supportedOutputVectorLayerExtensions() const;
3154 : :
3155 : : /**
3156 : : * Returns the layer type for this created vector layer.
3157 : : * \see setDataType()
3158 : : */
3159 : : QgsProcessing::SourceType dataType() const;
3160 : :
3161 : : /**
3162 : : * Returns TRUE if the created layer is likely to include geometries. In cases were presence of geometry
3163 : : * cannot be reliably determined in advance, this method will default to returning TRUE.
3164 : : */
3165 : : bool hasGeometry() const;
3166 : :
3167 : : /**
3168 : : * Sets the layer \a type for the created vector layer.
3169 : : * \see dataType()
3170 : : */
3171 : : void setDataType( QgsProcessing::SourceType type );
3172 : :
3173 : : QVariantMap toVariantMap() const override;
3174 : : bool fromVariantMap( const QVariantMap &map ) override;
3175 : :
3176 : : /**
3177 : : * Creates a new parameter using the definition from a script code.
3178 : : */
3179 : : static QgsProcessingParameterVectorDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3180 : :
3181 : :
3182 : : private:
3183 : :
3184 : : QgsProcessing::SourceType mDataType = QgsProcessing::TypeVectorAnyGeometry;
3185 : : };
3186 : :
3187 : : /**
3188 : : * \class QgsProcessingParameterRasterDestination
3189 : : * \ingroup core
3190 : : * \brief A raster layer destination parameter, for specifying the destination path for a raster layer
3191 : : * created by the algorithm.
3192 : : * \since QGIS 3.0
3193 : : */
3194 : 0 : class CORE_EXPORT QgsProcessingParameterRasterDestination : public QgsProcessingDestinationParameter
3195 : : {
3196 : : public:
3197 : :
3198 : : /**
3199 : : * Constructor for QgsProcessingParameterRasterDestination.
3200 : : *
3201 : : * If \a createByDefault is FALSE and the parameter is \a optional, then this destination
3202 : : * output will not be created by default.
3203 : : */
3204 : : QgsProcessingParameterRasterDestination( const QString &name, const QString &description = QString(),
3205 : : const QVariant &defaultValue = QVariant(),
3206 : : bool optional = false,
3207 : : bool createByDefault = true );
3208 : :
3209 : : /**
3210 : : * Returns the type name for the parameter class.
3211 : : */
3212 : 0 : static QString typeName() { return QStringLiteral( "rasterDestination" ); }
3213 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3214 : 0 : QString type() const override { return typeName(); }
3215 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3216 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3217 : : QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
3218 : : QString defaultFileExtension() const override;
3219 : : QString createFileFilter() const override;
3220 : :
3221 : : /**
3222 : : * Returns a list of the raster format file extensions supported for this parameter.
3223 : : * \see defaultFileExtension()
3224 : : * \since QGIS 3.2
3225 : : */
3226 : : virtual QStringList supportedOutputRasterLayerExtensions() const;
3227 : :
3228 : : /**
3229 : : * Creates a new parameter using the definition from a script code.
3230 : : */
3231 : : static QgsProcessingParameterRasterDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3232 : : };
3233 : :
3234 : : /**
3235 : : * \class QgsProcessingParameterFileDestination
3236 : : * \ingroup core
3237 : : * \brief A generic file based destination parameter, for specifying the destination path for a file (non-map layer)
3238 : : * created by the algorithm.
3239 : : *
3240 : : * In some circumstances it is desirable to avoid the usual file overwriting confirmation prompt when
3241 : : * users select an existing destination file for this parameter type (e.g., for algorithms which
3242 : : * append to an existing destination file instead of overwriting them.). This can be done by setting
3243 : : * the widget wrapper metadata "dontconfirmoverwrite" option:
3244 : : *
3245 : : * \code{.py}
3246 : : * param = QgsProcessingParameterFileDestination( 'OUTPUT', 'Destination file')
3247 : : * # don't show the file overwrite warning when users select a destination file:
3248 : : * param.setMetadata( {'widget_wrapper':
3249 : : * { 'dontconfirmoverwrite': True }
3250 : : * })
3251 : : * \endcode
3252 : : *
3253 : : * \since QGIS 3.0
3254 : : */
3255 : 0 : class CORE_EXPORT QgsProcessingParameterFileDestination : public QgsProcessingDestinationParameter
3256 : : {
3257 : : public:
3258 : :
3259 : : /**
3260 : : * Constructor for QgsProcessingParameterFileDestination.
3261 : : *
3262 : : * If \a createByDefault is FALSE and the parameter is \a optional, then this destination
3263 : : * output will not be created by default.
3264 : : */
3265 : : QgsProcessingParameterFileDestination( const QString &name, const QString &description = QString(),
3266 : : const QString &fileFilter = QString(),
3267 : : const QVariant &defaultValue = QVariant(),
3268 : : bool optional = false,
3269 : : bool createByDefault = true );
3270 : :
3271 : : /**
3272 : : * Returns the type name for the parameter class.
3273 : : */
3274 : 0 : static QString typeName() { return QStringLiteral( "fileDestination" ); }
3275 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3276 : 0 : QString type() const override { return typeName(); }
3277 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3278 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3279 : : QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
3280 : : QString defaultFileExtension() const override;
3281 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3282 : : QString createFileFilter() const override;
3283 : :
3284 : : /**
3285 : : * Returns the file filter string for file destinations compatible with this parameter.
3286 : : * \see setFileFilter()
3287 : : */
3288 : : QString fileFilter() const;
3289 : :
3290 : : /**
3291 : : * Sets the file \a filter string for file destinations compatible with this parameter.
3292 : : * \see fileFilter()
3293 : : */
3294 : : void setFileFilter( const QString &filter );
3295 : :
3296 : : QVariantMap toVariantMap() const override;
3297 : : bool fromVariantMap( const QVariantMap &map ) override;
3298 : :
3299 : : /**
3300 : : * Creates a new parameter using the definition from a script code.
3301 : : */
3302 : : static QgsProcessingParameterFileDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3303 : :
3304 : :
3305 : : private:
3306 : :
3307 : : QString mFileFilter;
3308 : : };
3309 : :
3310 : : /**
3311 : : * \class QgsProcessingParameterFolderDestination
3312 : : * \ingroup core
3313 : : * \brief A folder destination parameter, for specifying the destination path for a folder created
3314 : : * by the algorithm or used for creating new files within the algorithm.
3315 : : * \since QGIS 3.0
3316 : : */
3317 : 0 : class CORE_EXPORT QgsProcessingParameterFolderDestination : public QgsProcessingDestinationParameter
3318 : : {
3319 : : public:
3320 : :
3321 : : /**
3322 : : * Constructor for QgsProcessingParameterFolderDestination.
3323 : : */
3324 : : QgsProcessingParameterFolderDestination( const QString &name, const QString &description = QString(),
3325 : : const QVariant &defaultValue = QVariant(),
3326 : : bool optional = false,
3327 : : bool createByDefault = true );
3328 : :
3329 : : /**
3330 : : * Returns the type name for the parameter class.
3331 : : */
3332 : 0 : static QString typeName() { return QStringLiteral( "folderDestination" ); }
3333 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3334 : 0 : QString type() const override { return typeName(); }
3335 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3336 : : QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
3337 : : QString defaultFileExtension() const override;
3338 : :
3339 : : /**
3340 : : * Creates a new parameter using the definition from a script code.
3341 : : */
3342 : : static QgsProcessingParameterFolderDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3343 : :
3344 : : };
3345 : :
3346 : : /**
3347 : : * \class QgsProcessingParameterBand
3348 : : * \ingroup core
3349 : : * \brief A raster band parameter for Processing algorithms.
3350 : : * \since QGIS 3.0
3351 : : */
3352 : 0 : class CORE_EXPORT QgsProcessingParameterBand : public QgsProcessingParameterDefinition
3353 : : {
3354 : : public:
3355 : :
3356 : : /**
3357 : : * Constructor for QgsProcessingParameterBand.
3358 : : */
3359 : : QgsProcessingParameterBand( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
3360 : : const QString &parentLayerParameterName = QString(),
3361 : : bool optional = false,
3362 : : bool allowMultiple = false );
3363 : :
3364 : : /**
3365 : : * Returns the type name for the parameter class.
3366 : : */
3367 : 0 : static QString typeName() { return QStringLiteral( "band" ); }
3368 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3369 : 0 : QString type() const override { return typeName(); }
3370 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3371 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3372 : : QString asScriptCode() const override;
3373 : : QStringList dependsOnOtherParameters() const override;
3374 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3375 : :
3376 : : /**
3377 : : * Returns the name of the parent layer parameter, or an empty string if this is not set.
3378 : : * \see setParentLayerParameterName()
3379 : : */
3380 : : QString parentLayerParameterName() const;
3381 : :
3382 : : /**
3383 : : * Sets the name of the parent layer parameter. Use an empty string if this is not required.
3384 : : * \see parentLayerParameterName()
3385 : : */
3386 : : void setParentLayerParameterName( const QString &parentLayerParameterName );
3387 : :
3388 : : QVariantMap toVariantMap() const override;
3389 : : bool fromVariantMap( const QVariantMap &map ) override;
3390 : :
3391 : : /**
3392 : : * Creates a new parameter using the definition from a script code.
3393 : : */
3394 : : static QgsProcessingParameterBand *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3395 : :
3396 : : /**
3397 : : * Returns whether multiple band selections are permitted.
3398 : : * \see setAllowMultiple()
3399 : : * \since QGIS 3.4
3400 : : */
3401 : : bool allowMultiple() const;
3402 : :
3403 : : /**
3404 : : * Sets whether multiple band selections are permitted.
3405 : : * \see allowMultiple()
3406 : : * \since QGIS 3.4
3407 : : */
3408 : : void setAllowMultiple( bool allowMultiple );
3409 : :
3410 : : private:
3411 : :
3412 : : QString mParentLayerParameterName;
3413 : : bool mAllowMultiple = false;
3414 : : };
3415 : :
3416 : : /**
3417 : : * \class QgsProcessingParameterLayout
3418 : : * \ingroup core
3419 : : * \brief A print layout parameter, allowing users to select a print layout.
3420 : : *
3421 : : * QgsProcessingParameterLayout should be evaluated by calling QgsProcessingAlgorithm::parameterAsLayout().
3422 : : * This will return the matching layout from the context's current project. Alternatively, calling
3423 : : * QgsProcessingAlgorithm::parameterAsString() will return the name of the target print layout.
3424 : : *
3425 : : * \since QGIS 3.8
3426 : : */
3427 : 0 : class CORE_EXPORT QgsProcessingParameterLayout : public QgsProcessingParameterDefinition
3428 : : {
3429 : : public:
3430 : :
3431 : : /**
3432 : : * Constructor for QgsProcessingParameterLayout.
3433 : : */
3434 : : QgsProcessingParameterLayout( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
3435 : : bool optional = false );
3436 : :
3437 : : /**
3438 : : * Returns the type name for the parameter class.
3439 : : */
3440 : 0 : static QString typeName() { return QStringLiteral( "layout" ); }
3441 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3442 : 0 : QString type() const override { return typeName(); }
3443 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3444 : : QString asScriptCode() const override;
3445 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3446 : :
3447 : : /**
3448 : : * Creates a new parameter using the definition from a script code.
3449 : : */
3450 : : static QgsProcessingParameterLayout *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3451 : :
3452 : : };
3453 : :
3454 : : /**
3455 : : * \class QgsProcessingParameterLayoutItem
3456 : : * \ingroup core
3457 : : * \brief A print layout item parameter, allowing users to select a particular item from a print layout.
3458 : : *
3459 : : * QgsProcessingParameterLayoutItem should be evaluated by calling QgsProcessingAlgorithm::parameterAsLayoutItem().
3460 : : * Internally, QgsProcessingParameterLayoutItems are string parameters, storing references to items either by
3461 : : * their UUID (QgsLayoutItem::uuid()) or ID (QgsLayoutItem::id()).
3462 : : *
3463 : : * \since QGIS 3.8
3464 : : */
3465 : 0 : class CORE_EXPORT QgsProcessingParameterLayoutItem : public QgsProcessingParameterDefinition
3466 : : {
3467 : : public:
3468 : :
3469 : : /**
3470 : : * Constructor for QgsProcessingParameterLayoutItem.
3471 : : */
3472 : : QgsProcessingParameterLayoutItem( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
3473 : : const QString &parentLayoutParameterName = QString(),
3474 : : int itemType = -1,
3475 : : bool optional = false );
3476 : :
3477 : : /**
3478 : : * Returns the type name for the parameter class.
3479 : : */
3480 : 0 : static QString typeName() { return QStringLiteral( "layoutitem" ); }
3481 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3482 : 0 : QString type() const override { return typeName(); }
3483 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3484 : : QString asScriptCode() const override;
3485 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3486 : : QVariantMap toVariantMap() const override;
3487 : : bool fromVariantMap( const QVariantMap &map ) override;
3488 : : QStringList dependsOnOtherParameters() const override;
3489 : :
3490 : : /**
3491 : : * Creates a new parameter using the definition from a script code.
3492 : : */
3493 : : static QgsProcessingParameterLayoutItem *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3494 : :
3495 : : /**
3496 : : * Returns the name of the parent layout parameter, or an empty string if this is not set.
3497 : : * \see setParentLayoutParameterName()
3498 : : */
3499 : : QString parentLayoutParameterName() const;
3500 : :
3501 : : /**
3502 : : * Sets the \a name of the parent layout parameter. Use an empty string if this is not required.
3503 : : * \see parentLayoutParameterName()
3504 : : */
3505 : : void setParentLayoutParameterName( const QString &name );
3506 : :
3507 : : /**
3508 : : * Returns the acceptable item type, or -1 if any item type is allowed.
3509 : : *
3510 : : * These values correspond to the registered item types from QgsLayoutItemRegistry.
3511 : : *
3512 : : * \see setItemType()
3513 : : */
3514 : : int itemType() const;
3515 : :
3516 : : /**
3517 : : * Sets the acceptable item \a type, or -1 if any item type is allowed.
3518 : : *
3519 : : * These values correspond to the registered item types from QgsLayoutItemRegistry.
3520 : : *
3521 : : * \see itemType()
3522 : : */
3523 : : void setItemType( int type );
3524 : :
3525 : : private:
3526 : : QString mParentLayoutParameterName;
3527 : : int mItemType = -1;
3528 : : };
3529 : :
3530 : : /**
3531 : : * \class QgsProcessingParameterColor
3532 : : * \ingroup core
3533 : : * \brief A color parameter for processing algorithms.
3534 : : *
3535 : : * QgsProcessingParameterColor should be evaluated by calling QgsProcessingAlgorithm::parameterAsColor().
3536 : : *
3537 : : * \since QGIS 3.10
3538 : : */
3539 : 0 : class CORE_EXPORT QgsProcessingParameterColor : public QgsProcessingParameterDefinition
3540 : : {
3541 : : public:
3542 : :
3543 : : /**
3544 : : * Constructor for QgsProcessingParameterColor.
3545 : : *
3546 : : * If \a opacityEnabled is TRUE, then users will have the option of varying color opacity.
3547 : : */
3548 : : QgsProcessingParameterColor( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
3549 : : bool opacityEnabled = true,
3550 : : bool optional = false );
3551 : :
3552 : : /**
3553 : : * Returns the type name for the parameter class.
3554 : : */
3555 : 0 : static QString typeName() { return QStringLiteral( "color" ); }
3556 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3557 : 0 : QString type() const override { return typeName(); }
3558 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3559 : : QString asScriptCode() const override;
3560 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3561 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3562 : : QVariantMap toVariantMap() const override;
3563 : : bool fromVariantMap( const QVariantMap &map ) override;
3564 : :
3565 : : /**
3566 : : * Returns TRUE if the parameter allows opacity control.
3567 : : *
3568 : : * The default behavior is to allow users to set opacity for the color.
3569 : : * \see setOpacityEnabled()
3570 : : */
3571 : : bool opacityEnabled() const;
3572 : :
3573 : : /**
3574 : : * Sets whether the parameter allows opacity control.
3575 : : *
3576 : : * The default behavior is to allow users to set opacity for the color.
3577 : : *
3578 : : * \see opacityEnabled()
3579 : : */
3580 : : void setOpacityEnabled( bool enabled );
3581 : :
3582 : : /**
3583 : : * Creates a new parameter using the definition from a script code.
3584 : : */
3585 : : static QgsProcessingParameterColor *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3586 : :
3587 : : private:
3588 : :
3589 : : bool mAllowOpacity = true;
3590 : :
3591 : : };
3592 : :
3593 : :
3594 : : /**
3595 : : * \class QgsProcessingParameterCoordinateOperation
3596 : : * \ingroup core
3597 : : * \brief A coordinate operation parameter for processing algorithms, for selection between available
3598 : : * coordinate operations to use when projecting between a source and destination coordinate reference system.
3599 : : *
3600 : : * QgsProcessingParameterCoordinateOperation should be evaluated by calling QgsProcessingAlgorithm::parameterAsString().
3601 : : * \since QGIS 3.12
3602 : : */
3603 : 0 : class CORE_EXPORT QgsProcessingParameterCoordinateOperation : public QgsProcessingParameterDefinition
3604 : : {
3605 : : public:
3606 : :
3607 : : /**
3608 : : * Constructor for QgsProcessingParameterCoordinateOperation.
3609 : : */
3610 : : QgsProcessingParameterCoordinateOperation( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
3611 : : const QString &sourceCrsParameterName = QString(), const QString &destinationCrsParameterName = QString(),
3612 : : const QVariant &staticSourceCrs = QVariant(), const QVariant &staticDestinationCrs = QVariant(),
3613 : : bool optional = false );
3614 : :
3615 : : /**
3616 : : * Returns the type name for the parameter class.
3617 : : */
3618 : 0 : static QString typeName() { return QStringLiteral( "coordinateoperation" ); }
3619 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3620 : 0 : QString type() const override { return typeName(); }
3621 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3622 : : QString asScriptCode() const override;
3623 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3624 : : QStringList dependsOnOtherParameters() const override;
3625 : :
3626 : : QVariantMap toVariantMap() const override;
3627 : : bool fromVariantMap( const QVariantMap &map ) override;
3628 : :
3629 : : /**
3630 : : * Creates a new parameter using the definition from a script code.
3631 : : */
3632 : : static QgsProcessingParameterCoordinateOperation *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3633 : :
3634 : : /**
3635 : : * Returns the name of the source CRS parameter, or an empty string if this is not set.
3636 : : * \see setSourceCrsParameterName()
3637 : : * \see destinationCrsParameterName()
3638 : : */
3639 : : QString sourceCrsParameterName() const { return mSourceParameterName; }
3640 : :
3641 : : /**
3642 : : * Sets the \a name of the source CRS parameter. Use an empty string if this is not required.
3643 : : * \see sourceCrsParameterName()
3644 : : * \see setDestinationCrsParameterName()
3645 : : */
3646 : : void setSourceCrsParameterName( const QString &name ) { mSourceParameterName = name; }
3647 : :
3648 : : /**
3649 : : * Returns the name of the destination CRS parameter, or an empty string if this is not set.
3650 : : * \see setDestinationCrsParameterName()
3651 : : * \see sourceCrsParameterName()
3652 : : */
3653 : : QString destinationCrsParameterName() const { return mDestParameterName; }
3654 : :
3655 : : /**
3656 : : * Sets the \a name of the destination CRS parameter. Use an empty string if this is not required.
3657 : : * \see destinationCrsParameterName()
3658 : : * \see setSourceCrsParameterName()
3659 : : */
3660 : : void setDestinationCrsParameterName( const QString &name ) { mDestParameterName = name; }
3661 : :
3662 : : /**
3663 : : * Returns the static source CRS, or an invalid value if this is not set.
3664 : : * \see setSourceCrs()
3665 : : * \see destinationCrs()
3666 : : */
3667 : : QVariant sourceCrs() const { return mSourceCrs; }
3668 : :
3669 : : /**
3670 : : * Sets the static source \a crs.
3671 : : * \see sourceCrs()
3672 : : * \see setDestinationCrs()
3673 : : */
3674 : : void setSourceCrs( const QVariant &crs ) { mSourceCrs = crs; }
3675 : :
3676 : : /**
3677 : : * Returns the static destination CRS, or an invalid value if this is not set.
3678 : : * \see setDestinationCrs()
3679 : : * \see sourceCrs()
3680 : : */
3681 : : QVariant destinationCrs() const { return mDestCrs; }
3682 : :
3683 : : /**
3684 : : * Sets the static destination \a crs.
3685 : : * \see destinationCrs()
3686 : : * \see setSourceCrs()
3687 : : */
3688 : : void setDestinationCrs( const QVariant &crs ) { mDestCrs = crs; }
3689 : :
3690 : : private:
3691 : :
3692 : : QString mSourceParameterName;
3693 : : QString mDestParameterName;
3694 : : QVariant mSourceCrs;
3695 : : QVariant mDestCrs;
3696 : :
3697 : : };
3698 : :
3699 : :
3700 : : /**
3701 : : * \class QgsProcessingParameterMapTheme
3702 : : * \ingroup core
3703 : : * \brief A map theme parameter for processing algorithms, allowing users to select an existing map theme from a project.
3704 : : *
3705 : : * QgsProcessingParameterMapTheme should be evaluated by calling QgsProcessingAlgorithm::parameterAsString().
3706 : : *
3707 : : * \since QGIS 3.12
3708 : : */
3709 : 0 : class CORE_EXPORT QgsProcessingParameterMapTheme : public QgsProcessingParameterDefinition
3710 : : {
3711 : : public:
3712 : :
3713 : : /**
3714 : : * Constructor for QgsProcessingParameterMapTheme.
3715 : : */
3716 : : QgsProcessingParameterMapTheme( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
3717 : : bool optional = false );
3718 : :
3719 : : /**
3720 : : * Returns the type name for the parameter class.
3721 : : */
3722 : 0 : static QString typeName() { return QStringLiteral( "maptheme" ); }
3723 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3724 : 0 : QString type() const override { return typeName(); }
3725 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3726 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3727 : : QString asScriptCode() const override;
3728 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3729 : : QVariantMap toVariantMap() const override;
3730 : : bool fromVariantMap( const QVariantMap &map ) override;
3731 : :
3732 : : /**
3733 : : * Creates a new parameter using the definition from a script code.
3734 : : */
3735 : : static QgsProcessingParameterMapTheme *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3736 : :
3737 : : private:
3738 : :
3739 : : };
3740 : :
3741 : :
3742 : : /**
3743 : : * \class QgsProcessingParameterDateTime
3744 : : * \ingroup core
3745 : : * \brief A datetime (or pure date or time) parameter for processing algorithms.
3746 : : *
3747 : : * QgsProcessingParameterDateTime should be evaluated by calling QgsProcessingAlgorithm::parameterAsDateTime(),
3748 : : * which will return a date time value.
3749 : : *
3750 : : * \since QGIS 3.14
3751 : : */
3752 : 0 : class CORE_EXPORT QgsProcessingParameterDateTime : public QgsProcessingParameterDefinition
3753 : : {
3754 : : public:
3755 : :
3756 : : //! Datetime data type
3757 : : enum Type
3758 : : {
3759 : : DateTime, //!< Datetime values
3760 : : Date, //!< Date values
3761 : : Time, //!< Time values
3762 : : };
3763 : :
3764 : : /**
3765 : : * Constructor for QgsProcessingParameterDateTime.
3766 : : */
3767 : : explicit QgsProcessingParameterDateTime( const QString &name, const QString &description = QString(),
3768 : : Type type = DateTime,
3769 : : const QVariant &defaultValue = QVariant(),
3770 : : bool optional = false,
3771 : : const QDateTime &minValue = QDateTime(),
3772 : : const QDateTime &maxValue = QDateTime()
3773 : : );
3774 : :
3775 : : /**
3776 : : * Returns the type name for the parameter class.
3777 : : */
3778 : 0 : static QString typeName() { return QStringLiteral( "datetime" ); }
3779 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3780 : 0 : QString type() const override { return typeName(); }
3781 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3782 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3783 : : QString toolTip() const override;
3784 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3785 : :
3786 : : /**
3787 : : * Returns the minimum value acceptable by the parameter.
3788 : : *
3789 : : * An invalid QDateTime value indicates no minimum value.
3790 : : *
3791 : : * \see setMinimum()
3792 : : */
3793 : : QDateTime minimum() const;
3794 : :
3795 : : /**
3796 : : * Sets the \a minimum value acceptable by the parameter.
3797 : : *
3798 : : * An invalid QDateTime value indicates no minimum value.
3799 : : *
3800 : : * If the dataType() is QgsProcessingParameterDateTime::Time, then the date component of \a minimum
3801 : : * must be set to any valid date (but this date will not actually be considered when comparing parameter
3802 : : * values to the specified minimum value, only the time component will be considered).
3803 : : *
3804 : : * \see minimum()
3805 : : */
3806 : : void setMinimum( const QDateTime &minimum );
3807 : :
3808 : : /**
3809 : : * Returns the maximum value acceptable by the parameter.
3810 : : *
3811 : : * An invalid QDateTime value indicates no maximum value.
3812 : : *
3813 : : * \see setMaximum()
3814 : : */
3815 : : QDateTime maximum() const;
3816 : :
3817 : : /**
3818 : : * Sets the \a maximum value acceptable by the parameter.
3819 : : *
3820 : : * An invalid QDateTime value indicates no maximum value.
3821 : : *
3822 : : * If the dataType() is QgsProcessingParameterDateTime::Time, then the date component of \a maximum
3823 : : * must be set to any valid date (but this date will not actually be considered when comparing parameter
3824 : : * values to the specified maximum value, only the time component will be considered).
3825 : : *
3826 : : * \see maximum()
3827 : : */
3828 : : void setMaximum( const QDateTime &maximum );
3829 : :
3830 : : /**
3831 : : * Returns the acceptable data type for the parameter.
3832 : : * \see setDataType()
3833 : : */
3834 : : Type dataType() const;
3835 : :
3836 : : /**
3837 : : * Sets the acceptable data \a type for the parameter.
3838 : : * \see dataType()
3839 : : */
3840 : : void setDataType( Type type );
3841 : :
3842 : : QVariantMap toVariantMap() const override;
3843 : : bool fromVariantMap( const QVariantMap &map ) override;
3844 : :
3845 : : /**
3846 : : * Creates a new parameter using the definition from a script code.
3847 : : */
3848 : : static QgsProcessingParameterDateTime *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3849 : :
3850 : : private:
3851 : :
3852 : : QDateTime mMin;
3853 : : QDateTime mMax;
3854 : : Type mDataType = DateTime;
3855 : : };
3856 : :
3857 : :
3858 : : /**
3859 : : * \class QgsProcessingParameterProviderConnection
3860 : : * \ingroup core
3861 : : * \brief A data provider connection parameter for processing algorithms, allowing users to select from available registered
3862 : : * connections for a particular data provider.
3863 : : *
3864 : : * QgsProcessingParameterProviderConnection should be evaluated by calling QgsProcessingAlgorithm::parameterAsConnectionName().
3865 : : *
3866 : : * \since QGIS 3.14
3867 : : */
3868 : 0 : class CORE_EXPORT QgsProcessingParameterProviderConnection : public QgsProcessingParameterDefinition
3869 : : {
3870 : : public:
3871 : :
3872 : : /**
3873 : : * Constructor for QgsProcessingParameterProviderConnection, for the specified \a provider type.
3874 : : *
3875 : : * \warning The provider must support the connection API methods in its QgsProviderMetadata implementation
3876 : : * in order for the model to work correctly. This is only implemented for a subset of current data providers.
3877 : : */
3878 : : QgsProcessingParameterProviderConnection( const QString &name, const QString &description, const QString &provider, const QVariant &defaultValue = QVariant(),
3879 : : bool optional = false );
3880 : :
3881 : : /**
3882 : : * Returns the type name for the parameter class.
3883 : : */
3884 : 0 : static QString typeName() { return QStringLiteral( "providerconnection" ); }
3885 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3886 : 0 : QString type() const override { return typeName(); }
3887 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3888 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3889 : : QString asScriptCode() const override;
3890 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3891 : : QVariantMap toVariantMap() const override;
3892 : : bool fromVariantMap( const QVariantMap &map ) override;
3893 : :
3894 : : /**
3895 : : * Returns the ID of the provider associated with the connections.
3896 : : * \see setProviderId()
3897 : : */
3898 : : QString providerId() const { return mProviderId; }
3899 : :
3900 : : /**
3901 : : * Sets the ID of the \a provider associated with the connections.
3902 : : * \see providerId()
3903 : : */
3904 : : void setProviderId( const QString &provider ) { mProviderId = provider; }
3905 : :
3906 : : /**
3907 : : * Creates a new parameter using the definition from a script code.
3908 : : */
3909 : : static QgsProcessingParameterProviderConnection *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3910 : :
3911 : : private:
3912 : :
3913 : : QString mProviderId;
3914 : : };
3915 : :
3916 : :
3917 : : /**
3918 : : * \class QgsProcessingParameterDatabaseSchema
3919 : : * \ingroup core
3920 : : * \brief A database schema parameter for processing algorithms, allowing users to select from existing schemas
3921 : : * on a registered database connection.
3922 : : *
3923 : : * QgsProcessingParameterDatabaseSchema should be evaluated by calling QgsProcessingAlgorithm::parameterAsSchema().
3924 : : *
3925 : : * \since QGIS 3.14
3926 : : */
3927 : 0 : class CORE_EXPORT QgsProcessingParameterDatabaseSchema : public QgsProcessingParameterDefinition
3928 : : {
3929 : : public:
3930 : :
3931 : : /**
3932 : : * Constructor for QgsProcessingParameterDatabaseSchema.
3933 : : *
3934 : : * The \a connectionParameterName specifies the name of the parent QgsProcessingParameterProviderConnection parameter.
3935 : : *
3936 : : * \warning The provider must support the connection API methods in its QgsProviderMetadata implementation
3937 : : * in order for the model to work correctly. This is only implemented for a subset of current data providers.
3938 : : */
3939 : : QgsProcessingParameterDatabaseSchema( const QString &name, const QString &description, const QString &connectionParameterName = QString(), const QVariant &defaultValue = QVariant(),
3940 : : bool optional = false );
3941 : :
3942 : : /**
3943 : : * Returns the type name for the parameter class.
3944 : : */
3945 : 0 : static QString typeName() { return QStringLiteral( "databaseschema" ); }
3946 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3947 : 0 : QString type() const override { return typeName(); }
3948 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3949 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3950 : : QString asScriptCode() const override;
3951 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3952 : : QVariantMap toVariantMap() const override;
3953 : : bool fromVariantMap( const QVariantMap &map ) override;
3954 : : QStringList dependsOnOtherParameters() const override;
3955 : :
3956 : : /**
3957 : : * Returns the name of the parent connection parameter, or an empty string if this is not set.
3958 : : * \see setParentConnectionParameterName()
3959 : : */
3960 : : QString parentConnectionParameterName() const;
3961 : :
3962 : : /**
3963 : : * Sets the \a name of the parent connection parameter. Use an empty string if this is not required.
3964 : : * \see parentConnectionParameterName()
3965 : : */
3966 : : void setParentConnectionParameterName( const QString &name );
3967 : :
3968 : : /**
3969 : : * Creates a new parameter using the definition from a script code.
3970 : : */
3971 : : static QgsProcessingParameterDatabaseSchema *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3972 : :
3973 : : private:
3974 : :
3975 : : QString mParentConnectionParameterName;
3976 : : };
3977 : :
3978 : :
3979 : : /**
3980 : : * \class QgsProcessingParameterDatabaseTable
3981 : : * \ingroup core
3982 : : * \brief A database table name parameter for processing algorithms, allowing users to select from existing database tables
3983 : : * on a registered database connection (or optionally to enter a new table name).
3984 : : *
3985 : : * QgsProcessingParameterDatabaseTable should be evaluated by calling QgsProcessingAlgorithm::parameterAsDatabaseTableName().
3986 : : *
3987 : : * \since QGIS 3.14
3988 : : */
3989 : 0 : class CORE_EXPORT QgsProcessingParameterDatabaseTable : public QgsProcessingParameterDefinition
3990 : : {
3991 : : public:
3992 : :
3993 : : /**
3994 : : * Constructor for QgsProcessingParameterDatabaseTable.
3995 : : *
3996 : : * The \a connectionParameterName specifies the name of the parent QgsProcessingParameterProviderConnection parameter.
3997 : : * The \a schemaParameterName specifies the name of the parent QgsProcessingParameterDatabaseSchema parameter.
3998 : : *
3999 : : * \warning The provider must support the connection API methods in its QgsProviderMetadata implementation
4000 : : * in order for the model to work correctly. This is only implemented for a subset of current data providers.
4001 : : */
4002 : : QgsProcessingParameterDatabaseTable( const QString &name, const QString &description,
4003 : : const QString &connectionParameterName = QString(),
4004 : : const QString &schemaParameterName = QString(),
4005 : : const QVariant &defaultValue = QVariant(),
4006 : : bool optional = false,
4007 : : bool allowNewTableNames = false );
4008 : :
4009 : : /**
4010 : : * Returns the type name for the parameter class.
4011 : : */
4012 : 0 : static QString typeName() { return QStringLiteral( "databasetable" ); }
4013 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
4014 : 0 : QString type() const override { return typeName(); }
4015 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
4016 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
4017 : : QString asScriptCode() const override;
4018 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
4019 : : QVariantMap toVariantMap() const override;
4020 : : bool fromVariantMap( const QVariantMap &map ) override;
4021 : : QStringList dependsOnOtherParameters() const override;
4022 : :
4023 : : /**
4024 : : * Returns the name of the parent connection parameter, or an empty string if this is not set.
4025 : : * \see setParentConnectionParameterName()
4026 : : */
4027 : : QString parentConnectionParameterName() const;
4028 : :
4029 : : /**
4030 : : * Sets the \a name of the parent connection parameter. Use an empty string if this is not required.
4031 : : * \see parentConnectionParameterName()
4032 : : */
4033 : : void setParentConnectionParameterName( const QString &name );
4034 : :
4035 : : /**
4036 : : * Returns the name of the parent schema parameter, or an empty string if this is not set.
4037 : : * \see setParentSchemaParameterName()
4038 : : */
4039 : : QString parentSchemaParameterName() const;
4040 : :
4041 : : /**
4042 : : * Sets the \a name of the parent schema parameter. Use an empty string if this is not required.
4043 : : * \see parentSchemaParameterName()
4044 : : */
4045 : : void setParentSchemaParameterName( const QString &name );
4046 : :
4047 : : /**
4048 : : * Creates a new parameter using the definition from a script code.
4049 : : */
4050 : : static QgsProcessingParameterDatabaseTable *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
4051 : :
4052 : : /**
4053 : : * Returns TRUE if the parameter allows users to enter names for
4054 : : * a new (non-existing) tables.
4055 : : *
4056 : : * \see setAllowNewTableNames()
4057 : : */
4058 : : bool allowNewTableNames() const;
4059 : :
4060 : : /**
4061 : : * Sets whether the parameter allows users to enter names for
4062 : : * a new (non-existing) tables.
4063 : : *
4064 : : * \see allowNewTableNames()
4065 : : */
4066 : : void setAllowNewTableNames( bool allowed );
4067 : :
4068 : : private:
4069 : :
4070 : : QString mParentConnectionParameterName;
4071 : : QString mParentSchemaParameterName;
4072 : : bool mAllowNewTableNames = false;
4073 : : };
4074 : :
4075 : :
4076 : : // clazy:excludeall=qstring-allocations
4077 : :
4078 : : #endif // QGSPROCESSINGPARAMETERS_H
4079 : :
4080 : :
|
