api/3.2/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;

     QVariant toVariant() const;

     bool loadVariant( const QVariantMap &map );

     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() == QgsProcessingParameterDistance::typeName() )
       sipType = sipType_QgsProcessingParameterDistance;
     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,
       FlagIsModelOutput = 1 << 4,
     };
     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 = std::numeric_limits<double>::lowest() + 1,
                                            double maxValue = std::numeric_limits<double>::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 = std::numeric_limits<double>::lowest() + 1;
     double mMax = std::numeric_limits<double>::max();
     Type mDataType = Integer;
 };

 class CORE_EXPORT QgsProcessingParameterDistance : public QgsProcessingParameterNumber
 {
   public:

     explicit QgsProcessingParameterDistance( const QString &name, const QString &description = QString(),
         const QVariant &defaultValue = QVariant(),
         const QString &parentParameterName = QString(),
         bool optional = false,
         double minValue = std::numeric_limits<double>::lowest() + 1,
         double maxValue = std::numeric_limits<double>::max() );

     static QString typeName() { return QStringLiteral( "distance" ); }

     QgsProcessingParameterDistance *clone() const override SIP_FACTORY;

     QString type() const override;
     QStringList dependsOnOtherParameters() const override;

     QString parentParameterName() const;

     void setParentParameterName( const QString &parentParameterName );

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

   private:

     QString mParentParameterName;

 };

 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 createByDefault = true );

     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 );

   protected:

     QgsProcessingProvider *originalProvider() const { return mOriginalProvider; }

   private:

     QgsProcessingProvider *mOriginalProvider = nullptr;

     bool mSupportsNonFileBasedOutputs = true;
     bool mCreateByDefault = true;

     friend class QgsProcessingModelAlgorithm;
     friend class TestQgsProcessing;
 };


 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, bool createByDefault = true );

     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;

     virtual QStringList supportedOutputVectorLayerExtensions() const;

     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, bool createByDefault = true );

     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;

     virtual QStringList supportedOutputVectorLayerExtensions() const;

     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,
         bool createByDefault = true );

     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;

     virtual QStringList supportedOutputRasterLayerExtensions() const;

     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,
                                            bool createByDefault = true );

     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:2176

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

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

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

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

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

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

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

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:1351

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

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

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

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

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

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:1373

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:1329

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

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

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

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

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:491

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

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

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

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

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:2084

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

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

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

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

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

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

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

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

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

QgsProcessingDestinationParameter::originalProvider
QgsProcessingProvider * originalProvider() const
Original (source) provider which this parameter has been derived from.
Definition: qgsprocessingparameters.h:1844

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

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

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

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

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

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:104

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:1361

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

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

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

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

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:1340

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

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

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

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

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

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

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:1873

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:2019

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

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

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

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:465

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

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

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

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

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

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:322

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

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

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

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

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

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

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

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

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

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

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:550

QgsProcessingParameterDistance
A double numeric parameter for distance values.
Definition: qgsprocessingparameters.h:1261

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

SIP_END
#define SIP_END
Definition: qgis_sip.h:182

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

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

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

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

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:819

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:411

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

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

algorithm
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into allowing algorithms to be written in pure substantial changes are required in order to port existing x Processing algorithms for QGIS x The most significant changes are outlined not GeoAlgorithm For algorithms which operate on features one by consider subclassing the QgsProcessingFeatureBasedAlgorithm class This class allows much of the boilerplate code for looping over features from a vector layer to be bypassed and instead requires implementation of a processFeature method Ensure that your algorithm(or algorithm 's parent class) implements the new pure virtual createInstance(self) call

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

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

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

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:478

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

qgsproperty.h

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

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

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

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:1798

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

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

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

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

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

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:308

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

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

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

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

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

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

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

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

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:505

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

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:201

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:1328

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:3796

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

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

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

QgsProcessingParameterNumber::clone
QgsProcessingParameterDefinition * clone() const override
Creates a clone of the parameter definition.
Definition: qgsprocessingparameters.cpp:2159

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

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

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:2037

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

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

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:1805

qgis.h

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

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

QgsProcessingParameterMatrix
A table (matrix) parameter for processing algorithms.
Definition: qgsprocessingparameters.h:1018

qgsprocessing.h

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

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

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

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

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

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:956

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

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

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

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

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

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:47

qgscoordinatereferencesystem.h

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

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:931

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