api/3.0/qgsprocessingparameters_8h_source.html

 /***************************************************************************
                          qgsprocessingparameters.h
                          -------------------------
     begin                : April 2017
     copyright            : (C) 2017 by Nyall Dawson
     email                : nyall dot dawson at gmail dot com
  ***************************************************************************/

 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/

 #ifndef QGSPROCESSINGPARAMETERS_H
 #define QGSPROCESSINGPARAMETERS_H

 #include "qgis_core.h"
 #include "qgis.h"
 #include "qgsprocessing.h"
 #include "qgsproperty.h"
 #include "qgscoordinatereferencesystem.h"
 #include "qgsfeaturesource.h"
 #include <QMap>
 #include <limits>

 class QgsProcessingContext;
 class QgsRasterLayer;
 class QgsVectorLayer;
 class QgsFeatureSink;
 class QgsProcessingFeatureSource;
 class QgsProcessingOutputDefinition;
 class QgsProcessingFeedback;
 class QgsProcessingProvider;

 class CORE_EXPORT QgsProcessingFeatureSourceDefinition
 {
   public:

     QgsProcessingFeatureSourceDefinition( const QString &source = QString(), bool selectedFeaturesOnly = false )
       : source( QgsProperty::fromValue( source ) )
       , selectedFeaturesOnly( selectedFeaturesOnly )
     {}

     QgsProcessingFeatureSourceDefinition( const QgsProperty &source, bool selectedFeaturesOnly = false )
       : source( source )
       , selectedFeaturesOnly( selectedFeaturesOnly )
     {}

     QgsProperty source;

     bool selectedFeaturesOnly;

     bool operator==( const QgsProcessingFeatureSourceDefinition &other )
     {
       return source == other.source && selectedFeaturesOnly == other.selectedFeaturesOnly;
     }

     bool operator!=( const QgsProcessingFeatureSourceDefinition &other )
     {
       return !( *this == other );
     }

     operator QVariant() const
     {
       return QVariant::fromValue( *this );
     }

 };

 Q_DECLARE_METATYPE( QgsProcessingFeatureSourceDefinition )


 class CORE_EXPORT QgsProcessingOutputLayerDefinition
 {
   public:

     QgsProcessingOutputLayerDefinition( const QString &sink = QString(), QgsProject *destinationProject = nullptr )
       : sink( QgsProperty::fromValue( sink ) )
       , destinationProject( destinationProject )
     {}

     QgsProcessingOutputLayerDefinition( const QgsProperty &sink, QgsProject *destinationProject = nullptr )
       : sink( sink )
       , destinationProject( destinationProject )
     {}

     QgsProperty sink;

     QgsProject *destinationProject = nullptr;

     QString destinationName;

     QVariantMap createOptions;


     operator QVariant() const
     {
       return QVariant::fromValue( *this );
     }

 };

 Q_DECLARE_METATYPE( QgsProcessingOutputLayerDefinition )


 //
 // Parameter definitions
 //


 class CORE_EXPORT QgsProcessingParameterDefinition
 {

 #ifdef SIP_RUN
     SIP_CONVERT_TO_SUBCLASS_CODE
     if ( sipCpp->type() == QgsProcessingParameterBoolean::typeName() )
       sipType = sipType_QgsProcessingParameterBoolean;
     else if ( sipCpp->type() == QgsProcessingParameterCrs::typeName() )
       sipType = sipType_QgsProcessingParameterCrs;
     else if ( sipCpp->type() == QgsProcessingParameterMapLayer::typeName() )
       sipType = sipType_QgsProcessingParameterMapLayer;
     else if ( sipCpp->type() == QgsProcessingParameterExtent::typeName() )
       sipType = sipType_QgsProcessingParameterExtent;
     else if ( sipCpp->type() == QgsProcessingParameterPoint::typeName() )
       sipType = sipType_QgsProcessingParameterPoint;
     else if ( sipCpp->type() == QgsProcessingParameterFile::typeName() )
       sipType = sipType_QgsProcessingParameterFile;
     else if ( sipCpp->type() == QgsProcessingParameterMatrix::typeName() )
       sipType = sipType_QgsProcessingParameterMatrix;
     else if ( sipCpp->type() == QgsProcessingParameterMultipleLayers::typeName() )
       sipType = sipType_QgsProcessingParameterMultipleLayers;
     else if ( sipCpp->type() == QgsProcessingParameterNumber::typeName() )
       sipType = sipType_QgsProcessingParameterNumber;
     else if ( sipCpp->type() == QgsProcessingParameterRange::typeName() )
       sipType = sipType_QgsProcessingParameterRange;
     else if ( sipCpp->type() == QgsProcessingParameterRasterLayer::typeName() )
       sipType = sipType_QgsProcessingParameterRasterLayer;
     else if ( sipCpp->type() == QgsProcessingParameterEnum::typeName() )
       sipType = sipType_QgsProcessingParameterEnum;
     else if ( sipCpp->type() == QgsProcessingParameterString::typeName() )
       sipType = sipType_QgsProcessingParameterString;
     else if ( sipCpp->type() == QgsProcessingParameterExpression::typeName() )
       sipType = sipType_QgsProcessingParameterExpression;
     else if ( sipCpp->type() == QgsProcessingParameterVectorLayer::typeName() )
       sipType = sipType_QgsProcessingParameterVectorLayer;
     else if ( sipCpp->type() == QgsProcessingParameterField::typeName() )
       sipType = sipType_QgsProcessingParameterField;
     else if ( sipCpp->type() == QgsProcessingParameterFeatureSource::typeName() )
       sipType = sipType_QgsProcessingParameterFeatureSource;
     else if ( sipCpp->type() == QgsProcessingParameterFeatureSink::typeName() )
       sipType = sipType_QgsProcessingParameterFeatureSink;
     else if ( sipCpp->type() == QgsProcessingParameterVectorDestination::typeName() )
       sipType = sipType_QgsProcessingParameterVectorDestination;
     else if ( sipCpp->type() == QgsProcessingParameterRasterDestination::typeName() )
       sipType = sipType_QgsProcessingParameterRasterDestination;
     else if ( sipCpp->type() == QgsProcessingParameterFileDestination::typeName() )
       sipType = sipType_QgsProcessingParameterFileDestination;
     else if ( sipCpp->type() == QgsProcessingParameterFolderDestination::typeName() )
       sipType = sipType_QgsProcessingParameterFolderDestination;
     else if ( sipCpp->type() == QgsProcessingParameterBand::typeName() )
       sipType = sipType_QgsProcessingParameterBand;
     else
       sipType = nullptr;
     SIP_END
 #endif

   public:

     enum Flag
     {
       FlagAdvanced = 1 << 1,
       FlagHidden = 1 << 2,
       FlagOptional = 1 << 3,
     };
     Q_DECLARE_FLAGS( Flags, Flag )


     QgsProcessingParameterDefinition( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                       bool optional = false );

     virtual ~QgsProcessingParameterDefinition() = default;

     virtual QgsProcessingParameterDefinition *clone() const = 0 SIP_FACTORY;

     virtual QString type() const = 0;

     virtual bool isDestination() const { return false; }

     QString name() const { return mName; }

     void setName( const QString &name ) { mName = name; }

     QString description() const { return mDescription; }

     void setDescription( const QString &description ) { mDescription = description; }

     QVariant defaultValue() const { return mDefault; }

     void setDefaultValue( const QVariant &value ) { mDefault = value; }

     Flags flags() const { return mFlags; }

     void setFlags( Flags flags ) { mFlags = flags; }

     virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const;

     virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;

     virtual QString asScriptCode() const;

     virtual QVariantMap toVariantMap() const;

     virtual bool fromVariantMap( const QVariantMap &map );

     SIP_SKIP QVariantMap metadata() const { return mMetadata; }

     QVariantMap &metadata() { return mMetadata; }

     void setMetadata( const QVariantMap &metadata ) { mMetadata = metadata; }

     virtual QStringList dependsOnOtherParameters() const { return QStringList(); }

     QgsProcessingAlgorithm *algorithm() const;

     QgsProcessingProvider *provider() const;

     virtual QString toolTip() const;

     bool isDynamic() const { return mIsDynamic; }

     void setIsDynamic( bool dynamic ) { mIsDynamic = dynamic; }

     QgsPropertyDefinition dynamicPropertyDefinition() const { return mPropertyDefinition; }

     void setDynamicPropertyDefinition( const QgsPropertyDefinition &definition ) { mPropertyDefinition = definition; }

     QString dynamicLayerParameterName() const { return mDynamicLayerParameterName; }

     void setDynamicLayerParameterName( const QString &name ) { mDynamicLayerParameterName = name; }

   protected:

     QString mName;

     QString mDescription;

     QVariant mDefault;

     Flags mFlags;

     QVariantMap mMetadata;

     QgsProcessingAlgorithm *mAlgorithm = nullptr;

     bool mIsDynamic = false;

     QgsPropertyDefinition mPropertyDefinition;

     QString mDynamicLayerParameterName;

     // To allow access to mAlgorithm. We don't want a public setter for this!
     friend class QgsProcessingAlgorithm;

 };

 Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProcessingParameterDefinition::Flags )

 typedef QList< const QgsProcessingParameterDefinition * > QgsProcessingParameterDefinitions;

 class CORE_EXPORT QgsProcessingParameters
 {

   public:

     static bool isDynamic( const QVariantMap &parameters, const QString &name );

     static QString parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

     static QString parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

     static double parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

     static int parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

     static int parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

     static QList<int> parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

     static bool parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

     static QgsFeatureSink *parameterAsSink( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters,
                                             const QgsFields &fields, QgsWkbTypes::Type geometryType, const QgsCoordinateReferenceSystem &crs,
                                             QgsProcessingContext &context, QString &destinationIdentifier SIP_OUT ) SIP_FACTORY;

     static QgsProcessingFeatureSource *parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) SIP_FACTORY;

     static QString parameterAsCompatibleSourceLayerPath( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters,
         QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat = QString( "shp" ), QgsProcessingFeedback *feedback = nullptr );

     static QgsMapLayer *parameterAsLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

     static QgsRasterLayer *parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

     static QString parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

     static QString parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

     static QgsVectorLayer *parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

     static QgsCoordinateReferenceSystem parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

     static QgsRectangle parameterAsExtent( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context,
                                            const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );

     static QgsGeometry parameterAsExtentGeometry( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context,
         const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );

     static QgsCoordinateReferenceSystem parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

     static QgsPointXY parameterAsPoint( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context,
                                         const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );

     static QgsCoordinateReferenceSystem parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

     static QString parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

     static QVariantList parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

     static QList< QgsMapLayer *> parameterAsLayerList( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

     static QList<double> parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

     static QStringList parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

     static QgsProcessingParameterDefinition *parameterFromVariantMap( const QVariantMap &map ) SIP_FACTORY;

     static QString descriptionFromName( const QString &name );

     static QgsProcessingParameterDefinition *parameterFromScriptCode( const QString &code ) SIP_FACTORY;

   private:

     static bool parseScriptCodeParameterOptions( const QString &code, bool &isOptional, QString &name, QString &type, QString &definition );
 };


 class CORE_EXPORT QgsProcessingParameterBoolean : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingParameterBoolean( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                    bool optional = false );

     static QString typeName() { return QStringLiteral( "boolean" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
     QString asScriptCode() const override;

     static QgsProcessingParameterBoolean *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 };

 class CORE_EXPORT QgsProcessingParameterCrs : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingParameterCrs( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                bool optional = false );

     static QString typeName() { return QStringLiteral( "crs" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;

     static QgsProcessingParameterCrs *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

 };

 class CORE_EXPORT QgsProcessingParameterMapLayer : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingParameterMapLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                     bool optional = false );

     static QString typeName() { return QStringLiteral( "layer" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;

     static QgsProcessingParameterMapLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

 };

 class CORE_EXPORT QgsProcessingParameterExtent : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingParameterExtent( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                   bool optional = false );

     static QString typeName() { return QStringLiteral( "extent" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;

     static QgsProcessingParameterExtent *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

 };


 class CORE_EXPORT QgsProcessingParameterPoint : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingParameterPoint( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                  bool optional = false );

     static QString typeName() { return QStringLiteral( "point" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;

     static QgsProcessingParameterPoint *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

 };

 class CORE_EXPORT QgsProcessingParameterFile : public QgsProcessingParameterDefinition
 {
   public:

     enum Behavior
     {
       File = 0,
       Folder,
     };

     QgsProcessingParameterFile( const QString &name, const QString &description = QString(), Behavior behavior = File, const QString &extension = QString(), const QVariant &defaultValue = QVariant(),
                                 bool optional = false );

     static QString typeName() { return QStringLiteral( "file" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString asScriptCode() const override;

     Behavior behavior() const { return mBehavior; }

     void setBehavior( Behavior behavior ) { mBehavior = behavior; }

     QString extension() const { return mExtension; }

     void setExtension( const QString &extension ) { mExtension = extension; }

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterFile *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition, Behavior behavior = File ) SIP_FACTORY;

   private:

     Behavior mBehavior = File;
     QString mExtension;
 };

 class CORE_EXPORT QgsProcessingParameterMatrix : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingParameterMatrix( const QString &name, const QString &description = QString(), int numberRows = 3,
                                   bool hasFixedNumberRows = false, const QStringList &headers = QStringList(),
                                   const QVariant &defaultValue = QVariant(),
                                   bool optional = false );

     static QString typeName() { return QStringLiteral( "matrix" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;

     QStringList headers() const;

     void setHeaders( const QStringList &headers );

     int numberRows() const;

     void setNumberRows( int rows );

     bool hasFixedNumberRows() const;

     void setHasFixedNumberRows( bool hasFixedNumberRows );

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterMatrix *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

   private:

     QStringList mHeaders;
     int mNumberRows = 3;
     bool mFixedNumberRows = false;

 };

 class CORE_EXPORT QgsProcessingParameterMultipleLayers : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingParameterMultipleLayers( const QString &name, const QString &description = QString(), QgsProcessing::SourceType layerType = QgsProcessing::TypeVectorAnyGeometry,
                                           const QVariant &defaultValue = QVariant(),
                                           bool optional = false );

     static QString typeName() { return QStringLiteral( "multilayer" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
     QString asScriptCode() const override;

     QgsProcessing::SourceType layerType() const;

     void setLayerType( QgsProcessing::SourceType type );

     int minimumNumberInputs() const;

     void setMinimumNumberInputs( int minimum );

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterMultipleLayers *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

   private:

     QgsProcessing::SourceType mLayerType = QgsProcessing::TypeVectorAnyGeometry;
     int mMinimumNumberInputs = 0;

 };

 class CORE_EXPORT QgsProcessingParameterNumber : public QgsProcessingParameterDefinition
 {
   public:

     enum Type
     {
       Integer,
       Double,
     };

     explicit QgsProcessingParameterNumber( const QString &name, const QString &description = QString(),
                                            Type type = Integer,
                                            const QVariant &defaultValue = QVariant(),
                                            bool optional = false,
                                            double minValue = -DBL_MAX + 1,
                                            double maxValue = DBL_MAX
                                          );

     static QString typeName() { return QStringLiteral( "number" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
     QString toolTip() const override;

     double minimum() const;

     void setMinimum( double minimum );

     double maximum() const;

     void setMaximum( double maximum );

     Type dataType() const;

     void setDataType( Type type );

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterNumber *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

   private:

     double mMin = -DBL_MAX + 1;
     double mMax = DBL_MAX;
     Type mDataType = Integer;
 };

 class CORE_EXPORT QgsProcessingParameterRange : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingParameterRange( const QString &name, const QString &description = QString(),
                                  QgsProcessingParameterNumber::Type type = QgsProcessingParameterNumber::Integer,
                                  const QVariant &defaultValue = QVariant(),
                                  bool optional = false );

     static QString typeName() { return QStringLiteral( "range" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;

     QgsProcessingParameterNumber::Type dataType() const;

     void setDataType( QgsProcessingParameterNumber::Type dataType );

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterRange *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

   private:

     QgsProcessingParameterNumber::Type mDataType = QgsProcessingParameterNumber::Integer;
 };

 class CORE_EXPORT QgsProcessingParameterRasterLayer : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingParameterRasterLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                        bool optional = false );

     static QString typeName() { return QStringLiteral( "raster" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;

     static QgsProcessingParameterRasterLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

 };

 class CORE_EXPORT QgsProcessingParameterEnum : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingParameterEnum( const QString &name, const QString &description = QString(), const QStringList &options = QStringList(),
                                 bool allowMultiple = false,
                                 const QVariant &defaultValue = QVariant(),
                                 bool optional = false );

     static QString typeName() { return QStringLiteral( "enum" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
     QString asScriptCode() const override;

     QStringList options() const;

     void setOptions( const QStringList &options );

     bool allowMultiple() const;

     void setAllowMultiple( bool allowMultiple );

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterEnum *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

   private:

     QStringList mOptions;
     bool mAllowMultiple = false;

 };

 class CORE_EXPORT QgsProcessingParameterString : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingParameterString( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                   bool multiLine = false,
                                   bool optional = false );

     static QString typeName() { return QStringLiteral( "string" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
     QString asScriptCode() const override;

     bool multiLine() const;

     void setMultiLine( bool multiLine );

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterString *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

   private:

     bool mMultiLine = false;

 };

 class CORE_EXPORT QgsProcessingParameterExpression : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingParameterExpression( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                       const QString &parentLayerParameterName = QString(),
                                       bool optional = false );

     static QString typeName() { return QStringLiteral( "expression" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
     QStringList dependsOnOtherParameters() const override;

     QString parentLayerParameterName() const;

     void setParentLayerParameterName( const QString &parentLayerParameterName );

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterExpression *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

   private:

     QString mParentLayerParameterName;

 };


 class CORE_EXPORT QgsProcessingParameterLimitedDataTypes
 {
   public:

     QgsProcessingParameterLimitedDataTypes( const QList< int > &types = QList< int >() );

     QList< int > dataTypes() const;

     void setDataTypes( const QList< int > &types );

   protected:

     QList< int > mDataTypes;
 };

 class CORE_EXPORT QgsProcessingParameterVectorLayer : public QgsProcessingParameterDefinition, public QgsProcessingParameterLimitedDataTypes
 {
   public:

     QgsProcessingParameterVectorLayer( const QString &name,
                                        const QString &description = QString(),
                                        const QList< int > &types = QList< int >(),
                                        const QVariant &defaultValue = QVariant(),
                                        bool optional = false );

     static QString typeName() { return QStringLiteral( "vector" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterVectorLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

 };

 class CORE_EXPORT QgsProcessingParameterField : public QgsProcessingParameterDefinition
 {
   public:

     enum DataType
     {
       Any = -1,
       Numeric = 0,
       String = 1,
       DateTime = 2
     };

     QgsProcessingParameterField( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                  const QString &parentLayerParameterName = QString(),
                                  DataType type = Any,
                                  bool allowMultiple = false,
                                  bool optional = false );

     static QString typeName() { return QStringLiteral( "field" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
     QString asScriptCode() const override;
     QStringList dependsOnOtherParameters() const override;

     QString parentLayerParameterName() const;

     void setParentLayerParameterName( const QString &parentLayerParameterName );

     DataType dataType() const;

     void setDataType( DataType type );

     bool allowMultiple() const;

     void setAllowMultiple( bool allowMultiple );

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterField *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

   private:

     QString mParentLayerParameterName;
     DataType mDataType = Any;
     bool mAllowMultiple = false;

 };


 class CORE_EXPORT QgsProcessingParameterFeatureSource : public QgsProcessingParameterDefinition, public QgsProcessingParameterLimitedDataTypes
 {
   public:

     QgsProcessingParameterFeatureSource( const QString &name, const QString &description = QString(),
                                          const QList< int > &types = QList< int >(),
                                          const QVariant &defaultValue = QVariant(), bool optional = false );

     static QString typeName() { return QStringLiteral( "source" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
     QString asScriptCode() const override;

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterFeatureSource *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

 };

 class CORE_EXPORT QgsProcessingDestinationParameter : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingDestinationParameter( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                        bool optional = false );

     bool isDestination() const override { return true; }
     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     virtual QgsProcessingOutputDefinition *toOutputDefinition() const = 0 SIP_FACTORY;

     bool supportsNonFileBasedOutput() const { return mSupportsNonFileBasedOutputs; }

     void setSupportsNonFileBasedOutput( bool supportsNonFileBasedOutput ) { mSupportsNonFileBasedOutputs = supportsNonFileBasedOutput; }

     virtual QString defaultFileExtension() const = 0;

     virtual QString generateTemporaryDestination() const;

     bool createByDefault() const;

     void setCreateByDefault( bool createByDefault );

   private:

     bool mSupportsNonFileBasedOutputs = true;
     bool mCreateByDefault = true;

 };


 class CORE_EXPORT QgsProcessingParameterFeatureSink : public QgsProcessingDestinationParameter
 {
   public:

     QgsProcessingParameterFeatureSink( const QString &name, const QString &description = QString(), QgsProcessing::SourceType type = QgsProcessing::TypeVectorAnyGeometry, const QVariant &defaultValue = QVariant(),
                                        bool optional = false );

     static QString typeName() { return QStringLiteral( "sink" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
     QString asScriptCode() const override;
     QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
     QString defaultFileExtension() const override;

     QgsProcessing::SourceType dataType() const;

     bool hasGeometry() const;

     void setDataType( QgsProcessing::SourceType type );

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;
     QString generateTemporaryDestination() const override;

     static QgsProcessingParameterFeatureSink *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

   private:

     QgsProcessing::SourceType mDataType = QgsProcessing::TypeVectorAnyGeometry;
 };


 class CORE_EXPORT QgsProcessingParameterVectorDestination : public QgsProcessingDestinationParameter
 {
   public:

     QgsProcessingParameterVectorDestination( const QString &name, const QString &description = QString(), QgsProcessing::SourceType type = QgsProcessing::TypeVectorAnyGeometry, const QVariant &defaultValue = QVariant(),
         bool optional = false );

     static QString typeName() { return QStringLiteral( "vectorDestination" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
     QString asScriptCode() const override;
     QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
     QString defaultFileExtension() const override;

     QgsProcessing::SourceType dataType() const;

     bool hasGeometry() const;

     void setDataType( QgsProcessing::SourceType type );

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterVectorDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;


   private:

     QgsProcessing::SourceType mDataType = QgsProcessing::TypeVectorAnyGeometry;
 };

 class CORE_EXPORT QgsProcessingParameterRasterDestination : public QgsProcessingDestinationParameter
 {
   public:

     QgsProcessingParameterRasterDestination( const QString &name, const QString &description = QString(),
         const QVariant &defaultValue = QVariant(),
         bool optional = false );

     static QString typeName() { return QStringLiteral( "rasterDestination" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
     QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
     QString defaultFileExtension() const override;

     static QgsProcessingParameterRasterDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 };

 class CORE_EXPORT QgsProcessingParameterFileDestination : public QgsProcessingDestinationParameter
 {
   public:

     QgsProcessingParameterFileDestination( const QString &name, const QString &description = QString(),
                                            const QString &fileFilter = QString(),
                                            const QVariant &defaultValue = QVariant(),
                                            bool optional = false );

     static QString typeName() { return QStringLiteral( "fileDestination" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
     QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
     QString defaultFileExtension() const override;

     QString fileFilter() const;

     void setFileFilter( const QString &filter );

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterFileDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;


   private:

     QString mFileFilter;
 };

 class CORE_EXPORT QgsProcessingParameterFolderDestination : public QgsProcessingDestinationParameter
 {
   public:

     QgsProcessingParameterFolderDestination( const QString &name, const QString &description = QString(),
         const QVariant &defaultValue = QVariant(),
         bool optional = false );

     static QString typeName() { return QStringLiteral( "folderDestination" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
     QString defaultFileExtension() const override;

     static QgsProcessingParameterFolderDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

 };

 class CORE_EXPORT QgsProcessingParameterBand : public QgsProcessingParameterDefinition
 {
   public:

     QgsProcessingParameterBand( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                 const QString &parentLayerParameterName = QString(),
                                 bool optional = false );

     static QString typeName() { return QStringLiteral( "band" ); }
     QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
     QString type() const override { return typeName(); }
     bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
     QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
     QString asScriptCode() const override;
     QStringList dependsOnOtherParameters() const override;

     QString parentLayerParameterName() const;

     void setParentLayerParameterName( const QString &parentLayerParameterName );

     QVariantMap toVariantMap() const override;
     bool fromVariantMap( const QVariantMap &map ) override;

     static QgsProcessingParameterBand *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

   private:

     QString mParentLayerParameterName;
 };

 // clazy:excludeall=qstring-allocations

 #endif // QGSPROCESSINGPARAMETERS_H


QgsProcessingParameterBand::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:2045

QgsProcessingOutputLayerDefinition::sink
QgsProperty sink
Sink/layer definition.
Definition: qgsprocessingparameters.h:134

QgsProcessingParameterBoolean
A boolean parameter for processing algorithms.
Definition: qgsprocessingparameters.h:770

QgsProcessingParameterDefinitions
QList< const QgsProcessingParameterDefinition *> QgsProcessingParameterDefinitions
List of processing parameters.
Definition: qgsprocessingparameters.h:512

QgsProcessingParameterFile::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:950

QgsProcessingParameterDefinition::dynamicPropertyDefinition
QgsPropertyDefinition dynamicPropertyDefinition() const
Returns the property definition for dynamic properties.
Definition: qgsprocessingparameters.h:439

QgsProcessingParameterFile
An input file or folder parameter for processing algorithms.
Definition: qgsprocessingparameters.h:930

QgsProcessingParameterMultipleLayers
A parameter for processing algorithms which accepts multiple map layers.
Definition: qgsprocessingparameters.h:1085

QgsProcessingParameterDefinition::asScriptCode
virtual QString asScriptCode() const
Returns the parameter definition encoded in a string which can be used within a Python processing scr...
Definition: qgsprocessingparameters.cpp:1226

QgsRectangle
A rectangle specified with double values.
Definition: qgsrectangle.h:39

QgsMapLayer
Base class for all map layer types.
Definition: qgsmaplayer.h:56

QgsProcessingParameterExtent::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:880

QgsProcessingParameterString::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1407

QgsProcessingParameterDefinition::metadata
QVariantMap & metadata()
Returns the parameter&#39;s freeform metadata.
Definition: qgsprocessingparameters.h:380

QgsProcessingFeedback
Base class for providing feedback from a processing algorithm.
Definition: qgsprocessingfeedback.h:35

QgsProcessingParameterDefinition::fromVariantMap
virtual bool fromVariantMap(const QVariantMap &map)
Restores this parameter to a QVariantMap.
Definition: qgsprocessingparameters.cpp:1248

QgsProcessingOutputLayerDefinition
Encapsulates settings relating to a feature sink or output raster layer for a processing algorithm...
Definition: qgsprocessingparameters.h:107

QgsProcessingFeatureSourceDefinition::QgsProcessingFeatureSourceDefinition
QgsProcessingFeatureSourceDefinition(const QString &source=QString(), bool selectedFeaturesOnly=false)
Constructor for QgsProcessingFeatureSourceDefinition, accepting a static string source.
Definition: qgsprocessingparameters.h:55

QgsProcessingParameterRange::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1259

QgsProcessingParameterField::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1597

QgsProcessingParameterDefinition::setIsDynamic
void setIsDynamic(bool dynamic)
Sets whether the parameter is dynamic, and can support data-defined values (i.e.
Definition: qgsprocessingparameters.h:431

QgsProcessingParameterFeatureSink::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1792

QgsProcessingParameterField
A vector layer or feature source field parameter for processing algorithms.
Definition: qgsprocessingparameters.h:1570

QgsProcessingParameterDefinition::setDynamicLayerParameterName
void setDynamicLayerParameterName(const QString &name)
Sets the name for the parameter for a layer linked to a dynamic parameter, or an empty string if this...
Definition: qgsprocessingparameters.h:473

QgsProcessingParameterDefinition::mDynamicLayerParameterName
QString mDynamicLayerParameterName
Linked vector layer parameter name for dynamic properties.
Definition: qgsprocessingparameters.h:502

QgsProcessingParameterRasterLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1307

QgsProcessingParameterDefinition::metadata
QVariantMap metadata() const
Returns the parameter&#39;s freeform metadata.
Definition: qgsprocessingparameters.h:373

QgsProcessingParameterVectorLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1548

QgsRasterLayer
This class provides qgis with the ability to render raster datasets onto the mapcanvas.
Definition: qgsrasterlayer.h:139

QgsProcessingParameterFileDestination::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1953

QgsProcessingParameterFileDestination::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1955

QgsProcessingParameterVectorLayer::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1550

QgsProcessingParameterMapLayer
A map layer parameter for processing algorithms.
Definition: qgsprocessingparameters.h:833

QgsPointXY
A class to represent a 2D point.
Definition: qgspointxy.h:43

QgsProcessingParameterExpression
An expression parameter for processing algorithms.
Definition: qgsprocessingparameters.h:1445

QgsProcessingParameterMapLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:846

QgsProcessingParameterRasterLayer::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1309

QgsProcessingDestinationParameter::isDestination
bool isDestination() const override
Returns true if this parameter represents a file or layer destination, e.g.
Definition: qgsprocessingparameters.h:1710

QgsFeatureSink
An interface for objects which accept features via addFeature(s) methods.
Definition: qgsfeaturesink.h:33

QgsProcessingParameterMapLayer::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:848

QgsProcessingParameterMatrix::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1015

QgsProcessingParameterBoolean::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:783

QgsProcessingParameterDefinition::mMetadata
QVariantMap mMetadata
Freeform metadata for parameter. Mostly used by widget wrappers to customise their appearance and beh...
Definition: qgsprocessingparameters.h:490

QgsProcessingFeatureSource
QgsFeatureSource subclass which proxies methods to an underlying QgsFeatureSource, modifying results according to the settings in a QgsProcessingContext.
Definition: qgsprocessingutils.h:283

QgsFields
Container of fields for a vector layer.
Definition: qgsfields.h:42

QgsGeometry
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:111

QgsProcessingProvider
Abstract base class for processing providers.
Definition: qgsprocessingprovider.h:34

QgsProcessingParameterDefinition::toVariantMap
virtual QVariantMap toVariantMap() const
Saves this parameter to a QVariantMap.
Definition: qgsprocessingparameters.cpp:1236

QgsProcessingParameterDefinition::setFlags
void setFlags(Flags flags)
Sets the flags associated with the parameter.
Definition: qgsprocessingparameters.h:329

QgsProcessingParameterBand
A raster band parameter for Processing algorithms.
Definition: qgsprocessingparameters.h:2029

QgsProcessingParameterMultipleLayers::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1101

QgsProcessingParameterDefinition::valueAsPythonString
virtual QString valueAsPythonString(const QVariant &value, QgsProcessingContext &context) const
Returns a string version of the parameter input value, which is suitable for use as an input paramete...
Definition: qgsprocessingparameters.cpp:1218

QgsProcessingParameterCrs::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:814

QgsProcessingParameterNumber::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1180

QgsProcessingParameterString::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1409

QgsProcessingParameterField::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1595

QgsProcessingDestinationParameter
Base class for all parameter definitions which represent file or layer destinations, e.g.
Definition: qgsprocessingparameters.h:1700

QgsProcessingAlgorithm
Abstract base class for processing algorithms.
Definition: qgsprocessingalgorithm.h:51

Q_DECLARE_METATYPE
Q_DECLARE_METATYPE(QModelIndex)

QgsProcessingParameterFeatureSink
A feature sink output for processing algorithms.
Definition: qgsprocessingparameters.h:1777

QgsProcessingFeatureSourceDefinition::operator==
bool operator==(const QgsProcessingFeatureSourceDefinition &other)
Definition: qgsprocessingparameters.h:78

QgsProcessingFeatureSourceDefinition::selectedFeaturesOnly
bool selectedFeaturesOnly
True if only selected features in the source should be used by algorithms.
Definition: qgsprocessingparameters.h:76

QgsProcessingParameterRasterDestination
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
Definition: qgsprocessingparameters.h:1903

QgsProcessingParameterMultipleLayers::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1099

QgsProcessingParameterNumber::Double
Double/float values.
Definition: qgsprocessingparameters.h:1161

QgsProcessingParameterRange
A numeric range parameter for processing algorithms.
Definition: qgsprocessingparameters.h:1242

QgsProcessingFeatureSourceDefinition::operator!=
bool operator!=(const QgsProcessingFeatureSourceDefinition &other)
Definition: qgsprocessingparameters.h:83

QgsProcessingParameterDefinition::setDynamicPropertyDefinition
void setDynamicPropertyDefinition(const QgsPropertyDefinition &definition)
Sets the property definition for dynamic properties.
Definition: qgsprocessingparameters.h:447

QgsProcessingParameterRange::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1257

QgsProcessingParameterVectorDestination::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1855

QgsProcessingParameterNumber::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1178

QgsProcessingParameterLimitedDataTypes
Can be inherited by parameters which require limits to their acceptable data types.
Definition: qgsprocessingparameters.h:1498

QgsProcessingParameterRasterLayer
A raster layer parameter for processing algorithms.
Definition: qgsprocessingparameters.h:1294

QgsWkbTypes::Type
Type
The WKB type describes the number of dimensions a geometry has.
Definition: qgswkbtypes.h:67

QgsProcessingParameterDefinition::setDescription
void setDescription(const QString &description)
Sets the description for the parameter.
Definition: qgsprocessingparameters.h:304

QgsProcessingParameterDefinition::toolTip
virtual QString toolTip() const
Returns a formatted tooltip for use with the parameter, which gives helpful information like paramete...
Definition: qgsprocessingparameters.cpp:1268

QgsProcessingParameterPoint::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:911

QgsProcessingParameterBand::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:2043

QgsProcessingFeatureSourceDefinition::source
QgsProperty source
Source definition.
Definition: qgsprocessingparameters.h:71

QgsProcessingParameterEnum::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1343

QgsProcessingParameterEnum
An enum based parameter for processing algorithms, allowing for selection from predefined values...
Definition: qgsprocessingparameters.h:1326

QgsProcessingParameterNumber::Type
Type
Numeric data type.
Definition: qgsprocessingparameters.h:1158

QgsProcessingParameterDefinition::flags
Flags flags() const
Returns any flags associated with the parameter.
Definition: qgsprocessingparameters.h:323

QgsProcessingParameterFeatureSource::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1676

QgsProcessingParameterDefinition::defaultValue
QVariant defaultValue() const
Returns the default value for the parameter.
Definition: qgsprocessingparameters.h:310

SIP_SKIP
#define SIP_SKIP
Definition: qgis_sip.h:119

QgsProcessingOutputLayerDefinition::QgsProcessingOutputLayerDefinition
QgsProcessingOutputLayerDefinition(const QgsProperty &sink, QgsProject *destinationProject=nullptr)
Constructor for QgsProcessingOutputLayerDefinition, accepting a QgsProperty sink/layer.
Definition: qgsprocessingparameters.h:126

QgsProcessingParameters
A collection of utilities for working with parameters when running a processing algorithm.
Definition: qgsprocessingparameters.h:532

QgsProcessingParameterVectorDestination::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1857

SIP_END
#define SIP_END
Definition: qgis_sip.h:175

QgsProject
Reads and writes project states.
Definition: qgsproject.h:82

QgsProcessingParameterDefinition::setDefaultValue
void setDefaultValue(const QVariant &value)
Sets the default value for the parameter.
Definition: qgsprocessingparameters.h:317

QgsProcessingParameterMatrix::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1017

QgsProcessingParameterVectorLayer
A vector layer (with or without geometry) parameter for processing algorithms.
Definition: qgsprocessingparameters.h:1532

QgsProcessingDestinationParameter::defaultFileExtension
virtual QString defaultFileExtension() const =0
Returns the default file extension for destination file paths associated with this parameter...

SIP_FACTORY
#define SIP_FACTORY
Definition: qgis_sip.h:69

QgsProcessingParameterCrs
A coordinate reference system parameter for processing algorithms.
Definition: qgsprocessingparameters.h:801

QgsProperty
A store for object properties.
Definition: qgsproperty.h:229

QgsProcessingParameterDefinition::dependsOnOtherParameters
virtual QStringList dependsOnOtherParameters() const
Returns a list of other parameter names on which this parameter is dependent (e.g.
Definition: qgsprocessingparameters.h:393

QgsProcessingParameterExtent
A rectangular map extent parameter for processing algorithms.
Definition: qgsprocessingparameters.h:865

QgsProcessingParameterCrs::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:816

QgsProcessingParameterNumber
A numeric parameter for processing algorithms.
Definition: qgsprocessingparameters.h:1153

QgsProcessingParameterFileDestination
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
Definition: qgsprocessingparameters.h:1938

QgsProcessingParameterFile::setExtension
void setExtension(const QString &extension)
Sets a file extension for the parameter.
Definition: qgsprocessingparameters.h:978

QgsProcessingParameterDefinition::dynamicLayerParameterName
QString dynamicLayerParameterName() const
Returns the name of the parameter for a layer linked to a dynamic parameter, or an empty string if th...
Definition: qgsprocessingparameters.h:460

QgsPropertyDefinition
Definition for a property.
Definition: qgsproperty.h:46

qgsproperty.h

QgsProcessingParameterDefinition::name
QString name() const
Returns the name of the parameter.
Definition: qgsprocessingparameters.h:283

QgsProcessingParameterLimitedDataTypes::mDataTypes
QList< int > mDataTypes
List of acceptable data types for the parameter.
Definition: qgsprocessingparameters.h:1522

QgsProcessingFeatureSourceDefinition
Encapsulates settings relating to a feature source input to a processing algorithm.
Definition: qgsprocessingparameters.h:48

QgsProcessingDestinationParameter::supportsNonFileBasedOutput
bool supportsNonFileBasedOutput() const
Returns true if the destination parameter supports non filed-based outputs, such as memory layers or ...
Definition: qgsprocessingparameters.h:1725

QgsProcessingParameterFile::behavior
Behavior behavior() const
Returns the parameter behavior (e.g.
Definition: qgsprocessingparameters.h:960

QgsProcessingParameterBoolean::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:785

QgsProcessingParameterDefinition::isDestination
virtual bool isDestination() const
Returns true if this parameter represents a file or layer destination, e.g.
Definition: qgsprocessingparameters.h:276

QgsProcessingParameterFile::extension
QString extension() const
Returns any specified file extension for the parameter.
Definition: qgsprocessingparameters.h:972

QgsProcessingParameterFolderDestination::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:2011

QgsProcessingOutputDefinition
Base class for the definition of processing outputs.
Definition: qgsprocessingoutputs.h:41

QgsProcessingParameterDefinition::setName
void setName(const QString &name)
Sets the name of the parameter.
Definition: qgsprocessingparameters.h:290

QgsProcessingParameterVectorDestination
A vector layer destination parameter, for specifying the destination path for a vector layer created ...
Definition: qgsprocessingparameters.h:1842

QgsProcessingParameterRasterDestination::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1919

QgsProcessingParameterDefinition::isDynamic
bool isDynamic() const
Returns true if the parameter supports is dynamic, and can support data-defined values (i...
Definition: qgsprocessingparameters.h:422

QgsProcessingParameterPoint
A point parameter for processing algorithms.
Definition: qgsprocessingparameters.h:898

QgsProcessingParameterFolderDestination::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:2009

QgsProcessingParameterFeatureSource
An input feature source (such as vector layers) parameter for processing algorithms.
Definition: qgsprocessingparameters.h:1662

QgsProcessingParameterDefinition::setMetadata
void setMetadata(const QVariantMap &metadata)
Sets the parameter&#39;s freeform metadata.
Definition: qgsprocessingparameters.h:387

QgsProcessingParameterFolderDestination
A folder destination parameter, for specifying the destination path for a folder created by the algor...
Definition: qgsprocessingparameters.h:1995

QgsProcessingOutputLayerDefinition::destinationName
QString destinationName
Name to use for sink if it&#39;s to be loaded into a destination project.
Definition: qgsprocessingparameters.h:146

SIP_OUT
#define SIP_OUT
Definition: qgis_sip.h:51

QgsProcessingParameterDefinition::mFlags
Flags mFlags
Parameter flags.
Definition: qgsprocessingparameters.h:487

QgsProcessingParameterExpression::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1459

QgsCoordinateReferenceSystem
This class represents a coordinate reference system (CRS).
Definition: qgscoordinatereferencesystem.h:189

QgsProcessingOutputLayerDefinition::QgsProcessingOutputLayerDefinition
QgsProcessingOutputLayerDefinition(const QString &sink=QString(), QgsProject *destinationProject=nullptr)
Constructor for QgsProcessingOutputLayerDefinition, accepting a static sink/layer string...
Definition: qgsprocessingparameters.h:116

QgsProcessingParameterDefinition
Base class for the definition of processing parameters.
Definition: qgsprocessingparameters.h:186

QgsProcessingParameterDefinition::checkValueIsAcceptable
virtual bool checkValueIsAcceptable(const QVariant &input, QgsProcessingContext *context=nullptr) const
Checks whether the specified input value is acceptable for the parameter.
Definition: qgsprocessingparameters.cpp:1207

SIP_CONVERT_TO_SUBCLASS_CODE
#define SIP_CONVERT_TO_SUBCLASS_CODE(code)
Definition: qgis_sip.h:165

QgsProcessingDestinationParameter::toVariantMap
QVariantMap toVariantMap() const override
Saves this parameter to a QVariantMap.
Definition: qgsprocessingparameters.cpp:3493

QgsProcessingParameterDefinition::mDefault
QVariant mDefault
Default value for parameter.
Definition: qgsprocessingparameters.h:484

QgsProcessing::SourceType
SourceType
Data source types enum.
Definition: qgsprocessing.h:45

QgsProcessingParameterDefinition::mPropertyDefinition
QgsPropertyDefinition mPropertyDefinition
Data defined property definition.
Definition: qgsprocessingparameters.h:499

QgsProcessingParameterExtent::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:878

QgsProcessingParameterDefinition::mName
QString mName
Parameter name.
Definition: qgsprocessingparameters.h:478

QgsProcessingFeatureSourceDefinition::QgsProcessingFeatureSourceDefinition
QgsProcessingFeatureSourceDefinition(const QgsProperty &source, bool selectedFeaturesOnly=false)
Constructor for QgsProcessingFeatureSourceDefinition, accepting a QgsProperty source.
Definition: qgsprocessingparameters.h:63

QgsProcessingParameterRasterDestination::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1917

QgsProcessingParameterFile::Behavior
Behavior
Parameter behavior.
Definition: qgsprocessingparameters.h:935

QgsProcessingDestinationParameter::generateTemporaryDestination
virtual QString generateTemporaryDestination() const
Generates a temporary destination value for this parameter.
Definition: qgsprocessingparameters.cpp:3509

QgsProcessingDestinationParameter::setSupportsNonFileBasedOutput
void setSupportsNonFileBasedOutput(bool supportsNonFileBasedOutput)
Sets whether the destination parameter supports non filed-based outputs, such as memory layers or dir...
Definition: qgsprocessingparameters.h:1732

qgis.h

QgsProcessingParameterFeatureSink::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1790

QgsProcessingParameterField::DataType
DataType
Field data types.
Definition: qgsprocessingparameters.h:1575

QgsProcessingParameterMatrix
An table (matrix) parameter for processing algorithms.
Definition: qgsprocessingparameters.h:1000

qgsprocessing.h

QgsProcessingParameterFile::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:952

QgsProcessingParameterDefinition::mDescription
QString mDescription
Parameter description.
Definition: qgsprocessingparameters.h:481

QgsProcessingParameterDefinition::Flag
Flag
Parameter flags.
Definition: qgsprocessingparameters.h:245

QgsProcessingDestinationParameter::fromVariantMap
bool fromVariantMap(const QVariantMap &map) override
Restores this parameter to a QVariantMap.
Definition: qgsprocessingparameters.cpp:3501

QgsProcessingParameterFile::setBehavior
void setBehavior(Behavior behavior)
Sets the parameter behavior (e.g.
Definition: qgsprocessingparameters.h:966

QgsVectorLayer
Represents a vector layer which manages a vector based data sets.
Definition: qgsvectorlayer.h:353

QgsProcessingParameterFile::Folder
Parameter is a folder.
Definition: qgsprocessingparameters.h:938

QgsProcessingParameterNumber::Integer
Integer values.
Definition: qgsprocessingparameters.h:1160

QgsProcessingContext
Contains information about the context in which a processing algorithm is executed.
Definition: qgsprocessingcontext.h:40

QgsProcessingParameterString
A string parameter for processing algorithms.
Definition: qgsprocessingparameters.h:1393

QgsProcessingParameterExpression::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1461

QgsProcessingParameterDefinition::description
QString description() const
Returns the description for the parameter.
Definition: qgsprocessingparameters.h:297

QgsProcessingParameterDefinition::clone
virtual QgsProcessingParameterDefinition * clone() const =0
Creates a clone of the parameter definition.

QgsProcessingDestinationParameter::toOutputDefinition
virtual QgsProcessingOutputDefinition * toOutputDefinition() const =0
Returns a new QgsProcessingOutputDefinition corresponding to the definition of the destination parame...

QgsProcessing::TypeVectorAnyGeometry
Any vector layer with geometry.
Definition: qgsprocessing.h:48

qgscoordinatereferencesystem.h

QgsProcessingParameterFeatureSource::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:1678

QgsProcessingOutputLayerDefinition::createOptions
QVariantMap createOptions
Map of optional sink/layer creation options, which are passed to the underlying provider when creatin...
Definition: qgsprocessingparameters.h:154

qgsfeaturesource.h

QgsProcessingParameterPoint::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparameters.h:913

QgsProcessingParameterEnum::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparameters.h:1341