QGIS API Documentation  3.18.1-Zürich (202f1bf7e5)
qgsprocessingparametertypeimpl.h
Go to the documentation of this file.
1 /***************************************************************************
2  qgsprocessingparametertypeimpl.h
3  ------------------------
4  begin : March 2018
5  copyright : (C) 2018 by Matthias Kuhn
6  email : [email protected]
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 QGSPROCESSINGPARAMETERTYPEIMPL_H
19 #define QGSPROCESSINGPARAMETERTYPEIMPL_H
20 
21 #include "qgis.h"
22 #include "qgis_sip.h"
24 #include <QCoreApplication>
25 
26 #define SIP_NO_FILE
27 
36 {
37  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
38  {
39  return new QgsProcessingParameterRasterLayer( name );
40  }
41 
42  QString description() const override
43  {
44  return QCoreApplication::translate( "Processing", "A raster layer parameter." );
45  }
46 
47  QString name() const override
48  {
49  return QCoreApplication::translate( "Processing", "Raster Layer" );
50  }
51 
52  QString pythonImportString() const override
53  {
54  return QStringLiteral( "from qgis.core import QgsProcessingParameterRasterLayer" );
55  }
56 
57  QString className() const override
58  {
59  return QStringLiteral( "QgsProcessingParameterRasterLayer" );
60  }
61 
62  QString id() const override
63  {
64  return QStringLiteral( "raster" );
65  }
66 
67  QStringList acceptedPythonTypes() const override
68  {
69  return QStringList() << QObject::tr( "str: layer ID" )
70  << QObject::tr( "str: layer name" )
71  << QObject::tr( "str: layer source" )
72  << QStringLiteral( "QgsProperty" )
73  << QStringLiteral( "QgsRasterLayer" );
74  }
75 
76  QStringList acceptedStringValues() const override
77  {
78  return QStringList() << QObject::tr( "Path to a raster layer" );
79  }
80 };
81 
90 {
91  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
92  {
93  return new QgsProcessingParameterMeshLayer( name );
94  }
95 
96  QString description() const override
97  {
98  return QCoreApplication::translate( "Processing", "A mesh layer parameter." );
99  }
100 
101  QString name() const override
102  {
103  return QCoreApplication::translate( "Processing", "Mesh Layer" );
104  }
105 
106  QString pythonImportString() const override
107  {
108  return QStringLiteral( "from qgis.core import QgsProcessingParameterMeshLayer" );
109  }
110 
111  QString className() const override
112  {
113  return QStringLiteral( "QgsProcessingParameterMeshLayer" );
114  }
115 
116  QString id() const override
117  {
118  return QStringLiteral( "mesh" );
119  }
120 
121  QStringList acceptedPythonTypes() const override
122  {
123  return QStringList() << QObject::tr( "str: layer ID" )
124  << QObject::tr( "str: layer name" )
125  << QObject::tr( "str: layer source" )
126  << QStringLiteral( "QgsMeshLayer" );
127  }
128 
129  QStringList acceptedStringValues() const override
130  {
131  return QStringList() << QObject::tr( "Path to a mesh layer" );
132  }
133 };
134 
143 {
144  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
145  {
146  return new QgsProcessingParameterVectorLayer( name );
147  }
148 
149  QString description() const override
150  {
151  return QCoreApplication::translate( "Processing", "A vector layer parameter, e.g. for algorithms which change layer styles, edit layers in place, or other operations which affect an entire layer." );
152  }
153 
154  QString name() const override
155  {
156  return QCoreApplication::translate( "Processing", "Vector Layer" );
157  }
158 
159  QString pythonImportString() const override
160  {
161  return QStringLiteral( "from qgis.core import QgsProcessingParameterVectorLayer" );
162  }
163 
164  QString className() const override
165  {
166  return QStringLiteral( "QgsProcessingParameterVectorLayer" );
167  }
168 
169  QString id() const override
170  {
171  return QStringLiteral( "vector" );
172  }
173 
174  QStringList acceptedPythonTypes() const override
175  {
176  return QStringList() << QObject::tr( "str: layer ID" )
177  << QObject::tr( "str: layer name" )
178  << QObject::tr( "str: layer source" )
179  << QStringLiteral( "QgsProperty" )
180  << QStringLiteral( "QgsVectorLayer" );
181  }
182 
183  QStringList acceptedStringValues() const override
184  {
185  return QStringList() << QObject::tr( "Path to a vector layer" );
186  }
187 };
188 
197 {
198  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
199  {
200  return new QgsProcessingParameterMapLayer( name );
201  }
202 
203  QString description() const override
204  {
205  return QCoreApplication::translate( "Processing", "A generic map layer parameter, which accepts either vector or raster layers." );
206  }
207 
208  QString name() const override
209  {
210  return QCoreApplication::translate( "Processing", "Map Layer" );
211  }
212 
213  QString id() const override
214  {
215  return QStringLiteral( "layer" );
216  }
217 
218  QString pythonImportString() const override
219  {
220  return QStringLiteral( "from qgis.core import QgsProcessingParameterMapLayer" );
221  }
222 
223  QString className() const override
224  {
225  return QStringLiteral( "QgsProcessingParameterMapLayer" );
226  }
227 
228  QStringList acceptedPythonTypes() const override
229  {
230  return QStringList() << QObject::tr( "str: layer ID" )
231  << QObject::tr( "str: layer name" )
232  << QObject::tr( "str: layer source" )
233  << QStringLiteral( "QgsMapLayer" )
234  << QStringLiteral( "QgsProperty" )
235  << QStringLiteral( "QgsRasterLayer" )
236  << QStringLiteral( "QgsVectorLayer" );
237  }
238 
239  QStringList acceptedStringValues() const override
240  {
241  return QStringList() << QObject::tr( "Path to a vector, raster or mesh layer" );
242  }
243 };
244 
253 {
254  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
255  {
256  return new QgsProcessingParameterBoolean( name );
257  }
258 
259  QString description() const override
260  {
261  return QCoreApplication::translate( "Processing", "A boolean parameter, for true/false values." );
262  }
263 
264  QString name() const override
265  {
266  return QCoreApplication::translate( "Processing", "Boolean" );
267  }
268 
269  QString id() const override
270  {
271  return QStringLiteral( "boolean" );
272  }
273 
274  QString pythonImportString() const override
275  {
276  return QStringLiteral( "from qgis.core import QgsProcessingParameterBoolean" );
277  }
278 
279  QString className() const override
280  {
281  return QStringLiteral( "QgsProcessingParameterBoolean" );
282  }
283 
284  QStringList acceptedPythonTypes() const override
285  {
286  return QStringList() << QStringLiteral( "bool" )
287  << QStringLiteral( "int" )
288  << QStringLiteral( "str" )
289  << QStringLiteral( "QgsProperty" );
290  }
291 
292  QStringList acceptedStringValues() const override
293  {
294  return QStringList() << QObject::tr( "1 for true/yes" )
295  << QObject::tr( "0 for false/no" );
296  }
297 };
298 
307 {
308  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
309  {
310  return new QgsProcessingParameterExpression( name );
311  }
312 
313  QString description() const override
314  {
315  return QCoreApplication::translate( "Processing", "An expression parameter, to add custom expressions based on layer fields." );
316  }
317 
318  QString name() const override
319  {
320  return QCoreApplication::translate( "Processing", "Expression" );
321  }
322 
323  QString id() const override
324  {
325  return QStringLiteral( "expression" );
326  }
327 
328  QString pythonImportString() const override
329  {
330  return QStringLiteral( "from qgis.core import QgsProcessingParameterExpression" );
331  }
332 
333  QString className() const override
334  {
335  return QStringLiteral( "QgsProcessingParameterExpression" );
336  }
337 
338  QStringList acceptedPythonTypes() const override
339  {
340  return QStringList() << QStringLiteral( "str" )
341  << QStringLiteral( "QgsProperty" );
342  }
343 
344  QStringList acceptedStringValues() const override
345  {
346  return QStringList() << QObject::tr( "A valid QGIS expression string, e.g \"road_name\" = 'MAIN RD'" );
347  }
348 };
349 
358 {
359  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
360  {
361  return new QgsProcessingParameterCrs( name );
362  }
363 
364  QString description() const override
365  {
366  return QCoreApplication::translate( "Processing", "A coordinate reference system (CRS) input parameter." );
367  }
368 
369  QString name() const override
370  {
371  return QCoreApplication::translate( "Processing", "CRS" );
372  }
373 
374  QString id() const override
375  {
376  return QStringLiteral( "crs" );
377  }
378 
379  QString pythonImportString() const override
380  {
381  return QStringLiteral( "from qgis.core import QgsProcessingParameterCrs" );
382  }
383 
384  QString className() const override
385  {
386  return QStringLiteral( "QgsProcessingParameterCrs" );
387  }
388 
389  QStringList acceptedPythonTypes() const override
390  {
391  return QStringList()
392  << QStringLiteral( "str: 'ProjectCrs'" )
393  << QObject::tr( "str: CRS auth ID (e.g. 'EPSG:3111')" )
394  << QObject::tr( "str: CRS PROJ4 (e.g. 'PROJ4:…')" )
395  << QObject::tr( "str: CRS WKT (e.g. 'WKT:…')" )
396  << QObject::tr( "str: layer ID. CRS of layer is used." )
397  << QObject::tr( "str: layer name. CRS of layer is used." )
398  << QObject::tr( "str: layer source. CRS of layer is used." )
399  << QObject::tr( "QgsCoordinateReferenceSystem" )
400  << QObject::tr( "QgsMapLayer: CRS of layer is used" )
401  << QObject::tr( "QgsProcessingFeatureSourceDefinition: CRS of source is used" )
402  << QStringLiteral( "QgsProperty" );
403  }
404 
405  QStringList acceptedStringValues() const override
406  {
407  return QStringList() << QObject::tr( "CRS as an auth ID (e.g. 'EPSG:3111')" )
408  << QObject::tr( "CRS as a PROJ4 string (e.g. 'PROJ4:…')" )
409  << QObject::tr( "CRS as a WKT string (e.g. 'WKT:…')" )
410  << QObject::tr( "Path to a layer. The CRS of the layer is used." ) ;
411  }
412 };
413 
422 {
423  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
424  {
425  return new QgsProcessingParameterRange( name );
426  }
427 
428  QString description() const override
429  {
430  return QCoreApplication::translate( "Processing", "A numeric range parameter for processing algorithms." );
431  }
432 
433  QString name() const override
434  {
435  return QCoreApplication::translate( "Processing", "Range" );
436  }
437 
438  QString id() const override
439  {
440  return QStringLiteral( "range" );
441  }
442 
443  QString pythonImportString() const override
444  {
445  return QStringLiteral( "from qgis.core import QgsProcessingParameterRange" );
446  }
447 
448  QString className() const override
449  {
450  return QStringLiteral( "QgsProcessingParameterRange" );
451  }
452 
453  QStringList acceptedPythonTypes() const override
454  {
455  return QStringList() << QObject::tr( "list[float]: list of 2 float values" )
456  << QObject::tr( "list[str]: list of strings representing floats" )
457  << QObject::tr( "str: as two comma delimited floats, e.g. '1,10'" )
458  << QStringLiteral( "QgsProperty" );
459  }
460 
461  QStringList acceptedStringValues() const override
462  {
463  return QStringList() << QObject::tr( "Two comma separated numeric values, e.g. '1,10'" );
464  }
465 };
466 
475 {
476  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
477  {
478  return new QgsProcessingParameterPoint( name );
479  }
480 
481  QString description() const override
482  {
483  return QCoreApplication::translate( "Processing", "A geographic point parameter." );
484  }
485 
486  QString name() const override
487  {
488  return QCoreApplication::translate( "Processing", "Point" );
489  }
490 
491  QString id() const override
492  {
493  return QStringLiteral( "point" );
494  }
495 
496  QString pythonImportString() const override
497  {
498  return QStringLiteral( "from qgis.core import QgsProcessingParameterPoint" );
499  }
500 
501  QString className() const override
502  {
503  return QStringLiteral( "QgsProcessingParameterPoint" );
504  }
505 
506  QStringList acceptedPythonTypes() const override
507  {
508  return QStringList() << QObject::tr( "str: as an 'x,y' string, e.g. '1.5,10.1'" )
509  << QStringLiteral( "QgsPointXY" )
510  << QStringLiteral( "QgsProperty" )
511  << QStringLiteral( "QgsReferencedPointXY" )
512  << QStringLiteral( "QgsGeometry: centroid of geometry is used" );
513  }
514 
515  QStringList acceptedStringValues() const override
516  {
517  return QStringList() << QObject::tr( "Point coordinate as an 'x,y' string, e.g. '1.5,10.1'" );
518  }
519 };
520 
529 {
530  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
531  {
532  return new QgsProcessingParameterGeometry( name );
533  }
534 
535  QString description() const override
536  {
537  return QCoreApplication::translate( "Processing", "A geometry parameter." );
538  }
539 
540  QString name() const override
541  {
542  return QCoreApplication::translate( "Processing", "Geometry" );
543  }
544 
545  QString id() const override
546  {
547  return QStringLiteral( "geometry" );
548  }
549 
550  QString pythonImportString() const override
551  {
552  return QStringLiteral( "from qgis.core import QgsProcessingParameterGeometry" );
553  }
554 
555  QString className() const override
556  {
557  return QStringLiteral( "QgsProcessingParameterGeometry" );
558  }
559 
560  QStringList acceptedPythonTypes() const override
561  {
562  return QStringList() << QObject::tr( "str: as Well-Known Text string (WKT)" )
563  << QStringLiteral( "QgsGeometry" )
564  << QStringLiteral( "QgsProperty" );
565  }
566 
567  QStringList acceptedStringValues() const override
568  {
569  return QStringList() << QObject::tr( "Well-Known Text string (WKT)" );
570  }
571 };
572 
581 {
582  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
583  {
584  return new QgsProcessingParameterEnum( name );
585  }
586 
587  QString description() const override
588  {
589  return QCoreApplication::translate( "Processing", "An enumerated type parameter." );
590  }
591 
592  QString name() const override
593  {
594  return QCoreApplication::translate( "Processing", "Enum" );
595  }
596 
597  QString id() const override
598  {
599  return QStringLiteral( "enum" );
600  }
601 
602  QString pythonImportString() const override
603  {
604  return QStringLiteral( "from qgis.core import QgsProcessingParameterEnum" );
605  }
606 
607  QString className() const override
608  {
609  return QStringLiteral( "QgsProcessingParameterEnum" );
610  }
611 
612  QStringList acceptedPythonTypes() const override
613  {
614  return QStringList() << QStringLiteral( "int" )
615  << QObject::tr( "str: as string representation of int, e.g. '1'" )
616  << QStringLiteral( "QgsProperty" );
617  }
618 
619  QStringList acceptedStringValues() const override
620  {
621  return QStringList() << QObject::tr( "Number of selected option, e.g. '1'" )
622  << QObject::tr( "Comma separated list of options, e.g. '1,3'" );
623  }
624 };
625 
634 {
635  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
636  {
637  return new QgsProcessingParameterExtent( name );
638  }
639 
640  QString description() const override
641  {
642  return QCoreApplication::translate( "Processing", "A map extent parameter." );
643  }
644 
645  QString name() const override
646  {
647  return QCoreApplication::translate( "Processing", "Extent" );
648  }
649 
650  QString id() const override
651  {
652  return QStringLiteral( "extent" );
653  }
654 
655  QString pythonImportString() const override
656  {
657  return QStringLiteral( "from qgis.core import QgsProcessingParameterExtent" );
658  }
659 
660  QString className() const override
661  {
662  return QStringLiteral( "QgsProcessingParameterExtent" );
663  }
664 
665  QStringList acceptedPythonTypes() const override
666  {
667  return QStringList() << QObject::tr( "str: as comma delimited list of x min, x max, y min, y max. E.g. '4,10,101,105'" )
668  << QObject::tr( "str: layer ID. Extent of layer is used." )
669  << QObject::tr( "str: layer name. Extent of layer is used." )
670  << QObject::tr( "str: layer source. Extent of layer is used." )
671  << QObject::tr( "QgsMapLayer: Extent of layer is used" )
672  << QObject::tr( "QgsProcessingFeatureSourceDefinition: Extent of source is used" )
673  << QStringLiteral( "QgsProperty" )
674  << QStringLiteral( "QgsRectangle" )
675  << QStringLiteral( "QgsReferencedRectangle" )
676  << QStringLiteral( "QgsGeometry: bounding box of geometry is used" );
677  }
678 
679  QStringList acceptedStringValues() const override
680  {
681  return QStringList() << QObject::tr( "A comma delimited string of x min, x max, y min, y max. E.g. '4,10,101,105'" )
682  << QObject::tr( "Path to a layer. The extent of the layer is used." ) ;
683  }
684 };
685 
694 {
695  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
696  {
697  return new QgsProcessingParameterMatrix( name );
698  }
699 
700  QString description() const override
701  {
702  return QCoreApplication::translate( "Processing", "A table (matrix) parameter for processing algorithms." );
703  }
704 
705  QString name() const override
706  {
707  return QCoreApplication::translate( "Processing", "Matrix" );
708  }
709 
710  QString id() const override
711  {
712  return QStringLiteral( "matrix" );
713  }
714 
715  QString pythonImportString() const override
716  {
717  return QStringLiteral( "from qgis.core import QgsProcessingParameterMatrix" );
718  }
719 
720  QString className() const override
721  {
722  return QStringLiteral( "QgsProcessingParameterMatrix" );
723  }
724 
725  QStringList acceptedPythonTypes() const override
726  {
727  return QStringList() << QObject::tr( "str: as comma delimited list of values" )
728  << QStringLiteral( "list" )
729  << QStringLiteral( "QgsProperty" );
730  }
731 
732  QStringList acceptedStringValues() const override
733  {
734  return QStringList() << QObject::tr( "A comma delimited list of values" );
735  }
736 };
737 
746 {
747  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
748  {
749  return new QgsProcessingParameterFile( name );
750  }
751 
752  QString description() const override
753  {
754  return QCoreApplication::translate( "Processing", "A file or folder parameter, for use with non-map layer file sources or folders." );
755  }
756 
757  QString name() const override
758  {
759  return QCoreApplication::translate( "Processing", "File/Folder" );
760  }
761 
762  QString id() const override
763  {
764  return QStringLiteral( "file" );
765  }
766 
767  QString pythonImportString() const override
768  {
769  return QStringLiteral( "from qgis.core import QgsProcessingParameterFile" );
770  }
771 
772  QString className() const override
773  {
774  return QStringLiteral( "QgsProcessingParameterFile" );
775  }
776 
777  QStringList acceptedPythonTypes() const override
778  {
779  return QStringList() << QStringLiteral( "str" )
780  << QStringLiteral( "QgsProperty" );
781  }
782 
783  QStringList acceptedStringValues() const override
784  {
785  return QStringList() << QObject::tr( "Path to a file" );
786  }
787 };
788 
797 {
798  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
799  {
800  return new QgsProcessingParameterField( name );
801  }
802 
803  QString description() const override
804  {
805  return QCoreApplication::translate( "Processing", "A vector field parameter, for selecting an existing field from a vector source." );
806  }
807 
808  QString name() const override
809  {
810  return QCoreApplication::translate( "Processing", "Vector Field" );
811  }
812 
813  QString id() const override
814  {
815  return QStringLiteral( "field" );
816  }
817 
818  QString pythonImportString() const override
819  {
820  return QStringLiteral( "from qgis.core import QgsProcessingParameterField" );
821  }
822 
823  QString className() const override
824  {
825  return QStringLiteral( "QgsProcessingParameterField" );
826  }
827 
828  QStringList acceptedPythonTypes() const override
829  {
830  return QStringList() << QStringLiteral( "str" )
831  << QStringLiteral( "QgsProperty" );
832  }
833 
834  QStringList acceptedStringValues() const override
835  {
836  return QStringList() << QObject::tr( "The name of an existing field" )
837  << QObject::tr( "; delimited list of existing field names" );
838  }
839 };
840 
850 {
851  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
852  {
853  return new QgsProcessingParameterVectorDestination( name );
854  }
855 
856  QString description() const override
857  {
858  return QCoreApplication::translate( "Processing", "A vector layer destination parameter." );
859  }
860 
861  QString name() const override
862  {
863  return QCoreApplication::translate( "Processing", "Vector Destination" );
864  }
865 
866  QString id() const override
867  {
868  return QStringLiteral( "vectorDestination" );
869  }
870 
871  QString pythonImportString() const override
872  {
873  return QStringLiteral( "from qgis.core import QgsProcessingParameterVectorDestination" );
874  }
875 
876  QString className() const override
877  {
878  return QStringLiteral( "QgsProcessingParameterVectorDestination" );
879  }
880 
881  ParameterFlags flags() const override
882  {
883  ParameterFlags flags = QgsProcessingParameterType::flags();
884  flags.setFlag( ParameterFlag::ExposeToModeler, false );
885  return flags;
886  }
887 
888  QStringList acceptedPythonTypes() const override
889  {
890  return QStringList() << QStringLiteral( "str" )
891  << QStringLiteral( "QgsProperty" )
892  << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
893  }
894 
895  QStringList acceptedStringValues() const override
896  {
897  return QStringList() << QObject::tr( "Path for new vector layer" );
898  }
899 
900 };
901 
911 {
912  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
913  {
914  return new QgsProcessingParameterFileDestination( name );
915  }
916 
917  QString description() const override
918  {
919  return QCoreApplication::translate( "Processing", "A generic file based destination parameter." );
920  }
921 
922  QString name() const override
923  {
924  return QCoreApplication::translate( "Processing", "File Destination" );
925  }
926 
927  QString id() const override
928  {
929  return QStringLiteral( "fileDestination" );
930  }
931 
932  QString pythonImportString() const override
933  {
934  return QStringLiteral( "from qgis.core import QgsProcessingParameterFileDestination" );
935  }
936 
937  QString className() const override
938  {
939  return QStringLiteral( "QgsProcessingParameterFileDestination" );
940  }
941 
942  ParameterFlags flags() const override
943  {
944  ParameterFlags flags = QgsProcessingParameterType::flags();
945  flags.setFlag( ParameterFlag::ExposeToModeler, false );
946  return flags;
947  }
948 
949  QStringList acceptedPythonTypes() const override
950  {
951  return QStringList() << QStringLiteral( "str" )
952  << QStringLiteral( "QgsProperty" );
953  }
954 
955  QStringList acceptedStringValues() const override
956  {
957  return QStringList() << QObject::tr( "Path for new file" );
958  }
959 
960 };
961 
972 {
973  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
974  {
975  return new QgsProcessingParameterFolderDestination( name );
976  }
977 
978  QString description() const override
979  {
980  return QCoreApplication::translate( "Processing", "A folder destination parameter." );
981  }
982 
983  QString name() const override
984  {
985  return QCoreApplication::translate( "Processing", "Folder Destination" );
986  }
987 
988  QString id() const override
989  {
990  return QStringLiteral( "folderDestination" );
991  }
992 
993  QString pythonImportString() const override
994  {
995  return QStringLiteral( "from qgis.core import QgsProcessingParameterFolderDestination" );
996  }
997 
998  QString className() const override
999  {
1000  return QStringLiteral( "QgsProcessingParameterFolderDestination" );
1001  }
1002 
1003  ParameterFlags flags() const override
1004  {
1005  ParameterFlags flags = QgsProcessingParameterType::flags();
1006  flags.setFlag( ParameterFlag::ExposeToModeler, false );
1007  return flags;
1008  }
1009 
1010  QStringList acceptedPythonTypes() const override
1011  {
1012  return QStringList() << QStringLiteral( "str" )
1013  << QStringLiteral( "QgsProperty" );
1014  }
1015 
1016  QStringList acceptedStringValues() const override
1017  {
1018  return QStringList() << QObject::tr( "Path for an existing or new folder" );
1019  }
1020 
1021 };
1022 
1032 {
1033  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1034  {
1035  return new QgsProcessingParameterRasterDestination( name );
1036  }
1037 
1038  QString description() const override
1039  {
1040  return QCoreApplication::translate( "Processing", "A raster layer destination parameter." );
1041  }
1042 
1043  QString name() const override
1044  {
1045  return QCoreApplication::translate( "Processing", "Raster Destination" );
1046  }
1047 
1048  QString id() const override
1049  {
1050  return QStringLiteral( "rasterDestination" );
1051  }
1052 
1053  QString pythonImportString() const override
1054  {
1055  return QStringLiteral( "from qgis.core import QgsProcessingParameterRasterDestination" );
1056  }
1057 
1058  QString className() const override
1059  {
1060  return QStringLiteral( "QgsProcessingParameterRasterDestination" );
1061  }
1062 
1063  ParameterFlags flags() const override
1064  {
1065  ParameterFlags flags = QgsProcessingParameterType::flags();
1066  flags.setFlag( ParameterFlag::ExposeToModeler, false );
1067  return flags;
1068  }
1069 
1070  QStringList acceptedPythonTypes() const override
1071  {
1072  return QStringList() << QStringLiteral( "str" )
1073  << QStringLiteral( "QgsProperty" )
1074  << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
1075  }
1076 
1077  QStringList acceptedStringValues() const override
1078  {
1079  return QStringList() << QObject::tr( "Path for new raster layer" );
1080  }
1081 
1082 };
1083 
1092 {
1093  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1094  {
1095  return new QgsProcessingParameterString( name );
1096  }
1097 
1098  QString description() const override
1099  {
1100  return QCoreApplication::translate( "Processing", "A freeform string parameter." );
1101  }
1102 
1103  QString name() const override
1104  {
1105  return QCoreApplication::translate( "Processing", "String" );
1106  }
1107 
1108  QString id() const override
1109  {
1110  return QStringLiteral( "string" );
1111  }
1112 
1113  QString pythonImportString() const override
1114  {
1115  return QStringLiteral( "from qgis.core import QgsProcessingParameterString" );
1116  }
1117 
1118  QString className() const override
1119  {
1120  return QStringLiteral( "QgsProcessingParameterString" );
1121  }
1122 
1123  QStringList acceptedPythonTypes() const override
1124  {
1125  return QStringList() << QStringLiteral( "str" )
1126  << QStringLiteral( "QgsProperty" );
1127  }
1128 
1129  QStringList acceptedStringValues() const override
1130  {
1131  return QStringList() << QObject::tr( "String value" );
1132  }
1133 
1134 };
1135 
1144 {
1145  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1146  {
1147  return new QgsProcessingParameterAuthConfig( name );
1148  }
1149 
1150  QString description() const override
1151  {
1152  return QCoreApplication::translate( "Processing", "A authentication configuration parameter." );
1153  }
1154 
1155  QString name() const override
1156  {
1157  return QCoreApplication::translate( "Processing", "Authentication Configuration" );
1158  }
1159 
1160  QString id() const override
1161  {
1162  return QStringLiteral( "authcfg" );
1163  }
1164 
1165  QString pythonImportString() const override
1166  {
1167  return QStringLiteral( "from qgis.core import QgsProcessingParameterAuthConfig" );
1168  }
1169 
1170  QString className() const override
1171  {
1172  return QStringLiteral( "QgsProcessingParameterAuthConfig" );
1173  }
1174 
1175  QStringList acceptedPythonTypes() const override
1176  {
1177  return QStringList() << QStringLiteral( "str" );
1178  }
1179 
1180  QStringList acceptedStringValues() const override
1181  {
1182  return QStringList() << QObject::tr( "An existing QGIS authentication ID string" );
1183  }
1184 
1185 };
1186 
1195 {
1196  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1197  {
1198  return new QgsProcessingParameterMultipleLayers( name );
1199  }
1200 
1201  QString description() const override
1202  {
1203  return QCoreApplication::translate( "Processing", "An input allowing selection of multiple sources, including multiple map layers or file sources." );
1204  }
1205 
1206  QString name() const override
1207  {
1208  return QCoreApplication::translate( "Processing", "Multiple Input" );
1209  }
1210 
1211  QString id() const override
1212  {
1213  return QStringLiteral( "multilayer" );
1214  }
1215 
1216  QString pythonImportString() const override
1217  {
1218  return QStringLiteral( "from qgis.core import QgsProcessingParameterMultipleLayers" );
1219  }
1220 
1221  QString className() const override
1222  {
1223  return QStringLiteral( "QgsProcessingParameterMultipleLayers" );
1224  }
1225 
1226  QStringList acceptedPythonTypes() const override
1227  {
1228  return QStringList() << QObject::tr( "list[str]: list of layer IDs" )
1229  << QObject::tr( "list[str]: list of layer names" )
1230  << QObject::tr( "list[str]: list of layer sources" )
1231  << QStringLiteral( "list[QgsMapLayer]" )
1232  << QStringLiteral( "QgsProperty" );
1233  }
1234 };
1235 
1244 {
1245  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1246  {
1247  return new QgsProcessingParameterFeatureSource( name );
1248  }
1249 
1250  QString description() const override
1251  {
1252  return QCoreApplication::translate( "Processing", "A vector feature parameter, e.g. for algorithms which operate on the features within a layer." );
1253  }
1254 
1255  QString name() const override
1256  {
1257  return QCoreApplication::translate( "Processing", "Vector Features" );
1258  }
1259 
1260  QString id() const override
1261  {
1262  return QStringLiteral( "source" );
1263  }
1264 
1265  QString pythonImportString() const override
1266  {
1267  return QStringLiteral( "from qgis.core import QgsProcessingParameterFeatureSource" );
1268  }
1269 
1270  QString className() const override
1271  {
1272  return QStringLiteral( "QgsProcessingParameterFeatureSource" );
1273  }
1274 
1275  QStringList acceptedPythonTypes() const override
1276  {
1277  return QStringList() << QObject::tr( "str: layer ID" )
1278  << QObject::tr( "str: layer name" )
1279  << QObject::tr( "str: layer source" )
1280  << QStringLiteral( "QgsProcessingFeatureSourceDefinition" )
1281  << QStringLiteral( "QgsProperty" )
1282  << QStringLiteral( "QgsVectorLayer" );
1283  }
1284 
1285  QStringList acceptedStringValues() const override
1286  {
1287  return QStringList() << QObject::tr( "Path to a vector layer" );
1288  }
1289 
1290 };
1291 
1300 {
1301  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1302  {
1303  return new QgsProcessingParameterNumber( name );
1304  }
1305 
1306  QString description() const override
1307  {
1308  return QCoreApplication::translate( "Processing", "A numeric parameter, including float or integer values." );
1309  }
1310 
1311  QString name() const override
1312  {
1313  return QCoreApplication::translate( "Processing", "Number" );
1314  }
1315 
1316  QString id() const override
1317  {
1318  return QStringLiteral( "number" );
1319  }
1320 
1321  QString pythonImportString() const override
1322  {
1323  return QStringLiteral( "from qgis.core import QgsProcessingParameterNumber" );
1324  }
1325 
1326  QString className() const override
1327  {
1328  return QStringLiteral( "QgsProcessingParameterNumber" );
1329  }
1330 
1331  QStringList acceptedPythonTypes() const override
1332  {
1333  return QStringList() << QStringLiteral( "int" )
1334  << QStringLiteral( "float" )
1335  << QStringLiteral( "QgsProperty" );
1336  }
1337 
1338  QStringList acceptedStringValues() const override
1339  {
1340  return QStringList() << QObject::tr( "A numeric value" );
1341  }
1342 
1343 };
1344 
1353 {
1354  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1355  {
1356  return new QgsProcessingParameterDistance( name );
1357  }
1358 
1359  QString description() const override
1360  {
1361  return QCoreApplication::translate( "Processing", "A numeric parameter representing a distance measure." );
1362  }
1363 
1364  QString name() const override
1365  {
1366  return QCoreApplication::translate( "Processing", "Distance" );
1367  }
1368 
1369  QString id() const override
1370  {
1371  return QStringLiteral( "distance" );
1372  }
1373 
1374  QString pythonImportString() const override
1375  {
1376  return QStringLiteral( "from qgis.core import QgsProcessingParameterDistance" );
1377  }
1378 
1379  QString className() const override
1380  {
1381  return QStringLiteral( "QgsProcessingParameterDistance" );
1382  }
1383 
1384  QStringList acceptedPythonTypes() const override
1385  {
1386  return QStringList() << QStringLiteral( "int" )
1387  << QStringLiteral( "float" )
1388  << QStringLiteral( "QgsProperty" );
1389  }
1390 
1391  QStringList acceptedStringValues() const override
1392  {
1393  return QStringList() << QObject::tr( "A numeric value" );
1394  }
1395 
1396 
1397 };
1398 
1399 
1408 {
1409  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1410  {
1411  return new QgsProcessingParameterScale( name );
1412  }
1413 
1414  QString description() const override
1415  {
1416  return QCoreApplication::translate( "Processing", "A numeric parameter representing a map scale." );
1417  }
1418 
1419  QString name() const override
1420  {
1421  return QCoreApplication::translate( "Processing", "Scale" );
1422  }
1423 
1424  QString id() const override
1425  {
1426  return QStringLiteral( "scale" );
1427  }
1428 
1429  QString pythonImportString() const override
1430  {
1431  return QStringLiteral( "from qgis.core import QgsProcessingParameterScale" );
1432  }
1433 
1434  QString className() const override
1435  {
1436  return QStringLiteral( "QgsProcessingParameterScale" );
1437  }
1438 
1439  QStringList acceptedPythonTypes() const override
1440  {
1441  return QStringList() << QStringLiteral( "int: scale denominator" )
1442  << QStringLiteral( "float: scale denominator" )
1443  << QStringLiteral( "QgsProperty" );
1444  }
1445 
1446  QStringList acceptedStringValues() const override
1447  {
1448  return QStringList() << QObject::tr( "A numeric value representing the scale denominator" );
1449  }
1450 
1451 
1452 };
1453 
1462 {
1463  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1464  {
1465  return new QgsProcessingParameterBand( name );
1466  }
1467 
1468  QString description() const override
1469  {
1470  return QCoreApplication::translate( "Processing", "A raster band parameter, for selecting an existing band from a raster source." );
1471  }
1472 
1473  QString name() const override
1474  {
1475  return QCoreApplication::translate( "Processing", "Raster Band" );
1476  }
1477 
1478  QString id() const override
1479  {
1480  return QStringLiteral( "band" );
1481  }
1482 
1483  QString pythonImportString() const override
1484  {
1485  return QStringLiteral( "from qgis.core import QgsProcessingParameterBand" );
1486  }
1487 
1488  QString className() const override
1489  {
1490  return QStringLiteral( "QgsProcessingParameterBand" );
1491  }
1492 
1493  QStringList acceptedPythonTypes() const override
1494  {
1495  return QStringList() << QStringLiteral( "int" )
1496  << QStringLiteral( "QgsProperty" );
1497  }
1498 
1499  QStringList acceptedStringValues() const override
1500  {
1501  return QStringList() << QObject::tr( "Integer value representing an existing raster band number" );
1502  }
1503 
1504 
1505 };
1506 
1515 {
1516  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1517  {
1518  return new QgsProcessingParameterFeatureSink( name );
1519  }
1520 
1521  ParameterFlags flags() const override
1522  {
1523  ParameterFlags flags = QgsProcessingParameterType::flags();
1524  flags.setFlag( ParameterFlag::ExposeToModeler, false );
1525  return flags;
1526  }
1527 
1528  QString description() const override
1529  {
1530  return QCoreApplication::translate( "Processing", "A feature sink destination parameter." );
1531  }
1532 
1533  QString name() const override
1534  {
1535  return QCoreApplication::translate( "Processing", "Feature Sink" );
1536  }
1537 
1538  QString id() const override
1539  {
1540  return QStringLiteral( "sink" );
1541  }
1542 
1543  QString pythonImportString() const override
1544  {
1545  return QStringLiteral( "from qgis.core import QgsProcessingParameterFeatureSink" );
1546  }
1547 
1548  QString className() const override
1549  {
1550  return QStringLiteral( "QgsProcessingParameterFeatureSink" );
1551  }
1552 
1553  QStringList acceptedPythonTypes() const override
1554  {
1555  return QStringList() << QObject::tr( "str: destination vector file, e.g. 'd:/test.shp'" )
1556  << QObject::tr( "str: 'memory:' to store result in temporary memory layer" )
1557  << QObject::tr( "str: using vector provider ID prefix and destination URI, e.g. 'postgres:…' to store result in PostGIS table" )
1558  << QStringLiteral( "QgsProcessingOutputLayerDefinition" )
1559  << QStringLiteral( "QgsProperty" );
1560  }
1561 
1562  QStringList acceptedStringValues() const override
1563  {
1564  return QStringList() << QObject::tr( "Path for new vector layer" );
1565  }
1566 
1567 
1568 };
1569 
1570 
1579 {
1580  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1581  {
1582  return new QgsProcessingParameterLayout( name );
1583  }
1584 
1585  QString description() const override
1586  {
1587  return QCoreApplication::translate( "Processing", "A print layout parameter." );
1588  }
1589 
1590  QString name() const override
1591  {
1592  return QCoreApplication::translate( "Processing", "Print Layout" );
1593  }
1594 
1595  QString id() const override
1596  {
1597  return QStringLiteral( "layout" );
1598  }
1599 
1600  QString pythonImportString() const override
1601  {
1602  return QStringLiteral( "from qgis.core import QgsProcessingParameterLayout" );
1603  }
1604 
1605  QString className() const override
1606  {
1607  return QStringLiteral( "QgsProcessingParameterLayout" );
1608  }
1609 
1610  QStringList acceptedPythonTypes() const override
1611  {
1612  return QStringList() << QObject::tr( "str: name of print layout in current project" )
1613  << QStringLiteral( "QgsProperty" );
1614  }
1615 
1616  QStringList acceptedStringValues() const override
1617  {
1618  return QStringList() << QObject::tr( "Name of print layout in current project" );
1619  }
1620 
1621 
1622 };
1623 
1624 
1625 
1634 {
1635  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1636  {
1637  return new QgsProcessingParameterLayoutItem( name );
1638  }
1639 
1640  QString description() const override
1641  {
1642  return QCoreApplication::translate( "Processing", "A print layout item parameter." );
1643  }
1644 
1645  QString name() const override
1646  {
1647  return QCoreApplication::translate( "Processing", "Print Layout Item" );
1648  }
1649 
1650  QString id() const override
1651  {
1652  return QStringLiteral( "layoutitem" );
1653  }
1654 
1655  QString pythonImportString() const override
1656  {
1657  return QStringLiteral( "from qgis.core import QgsProcessingParameterLayoutItem" );
1658  }
1659 
1660  QString className() const override
1661  {
1662  return QStringLiteral( "QgsProcessingParameterLayoutItem" );
1663  }
1664 
1665  QStringList acceptedPythonTypes() const override
1666  {
1667  return QStringList() << QObject::tr( "str: UUID of print layout item" )
1668  << QObject::tr( "str: id of print layout item" )
1669  << QStringLiteral( "QgsProperty" );
1670  }
1671 
1672  QStringList acceptedStringValues() const override
1673  {
1674  return QStringList() << QObject::tr( "UUID or item id of layout item" );
1675  }
1676 
1677 
1678 };
1679 
1680 
1689 {
1690  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1691  {
1692  return new QgsProcessingParameterColor( name );
1693  }
1694 
1695  QString description() const override
1696  {
1697  return QCoreApplication::translate( "Processing", "A color parameter." );
1698  }
1699 
1700  QString name() const override
1701  {
1702  return QCoreApplication::translate( "Processing", "Color" );
1703  }
1704 
1705  QString id() const override
1706  {
1707  return QStringLiteral( "color" );
1708  }
1709 
1710  QString pythonImportString() const override
1711  {
1712  return QStringLiteral( "from qgis.core import QgsProcessingParameterColor" );
1713  }
1714 
1715  QString className() const override
1716  {
1717  return QStringLiteral( "QgsProcessingParameterColor" );
1718  }
1719 
1720  QStringList acceptedPythonTypes() const override
1721  {
1722  return QStringList() << QObject::tr( "str: string representation of color, e.g #ff0000 or rgba(200,100,50,0.8)" )
1723  << QStringLiteral( "QColor" )
1724  << QStringLiteral( "QgsProperty" );
1725  }
1726 
1727  QStringList acceptedStringValues() const override
1728  {
1729  return QStringList() << QObject::tr( "String representation of color, e.g #ff0000 or rgba(200,100,50,0.8)" );
1730  }
1731 
1732 
1733 };
1734 
1743 {
1744  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1745  {
1746  return new QgsProcessingParameterCoordinateOperation( name );
1747  }
1748 
1749  QString description() const override
1750  {
1751  return QCoreApplication::translate( "Processing", "A coordinate operation parameter." );
1752  }
1753 
1754  QString name() const override
1755  {
1756  return QCoreApplication::translate( "Processing", "Coordinate Operation" );
1757  }
1758 
1759  QString id() const override
1760  {
1761  return QStringLiteral( "coordinateoperation" );
1762  }
1763 
1764  QString pythonImportString() const override
1765  {
1766  return QStringLiteral( "from qgis.core import QgsProcessingParameterCoordinateOperation" );
1767  }
1768 
1769  QString className() const override
1770  {
1771  return QStringLiteral( "QgsProcessingParameterCoordinateOperation" );
1772  }
1773 
1774  QStringList acceptedPythonTypes() const override
1775  {
1776  return QStringList() << QObject::tr( "str: string representation of a Proj coordinate operation" );
1777  }
1778 
1779  QStringList acceptedStringValues() const override
1780  {
1781  return QStringList() << QObject::tr( "String representation of Proj coordinate operation" );
1782  }
1783 
1784 
1785 };
1786 
1787 
1796 {
1797  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1798  {
1799  return new QgsProcessingParameterMapTheme( name );
1800  }
1801 
1802  QString description() const override
1803  {
1804  return QCoreApplication::translate( "Processing", "A map theme parameter." );
1805  }
1806 
1807  QString name() const override
1808  {
1809  return QCoreApplication::translate( "Processing", "Map Theme" );
1810  }
1811 
1812  QString id() const override
1813  {
1814  return QStringLiteral( "maptheme" );
1815  }
1816 
1817  QString pythonImportString() const override
1818  {
1819  return QStringLiteral( "from qgis.core import QgsProcessingParameterMapTheme" );
1820  }
1821 
1822  QString className() const override
1823  {
1824  return QStringLiteral( "QgsProcessingParameterMapTheme" );
1825  }
1826 
1827  QStringList acceptedPythonTypes() const override
1828  {
1829  return QStringList() << QObject::tr( "str: name of an existing map theme" )
1830  << QStringLiteral( "QgsProperty" );
1831  }
1832 
1833  QStringList acceptedStringValues() const override
1834  {
1835  return QStringList() << QObject::tr( "Name of an existing map theme" );
1836  }
1837 
1838 };
1839 
1848 {
1849  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1850  {
1851  return new QgsProcessingParameterDateTime( name );
1852  }
1853 
1854  QString description() const override
1855  {
1856  return QCoreApplication::translate( "Processing", "A datetime parameter, including datetime, date or time values." );
1857  }
1858 
1859  QString name() const override
1860  {
1861  return QCoreApplication::translate( "Processing", "Datetime" );
1862  }
1863 
1864  QString id() const override
1865  {
1866  return QStringLiteral( "datetime" );
1867  }
1868 
1869  QString pythonImportString() const override
1870  {
1871  return QStringLiteral( "from qgis.core import QgsProcessingParameterDateTime" );
1872  }
1873 
1874  QString className() const override
1875  {
1876  return QStringLiteral( "QgsProcessingParameterDateTime" );
1877  }
1878 
1879  QStringList acceptedPythonTypes() const override
1880  {
1881  return QStringList() << QStringLiteral( "str" )
1882  << QStringLiteral( "QDateTime" )
1883  << QStringLiteral( "QDate" )
1884  << QStringLiteral( "QTime" )
1885  << QStringLiteral( "QgsProperty" );
1886  }
1887 
1888  QStringList acceptedStringValues() const override
1889  {
1890  return QStringList() << QObject::tr( "A datetime value in ISO format" );
1891  }
1892 
1893 };
1894 
1895 
1904 {
1905  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1906  {
1907  return new QgsProcessingParameterProviderConnection( name, QString(), QString() );
1908  }
1909 
1910  QString description() const override
1911  {
1912  return QCoreApplication::translate( "Processing", "A connection name parameter, for registered database connections." );
1913  }
1914 
1915  QString name() const override
1916  {
1917  return QCoreApplication::translate( "Processing", "Connection Name" );
1918  }
1919 
1920  QString id() const override
1921  {
1922  return QStringLiteral( "providerconnection" );
1923  }
1924 
1925  QString pythonImportString() const override
1926  {
1927  return QStringLiteral( "from qgis.core import QgsProcessingParameterProviderConnection" );
1928  }
1929 
1930  QString className() const override
1931  {
1932  return QStringLiteral( "QgsProcessingParameterProviderConnection" );
1933  }
1934 
1935  QStringList acceptedPythonTypes() const override
1936  {
1937  return QStringList() << QStringLiteral( "str" )
1938  << QStringLiteral( "QgsProperty" );
1939  }
1940 
1941  QStringList acceptedStringValues() const override
1942  {
1943  return QStringList() << QObject::tr( "Name of registered database connection" );
1944  }
1945 
1946 };
1947 
1956 {
1957  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1958  {
1959  return new QgsProcessingParameterDatabaseSchema( name, QString(), QString() );
1960  }
1961 
1962  QString description() const override
1963  {
1964  return QCoreApplication::translate( "Processing", "A database schema parameter." );
1965  }
1966 
1967  QString name() const override
1968  {
1969  return QCoreApplication::translate( "Processing", "Database Schema" );
1970  }
1971 
1972  QString id() const override
1973  {
1974  return QStringLiteral( "databaseschema" );
1975  }
1976 
1977  QString pythonImportString() const override
1978  {
1979  return QStringLiteral( "from qgis.core import QgsProcessingParameterDatabaseSchema" );
1980  }
1981 
1982  QString className() const override
1983  {
1984  return QStringLiteral( "QgsProcessingParameterDatabaseSchema" );
1985  }
1986 
1987  QStringList acceptedPythonTypes() const override
1988  {
1989  return QStringList() << QStringLiteral( "str" )
1990  << QStringLiteral( "QgsProperty" );
1991  }
1992 
1993  QStringList acceptedStringValues() const override
1994  {
1995  return QStringList() << QObject::tr( "Name of existing database schema" );
1996  }
1997 
1998 };
1999 
2000 
2009 {
2010  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2011  {
2012  return new QgsProcessingParameterDatabaseTable( name, QString(), QString(), QString() );
2013  }
2014 
2015  QString description() const override
2016  {
2017  return QCoreApplication::translate( "Processing", "A database table parameter." );
2018  }
2019 
2020  QString name() const override
2021  {
2022  return QCoreApplication::translate( "Processing", "Database Table" );
2023  }
2024 
2025  QString id() const override
2026  {
2027  return QStringLiteral( "databasetable" );
2028  }
2029 
2030  QString pythonImportString() const override
2031  {
2032  return QStringLiteral( "from qgis.core import QgsProcessingParameterDatabaseTable" );
2033  }
2034 
2035  QString className() const override
2036  {
2037  return QStringLiteral( "QgsProcessingParameterDatabaseTable" );
2038  }
2039 
2040  QStringList acceptedPythonTypes() const override
2041  {
2042  return QStringList() << QStringLiteral( "str" )
2043  << QStringLiteral( "QgsProperty" );
2044  }
2045 
2046  QStringList acceptedStringValues() const override
2047  {
2048  return QStringList() << QObject::tr( "Name of existing database table" );
2049  }
2050 
2051 };
2052 #endif // QGSPROCESSINGPARAMETERTYPEIMPL_H
A string parameter for authentication configuration ID values.
A raster band parameter for Processing algorithms.
A boolean parameter for processing algorithms.
A color parameter for processing algorithms.
A coordinate operation parameter for processing algorithms, for selection between available coordinat...
A coordinate reference system parameter for processing algorithms.
A database schema parameter for processing algorithms, allowing users to select from existing schemas...
A database table name parameter for processing algorithms, allowing users to select from existing dat...
A datetime (or pure date or time) parameter for processing algorithms.
Base class for the definition of processing parameters.
A double numeric parameter for distance values.
An enum based parameter for processing algorithms, allowing for selection from predefined values.
An expression parameter for processing algorithms.
A rectangular map extent parameter for processing algorithms.
A feature sink output for processing algorithms.
An input feature source (such as vector layers) parameter for processing algorithms.
A vector layer or feature source field parameter for processing algorithms.
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
An input file or folder parameter for processing algorithms.
A folder destination parameter, for specifying the destination path for a folder created by the algor...
A geometry parameter for processing algorithms.
A print layout item parameter, allowing users to select a particular item from a print layout.
A print layout parameter, allowing users to select a print layout.
A map layer parameter for processing algorithms.
A map theme parameter for processing algorithms, allowing users to select an existing map theme from ...
A table (matrix) parameter for processing algorithms.
A mesh layer parameter for processing algorithms.
A parameter for processing algorithms which accepts multiple map layers.
A numeric parameter for processing algorithms.
A point parameter for processing algorithms.
A data provider connection parameter for processing algorithms, allowing users to select from availab...
A numeric range parameter for processing algorithms.
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
A raster layer parameter for processing algorithms.
A double numeric parameter for map scale values.
A string parameter for processing algorithms.
A authentication configuration parameter for processing algorithms.
A raster band parameter for Processing algorithms.
A boolean parameter for processing algorithms.
A color parameter for Processing algorithms.
A coordinate operation parameter for Processing algorithms.
A crs parameter for processing algorithms.
A database schema name parameter for processing algorithms.
A database table name parameter for processing algorithms.
A datetime parameter for processing algorithms.
A distance parameter for processing algorithms.
An enum based parameter for processing algorithms, allowing for selection from predefined values.
An expression parameter for processing algorithms.
A rectangular map extent parameter for processing algorithms.
A feature sink parameter for Processing algorithms.
An input feature source (such as vector layers) parameter for processing algorithms.
A vector layer or feature source field parameter for processing algorithms.
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
An input file or folder parameter for processing algorithms.
A folder destination parameter, for specifying the destination path for a folder created by the algor...
A geometry parameter for processing algorithms.
A print layout item parameter for Processing algorithms.
A print layout parameter for Processing algorithms.
A generic map layer parameter for processing algorithms.
A map theme parameter for Processing algorithms.
A table (matrix) parameter for processing algorithms.
A mesh layer parameter for processing algorithms.
A parameter for processing algorithms which accepts multiple map layers.
A numeric parameter for processing algorithms.
A point parameter for processing algorithms.
A provider connection name parameter for processing algorithms.
A numeric range parameter for processing algorithms.
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
A raster layer parameter for processing algorithms.
A scale parameter for processing algorithms.
A string parameter for processing algorithms.
A vector layer destination parameter, for specifying the destination path for a vector layer created ...
A vector layer parameter for processing algorithms.
Makes metadata of processing parameters available.
virtual QString name() const =0
A human readable and translatable short name for this parameter type.
virtual QStringList acceptedPythonTypes() const
Returns a list of the Python data types accepted as values for the parameter.
virtual QString description() const =0
A human readable and translatable description for this parameter type.
virtual ParameterFlags flags() const
Determines if this parameter is available in the modeler.
virtual QString id() const =0
A static id for this type which will be used for storing this parameter type.
virtual QString className() const
Returns the corresponding class name for the parameter type.
virtual QgsProcessingParameterDefinition * create(const QString &name) const =0
Creates a new parameter of this type.
virtual QStringList acceptedStringValues() const
Returns a descriptive list of the possible string values acceptable for the parameter.
virtual QString pythonImportString() const
Returns a valid Python import string for importing the corresponding parameter type,...
A vector layer destination parameter, for specifying the destination path for a vector layer created ...
A vector layer (with or without geometry) parameter for processing algorithms.
#define SIP_FACTORY
Definition: qgis_sip.h:76