qgsprocessingparameters.cpp

Go to the documentation of this file.

/***************************************************************************
                         qgsprocessingparameters.cpp
                         ---------------------------
    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.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgsprocessingparameters.h"
#include "qgsprocessingprovider.h"
#include "qgsprocessingcontext.h"
#include "qgsprocessingutils.h"
#include "qgsprocessingalgorithm.h"
#include "qgsprocessingoutputs.h"
#include "qgsvectorfilewriter.h"
#include "qgsreferencedgeometry.h"
#include "qgsprocessingregistry.h"
#include "qgsprocessingparametertype.h"
#include "qgsrasterfilewriter.h"
#include "qgsvectorlayer.h"
#include "qgsmeshlayer.h"
#include "qgspointcloudlayer.h"
#include "qgsannotationlayer.h"
#include "qgsapplication.h"
#include "qgslayoutmanager.h"
#include "qgsprintlayout.h"
#include "qgssettings.h"
#include "qgssymbollayerutils.h"
#include "qgsfileutils.h"
#include "qgsproviderregistry.h"
#include "qgsvariantutils.h"
#include "qgsmessagelog.h"
#include <functional>
#include <QRegularExpression>
 
 
QVariant QgsProcessingFeatureSourceDefinition::toVariant() const
{
  QVariantMap map;
  map.insert( QStringLiteral( "source" ), source.toVariant() );
  map.insert( QStringLiteral( "selected_only" ), selectedFeaturesOnly );
  map.insert( QStringLiteral( "feature_limit" ), featureLimit );
  map.insert( QStringLiteral( "filter" ), filterExpression );
  map.insert( QStringLiteral( "flags" ), static_cast< int >( flags ) );
  map.insert( QStringLiteral( "geometry_check" ), static_cast< int >( geometryCheck ) );
  return map;
}
QVariant QgsProcessingFeatureSourceDefinition::toVariant() const {…}
 
bool QgsProcessingFeatureSourceDefinition::loadVariant( const QVariantMap &map )
{
  source.loadVariant( map.value( QStringLiteral( "source" ) ) );
  selectedFeaturesOnly = map.value( QStringLiteral( "selected_only" ), false ).toBool();
  featureLimit = map.value( QStringLiteral( "feature_limit" ), -1 ).toLongLong();
  filterExpression = map.value( QStringLiteral( "filter" ) ).toString();
  flags = static_cast< Qgis::ProcessingFeatureSourceDefinitionFlags >( map.value( QStringLiteral( "flags" ), 0 ).toInt() );
  geometryCheck = static_cast< Qgis::InvalidGeometryCheck >( map.value( QStringLiteral( "geometry_check" ), static_cast< int >( Qgis::InvalidGeometryCheck::AbortOnInvalid ) ).toInt() );
  return true;
}
bool QgsProcessingFeatureSourceDefinition::loadVariant( const QVariantMap &map ) {…}
 
 
//
// QgsProcessingOutputLayerDefinition
//
 
void QgsProcessingOutputLayerDefinition::setRemappingDefinition( const QgsRemappingSinkDefinition &definition )
{
  mUseRemapping = true;
  mRemappingDefinition = definition;
}
void QgsProcessingOutputLayerDefinition::setRemappingDefinition( const QgsRemappingSinkDefinition &definition ) {…}
 
QVariant QgsProcessingOutputLayerDefinition::toVariant() const
{
  QVariantMap map;
  map.insert( QStringLiteral( "sink" ), sink.toVariant() );
  map.insert( QStringLiteral( "create_options" ), createOptions );
  if ( mUseRemapping )
    map.insert( QStringLiteral( "remapping" ), QVariant::fromValue( mRemappingDefinition ) );
  return map;
}
QVariant QgsProcessingOutputLayerDefinition::toVariant() const {…}
 
bool QgsProcessingOutputLayerDefinition::loadVariant( const QVariantMap &map )
{
  sink.loadVariant( map.value( QStringLiteral( "sink" ) ) );
  createOptions = map.value( QStringLiteral( "create_options" ) ).toMap();
  if ( map.contains( QStringLiteral( "remapping" ) ) )
  {
    mUseRemapping = true;
    mRemappingDefinition = map.value( QStringLiteral( "remapping" ) ).value< QgsRemappingSinkDefinition >();
  }
  else
  {
    mUseRemapping = false;
  }
  return true;
}
bool QgsProcessingOutputLayerDefinition::loadVariant( const QVariantMap &map ) {…}
 
bool QgsProcessingOutputLayerDefinition::operator==( const QgsProcessingOutputLayerDefinition &other ) const
{
  return sink == other.sink && destinationProject == other.destinationProject && destinationName == other.destinationName && createOptions == other.createOptions
         && mUseRemapping == other.mUseRemapping && mRemappingDefinition == other.mRemappingDefinition;
}
bool QgsProcessingOutputLayerDefinition::operator==( const QgsProcessingOutputLayerDefinition &other ) const {…}
 
bool QgsProcessingOutputLayerDefinition::operator!=( const QgsProcessingOutputLayerDefinition &other ) const
{
  return !( *this == other );
}
bool QgsProcessingOutputLayerDefinition::operator!=( const QgsProcessingOutputLayerDefinition &other ) const {…}
 
bool QgsProcessingParameters::isDynamic( const QVariantMap &parameters, const QString &name )
{
  const QVariant val = parameters.value( name );
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return val.value< QgsProperty >().propertyType() != Qgis::PropertyType::Static;
  else
    return false;
}
bool QgsProcessingParameters::isDynamic( const QVariantMap &parameters, const QString &name ) {…}
 
QString QgsProcessingParameters::parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return QString();
 
  return parameterAsString( definition, parameters.value( definition->name() ), context );
}
QString QgsProcessingParameters::parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return QString();
 
  QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
 
  if ( !val.isValid() )
  {
    // fall back to default
    val = definition->defaultValue();
  }
 
  if ( val == QgsProcessing::TEMPORARY_OUTPUT )
  {
    if ( const QgsProcessingDestinationParameter *destParam = dynamic_cast< const QgsProcessingDestinationParameter * >( definition ) )
      return destParam->generateTemporaryDestination( &context );
  }
 
  return val.toString();
}
QString QgsProcessingParameters::parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return QString();
 
  return parameterAsExpression( definition, parameters.value( definition->name() ), context );
}
QString QgsProcessingParameters::parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return QString();
 
  const QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
 
  if ( val.isValid() && !val.toString().isEmpty() )
  {
    const QgsExpression e( val.toString() );
    if ( e.isValid() )
      return val.toString();
  }
 
  // fall back to default
  return definition->defaultValue().toString();
}
QString QgsProcessingParameters::parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
double QgsProcessingParameters::parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return 0;
 
  return parameterAsDouble( definition, parameters.value( definition->name() ), context );
}
double QgsProcessingParameters::parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
double QgsProcessingParameters::parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return 0;
 
  QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return val.value< QgsProperty >().valueAsDouble( context.expressionContext(), definition->defaultValue().toDouble() );
 
  bool ok = false;
  const double res = val.toDouble( &ok );
  if ( ok )
    return res;
 
  // fall back to default
  val = definition->defaultValue();
  return val.toDouble();
}
double QgsProcessingParameters::parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
int QgsProcessingParameters::parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return 0;
 
  return parameterAsInt( definition, parameters.value( definition->name() ), context );
}
int QgsProcessingParameters::parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
int QgsProcessingParameters::parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return 0;
 
  QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return val.value< QgsProperty >().valueAsInt( context.expressionContext(), definition->defaultValue().toInt() );
 
  bool ok = false;
  double dbl = val.toDouble( &ok );
  if ( !ok )
  {
    // fall back to default
    val = definition->defaultValue();
    dbl = val.toDouble( &ok );
  }
 
  //String representations of doubles in QVariant will not convert to int
  //work around this by first converting to double, and then checking whether the double is convertible to int
  if ( ok )
  {
    const double round = std::round( dbl );
    if ( round  > std::numeric_limits<int>::max() || round < -std::numeric_limits<int>::max() )
    {
      //double too large to fit in int
      return 0;
    }
    return static_cast< int >( std::round( dbl ) );
  }
 
  return val.toInt();
}
int QgsProcessingParameters::parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
QList< int > QgsProcessingParameters::parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return QList< int >();
 
  return parameterAsInts( definition, parameters.value( definition->name() ), context );
}
QList< int > QgsProcessingParameters::parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
QList< int > QgsProcessingParameters::parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return QList< int >();
 
  QList< int > resultList;
  const QVariant val = value;
  if ( val.isValid() )
  {
    if ( val.userType() == qMetaTypeId<QgsProperty>() )
      resultList << val.value< QgsProperty >().valueAsInt( context.expressionContext(), definition->defaultValue().toInt() );
    else if ( val.userType() == QMetaType::Type::QVariantList )
    {
      const QVariantList list = val.toList();
      for ( auto it = list.constBegin(); it != list.constEnd(); ++it )
        resultList << it->toInt();
    }
    else
    {
      const QStringList parts = val.toString().split( ';' );
      for ( auto it = parts.constBegin(); it != parts.constEnd(); ++it )
        resultList << it->toInt();
    }
  }
 
  if ( resultList.isEmpty() )
  {
    // check default
    if ( definition->defaultValue().isValid() )
    {
      if ( definition->defaultValue().userType() == QMetaType::Type::QVariantList )
      {
        const QVariantList list = definition->defaultValue().toList();
        for ( auto it = list.constBegin(); it != list.constEnd(); ++it )
          resultList << it->toInt();
      }
      else
      {
        const QStringList parts = definition->defaultValue().toString().split( ';' );
        for ( auto it = parts.constBegin(); it != parts.constEnd(); ++it )
          resultList << it->toInt();
      }
    }
  }
 
  return resultList;
}
QList< int > QgsProcessingParameters::parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
QDateTime QgsProcessingParameters::parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return QDateTime();
 
  return parameterAsDateTime( definition, parameters.value( definition->name() ), context );
}
QDateTime QgsProcessingParameters::parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
QDateTime QgsProcessingParameters::parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return QDateTime();
 
  QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    val = val.value< QgsProperty >().value( context.expressionContext(), definition->defaultValue() );
 
  QDateTime d = val.toDateTime();
  if ( !d.isValid() && val.userType() == QMetaType::Type::QString )
  {
    d = QDateTime::fromString( val.toString() );
  }
 
  if ( !d.isValid() )
  {
    // fall back to default
    val = definition->defaultValue();
    d = val.toDateTime();
  }
  if ( !d.isValid() && val.userType() == QMetaType::Type::QString )
  {
    d = QDateTime::fromString( val.toString() );
  }
 
  return d;
}
QDateTime QgsProcessingParameters::parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
QDate QgsProcessingParameters::parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return QDate();
 
  return parameterAsDate( definition, parameters.value( definition->name() ), context );
}
QDate QgsProcessingParameters::parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
QDate QgsProcessingParameters::parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return QDate();
 
  QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    val = val.value< QgsProperty >().value( context.expressionContext(), definition->defaultValue() );
 
  QDate d = val.toDate();
  if ( !d.isValid() && val.userType() == QMetaType::Type::QString )
  {
    d = QDate::fromString( val.toString() );
  }
 
  if ( !d.isValid() )
  {
    // fall back to default
    val = definition->defaultValue();
    d = val.toDate();
  }
  if ( !d.isValid() && val.userType() == QMetaType::Type::QString )
  {
    d = QDate::fromString( val.toString() );
  }
 
  return d;
}
QDate QgsProcessingParameters::parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
QTime QgsProcessingParameters::parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return QTime();
 
  return parameterAsTime( definition, parameters.value( definition->name() ), context );
}
QTime QgsProcessingParameters::parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
QTime QgsProcessingParameters::parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return QTime();
 
  QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    val = val.value< QgsProperty >().value( context.expressionContext(), definition->defaultValue() );
 
  QTime d;
 
  if ( val.userType() == QMetaType::Type::QDateTime )
    d = val.toDateTime().time();
  else
    d = val.toTime();
 
  if ( !d.isValid() && val.userType() == QMetaType::Type::QString )
  {
    d = QTime::fromString( val.toString() );
  }
 
  if ( !d.isValid() )
  {
    // fall back to default
    val = definition->defaultValue();
    d = val.toTime();
  }
  if ( !d.isValid() && val.userType() == QMetaType::Type::QString )
  {
    d = QTime::fromString( val.toString() );
  }
 
  return d;
}
QTime QgsProcessingParameters::parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
int QgsProcessingParameters::parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return 0;
 
  return parameterAsEnum( definition, parameters.value( definition->name() ), context );
}
int QgsProcessingParameters::parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
int QgsProcessingParameters::parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return 0;
 
  const int val = parameterAsInt( definition, value, context );
  const QgsProcessingParameterEnum *enumDef = dynamic_cast< const QgsProcessingParameterEnum *>( definition );
  if ( enumDef && val >= enumDef->options().size() )
  {
    return enumDef->defaultValue().toInt();
  }
  return val;
}
int QgsProcessingParameters::parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
QList<int> QgsProcessingParameters::parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return QList<int>();
 
  return parameterAsEnums( definition, parameters.value( definition->name() ), context );
}
QList<int> QgsProcessingParameters::parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
QList<int> QgsProcessingParameters::parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return QList<int>();
 
  QVariantList resultList;
  const QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    resultList << val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
  else if ( val.userType() == QMetaType::Type::QVariantList )
  {
    const auto constToList = val.toList();
    for ( const QVariant &var : constToList )
      resultList << var;
  }
  else if ( val.userType() == QMetaType::Type::QString )
  {
    const auto constSplit = val.toString().split( ',' );
    for ( const QString &var : constSplit )
      resultList << var;
  }
  else
    resultList << val;
 
  if ( resultList.isEmpty() )
    return QList< int >();
 
  if ( ( !val.isValid() || !resultList.at( 0 ).isValid() ) && definition )
  {
    resultList.clear();
    // check default
    if ( definition->defaultValue().userType() == QMetaType::Type::QVariantList )
    {
      const auto constToList = definition->defaultValue().toList();
      for ( const QVariant &var : constToList )
        resultList << var;
    }
    else if ( definition->defaultValue().userType() == QMetaType::Type::QString )
    {
      const auto constSplit = definition->defaultValue().toString().split( ',' );
      for ( const QString &var : constSplit )
        resultList << var;
    }
    else
      resultList << definition->defaultValue();
  }
 
  QList< int > result;
  const QgsProcessingParameterEnum *enumDef = dynamic_cast< const QgsProcessingParameterEnum *>( definition );
  const auto constResultList = resultList;
  for ( const QVariant &var : constResultList )
  {
    const int resInt = var.toInt();
    if ( !enumDef || resInt < enumDef->options().size() )
    {
      result << resInt;
    }
  }
  return result;
}
QList<int> QgsProcessingParameters::parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return QString();
 
  return parameterAsEnumString( definition, parameters.value( definition->name() ), context );
}
QString QgsProcessingParameters::parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return QString();
 
  QString enumText = parameterAsString( definition, value, context );
  const QgsProcessingParameterEnum *enumDef = dynamic_cast< const QgsProcessingParameterEnum *>( definition );
  if ( enumText.isEmpty() || !enumDef->options().contains( enumText ) )
    enumText = definition->defaultValue().toString();
 
  return enumText;
}
QString QgsProcessingParameters::parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
QStringList QgsProcessingParameters::parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return QStringList();
 
  return parameterAsEnumStrings( definition, parameters.value( definition->name() ), context );
}
QStringList QgsProcessingParameters::parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
QStringList QgsProcessingParameters::parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return QStringList();
 
  const QVariant val = value;
 
  QStringList enumValues;
 
  std::function< void( const QVariant &var ) > processVariant;
  processVariant = [ &enumValues, &context, &definition, &processVariant ]( const QVariant & var )
  {
    if ( var.userType() == QMetaType::Type::QVariantList )
    {
      const auto constToList = var.toList();
      for ( const QVariant &listVar : constToList )
      {
        processVariant( listVar );
      }
    }
    else if ( var.userType() == QMetaType::Type::QStringList )
    {
      const auto constToStringList = var.toStringList();
      for ( const QString &s : constToStringList )
      {
        processVariant( s );
      }
    }
    else if ( var.userType() == qMetaTypeId<QgsProperty>() )
      processVariant( var.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() ) );
    else
    {
      const QStringList parts = var.toString().split( ',' );
      for ( const QString &s : parts )
      {
        enumValues << s;
      }
    }
  };
 
  processVariant( val );
 
  const QgsProcessingParameterEnum *enumDef = dynamic_cast< const QgsProcessingParameterEnum *>( definition );
  // check that values are valid enum values. The resulting set will be empty
  // if all values are present in the enumDef->options(), otherwise it will contain
  // values which are invalid
  const QStringList options = enumDef->options();
  const QSet<QString> subtraction = QSet<QString>( enumValues.begin(), enumValues.end() ).subtract( QSet<QString>( options.begin(), options.end() ) );
 
  if ( enumValues.isEmpty() || !subtraction.isEmpty() )
  {
    enumValues.clear();
    // cppcheck-suppress invalidContainer
    processVariant( definition->defaultValue() );
  }
 
  return enumValues;
}
QStringList QgsProcessingParameters::parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
bool QgsProcessingParameters::parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return false;
 
  return parameterAsBool( definition, parameters.value( definition->name() ), context );
}
bool QgsProcessingParameters::parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
bool QgsProcessingParameters::parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return false;
 
  return parameterAsBoolean( definition, parameters.value( definition->name() ), context );
}
bool QgsProcessingParameters::parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
bool QgsProcessingParameters::parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return false;
 
  const QVariant def = definition->defaultValue();
 
  const QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return val.value< QgsProperty >().valueAsBool( context.expressionContext(), def.toBool() );
  else if ( val.isValid() )
    return val.toBool();
  else
    return def.toBool();
}
bool QgsProcessingParameters::parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
bool QgsProcessingParameters::parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  if ( !definition )
    return false;
 
  const QVariant def = definition->defaultValue();
 
  const QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return val.value< QgsProperty >().valueAsBool( context.expressionContext(), def.toBool() );
  else if ( val.isValid() )
    return val.toBool();
  else
    return def.toBool();
}
bool QgsProcessingParameters::parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
QgsFeatureSink *QgsProcessingParameters::parameterAsSink( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsFields &fields,
    Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &crs,
    QgsProcessingContext &context, QString &destinationIdentifier, QgsFeatureSink::SinkFlags sinkFlags,
    const QVariantMap &createOptions, const QStringList &datasourceOptions, const QStringList &layerOptions )
{
  QVariant val;
  if ( definition )
  {
    val = parameters.value( definition->name() );
  }
 
  return parameterAsSink( definition, val, fields, geometryType, crs, context, destinationIdentifier, sinkFlags, createOptions, datasourceOptions, layerOptions );
}
QgsFeatureSink *QgsProcessingParameters::parameterAsSink( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsFields &fields, {…}
 
QgsFeatureSink *QgsProcessingParameters::parameterAsSink( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsFields &fields, Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &crs, QgsProcessingContext &context, QString &destinationIdentifier, QgsFeatureSink::SinkFlags sinkFlags, const QVariantMap &createOptions, const QStringList &datasourceOptions, const QStringList &layerOptions )
{
  QVariantMap options = createOptions;
  QVariant val = value;
 
  QgsProject *destinationProject = nullptr;
  QString destName;
  QgsRemappingSinkDefinition remapDefinition;
  bool useRemapDefinition = false;
  if ( val.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    // input is a QgsProcessingOutputLayerDefinition - get extra properties from it
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( val );
    destinationProject = fromVar.destinationProject;
    options = fromVar.createOptions;
 
    val = fromVar.sink;
    destName = fromVar.destinationName;
    if ( fromVar.useRemapping() )
    {
      useRemapDefinition = true;
      remapDefinition = fromVar.remappingDefinition();
    }
  }
 
  QString dest;
  if ( definition && val.userType() == qMetaTypeId<QgsProperty>() )
  {
    dest = val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
  }
  else if ( !val.isValid() || val.toString().isEmpty() )
  {
    if ( definition && definition->flags() & Qgis::ProcessingParameterFlag::Optional && !definition->defaultValue().isValid() )
    {
      // unset, optional sink, no default => no sink
      return nullptr;
    }
    // fall back to default
    if ( !definition )
    {
      throw QgsProcessingException( QObject::tr( "No parameter definition for the sink" ) );
    }
    dest = definition->defaultValue().toString();
  }
  else
  {
    dest = val.toString();
  }
  if ( dest == QgsProcessing::TEMPORARY_OUTPUT )
  {
    if ( const QgsProcessingDestinationParameter *destParam = dynamic_cast< const QgsProcessingDestinationParameter * >( definition ) )
      dest = destParam->generateTemporaryDestination( &context );
  }
 
  if ( dest.isEmpty() )
    return nullptr;
 
  std::unique_ptr< QgsFeatureSink > sink( QgsProcessingUtils::createFeatureSink( dest, context, fields, geometryType, crs, options, datasourceOptions, layerOptions, sinkFlags, useRemapDefinition ? &remapDefinition : nullptr ) );
  destinationIdentifier = dest;
 
  if ( destinationProject )
  {
    if ( destName.isEmpty() && definition )
    {
      destName = definition->description();
    }
    QString outputName;
    if ( definition )
      outputName = definition->name();
    context.addLayerToLoadOnCompletion( destinationIdentifier, QgsProcessingContext::LayerDetails( destName, destinationProject, outputName, QgsProcessingUtils::LayerHint::Vector ) );
  }
 
  return sink.release();
}
QgsFeatureSink *QgsProcessingParameters::parameterAsSink( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsFields &fields, Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &crs, QgsProcessingContext &context, QString &destinationIdentifier, QgsFeatureSink::SinkFlags sinkFlags, const QVariantMap &createOptions, const QStringList &datasourceOptions, const QStringList &layerOptions ) {…}
 
QgsProcessingFeatureSource *QgsProcessingParameters::parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  if ( !definition )
    return nullptr;
 
  return parameterAsSource( definition, parameters.value( definition->name() ), context );
}
QgsProcessingFeatureSource *QgsProcessingParameters::parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QgsProcessingFeatureSource *QgsProcessingParameters::parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  if ( !definition )
    return nullptr;
 
  return QgsProcessingUtils::variantToSource( value, context, definition->defaultValue() );
}
QgsProcessingFeatureSource *QgsProcessingParameters::parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QString parameterAsCompatibleSourceLayerPathInternal( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat, QgsProcessingFeedback *feedback, QString *layerName )
{
  if ( !definition )
    return QString();
 
  QVariant val = parameters.value( definition->name() );
 
  bool selectedFeaturesOnly = false;
  long long featureLimit = -1;
  QString filterExpression;
  if ( val.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
  {
    // input is a QgsProcessingFeatureSourceDefinition - get extra properties from it
    const QgsProcessingFeatureSourceDefinition fromVar = qvariant_cast<QgsProcessingFeatureSourceDefinition>( val );
    selectedFeaturesOnly = fromVar.selectedFeaturesOnly;
    featureLimit = fromVar.featureLimit;
    filterExpression = fromVar.filterExpression;
    val = fromVar.source;
  }
  else if ( val.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    // input is a QgsProcessingOutputLayerDefinition - get extra properties from it
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( val );
    val = fromVar.sink;
  }
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
  {
    val = val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
  }
 
  QgsVectorLayer *vl = nullptr;
  vl = qobject_cast< QgsVectorLayer * >( qvariant_cast<QObject *>( val ) );
 
  if ( !vl )
  {
    QString layerRef;
    if ( val.userType() == qMetaTypeId<QgsProperty>() )
    {
      layerRef = val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
    }
    else if ( !val.isValid() || val.toString().isEmpty() )
    {
      // fall back to default
      val = definition->defaultValue();
 
      // default value may be a vector layer
      vl = qobject_cast< QgsVectorLayer * >( qvariant_cast<QObject *>( val ) );
      if ( !vl )
        layerRef = definition->defaultValue().toString();
    }
    else
    {
      layerRef = val.toString();
    }
 
    if ( !vl )
    {
      if ( layerRef.isEmpty() )
        return QString();
 
      vl = qobject_cast< QgsVectorLayer *>( QgsProcessingUtils::mapLayerFromString( layerRef, context, true, QgsProcessingUtils::LayerHint::Vector ) );
    }
  }
 
  if ( !vl )
    return QString();
 
  if ( layerName )
    return QgsProcessingUtils::convertToCompatibleFormatAndLayerName( vl, selectedFeaturesOnly, definition->name(),
           compatibleFormats, preferredFormat, context, feedback, *layerName, featureLimit, filterExpression );
  else
    return QgsProcessingUtils::convertToCompatibleFormat( vl, selectedFeaturesOnly, definition->name(),
           compatibleFormats, preferredFormat, context, feedback, featureLimit, filterExpression );
}
QString parameterAsCompatibleSourceLayerPathInternal( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat, QgsProcessingFeedback *feedback, QString *layerName ) {…}
 
QString QgsProcessingParameters::parameterAsCompatibleSourceLayerPath( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat, QgsProcessingFeedback *feedback )
{
  return parameterAsCompatibleSourceLayerPathInternal( definition, parameters, context, compatibleFormats, preferredFormat, feedback, nullptr );
}
QString QgsProcessingParameters::parameterAsCompatibleSourceLayerPath( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat, QgsProcessingFeedback *feedback ) {…}
 
QString QgsProcessingParameters::parameterAsCompatibleSourceLayerPathAndLayerName( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat, QgsProcessingFeedback *feedback, QString *layerName )
{
  QString *destLayer = layerName;
  QString tmp;
  if ( destLayer )
    destLayer->clear();
  else
    destLayer = &tmp;
 
  return parameterAsCompatibleSourceLayerPathInternal( definition, parameters, context, compatibleFormats, preferredFormat, feedback, destLayer );
}
QString QgsProcessingParameters::parameterAsCompatibleSourceLayerPathAndLayerName( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat, QgsProcessingFeedback *feedback, QString *layerName ) {…}
 
QgsMapLayer *QgsProcessingParameters::parameterAsLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingUtils::LayerHint layerHint, QgsProcessing::LayerOptionsFlags flags )
{
  if ( !definition )
    return nullptr;
 
  return parameterAsLayer( definition, parameters.value( definition->name() ), context, layerHint, flags );
}
QgsMapLayer *QgsProcessingParameters::parameterAsLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingUtils::LayerHint layerHint, QgsProcessing::LayerOptionsFlags flags ) {…}
 
QgsMapLayer *QgsProcessingParameters::parameterAsLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessingUtils::LayerHint layerHint, QgsProcessing::LayerOptionsFlags flags )
{
  if ( !definition )
    return nullptr;
 
  QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
  {
    val = val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
  }
 
  if ( QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( val ) ) )
  {
    return layer;
  }
 
  if ( val.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    // input is a QgsProcessingOutputLayerDefinition - get extra properties from it
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( val );
    val = fromVar.sink;
  }
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() && val.value< QgsProperty >().propertyType() == Qgis::PropertyType::Static )
  {
    val = val.value< QgsProperty >().staticValue();
  }
 
  if ( !val.isValid() || val.toString().isEmpty() )
  {
    // fall back to default
    val = definition->defaultValue();
  }
 
  if ( QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( val ) ) )
  {
    return layer;
  }
 
  QString layerRef = val.toString();
  if ( layerRef.isEmpty() )
    layerRef = definition->defaultValue().toString();
 
  if ( layerRef.isEmpty() )
    return nullptr;
 
  return QgsProcessingUtils::mapLayerFromString( layerRef, context, true, layerHint, flags );
}
QgsMapLayer *QgsProcessingParameters::parameterAsLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessingUtils::LayerHint layerHint, QgsProcessing::LayerOptionsFlags flags ) {…}
 
QgsRasterLayer *QgsProcessingParameters::parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  return qobject_cast< QgsRasterLayer *>( parameterAsLayer( definition, parameters, context, QgsProcessingUtils::LayerHint::Raster ) );
}
QgsRasterLayer *QgsProcessingParameters::parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QgsRasterLayer *QgsProcessingParameters::parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  return qobject_cast< QgsRasterLayer *>( parameterAsLayer( definition, value, context, QgsProcessingUtils::LayerHint::Raster ) );
}
QgsRasterLayer *QgsProcessingParameters::parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QgsMeshLayer *QgsProcessingParameters::parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  return qobject_cast< QgsMeshLayer *>( parameterAsLayer( definition, parameters, context, QgsProcessingUtils::LayerHint::Mesh ) );
}
QgsMeshLayer *QgsProcessingParameters::parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QgsMeshLayer *QgsProcessingParameters::parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  return qobject_cast< QgsMeshLayer *>( parameterAsLayer( definition, value, context, QgsProcessingUtils::LayerHint::Mesh ) );
}
QgsMeshLayer *QgsProcessingParameters::parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  QVariant val;
  if ( definition )
  {
    val = parameters.value( definition->name() );
  }
  return parameterAsOutputLayer( definition, val, context );
}
QString QgsProcessingParameters::parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, bool testOnly )
{
  QVariant val = value;
 
  QgsProject *destinationProject = nullptr;
  QString destName;
  if ( val.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    // input is a QgsProcessingOutputLayerDefinition - get extra properties from it
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( val );
    destinationProject = fromVar.destinationProject;
    val = fromVar.sink;
    destName = fromVar.destinationName;
  }
 
  QString dest;
  if ( definition && val.userType() == qMetaTypeId<QgsProperty>() )
  {
    dest = val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
  }
  else if ( definition && ( !val.isValid() || val.toString().isEmpty() ) )
  {
    // fall back to default
    dest = definition->defaultValue().toString();
  }
  else
  {
    dest = val.toString();
  }
  if ( dest == QgsProcessing::TEMPORARY_OUTPUT )
  {
    if ( const QgsProcessingDestinationParameter *destParam = dynamic_cast< const QgsProcessingDestinationParameter * >( definition ) )
      dest = destParam->generateTemporaryDestination( &context );
  }
 
  if ( destinationProject )
  {
    QString outputName;
    if ( destName.isEmpty() && definition )
    {
      destName = definition->description();
    }
    if ( definition )
      outputName = definition->name();
 
    QgsProcessingUtils::LayerHint layerTypeHint = QgsProcessingUtils::LayerHint::UnknownType;
    if ( definition && definition->type() == QgsProcessingParameterVectorDestination::typeName() )
      layerTypeHint = QgsProcessingUtils::LayerHint::Vector;
    else if ( definition && definition->type() == QgsProcessingParameterRasterDestination::typeName() )
      layerTypeHint = QgsProcessingUtils::LayerHint::Raster;
    else if ( definition && definition->type() == QgsProcessingParameterPointCloudDestination::typeName() )
      layerTypeHint = QgsProcessingUtils::LayerHint::PointCloud;
    else if ( definition && definition->type() == QgsProcessingParameterVectorTileDestination::typeName() )
      layerTypeHint = QgsProcessingUtils::LayerHint::VectorTile;
 
    if ( !testOnly )
      context.addLayerToLoadOnCompletion( dest, QgsProcessingContext::LayerDetails( destName, destinationProject, outputName, layerTypeHint ) );
  }
 
  return dest;
}
QString QgsProcessingParameters::parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, bool testOnly ) {…}
 
QString QgsProcessingParameters::parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  QVariant val;
  if ( definition )
  {
    val = parameters.value( definition->name() );
  }
  return parameterAsFileOutput( definition, val, context );
}
QString QgsProcessingParameters::parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  QVariant val = value;
 
  if ( val.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    // input is a QgsProcessingOutputLayerDefinition - get extra properties from it
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( val );
    val = fromVar.sink;
  }
 
  QString dest;
  if ( definition && val.userType() == qMetaTypeId<QgsProperty>() )
  {
    dest = val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
  }
  else if ( definition && ( !val.isValid() || val.toString().isEmpty() ) )
  {
    // fall back to default
    dest = definition->defaultValue().toString();
  }
  else
  {
    dest = val.toString();
  }
  if ( dest == QgsProcessing::TEMPORARY_OUTPUT )
  {
    if ( const QgsProcessingDestinationParameter *destParam = dynamic_cast< const QgsProcessingDestinationParameter * >( definition ) )
      dest = destParam->generateTemporaryDestination( &context );
  }
  return dest;
}
QString QgsProcessingParameters::parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QgsVectorLayer *QgsProcessingParameters::parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  return qobject_cast< QgsVectorLayer *>( parameterAsLayer( definition, parameters, context, QgsProcessingUtils::LayerHint::Vector ) );
}
QgsVectorLayer *QgsProcessingParameters::parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QgsVectorLayer *QgsProcessingParameters::parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  return qobject_cast< QgsVectorLayer *>( parameterAsLayer( definition, value, context, QgsProcessingUtils::LayerHint::Vector ) );
}
QgsVectorLayer *QgsProcessingParameters::parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  if ( !definition )
    return QgsCoordinateReferenceSystem();
 
  return parameterAsCrs( definition, parameters.value( definition->name() ), context );
}
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  if ( !definition )
    return QgsCoordinateReferenceSystem();
 
  return QgsProcessingUtils::variantToCrs( value, context, definition->defaultValue() );
}
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QgsRectangle QgsProcessingParameters::parameterAsExtent( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context,
    const QgsCoordinateReferenceSystem &crs )
{
  if ( !definition )
    return QgsRectangle();
 
  return parameterAsExtent( definition, parameters.value( definition->name() ), context, crs );
}
QgsRectangle QgsProcessingParameters::parameterAsExtent( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, {…}
 
QgsRectangle QgsProcessingParameters::parameterAsExtent( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs )
{
  if ( !definition )
    return QgsRectangle();
 
  QVariant val = value;
 
  if ( val.userType() == qMetaTypeId<QgsRectangle>() )
  {
    return val.value<QgsRectangle>();
  }
  if ( val.userType() == qMetaTypeId< QgsGeometry>() )
  {
    const QgsGeometry geom = val.value<QgsGeometry>();
    if ( !geom.isNull() )
      return geom.boundingBox();
  }
  if ( val.userType() == qMetaTypeId<QgsReferencedRectangle>() )
  {
    const QgsReferencedRectangle rr = val.value<QgsReferencedRectangle>();
    if ( crs.isValid() && rr.crs().isValid() && crs != rr.crs() )
    {
      QgsCoordinateTransform ct( rr.crs(), crs, context.project() );
      ct.setBallparkTransformsAreAppropriate( true );
      try
      {
        return ct.transformBoundingBox( rr );
      }
      catch ( QgsCsException & )
      {
        QgsMessageLog::logMessage( QObject::tr( "Error transforming extent geometry" ) );
      }
    }
    return rr;
  }
 
  if ( val.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
  {
    // input is a QgsProcessingFeatureSourceDefinition - get extra properties from it
    const QgsProcessingFeatureSourceDefinition fromVar = qvariant_cast<QgsProcessingFeatureSourceDefinition>( val );
    val = fromVar.source;
  }
  else if ( val.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    // input is a QgsProcessingOutputLayerDefinition - get extra properties from it
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( val );
    val = fromVar.sink;
  }
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() && val.value< QgsProperty >().propertyType() == Qgis::PropertyType::Static )
  {
    val = val.value< QgsProperty >().staticValue();
  }
 
  // maybe parameter is a direct layer value?
  QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( val ) );
 
  QString rectText;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    rectText = val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
  else
    rectText = val.toString();
 
  if ( rectText.isEmpty() && !layer )
    return QgsRectangle();
 
  const thread_local QRegularExpression rx( QStringLiteral( "^(.*?)\\s*,\\s*(.*?),\\s*(.*?),\\s*(.*?)\\s*(?:\\[(.*)\\])?\\s*$" ) );
  const QRegularExpressionMatch match = rx.match( rectText );
  if ( match.hasMatch() )
  {
    bool xMinOk = false;
    const double xMin = match.captured( 1 ).toDouble( &xMinOk );
    bool xMaxOk = false;
    const double xMax = match.captured( 2 ).toDouble( &xMaxOk );
    bool yMinOk = false;
    const double yMin = match.captured( 3 ).toDouble( &yMinOk );
    bool yMaxOk = false;
    const double yMax = match.captured( 4 ).toDouble( &yMaxOk );
    if ( xMinOk && xMaxOk && yMinOk && yMaxOk )
    {
      const QgsRectangle rect( xMin, yMin, xMax, yMax );
      const QgsCoordinateReferenceSystem rectCrs( match.captured( 5 ) );
      if ( crs.isValid() && rectCrs.isValid() && crs != rectCrs )
      {
        QgsCoordinateTransform ct( rectCrs, crs, context.project() );
        ct.setBallparkTransformsAreAppropriate( true );
        try
        {
          return ct.transformBoundingBox( rect );
        }
        catch ( QgsCsException & )
        {
          QgsMessageLog::logMessage( QObject::tr( "Error transforming extent geometry" ) );
        }
      }
      return rect;
    }
  }
 
  // try as layer extent
  if ( !layer )
    layer = QgsProcessingUtils::mapLayerFromString( rectText, context );
 
  if ( layer )
  {
    const QgsRectangle rect = layer->extent();
    if ( crs.isValid() && layer->crs().isValid() && crs != layer->crs() )
    {
      QgsCoordinateTransform ct( layer->crs(), crs, context.project() );
      ct.setBallparkTransformsAreAppropriate( true );
      try
      {
        return ct.transformBoundingBox( rect );
      }
      catch ( QgsCsException & )
      {
        QgsMessageLog::logMessage( QObject::tr( "Error transforming extent geometry" ) );
      }
    }
    return rect;
  }
  return QgsRectangle();
}
QgsRectangle QgsProcessingParameters::parameterAsExtent( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs ) {…}
 
QgsGeometry QgsProcessingParameters::parameterAsExtentGeometry( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs )
{
  if ( !definition )
    return QgsGeometry();
 
  QVariant val = parameters.value( definition->name() );
 
  if ( val.userType() == qMetaTypeId<QgsReferencedRectangle>() )
  {
    const QgsReferencedRectangle rr = val.value<QgsReferencedRectangle>();
    QgsGeometry g = QgsGeometry::fromRect( rr );
    if ( crs.isValid() && rr.crs().isValid() && crs != rr.crs() )
    {
      g = g.densifyByCount( 20 );
      const QgsCoordinateTransform ct( rr.crs(), crs, context.project() );
      try
      {
        g.transform( ct );
      }
      catch ( QgsCsException & )
      {
        QgsMessageLog::logMessage( QObject::tr( "Error transforming extent geometry" ) );
      }
      return g;
    }
  }
 
  if ( val.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
  {
    // input is a QgsProcessingFeatureSourceDefinition - get extra properties from it
    const QgsProcessingFeatureSourceDefinition fromVar = qvariant_cast<QgsProcessingFeatureSourceDefinition>( val );
    val = fromVar.source;
  }
  else if ( val.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    // input is a QgsProcessingOutputLayerDefinition - get extra properties from it
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( val );
    val = fromVar.sink;
  }
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() && val.value< QgsProperty >().propertyType() == Qgis::PropertyType::Static )
  {
    val = val.value< QgsProperty >().staticValue();
  }
 
  QString rectText;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    rectText = val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
  else
    rectText = val.toString();
 
  if ( !rectText.isEmpty() )
  {
    const thread_local QRegularExpression rx( QStringLiteral( "^(.*?)\\s*,\\s*(.*?),\\s*(.*?),\\s*(.*?)\\s*(?:\\[(.*)\\])?\\s*$" ) );
    const QRegularExpressionMatch match = rx.match( rectText );
    if ( match.hasMatch() )
    {
      bool xMinOk = false;
      const double xMin = match.captured( 1 ).toDouble( &xMinOk );
      bool xMaxOk = false;
      const double xMax = match.captured( 2 ).toDouble( &xMaxOk );
      bool yMinOk = false;
      const double yMin = match.captured( 3 ).toDouble( &yMinOk );
      bool yMaxOk = false;
      const double yMax = match.captured( 4 ).toDouble( &yMaxOk );
      if ( xMinOk && xMaxOk && yMinOk && yMaxOk )
      {
        const QgsRectangle rect( xMin, yMin, xMax, yMax );
        const QgsCoordinateReferenceSystem rectCrs( match.captured( 5 ) );
        QgsGeometry g = QgsGeometry::fromRect( rect );
        if ( crs.isValid() && rectCrs.isValid() && crs != rectCrs )
        {
          g = g.densifyByCount( 20 );
          const QgsCoordinateTransform ct( rectCrs, crs, context.project() );
          try
          {
            g.transform( ct );
          }
          catch ( QgsCsException & )
          {
            QgsMessageLog::logMessage( QObject::tr( "Error transforming extent geometry" ) );
          }
          return g;
        }
        else
        {
          return g;
        }
      }
    }
  }
 
  // try as layer extent
 
  // maybe parameter is a direct layer value?
  QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( val ) );
  if ( !layer )
    layer = QgsProcessingUtils::mapLayerFromString( rectText, context );
 
  if ( layer )
  {
    const QgsRectangle rect = layer->extent();
    QgsGeometry g = QgsGeometry::fromRect( rect );
    if ( crs.isValid() && layer->crs().isValid() && crs != layer->crs() )
    {
      g = g.densifyByCount( 20 );
      const QgsCoordinateTransform ct( layer->crs(), crs, context.project() );
      try
      {
        g.transform( ct );
      }
      catch ( QgsCsException & )
      {
        QgsMessageLog::logMessage( QObject::tr( "Error transforming extent geometry" ) );
      }
    }
    return g;
  }
 
  return QgsGeometry::fromRect( parameterAsExtent( definition, parameters, context, crs ) );
}
QgsGeometry QgsProcessingParameters::parameterAsExtentGeometry( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs ) {…}
 
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  const QVariant val = parameters.value( definition->name() );
  return parameterAsExtentCrs( definition, val, context );
}
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsReferencedRectangle>() )
  {
    const QgsReferencedRectangle rr = val.value<QgsReferencedRectangle>();
    if ( rr.crs().isValid() )
    {
      return rr.crs();
    }
  }
 
  if ( val.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
  {
    // input is a QgsProcessingFeatureSourceDefinition - get extra properties from it
    const QgsProcessingFeatureSourceDefinition fromVar = qvariant_cast<QgsProcessingFeatureSourceDefinition>( val );
    val = fromVar.source;
  }
  else if ( val.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    // input is a QgsProcessingOutputLayerDefinition - get extra properties from it
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( val );
    val = fromVar.sink;
  }
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() && val.value< QgsProperty >().propertyType() == Qgis::PropertyType::Static )
  {
    val = val.value< QgsProperty >().staticValue();
  }
 
  QString valueAsString;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    valueAsString = val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
  else
    valueAsString = val.toString();
 
  const thread_local QRegularExpression rx( QStringLiteral( "^(.*?)\\s*,\\s*(.*?),\\s*(.*?),\\s*(.*?)\\s*(?:\\[(.*)\\])?\\s*$" ) );
 
  const QRegularExpressionMatch match = rx.match( valueAsString );
  if ( match.hasMatch() )
  {
    const QgsCoordinateReferenceSystem crs( match.captured( 5 ) );
    if ( crs.isValid() )
      return crs;
  }
 
  if ( val.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
  {
    // input is a QgsProcessingFeatureSourceDefinition - get extra properties from it
    const QgsProcessingFeatureSourceDefinition fromVar = qvariant_cast<QgsProcessingFeatureSourceDefinition>( val );
    val = fromVar.source;
  }
  else if ( val.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    // input is a QgsProcessingOutputLayerDefinition - get extra properties from it
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( val );
    val = fromVar.sink;
  }
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() && val.value< QgsProperty >().propertyType() == Qgis::PropertyType::Static )
  {
    val = val.value< QgsProperty >().staticValue();
  }
 
  // try as layer crs
  if ( QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( val ) ) )
    return layer->crs();
  else if ( QgsMapLayer *layer = QgsProcessingUtils::mapLayerFromString( valueAsString, context ) )
    return layer->crs();
 
  if ( auto *lProject = context.project() )
    return lProject->crs();
  else
    return QgsCoordinateReferenceSystem();
}
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QgsPointXY QgsProcessingParameters::parameterAsPoint( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs )
{
  if ( !definition )
    return QgsPointXY();
 
  return parameterAsPoint( definition, parameters.value( definition->name() ), context, crs );
}
QgsPointXY QgsProcessingParameters::parameterAsPoint( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs ) {…}
 
QgsPointXY QgsProcessingParameters::parameterAsPoint( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs )
{
  if ( !definition )
    return QgsPointXY();
 
  const QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsPointXY>() )
  {
    return val.value<QgsPointXY>();
  }
  if ( val.userType() == qMetaTypeId< QgsGeometry>() )
  {
    const QgsGeometry geom = val.value<QgsGeometry>();
    if ( !geom.isNull() )
      return geom.centroid().asPoint();
  }
  if ( val.userType() == qMetaTypeId<QgsReferencedPointXY>() )
  {
    const QgsReferencedPointXY rp = val.value<QgsReferencedPointXY>();
    if ( crs.isValid() && rp.crs().isValid() && crs != rp.crs() )
    {
      const QgsCoordinateTransform ct( rp.crs(), crs, context.project() );
      try
      {
        return ct.transform( rp );
      }
      catch ( QgsCsException & )
      {
        QgsMessageLog::logMessage( QObject::tr( "Error transforming point geometry" ) );
      }
    }
    return rp;
  }
 
  QString pointText = parameterAsString( definition, value, context );
  if ( pointText.isEmpty() )
    pointText = definition->defaultValue().toString();
 
  if ( pointText.isEmpty() )
    return QgsPointXY();
 
  const thread_local QRegularExpression rx( QStringLiteral( "^\\s*\\(?\\s*(.*?)\\s*,\\s*(.*?)\\s*(?:\\[(.*)\\])?\\s*\\)?\\s*$" ) );
 
  const QString valueAsString = parameterAsString( definition, value, context );
  const QRegularExpressionMatch match = rx.match( valueAsString );
  if ( match.hasMatch() )
  {
    bool xOk = false;
    const double x = match.captured( 1 ).toDouble( &xOk );
    bool yOk = false;
    const double y = match.captured( 2 ).toDouble( &yOk );
 
    if ( xOk && yOk )
    {
      const QgsPointXY pt( x, y );
 
      const QgsCoordinateReferenceSystem pointCrs( match.captured( 3 ) );
      if ( crs.isValid() && pointCrs.isValid() && crs != pointCrs )
      {
        const QgsCoordinateTransform ct( pointCrs, crs, context.project() );
        try
        {
          return ct.transform( pt );
        }
        catch ( QgsCsException & )
        {
          QgsMessageLog::logMessage( QObject::tr( "Error transforming point geometry" ) );
        }
      }
      return pt;
    }
  }
 
  return QgsPointXY();
}
QgsPointXY QgsProcessingParameters::parameterAsPoint( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs ) {…}
 
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  const QVariant val = parameters.value( definition->name() );
  return parameterAsPointCrs( definition, val, context );
}
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  if ( value.userType() == qMetaTypeId<QgsReferencedPointXY>() )
  {
    const QgsReferencedPointXY rr = value.value<QgsReferencedPointXY>();
    if ( rr.crs().isValid() )
    {
      return rr.crs();
    }
  }
 
  const thread_local QRegularExpression rx( QStringLiteral( "^\\s*\\(?\\s*(.*?)\\s*,\\s*(.*?)\\s*(?:\\[(.*)\\])?\\s*\\)?\\s*$" ) );
 
  const QString valueAsString = parameterAsString( definition, value, context );
  const QRegularExpressionMatch match = rx.match( valueAsString );
  if ( match.hasMatch() )
  {
    const QgsCoordinateReferenceSystem crs( match.captured( 3 ) );
    if ( crs.isValid() )
      return crs;
  }
 
  if ( auto *lProject = context.project() )
    return lProject->crs();
  else
    return QgsCoordinateReferenceSystem();
}
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QgsGeometry QgsProcessingParameters::parameterAsGeometry( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs )
{
  if ( !definition )
    return QgsGeometry();
 
  return parameterAsGeometry( definition, parameters.value( definition->name() ), context, crs );
}
QgsGeometry QgsProcessingParameters::parameterAsGeometry( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs ) {…}
 
QgsGeometry QgsProcessingParameters::parameterAsGeometry( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs )
{
  if ( !definition )
    return QgsGeometry();
 
  const QVariant val = value;
  if ( val.userType() == qMetaTypeId< QgsGeometry>() )
  {
    return val.value<QgsGeometry>();
  }
 
  if ( val.userType() == qMetaTypeId<QgsPointXY>() )
  {
    return QgsGeometry::fromPointXY( val.value<QgsPointXY>() );
  }
 
  if ( val.userType() == qMetaTypeId<QgsRectangle>() )
  {
    return QgsGeometry::fromRect( val.value<QgsRectangle>() );
  }
 
  if ( val.userType() == qMetaTypeId<QgsReferencedPointXY>() )
  {
    const QgsReferencedPointXY rp = val.value<QgsReferencedPointXY>();
    if ( crs.isValid() && rp.crs().isValid() && crs != rp.crs() )
    {
      const QgsCoordinateTransform ct( rp.crs(), crs, context.project() );
      try
      {
        return QgsGeometry::fromPointXY( ct.transform( rp ) );
      }
      catch ( QgsCsException & )
      {
        QgsMessageLog::logMessage( QObject::tr( "Error transforming point geometry" ) );
      }
    }
    return QgsGeometry::fromPointXY( rp );
  }
 
  if ( val.userType() == qMetaTypeId<QgsReferencedRectangle>() )
  {
    const QgsReferencedRectangle rr = val.value<QgsReferencedRectangle>();
    QgsGeometry g = QgsGeometry::fromRect( rr );
    if ( crs.isValid() && rr.crs().isValid() && crs != rr.crs() )
    {
      g = g.densifyByCount( 20 );
      const QgsCoordinateTransform ct( rr.crs(), crs, context.project() );
      try
      {
        g.transform( ct );
      }
      catch ( QgsCsException & )
      {
        QgsMessageLog::logMessage( QObject::tr( "Error transforming rectangle geometry" ) );
      }
    }
    return g;
  }
 
  if ( val.userType() == qMetaTypeId<QgsReferencedGeometry>() )
  {
    QgsReferencedGeometry rg = val.value<QgsReferencedGeometry>();
    if ( crs.isValid() && rg.crs().isValid() && crs != rg.crs() )
    {
      const QgsCoordinateTransform ct( rg.crs(), crs, context.project() );
      try
      {
        rg.transform( ct );
      }
      catch ( QgsCsException & )
      {
        QgsMessageLog::logMessage( QObject::tr( "Error transforming geometry" ) );
      }
    }
    return rg;
  }
 
  QString valueAsString = parameterAsString( definition, value, context );
  if ( valueAsString.isEmpty() )
    valueAsString = definition->defaultValue().toString();
 
  if ( valueAsString.isEmpty() )
    return QgsGeometry();
 
  const thread_local QRegularExpression rx( QStringLiteral( "^\\s*(?:CRS=(.*);)?(.*?)$" ) );
 
  const QRegularExpressionMatch match = rx.match( valueAsString );
  if ( match.hasMatch() )
  {
    QgsGeometry g =  QgsGeometry::fromWkt( match.captured( 2 ) );
    if ( !g.isNull() )
    {
      const QgsCoordinateReferenceSystem geomCrs( match.captured( 1 ) );
      if ( crs.isValid() && geomCrs.isValid() && crs != geomCrs )
      {
        const QgsCoordinateTransform ct( geomCrs, crs, context.project() );
        try
        {
          g.transform( ct );
        }
        catch ( QgsCsException & )
        {
          QgsMessageLog::logMessage( QObject::tr( "Error transforming geometry" ) );
        }
      }
      return g;
    }
  }
 
  return QgsGeometry();
}
QgsGeometry QgsProcessingParameters::parameterAsGeometry( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs ) {…}
 
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  const QVariant val = parameters.value( definition->name() );
  return parameterAsGeometryCrs( definition, val, context );
}
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  if ( value.userType() == qMetaTypeId<QgsReferencedGeometry>() )
  {
    const QgsReferencedGeometry rg = value.value<QgsReferencedGeometry>();
    if ( rg.crs().isValid() )
    {
      return rg.crs();
    }
  }
 
  if ( value.userType() == qMetaTypeId<QgsReferencedPointXY>() )
  {
    const QgsReferencedPointXY rp = value.value<QgsReferencedPointXY>();
    if ( rp.crs().isValid() )
    {
      return rp.crs();
    }
  }
 
  if ( value.userType() == qMetaTypeId<QgsReferencedRectangle>() )
  {
    const QgsReferencedRectangle rr = value.value<QgsReferencedRectangle>();
    if ( rr.crs().isValid() )
    {
      return rr.crs();
    }
  }
 
  // Match against EWKT
  const QRegularExpression rx( QStringLiteral( "^\\s*(?:CRS=(.*);)?(.*?)$" ) );
 
  const QString valueAsString = parameterAsString( definition, value, context );
  const QRegularExpressionMatch match = rx.match( valueAsString );
  if ( match.hasMatch() )
  {
    const QgsCoordinateReferenceSystem crs( match.captured( 1 ) );
    if ( crs.isValid() )
      return crs;
  }
 
  if ( auto *lProject = context.project() )
    return lProject->crs();
  else
    return QgsCoordinateReferenceSystem();
}
QgsCoordinateReferenceSystem QgsProcessingParameters::parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  if ( !definition )
    return QString();
 
  QString fileText = parameterAsString( definition, parameters, context );
  if ( fileText.isEmpty() )
    fileText = definition->defaultValue().toString();
  return fileText;
}
QString QgsProcessingParameters::parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  if ( !definition )
    return QString();
 
  QString fileText = parameterAsString( definition, value, context );
  if ( fileText.isEmpty() )
    fileText = definition->defaultValue().toString();
  return fileText;
}
QString QgsProcessingParameters::parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QVariantList QgsProcessingParameters::parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  if ( !definition )
    return QVariantList();
 
  return parameterAsMatrix( definition, parameters.value( definition->name() ), context );
}
QVariantList QgsProcessingParameters::parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QVariantList QgsProcessingParameters::parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  if ( !definition )
    return QVariantList();
 
  QString resultString;
  const QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    resultString = val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
  else if ( val.userType() == QMetaType::Type::QVariantList )
    return val.toList();
  else
    resultString = val.toString();
 
  if ( resultString.isEmpty() )
  {
    // check default
    if ( definition->defaultValue().userType() == QMetaType::Type::QVariantList )
      return definition->defaultValue().toList();
    else
      resultString = definition->defaultValue().toString();
  }
 
  QVariantList result;
  const auto constSplit = resultString.split( ',' );
  bool ok;
  double number;
  for ( const QString &s : constSplit )
  {
    number = s.toDouble( &ok );
    result << ( ok ? QVariant( number ) : s );
  }
 
  return result;
}
QVariantList QgsProcessingParameters::parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QList<QgsMapLayer *> QgsProcessingParameters::parameterAsLayerList( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags )
{
  if ( !definition )
    return QList<QgsMapLayer *>();
 
  return parameterAsLayerList( definition, parameters.value( definition->name() ), context, flags );
}
QList<QgsMapLayer *> QgsProcessingParameters::parameterAsLayerList( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags ) {…}
 
QList<QgsMapLayer *> QgsProcessingParameters::parameterAsLayerList( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags )
{
  if ( !definition )
    return QList<QgsMapLayer *>();
 
  const QVariant val = value;
  if ( QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( val ) ) )
  {
    return QList<QgsMapLayer *>() << layer;
  }
 
  QList<QgsMapLayer *> layers;
 
  std::function< void( const QVariant &var ) > processVariant;
  processVariant = [ &layers, &context, &definition, flags, &processVariant]( const QVariant & var )
  {
    if ( var.userType() == QMetaType::Type::QVariantList )
    {
      const auto constToList = var.toList();
      for ( const QVariant &listVar : constToList )
      {
        processVariant( listVar );
      }
    }
    else if ( var.userType() == QMetaType::Type::QStringList )
    {
      const auto constToStringList = var.toStringList();
      for ( const QString &s : constToStringList )
      {
        processVariant( s );
      }
    }
    else if ( var.userType() == qMetaTypeId<QgsProperty>() )
      processVariant( var.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() ) );
    else if ( var.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
    {
      // input is a QgsProcessingOutputLayerDefinition - get extra properties from it
      const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( var );
      const QVariant sink = fromVar.sink;
      if ( sink.userType() == qMetaTypeId<QgsProperty>() )
      {
        processVariant( sink.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() ) );
      }
    }
    else if ( QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( var ) ) )
    {
      layers << layer;
    }
    else
    {
      QgsMapLayer *alayer = QgsProcessingUtils::mapLayerFromString( var.toString(), context, true, QgsProcessingUtils::LayerHint::UnknownType, flags );
      if ( alayer )
        layers << alayer;
    }
  };
 
  processVariant( val );
 
  if ( layers.isEmpty() )
  {
    // check default
    if ( QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( definition->defaultValue() ) ) )
    {
      layers << layer;
    }
    else if ( definition->defaultValue().userType() == QMetaType::Type::QVariantList )
    {
      const auto constToList = definition->defaultValue().toList();
      for ( const QVariant &var : constToList )
      {
        if ( QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( var ) ) )
        {
          layers << layer;
        }
        else
        {
          processVariant( var );
        }
      }
    }
    else
      processVariant( definition->defaultValue() );
  }
 
  return layers;
}
QList<QgsMapLayer *> QgsProcessingParameters::parameterAsLayerList( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags ) {…}
 
QStringList QgsProcessingParameters::parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  if ( !definition )
    return QStringList();
 
  const QVariant val = value;
 
  QStringList files;
 
  std::function< void( const QVariant &var ) > processVariant;
  processVariant = [ &files, &context, &definition, &processVariant ]( const QVariant & var )
  {
    if ( var.userType() == QMetaType::Type::QVariantList )
    {
      const auto constToList = var.toList();
      for ( const QVariant &listVar : constToList )
      {
        processVariant( listVar );
      }
    }
    else if ( var.userType() == QMetaType::Type::QStringList )
    {
      const auto constToStringList = var.toStringList();
      for ( const QString &s : constToStringList )
      {
        processVariant( s );
      }
    }
    else if ( var.userType() == qMetaTypeId<QgsProperty>() )
      processVariant( var.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() ) );
    else
    {
      files << var.toString();
    }
  };
 
  processVariant( val );
 
  if ( files.isEmpty() )
  {
    processVariant( definition->defaultValue() );
  }
 
  return files;
}
QStringList QgsProcessingParameters::parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QStringList QgsProcessingParameters::parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  if ( !definition )
    return QStringList();
 
  return parameterAsFileList( definition, parameters.value( definition->name() ), context );
}
QStringList QgsProcessingParameters::parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QList<double> QgsProcessingParameters::parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  if ( !definition )
    return QList<double>();
 
  return parameterAsRange( definition, parameters.value( definition->name() ), context );
}
QList<double> QgsProcessingParameters::parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QList<double> QgsProcessingParameters::parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  if ( !definition )
    return QList<double>();
 
  QStringList resultStringList;
  const QVariant val = value;
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    resultStringList << val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
  else if ( val.userType() == QMetaType::Type::QVariantList )
  {
    const auto constToList = val.toList();
    for ( const QVariant &var : constToList )
      resultStringList << var.toString();
  }
  else
    resultStringList << val.toString();
 
  if ( ( resultStringList.isEmpty() || ( resultStringList.size() == 1 && resultStringList.at( 0 ).isEmpty() ) ) )
  {
    resultStringList.clear();
    // check default
    if ( definition->defaultValue().userType() == QMetaType::Type::QVariantList )
    {
      const auto constToList = definition->defaultValue().toList();
      for ( const QVariant &var : constToList )
        resultStringList << var.toString();
    }
    else
      resultStringList << definition->defaultValue().toString();
  }
 
  if ( resultStringList.size() == 1 )
  {
    resultStringList = resultStringList.at( 0 ).split( ',' );
  }
 
  if ( resultStringList.size() < 2 )
    return QList< double >() << std::numeric_limits<double>::quiet_NaN()  << std::numeric_limits<double>::quiet_NaN() ;
 
  QList< double > result;
  bool ok = false;
  double n = resultStringList.at( 0 ).toDouble( &ok );
  if ( ok )
    result << n;
  else
    result << std::numeric_limits<double>::quiet_NaN() ;
  ok = false;
  n = resultStringList.at( 1 ).toDouble( &ok );
  if ( ok )
    result << n;
  else
    result << std::numeric_limits<double>::quiet_NaN() ;
 
  return result;
}
QList<double> QgsProcessingParameters::parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QStringList QgsProcessingParameters::parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  if ( !definition )
    return QStringList();
 
  return parameterAsStrings( definition, parameters.value( definition->name() ), context );
}
QStringList QgsProcessingParameters::parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QStringList QgsProcessingParameters::parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  return parameterAsStrings( definition, value, context );
}
QStringList QgsProcessingParameters::parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QStringList QgsProcessingParameters::parameterAsStrings( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  if ( !definition )
    return QStringList();
 
  return parameterAsStrings( definition, parameters.value( definition->name() ), context );
}
QStringList QgsProcessingParameters::parameterAsStrings( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QStringList QgsProcessingParameters::parameterAsStrings( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  if ( !definition )
    return QStringList();
 
  QStringList resultStringList;
  const QVariant val = value;
  if ( val.isValid() )
  {
    if ( val.userType() == qMetaTypeId<QgsProperty>() )
      resultStringList << val.value< QgsProperty >().valueAsString( context.expressionContext(), definition->defaultValue().toString() );
    else if ( val.userType() == QMetaType::Type::QVariantList )
    {
      const auto constToList = val.toList();
      for ( const QVariant &var : constToList )
        resultStringList << var.toString();
    }
    else if ( val.userType() == QMetaType::Type::QStringList )
    {
      resultStringList = val.toStringList();
    }
    else
      resultStringList.append( val.toString().split( ';' ) );
  }
 
  if ( ( resultStringList.isEmpty() || resultStringList.at( 0 ).isEmpty() ) )
  {
    resultStringList.clear();
    // check default
    if ( definition->defaultValue().isValid() )
    {
      if ( definition->defaultValue().userType() == QMetaType::Type::QVariantList )
      {
        const auto constToList = definition->defaultValue().toList();
        for ( const QVariant &var : constToList )
          resultStringList << var.toString();
      }
      else if ( definition->defaultValue().userType() == QMetaType::Type::QStringList )
      {
        resultStringList = definition->defaultValue().toStringList();
      }
      else
        resultStringList.append( definition->defaultValue().toString().split( ';' ) );
    }
  }
 
  return resultStringList;
}
QStringList QgsProcessingParameters::parameterAsStrings( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QgsPrintLayout *QgsProcessingParameters::parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  if ( !definition )
    return nullptr;
 
  return parameterAsLayout( definition, parameters.value( definition->name() ), context );
}
QgsPrintLayout *QgsProcessingParameters::parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QgsPrintLayout *QgsProcessingParameters::parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  const QString layoutName = parameterAsString( definition, value, context );
  if ( layoutName.isEmpty() )
    return nullptr;
 
  if ( !context.project() )
    return nullptr;
 
  QgsMasterLayoutInterface *l = context.project()->layoutManager()->layoutByName( layoutName );
  if ( l && l->layoutType() == QgsMasterLayoutInterface::PrintLayout )
    return static_cast< QgsPrintLayout * >( l );
  else
    return nullptr;
}
QgsPrintLayout *QgsProcessingParameters::parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QgsLayoutItem *QgsProcessingParameters::parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsPrintLayout *layout )
{
  if ( !definition )
    return nullptr;
 
  return parameterAsLayoutItem( definition, parameters.value( definition->name() ), context, layout );
}
QgsLayoutItem *QgsProcessingParameters::parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsPrintLayout *layout ) {…}
 
QgsLayoutItem *QgsProcessingParameters::parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsPrintLayout *layout )
{
  if ( !layout )
    return nullptr;
 
  const QString id = parameterAsString( definition, value, context );
  if ( id.isEmpty() )
    return nullptr;
 
  // prefer matching by uuid, since it's guaranteed to be unique.
  if ( QgsLayoutItem *item = layout->itemByUuid( id ) )
    return item;
  else if ( QgsLayoutItem *item = layout->itemById( id ) )
    return item;
  else
    return nullptr;
}
QgsLayoutItem *QgsProcessingParameters::parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsPrintLayout *layout ) {…}
 
QColor QgsProcessingParameters::parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  if ( !definition )
    return QColor();
 
  return parameterAsColor( definition, parameters.value( definition->name() ), context );
}
QColor QgsProcessingParameters::parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QColor QgsProcessingParameters::parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  if ( !definition )
    return QColor();
 
  QVariant val = value;
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
  {
    val = val.value< QgsProperty >().value( context.expressionContext(), definition->defaultValue() );
  }
  if ( val.userType() == QMetaType::Type::QColor )
  {
    QColor c = val.value< QColor >();
    if ( const QgsProcessingParameterColor *colorParam = dynamic_cast< const QgsProcessingParameterColor * >( definition ) )
      if ( !colorParam->opacityEnabled() )
        c.setAlpha( 255 );
    return c;
  }
 
  QString colorText = parameterAsString( definition, value, context );
  if ( colorText.isEmpty() && !( definition->flags() & Qgis::ProcessingParameterFlag::Optional ) )
  {
    if ( definition->defaultValue().userType() == QMetaType::Type::QColor )
      return definition->defaultValue().value< QColor >();
    else
      colorText = definition->defaultValue().toString();
  }
 
  if ( colorText.isEmpty() )
    return QColor();
 
  bool containsAlpha = false;
  QColor c = QgsSymbolLayerUtils::parseColorWithAlpha( colorText, containsAlpha );
  if ( const QgsProcessingParameterColor *colorParam = dynamic_cast< const QgsProcessingParameterColor * >( definition ) )
    if ( c.isValid() && !colorParam->opacityEnabled() )
      c.setAlpha( 255 );
  return c;
}
QColor QgsProcessingParameters::parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return QString();
 
  return parameterAsConnectionName( definition, parameters.value( definition->name() ), context );
}
QString QgsProcessingParameters::parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  // for now it's just treated identical to strings, but in future we may want flexibility to amend this
  // (hence the new method)
  return parameterAsString( definition, value, context );
}
QString QgsProcessingParameters::parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return QString();
 
  return parameterAsSchema( definition, parameters.value( definition->name() ), context );
}
QString QgsProcessingParameters::parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  // for now it's just treated identical to strings, but in future we may want flexibility to amend this (e.g. if we want to embed connection details into the schema
  // parameter values, such as via a delimiter separated string)
  return parameterAsString( definition, value, context );
}
QString QgsProcessingParameters::parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context )
{
  if ( !definition )
    return QString();
 
  return parameterAsDatabaseTableName( definition, parameters.value( definition->name() ), context );
}
QString QgsProcessingParameters::parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context ) {…}
 
QString QgsProcessingParameters::parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context )
{
  // for now it's just treated identical to strings, but in future we may want flexibility to amend this (e.g. if we want to embed connection details into the table name
  // parameter values, such as via a delimiter separated string)
  return parameterAsString( definition, value, context );
}
QString QgsProcessingParameters::parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context ) {…}
 
QgsPointCloudLayer *QgsProcessingParameters::parameterAsPointCloudLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags )
{
  return qobject_cast< QgsPointCloudLayer *>( parameterAsLayer( definition, parameters, context, QgsProcessingUtils::LayerHint::PointCloud, flags ) );
}
QgsPointCloudLayer *QgsProcessingParameters::parameterAsPointCloudLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags ) {…}
 
QgsPointCloudLayer *QgsProcessingParameters::parameterAsPointCloudLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags )
{
  return qobject_cast< QgsPointCloudLayer *>( parameterAsLayer( definition, value, context, QgsProcessingUtils::LayerHint::PointCloud, flags ) );
}
QgsPointCloudLayer *QgsProcessingParameters::parameterAsPointCloudLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags ) {…}
 
QgsAnnotationLayer *QgsProcessingParameters::parameterAsAnnotationLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context )
{
  return qobject_cast< QgsAnnotationLayer *>( parameterAsLayer( definition, parameters, context, QgsProcessingUtils::LayerHint::Annotation ) );
}
QgsAnnotationLayer *QgsProcessingParameters::parameterAsAnnotationLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) {…}
 
QgsAnnotationLayer *QgsProcessingParameters::parameterAsAnnotationLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context )
{
  return qobject_cast< QgsAnnotationLayer *>( parameterAsLayer( definition, value, context, QgsProcessingUtils::LayerHint::Annotation ) );
}
QgsAnnotationLayer *QgsProcessingParameters::parameterAsAnnotationLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameters::parameterFromVariantMap( const QVariantMap &map )
{
  const QString type = map.value( QStringLiteral( "parameter_type" ) ).toString();
  const QString name = map.value( QStringLiteral( "name" ) ).toString();
  std::unique_ptr< QgsProcessingParameterDefinition > def;
 
  // probably all these hardcoded values aren't required anymore, and we could
  // always resort to the registry lookup...
  // TODO: confirm
  if ( type == QgsProcessingParameterBoolean::typeName() )
    def.reset( new QgsProcessingParameterBoolean( name ) );
  else if ( type == QgsProcessingParameterCrs::typeName() )
    def.reset( new QgsProcessingParameterCrs( name ) );
  else if ( type == QgsProcessingParameterMapLayer::typeName() )
    def.reset( new QgsProcessingParameterMapLayer( name ) );
  else if ( type == QgsProcessingParameterExtent::typeName() )
    def.reset( new QgsProcessingParameterExtent( name ) );
  else if ( type == QgsProcessingParameterPoint::typeName() )
    def.reset( new QgsProcessingParameterPoint( name ) );
  else if ( type == QgsProcessingParameterFile::typeName() )
    def.reset( new QgsProcessingParameterFile( name ) );
  else if ( type == QgsProcessingParameterMatrix::typeName() )
    def.reset( new QgsProcessingParameterMatrix( name ) );
  else if ( type == QgsProcessingParameterMultipleLayers::typeName() )
    def.reset( new QgsProcessingParameterMultipleLayers( name ) );
  else if ( type == QgsProcessingParameterNumber::typeName() )
    def.reset( new QgsProcessingParameterNumber( name ) );
  else if ( type == QgsProcessingParameterRange::typeName() )
    def.reset( new QgsProcessingParameterRange( name ) );
  else if ( type == QgsProcessingParameterRasterLayer::typeName() )
    def.reset( new QgsProcessingParameterRasterLayer( name ) );
  else if ( type == QgsProcessingParameterEnum::typeName() )
    def.reset( new QgsProcessingParameterEnum( name ) );
  else if ( type == QgsProcessingParameterString::typeName() )
    def.reset( new QgsProcessingParameterString( name ) );
  else if ( type == QgsProcessingParameterAuthConfig::typeName() )
    def.reset( new QgsProcessingParameterAuthConfig( name ) );
  else if ( type == QgsProcessingParameterExpression::typeName() )
    def.reset( new QgsProcessingParameterExpression( name ) );
  else if ( type == QgsProcessingParameterVectorLayer::typeName() )
    def.reset( new QgsProcessingParameterVectorLayer( name ) );
  else if ( type == QgsProcessingParameterField::typeName() )
    def.reset( new QgsProcessingParameterField( name ) );
  else if ( type == QgsProcessingParameterFeatureSource::typeName() )
    def.reset( new QgsProcessingParameterFeatureSource( name ) );
  else if ( type == QgsProcessingParameterFeatureSink::typeName() )
    def.reset( new QgsProcessingParameterFeatureSink( name ) );
  else if ( type == QgsProcessingParameterVectorDestination::typeName() )
    def.reset( new QgsProcessingParameterVectorDestination( name ) );
  else if ( type == QgsProcessingParameterRasterDestination::typeName() )
    def.reset( new QgsProcessingParameterRasterDestination( name ) );
  else if ( type == QgsProcessingParameterPointCloudDestination::typeName() )
    def.reset( new QgsProcessingParameterPointCloudDestination( name ) );
  else if ( type == QgsProcessingParameterFileDestination::typeName() )
    def.reset( new QgsProcessingParameterFileDestination( name ) );
  else if ( type == QgsProcessingParameterFolderDestination::typeName() )
    def.reset( new QgsProcessingParameterFolderDestination( name ) );
  else if ( type == QgsProcessingParameterBand::typeName() )
    def.reset( new QgsProcessingParameterBand( name ) );
  else if ( type == QgsProcessingParameterMeshLayer::typeName() )
    def.reset( new QgsProcessingParameterMeshLayer( name ) );
  else if ( type == QgsProcessingParameterLayout::typeName() )
    def.reset( new QgsProcessingParameterLayout( name ) );
  else if ( type == QgsProcessingParameterLayoutItem::typeName() )
    def.reset( new QgsProcessingParameterLayoutItem( name ) );
  else if ( type == QgsProcessingParameterColor::typeName() )
    def.reset( new QgsProcessingParameterColor( name ) );
  else if ( type == QgsProcessingParameterCoordinateOperation::typeName() )
    def.reset( new QgsProcessingParameterCoordinateOperation( name ) );
  else if ( type == QgsProcessingParameterPointCloudLayer::typeName() )
    def.reset( new QgsProcessingParameterPointCloudLayer( name ) );
  else if ( type == QgsProcessingParameterAnnotationLayer::typeName() )
    def.reset( new QgsProcessingParameterAnnotationLayer( name ) );
  else if ( type == QgsProcessingParameterPointCloudAttribute::typeName() )
    def.reset( new QgsProcessingParameterPointCloudAttribute( name ) );
  else if ( type == QgsProcessingParameterVectorTileDestination::typeName() )
    def.reset( new QgsProcessingParameterVectorTileDestination( name ) );
  else
  {
    QgsProcessingParameterType *paramType = QgsApplication::processingRegistry()->parameterType( type );
    if ( paramType )
      def.reset( paramType->create( name ) );
  }
 
  if ( !def )
    return nullptr;
 
  def->fromVariantMap( map );
  return def.release();
}
QgsProcessingParameterDefinition *QgsProcessingParameters::parameterFromVariantMap( const QVariantMap &map ) {…}
 
QString QgsProcessingParameters::descriptionFromName( const QString &name )
{
  QString desc = name;
  desc.replace( '_', ' ' );
  return desc;
}
QString QgsProcessingParameters::descriptionFromName( const QString &name ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameters::parameterFromScriptCode( const QString &code )
{
  bool isOptional = false;
  QString name;
  QString definition;
  QString type;
  if ( !parseScriptCodeParameterOptions( code, isOptional, name, type, definition ) )
    return nullptr;
 
  const QString description = descriptionFromName( name );
 
  if ( type == QLatin1String( "boolean" ) )
    return QgsProcessingParameterBoolean::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "crs" ) )
    return QgsProcessingParameterCrs::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "layer" ) )
    return QgsProcessingParameterMapLayer::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "extent" ) )
    return QgsProcessingParameterExtent::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "point" ) )
    return QgsProcessingParameterPoint::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "geometry" ) )
    return QgsProcessingParameterGeometry::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "file" ) )
    return QgsProcessingParameterFile::fromScriptCode( name, description, isOptional, definition, Qgis::ProcessingFileParameterBehavior::File );
  else if ( type == QLatin1String( "folder" ) )
    return QgsProcessingParameterFile::fromScriptCode( name, description, isOptional, definition, Qgis::ProcessingFileParameterBehavior::Folder );
  else if ( type == QLatin1String( "matrix" ) )
    return QgsProcessingParameterMatrix::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "multiple" ) )
    return QgsProcessingParameterMultipleLayers::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "number" ) )
    return QgsProcessingParameterNumber::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "distance" ) )
    return QgsProcessingParameterDistance::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "area" ) )
    return QgsProcessingParameterArea::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "volume" ) )
    return QgsProcessingParameterVolume::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "duration" ) )
    return QgsProcessingParameterDuration::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "scale" ) )
    return QgsProcessingParameterScale::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "range" ) )
    return QgsProcessingParameterRange::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "raster" ) )
    return QgsProcessingParameterRasterLayer::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "enum" ) )
    return QgsProcessingParameterEnum::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "string" ) )
    return QgsProcessingParameterString::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "authcfg" ) )
    return QgsProcessingParameterAuthConfig::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "expression" ) )
    return QgsProcessingParameterExpression::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "field" ) )
    return QgsProcessingParameterField::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "vector" ) )
    return QgsProcessingParameterVectorLayer::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "source" ) )
    return QgsProcessingParameterFeatureSource::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "sink" ) )
    return QgsProcessingParameterFeatureSink::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "vectordestination" ) )
    return QgsProcessingParameterVectorDestination::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "rasterdestination" ) )
    return QgsProcessingParameterRasterDestination::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "pointclouddestination" ) )
    return QgsProcessingParameterPointCloudDestination::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "filedestination" ) )
    return QgsProcessingParameterFileDestination::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "folderdestination" ) )
    return QgsProcessingParameterFolderDestination::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "band" ) )
    return QgsProcessingParameterBand::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "mesh" ) )
    return QgsProcessingParameterMeshLayer::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "layout" ) )
    return QgsProcessingParameterLayout::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "layoutitem" ) )
    return QgsProcessingParameterLayoutItem::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "color" ) )
    return QgsProcessingParameterColor::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "coordinateoperation" ) )
    return QgsProcessingParameterCoordinateOperation::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "maptheme" ) )
    return QgsProcessingParameterMapTheme::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "datetime" ) )
    return QgsProcessingParameterDateTime::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "providerconnection" ) )
    return QgsProcessingParameterProviderConnection::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "databaseschema" ) )
    return QgsProcessingParameterDatabaseSchema::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "databasetable" ) )
    return QgsProcessingParameterDatabaseTable::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "pointcloud" ) )
    return QgsProcessingParameterPointCloudLayer::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "annotation" ) )
    return QgsProcessingParameterAnnotationLayer::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "attribute" ) )
    return QgsProcessingParameterPointCloudAttribute::fromScriptCode( name, description, isOptional, definition );
  else if ( type == QLatin1String( "vectortiledestination" ) )
    return QgsProcessingParameterVectorTileDestination::fromScriptCode( name, description, isOptional, definition );
 
  return nullptr;
}
QgsProcessingParameterDefinition *QgsProcessingParameters::parameterFromScriptCode( const QString &code ) {…}
 
bool QgsProcessingParameters::parseScriptCodeParameterOptions( const QString &code, bool &isOptional, QString &name, QString &type, QString &definition )
{
  const thread_local QRegularExpression re( QStringLiteral( "(?:#*)(.*?)=\\s*(.*)" ) );
  QRegularExpressionMatch m = re.match( code );
  if ( !m.hasMatch() )
    return false;
 
  name = m.captured( 1 );
  QString tokens = m.captured( 2 );
  if ( tokens.startsWith( QLatin1String( "optional" ), Qt::CaseInsensitive ) )
  {
    isOptional = true;
    tokens.remove( 0, 8 ); // length "optional" = 8
  }
  else
  {
    isOptional = false;
  }
 
  tokens = tokens.trimmed();
 
  const thread_local QRegularExpression re2( QStringLiteral( "(.*?)\\s+(.*)" ) );
  m = re2.match( tokens );
  if ( !m.hasMatch() )
  {
    type = tokens.toLower().trimmed();
    definition.clear();
  }
  else
  {
    type = m.captured( 1 ).toLower().trimmed();
    definition = m.captured( 2 );
  }
  return true;
}
 
//
// QgsProcessingParameterDefinition
//
 
QgsProcessingParameterDefinition::QgsProcessingParameterDefinition( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, const QString &help )
  : mName( name )
  , mDescription( description )
  , mHelp( help )
  , mDefault( defaultValue )
  , mFlags( optional ? Qgis::ProcessingParameterFlag::Optional : Qgis::ProcessingParameterFlag() )
{}
QgsProcessingParameterDefinition::QgsProcessingParameterDefinition( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, const QString &help ) {…}
 
QVariant QgsProcessingParameterDefinition::guiDefaultValueOverride() const
{
  QVariant defaultSettingsValue = defaultGuiValueFromSetting();
  if ( defaultSettingsValue.isValid() )
  {
    return defaultSettingsValue;
  }
  return mGuiDefault;
}
QVariant QgsProcessingParameterDefinition::guiDefaultValueOverride() const {…}
 
QVariant QgsProcessingParameterDefinition::defaultValueForGui() const
{
  QVariant defaultSettingsValue = defaultGuiValueFromSetting();
  if ( defaultSettingsValue.isValid() )
  {
    return defaultSettingsValue;
  }
  return mGuiDefault.isValid() ? mGuiDefault : mDefault;
}
QVariant QgsProcessingParameterDefinition::defaultValueForGui() const {…}
 
QVariant QgsProcessingParameterDefinition::defaultGuiValueFromSetting() const
{
  if ( mAlgorithm )
  {
    QgsSettings s;
    QVariant settingValue = s.value( QStringLiteral( "/Processing/DefaultGuiParam/%1/%2" ).arg( mAlgorithm->id() ).arg( mName ) );
    if ( settingValue.isValid() )
    {
      return settingValue;
    }
  }
  return QVariant();
}
QVariant QgsProcessingParameterDefinition::defaultGuiValueFromSetting() const {…}
 
bool QgsProcessingParameterDefinition::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const
{
  if ( !input.isValid() && !mDefault.isValid() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( ( input.userType() == QMetaType::Type::QString && input.toString().isEmpty() )
       || ( !input.isValid() && mDefault.userType() == QMetaType::Type::QString && mDefault.toString().isEmpty() ) )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  return true;
}
bool QgsProcessingParameterDefinition::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterDefinition::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
}
QString QgsProcessingParameterDefinition::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QVariant QgsProcessingParameterDefinition::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const
{
  return valueAsJsonObjectPrivate( value, context, ValueAsStringFlags() );
}
QVariant QgsProcessingParameterDefinition::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QVariant QgsProcessingParameterDefinition::valueAsJsonObjectPrivate( const QVariant &value, QgsProcessingContext &context, ValueAsStringFlags flags ) const
{
  if ( !value.isValid() )
    return value;
 
  // dive into map and list types and convert each value
  if ( value.userType() == QMetaType::Type::QVariantMap )
  {
    const QVariantMap sourceMap = value.toMap();
    QVariantMap resultMap;
    for ( auto it = sourceMap.constBegin(); it != sourceMap.constEnd(); it++ )
    {
      resultMap[ it.key() ] = valueAsJsonObject( it.value(), context );
    }
    return resultMap;
  }
  else if ( value.userType() == QMetaType::Type::QVariantList || value.userType() == QMetaType::Type::QStringList )
  {
    const QVariantList sourceList = value.toList();
    QVariantList resultList;
    resultList.reserve( sourceList.size() );
    for ( const QVariant &v : sourceList )
    {
      resultList.push_back( valueAsJsonObject( v, context ) );
    }
    return resultList;
  }
  else
  {
    switch ( value.userType() )
    {
      // simple types which can be directly represented in JSON -- note that strings are NOT handled here yet!
      case QMetaType::Bool:
      case QMetaType::Char:
      case QMetaType::Int:
      case QMetaType::Double:
      case QMetaType::Float:
      case QMetaType::LongLong:
      case QMetaType::ULongLong:
      case QMetaType::UInt:
      case QMetaType::ULong:
      case QMetaType::UShort:
        return value;
 
      default:
        break;
    }
 
    if ( value.userType() == qMetaTypeId<QgsProperty>() )
    {
      const QgsProperty prop = value.value< QgsProperty >();
      switch ( prop.propertyType() )
      {
        case Qgis::PropertyType::Invalid:
          return QVariant();
        case Qgis::PropertyType::Static:
          return valueAsJsonObject( prop.staticValue(), context );
        case Qgis::PropertyType::Field:
          return QVariantMap( {{QStringLiteral( "type" ), QStringLiteral( "data_defined" )}, {QStringLiteral( "field" ), prop.field() }} );
        case Qgis::PropertyType::Expression:
          return QVariantMap( {{QStringLiteral( "type" ), QStringLiteral( "data_defined" )}, {QStringLiteral( "expression" ), prop.expressionString() }} );
      }
    }
 
    // value may be a CRS
    if ( value.userType() == qMetaTypeId<QgsCoordinateReferenceSystem>() )
    {
      const QgsCoordinateReferenceSystem crs = value.value< QgsCoordinateReferenceSystem >();
      if ( !crs.isValid() )
        return QString();
      else if ( !crs.authid().isEmpty() )
        return crs.authid();
      else
        return crs.toWkt( Qgis::CrsWktVariant::Preferred );
    }
    else if ( value.userType() == qMetaTypeId<QgsRectangle>() )
    {
      const QgsRectangle r = value.value<QgsRectangle>();
      return QStringLiteral( "%1, %3, %2, %4" ).arg( qgsDoubleToString( r.xMinimum() ),
             qgsDoubleToString( r.yMinimum() ),
             qgsDoubleToString( r.xMaximum() ),
             qgsDoubleToString( r.yMaximum() ) );
    }
    else if ( value.userType() == qMetaTypeId<QgsReferencedRectangle>() )
    {
      const QgsReferencedRectangle r = value.value<QgsReferencedRectangle>();
      return QStringLiteral( "%1, %3, %2, %4 [%5]" ).arg( qgsDoubleToString( r.xMinimum() ),
             qgsDoubleToString( r.yMinimum() ),
             qgsDoubleToString( r.xMaximum() ),
             qgsDoubleToString( r.yMaximum() ),
             r.crs().authid() );
    }
    else if ( value.userType() == qMetaTypeId< QgsGeometry>() )
    {
      const QgsGeometry g = value.value<QgsGeometry>();
      if ( !g.isNull() )
      {
        return g.asWkt();
      }
      else
      {
        return QString();
      }
    }
    else if ( value.userType() == qMetaTypeId<QgsReferencedGeometry>() )
    {
      const QgsReferencedGeometry g = value.value<QgsReferencedGeometry>();
      if ( !g.isNull() )
      {
        if ( !g.crs().isValid() )
          return g.asWkt();
        else
          return QStringLiteral( "CRS=%1;%2" ).arg( g.crs().authid().isEmpty() ? g.crs().toWkt( Qgis::CrsWktVariant::Preferred ) : g.crs().authid(), g.asWkt() );
      }
      else
      {
        return QString();
      }
    }
    else if ( value.userType() == qMetaTypeId<QgsPointXY>() )
    {
      const QgsPointXY r = value.value<QgsPointXY>();
      return QStringLiteral( "%1,%2" ).arg( qgsDoubleToString( r.x() ),
                                            qgsDoubleToString( r.y() ) );
    }
    else if ( value.userType() == qMetaTypeId<QgsReferencedPointXY>() )
    {
      const QgsReferencedPointXY r = value.value<QgsReferencedPointXY>();
      return QStringLiteral( "%1,%2 [%3]" ).arg( qgsDoubleToString( r.x() ),
             qgsDoubleToString( r.y() ),
             r.crs().authid() );
    }
    else if ( value.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
    {
      const QgsProcessingFeatureSourceDefinition fromVar = qvariant_cast<QgsProcessingFeatureSourceDefinition>( value );
 
      // TODO -- we could consider also serializating the additional properties like invalid feature handling, limits, etc
      return valueAsJsonObject( fromVar.source, context );
    }
    else if ( value.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
    {
      const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( value );
      return valueAsJsonObject( fromVar.sink, context );
    }
    else if ( value.userType() == qMetaTypeId<QColor>() )
    {
      const QColor fromVar = value.value< QColor >();
      if ( !fromVar.isValid() )
        return QString();
 
      return QStringLiteral( "rgba( %1, %2, %3, %4 )" ).arg( fromVar.red() ).arg( fromVar.green() ).arg( fromVar.blue() ).arg( QString::number( fromVar.alphaF(), 'f', 2 ) );
    }
    else if ( value.userType() == qMetaTypeId<QDateTime>() )
    {
      const QDateTime fromVar = value.toDateTime();
      if ( !fromVar.isValid() )
        return QString();
 
      return fromVar.toString( Qt::ISODate );
    }
    else if ( value.userType() == qMetaTypeId<QDate>() )
    {
      const QDate fromVar = value.toDate();
      if ( !fromVar.isValid() )
        return QString();
 
      return fromVar.toString( Qt::ISODate );
    }
    else if ( value.userType() == qMetaTypeId<QTime>() )
    {
      const QTime fromVar = value.toTime();
      if ( !fromVar.isValid() )
        return QString();
 
      return fromVar.toString( Qt::ISODate );
    }
 
    if ( flags & ValueAsStringFlag::AllowMapLayerValues )
    {
      // value may be a map layer
      QVariantMap p;
      p.insert( name(), value );
      if ( QgsMapLayer *layer = QgsProcessingParameters::parameterAsLayer( this, p, context ) )
      {
        return QgsProcessingUtils::layerToStringIdentifier( layer, value.toString() );
      }
    }
 
    // now we handle strings, after any other specific logic has already been applied
    if ( value.userType() == QMetaType::QString )
      return value;
  }
 
  // unhandled type
  Q_ASSERT_X( false, "QgsProcessingParameterDefinition::valueAsJsonObject", QStringLiteral( "unsupported variant type %1" ).arg( QMetaType::typeName( value.userType() ) ).toLocal8Bit() );
  return value;
}
QVariant QgsProcessingParameterDefinition::valueAsJsonObjectPrivate( const QVariant &value, QgsProcessingContext &context, ValueAsStringFlags flags ) const {…}
 
QString QgsProcessingParameterDefinition::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const
{
  return valueAsStringPrivate( value, context, ok, ValueAsStringFlags() );
}
QString QgsProcessingParameterDefinition::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const {…}
 
QString QgsProcessingParameterDefinition::valueAsStringPrivate( const QVariant &value, QgsProcessingContext &context, bool &ok, ValueAsStringFlags flags ) const
{
  ok = true;
 
  if ( !value.isValid() )
    return QString();
 
  switch ( value.userType() )
  {
    // simple types which can be directly represented in JSON -- note that strings are NOT handled here yet!
    case QMetaType::Bool:
    case QMetaType::Char:
    case QMetaType::Int:
    case QMetaType::Double:
    case QMetaType::Float:
    case QMetaType::LongLong:
    case QMetaType::ULongLong:
    case QMetaType::UInt:
    case QMetaType::ULong:
    case QMetaType::UShort:
      return value.toString();
 
    default:
      break;
  }
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
  {
    const QgsProperty prop = value.value< QgsProperty >();
    switch ( prop.propertyType() )
    {
      case Qgis::PropertyType::Invalid:
        return QString();
      case Qgis::PropertyType::Static:
        return valueAsString( prop.staticValue(), context, ok );
      case Qgis::PropertyType::Field:
        return QStringLiteral( "field:%1" ).arg( prop.field() );
      case Qgis::PropertyType::Expression:
        return QStringLiteral( "expression:%1" ).arg( prop.expressionString() );
    }
  }
 
  // value may be a CRS
  if ( value.userType() == qMetaTypeId<QgsCoordinateReferenceSystem>() )
  {
    const QgsCoordinateReferenceSystem crs = value.value< QgsCoordinateReferenceSystem >();
    if ( !crs.isValid() )
      return QString();
    else if ( !crs.authid().isEmpty() )
      return crs.authid();
    else
      return crs.toWkt( Qgis::CrsWktVariant::Preferred );
  }
  else if ( value.userType() == qMetaTypeId<QgsRectangle>() )
  {
    const QgsRectangle r = value.value<QgsRectangle>();
    return QStringLiteral( "%1, %3, %2, %4" ).arg( qgsDoubleToString( r.xMinimum() ),
           qgsDoubleToString( r.yMinimum() ),
           qgsDoubleToString( r.xMaximum() ),
           qgsDoubleToString( r.yMaximum() ) );
  }
  else if ( value.userType() == qMetaTypeId<QgsReferencedRectangle>() )
  {
    const QgsReferencedRectangle r = value.value<QgsReferencedRectangle>();
    return QStringLiteral( "%1, %3, %2, %4 [%5]" ).arg( qgsDoubleToString( r.xMinimum() ),
           qgsDoubleToString( r.yMinimum() ),
           qgsDoubleToString( r.xMaximum() ),
           qgsDoubleToString( r.yMaximum() ), r.crs().authid() );
  }
  else if ( value.userType() == qMetaTypeId< QgsGeometry>() )
  {
    const QgsGeometry g = value.value<QgsGeometry>();
    if ( !g.isNull() )
    {
      return g.asWkt();
    }
    else
    {
      return QString();
    }
  }
  else if ( value.userType() == qMetaTypeId<QgsReferencedGeometry>() )
  {
    const QgsReferencedGeometry g = value.value<QgsReferencedGeometry>();
    if ( !g.isNull() )
    {
      if ( !g.crs().isValid() )
        return g.asWkt();
      else
        return QStringLiteral( "CRS=%1;%2" ).arg( g.crs().authid().isEmpty() ? g.crs().toWkt( Qgis::CrsWktVariant::Preferred ) : g.crs().authid(), g.asWkt() );
    }
    else
    {
      return QString();
    }
  }
  else if ( value.userType() == qMetaTypeId<QgsPointXY>() )
  {
    const QgsPointXY r = value.value<QgsPointXY>();
    return QStringLiteral( "%1,%2" ).arg( qgsDoubleToString( r.x() ),
                                          qgsDoubleToString( r.y() ) );
  }
  else if ( value.userType() == qMetaTypeId<QgsReferencedPointXY>() )
  {
    const QgsReferencedPointXY r = value.value<QgsReferencedPointXY>();
    return QStringLiteral( "%1,%2 [%3]" ).arg( qgsDoubleToString( r.x() ),
           qgsDoubleToString( r.y() ),
           r.crs().authid() );
  }
  else if ( value.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
  {
    const QgsProcessingFeatureSourceDefinition fromVar = qvariant_cast<QgsProcessingFeatureSourceDefinition>( value );
    return valueAsString( fromVar.source, context, ok );
  }
  else if ( value.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( value );
    return valueAsString( fromVar.sink, context, ok );
  }
  else if ( value.userType() == qMetaTypeId<QColor>() )
  {
    const QColor fromVar = value.value< QColor >();
    if ( !fromVar.isValid() )
      return QString();
 
    return QStringLiteral( "rgba( %1, %2, %3, %4 )" ).arg( fromVar.red() ).arg( fromVar.green() ).arg( fromVar.blue() ).arg( QString::number( fromVar.alphaF(), 'f', 2 ) );
  }
  else if ( value.userType() == qMetaTypeId<QDateTime>() )
  {
    const QDateTime fromVar = value.toDateTime();
    if ( !fromVar.isValid() )
      return QString();
 
    return fromVar.toString( Qt::ISODate );
  }
  else if ( value.userType() == qMetaTypeId<QDate>() )
  {
    const QDate fromVar = value.toDate();
    if ( !fromVar.isValid() )
      return QString();
 
    return fromVar.toString( Qt::ISODate );
  }
  else if ( value.userType() == qMetaTypeId<QTime>() )
  {
    const QTime fromVar = value.toTime();
    if ( !fromVar.isValid() )
      return QString();
 
    return fromVar.toString( Qt::ISODate );
  }
 
  if ( flags & ValueAsStringFlag::AllowMapLayerValues )
  {
    // value may be a map layer
    QVariantMap p;
    p.insert( name(), value );
    if ( QgsMapLayer *layer = QgsProcessingParameters::parameterAsLayer( this, p, context ) )
    {
      return QgsProcessingUtils::layerToStringIdentifier( layer, value.toString() );
    }
  }
 
  // now we handle strings, after any other specific logic has already been applied
  if ( value.userType() == QMetaType::QString )
    return value.toString();
 
  // unhandled type
  QgsDebugError( QStringLiteral( "unsupported variant type %1" ).arg( QMetaType::typeName( value.userType() ) ) );
  ok = false;
  return value.toString();
}
QString QgsProcessingParameterDefinition::valueAsStringPrivate( const QVariant &value, QgsProcessingContext &context, bool &ok, ValueAsStringFlags flags ) const {…}
 
QStringList QgsProcessingParameterDefinition::valueAsStringList( const QVariant &value, QgsProcessingContext &context, bool &ok ) const
{
  ok = true;
  if ( !value.isValid( ) )
    return QStringList();
 
  if ( value.userType() == QMetaType::Type::QVariantList || value.userType() == QMetaType::Type::QStringList )
  {
    const QVariantList sourceList = value.toList();
    QStringList resultList;
    resultList.reserve( sourceList.size() );
    for ( const QVariant &v : sourceList )
    {
      resultList.append( valueAsStringList( v, context, ok ) );
    }
    return resultList;
  }
 
  const QString res = valueAsString( value, context, ok );
  if ( !ok )
    return QStringList();
 
  return {res};
}
QStringList QgsProcessingParameterDefinition::valueAsStringList( const QVariant &value, QgsProcessingContext &context, bool &ok ) const {…}
 
QString QgsProcessingParameterDefinition::valueAsPythonComment( const QVariant &, QgsProcessingContext & ) const
{
  return QString();
}
QString QgsProcessingParameterDefinition::valueAsPythonComment( const QVariant &, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterDefinition::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += type() + ' ';
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterDefinition::asScriptCode() const {…}
 
QString QgsProcessingParameterDefinition::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  // base class method is probably not much use
  if ( QgsProcessingParameterType *t = QgsApplication::processingRegistry()->parameterType( type() ) )
  {
    switch ( outputType )
    {
      case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
      {
        QString code = t->className() + QStringLiteral( "('%1', %2" )
                       .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
        if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
          code += QLatin1String( ", optional=True" );
 
        QgsProcessingContext c;
        code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
        return code;
      }
    }
  }
 
  // oh well, we tried
  return QString();
}
QString QgsProcessingParameterDefinition::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QVariantMap QgsProcessingParameterDefinition::toVariantMap() const
{
  QVariantMap map;
  map.insert( QStringLiteral( "parameter_type" ), type() );
  map.insert( QStringLiteral( "name" ), mName );
  map.insert( QStringLiteral( "description" ), mDescription );
  map.insert( QStringLiteral( "help" ), mHelp );
  map.insert( QStringLiteral( "default" ), mDefault );
  map.insert( QStringLiteral( "defaultGui" ), mGuiDefault );
  map.insert( QStringLiteral( "flags" ), static_cast< int >( mFlags ) );
  map.insert( QStringLiteral( "metadata" ), mMetadata );
  return map;
}
QVariantMap QgsProcessingParameterDefinition::toVariantMap() const {…}
 
bool QgsProcessingParameterDefinition::fromVariantMap( const QVariantMap &map )
{
  mName = map.value( QStringLiteral( "name" ) ).toString();
  mDescription = map.value( QStringLiteral( "description" ) ).toString();
  mHelp = map.value( QStringLiteral( "help" ) ).toString();
  mDefault = map.value( QStringLiteral( "default" ) );
  mGuiDefault = map.value( QStringLiteral( "defaultGui" ) );
  mFlags = static_cast< Qgis::ProcessingParameterFlags >( map.value( QStringLiteral( "flags" ) ).toInt() );
  mMetadata = map.value( QStringLiteral( "metadata" ) ).toMap();
  return true;
}
bool QgsProcessingParameterDefinition::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingAlgorithm *QgsProcessingParameterDefinition::algorithm() const
{
  return mAlgorithm;
}
QgsProcessingAlgorithm *QgsProcessingParameterDefinition::algorithm() const {…}
 
QgsProcessingProvider *QgsProcessingParameterDefinition::provider() const
{
  return mAlgorithm ? mAlgorithm->provider() : nullptr;
}
QgsProcessingProvider *QgsProcessingParameterDefinition::provider() const {…}
 
QString QgsProcessingParameterDefinition::toolTip() const
{
  QString text = QStringLiteral( "<p><b>%1</b></p>" ).arg( description() );
  if ( !help().isEmpty() )
  {
    text += QStringLiteral( "<p>%1</p>" ).arg( help() );
  }
  text += QStringLiteral( "<p>%1</p>" ).arg( QObject::tr( "Python identifier: ‘%1’" ).arg( QStringLiteral( "<i>%1</i>" ).arg( name() ) ) );
  return text;
}
QString QgsProcessingParameterDefinition::toolTip() const {…}
 
QgsProcessingParameterBoolean::QgsProcessingParameterBoolean( const QString &name, const QString &description, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
{}
QgsProcessingParameterBoolean::QgsProcessingParameterBoolean( const QString &name, const QString &description, const QVariant &defaultValue, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterBoolean::clone() const
{
  return new QgsProcessingParameterBoolean( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterBoolean::clone() const {…}
 
QString QgsProcessingParameterBoolean::valueAsPythonString( const QVariant &val, QgsProcessingContext & ) const
{
  if ( !val.isValid() )
    return QStringLiteral( "None" );
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( val.value< QgsProperty >().asExpression() );
  return val.toBool() ? QStringLiteral( "True" ) : QStringLiteral( "False" );
}
QString QgsProcessingParameterBoolean::valueAsPythonString( const QVariant &val, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterBoolean::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += type() + ' ';
  code += mDefault.toBool() ? QStringLiteral( "true" ) : QStringLiteral( "false" );
  return code.trimmed();
}
QString QgsProcessingParameterBoolean::asScriptCode() const {…}
 
QgsProcessingParameterBoolean *QgsProcessingParameterBoolean::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterBoolean( name, description, definition.toLower().trimmed() != QStringLiteral( "false" ), isOptional );
}
QgsProcessingParameterBoolean *QgsProcessingParameterBoolean::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterCrs::QgsProcessingParameterCrs( const QString &name, const QString &description, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
{
 
}
QgsProcessingParameterCrs::QgsProcessingParameterCrs( const QString &name, const QString &description, const QVariant &defaultValue, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterCrs::clone() const
{
  return new QgsProcessingParameterCrs( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterCrs::clone() const {…}
 
bool QgsProcessingParameterCrs::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const
{
  QVariant input = v;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsCoordinateReferenceSystem>() )
  {
    return true;
  }
  else if ( input.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
  {
    return true;
  }
  else if ( input.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    return true;
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  if ( input.type() == QVariant::String )
  {
    const QString string = input.toString();
    if ( string.compare( QLatin1String( "ProjectCrs" ), Qt::CaseInsensitive ) == 0 )
      return true;
 
    const QgsCoordinateReferenceSystem crs( string );
    if ( crs.isValid() )
      return true;
  }
 
  // direct map layer value
  if ( qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( input ) ) )
    return true;
 
  if ( input.userType() != QMetaType::Type::QString || input.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  return true;
}
bool QgsProcessingParameterCrs::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterCrs::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsCoordinateReferenceSystem>() )
  {
    if ( !value.value< QgsCoordinateReferenceSystem >().isValid() )
      return QStringLiteral( "QgsCoordinateReferenceSystem()" );
    else
      return QStringLiteral( "QgsCoordinateReferenceSystem('%1')" ).arg( value.value< QgsCoordinateReferenceSystem >().authid() );
  }
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.type() == QVariant::String )
  {
    const QString string = value.toString();
    if ( string.compare( QLatin1String( "ProjectCrs" ), Qt::CaseInsensitive ) == 0 )
      return QgsProcessingUtils::stringToPythonLiteral( string );
 
    const QgsCoordinateReferenceSystem crs( string );
    if ( crs.isValid() )
      return QgsProcessingUtils::stringToPythonLiteral( string );
  }
 
  QVariantMap p;
  p.insert( name(), value );
  QgsMapLayer *layer = QgsProcessingParameters::parameterAsLayer( this, p, context );
  if ( layer )
    return QgsProcessingUtils::stringToPythonLiteral( QgsProcessingUtils::layerToStringIdentifier( layer ) );
 
  return QgsProcessingParameterDefinition::valueAsPythonString( value, context );
}
QString QgsProcessingParameterCrs::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterCrs::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const
{
  if ( value.type() == QVariant::String )
  {
    const QString string = value.toString();
    if ( string.compare( QLatin1String( "ProjectCrs" ), Qt::CaseInsensitive ) == 0 )
      return string;
 
    const QgsCoordinateReferenceSystem crs( string );
    if ( crs.isValid() )
      return string;
  }
 
  return valueAsStringPrivate( value, context, ok, ValueAsStringFlag::AllowMapLayerValues );
}
QString QgsProcessingParameterCrs::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const {…}
 
QVariant QgsProcessingParameterCrs::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const
{
  if ( value.type() == QVariant::String )
  {
    const QString string = value.toString();
    if ( string.compare( QLatin1String( "ProjectCrs" ), Qt::CaseInsensitive ) == 0 )
      return string;
 
    const QgsCoordinateReferenceSystem crs( string );
    if ( crs.isValid() )
      return string;
  }
 
  return valueAsJsonObjectPrivate( value, context, ValueAsStringFlag::AllowMapLayerValues );
}
QVariant QgsProcessingParameterCrs::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QgsProcessingParameterCrs *QgsProcessingParameterCrs::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterCrs( name, description, definition.compare( QLatin1String( "none" ), Qt::CaseInsensitive ) == 0 ? QVariant() : definition, isOptional );
}
QgsProcessingParameterCrs *QgsProcessingParameterCrs::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterMapLayer::QgsProcessingParameterMapLayer( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, const QList<int> &types )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , QgsProcessingParameterLimitedDataTypes( types )
{
 
}
QgsProcessingParameterMapLayer::QgsProcessingParameterMapLayer( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, const QList<int> &types ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterMapLayer::clone() const
{
  return new QgsProcessingParameterMapLayer( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterMapLayer::clone() const {…}
 
bool QgsProcessingParameterMapLayer::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const
{
  QVariant input = v;
 
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  if ( qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( input ) ) )
  {
    return true;
  }
 
  if ( input.userType() != QMetaType::Type::QString || input.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( !context )
  {
    // that's as far as we can get without a context
    return true;
  }
 
  // try to load as layer
  if ( QgsProcessingUtils::mapLayerFromString( input.toString(), *context ) )
    return true;
 
  return false;
}
bool QgsProcessingParameterMapLayer::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const {…}
 
QString QgsProcessingParameterMapLayer::valueAsPythonString( const QVariant &val, QgsProcessingContext &context ) const
{
  if ( !val.isValid() )
    return QStringLiteral( "None" );
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( val.value< QgsProperty >().asExpression() );
 
  QVariantMap p;
  p.insert( name(), val );
  QgsMapLayer *layer = QgsProcessingParameters::parameterAsLayer( this, p, context );
  return layer ? QgsProcessingUtils::stringToPythonLiteral( QgsProcessingUtils::layerToStringIdentifier( layer ) )
         : QgsProcessingUtils::stringToPythonLiteral( val.toString() );
}
QString QgsProcessingParameterMapLayer::valueAsPythonString( const QVariant &val, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterMapLayer::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const
{
  return valueAsStringPrivate( value, context, ok, ValueAsStringFlag::AllowMapLayerValues );
}
QString QgsProcessingParameterMapLayer::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const {…}
 
QVariant QgsProcessingParameterMapLayer::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const
{
  return valueAsJsonObjectPrivate( value, context, ValueAsStringFlag::AllowMapLayerValues );
}
QVariant QgsProcessingParameterMapLayer::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString createAllMapLayerFileFilter()
{
  QStringList vectors = QgsProviderRegistry::instance()->fileVectorFilters().split( QStringLiteral( ";;" ) );
  const QStringList rasters = QgsProviderRegistry::instance()->fileRasterFilters().split( QStringLiteral( ";;" ) );
  for ( const QString &raster : rasters )
  {
    if ( !vectors.contains( raster ) )
      vectors << raster;
  }
  const QStringList meshFilters = QgsProviderRegistry::instance()->fileMeshFilters().split( QStringLiteral( ";;" ) );
  for ( const QString &mesh : meshFilters )
  {
    if ( !vectors.contains( mesh ) )
      vectors << mesh;
  }
  const QStringList pointCloudFilters = QgsProviderRegistry::instance()->filePointCloudFilters().split( QStringLiteral( ";;" ) );
  for ( const QString &pointCloud : pointCloudFilters )
  {
    if ( !vectors.contains( pointCloud ) )
      vectors << pointCloud;
  }
  vectors.removeAll( QObject::tr( "All files (*.*)" ) );
  std::sort( vectors.begin(), vectors.end() );
 
  return QObject::tr( "All files (*.*)" ) + QStringLiteral( ";;" ) + vectors.join( QLatin1String( ";;" ) );
}
QString createAllMapLayerFileFilter() {…}
 
QString QgsProcessingParameterMapLayer::createFileFilter() const
{
  return createAllMapLayerFileFilter();
}
QString QgsProcessingParameterMapLayer::createFileFilter() const {…}
 
QString QgsProcessingParameterMapLayer::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "layer " );
 
  for ( const int type : mDataTypes )
  {
    switch ( static_cast< Qgis::ProcessingSourceType >( type ) )
    {
      case Qgis::ProcessingSourceType::Vector:
        code += QLatin1String( "table " );
        break;
 
      case Qgis::ProcessingSourceType::VectorAnyGeometry:
        code += QLatin1String( "hasgeometry " );
        break;
 
      case Qgis::ProcessingSourceType::VectorPoint:
        code += QLatin1String( "point " );
        break;
 
      case Qgis::ProcessingSourceType::VectorLine:
        code += QLatin1String( "line " );
        break;
 
      case Qgis::ProcessingSourceType::VectorPolygon:
        code += QLatin1String( "polygon " );
        break;
 
      case Qgis::ProcessingSourceType::Raster:
        code += QLatin1String( "raster " );
        break;
 
      case Qgis::ProcessingSourceType::Mesh:
        code += QLatin1String( "mesh " );
        break;
 
      case Qgis::ProcessingSourceType::Plugin:
        code += QLatin1String( "plugin " );
        break;
 
      case Qgis::ProcessingSourceType::PointCloud:
        code += QLatin1String( "pointcloud " );
        break;
 
      case Qgis::ProcessingSourceType::Annotation:
        code += QLatin1String( "annotation " );
        break;
 
      default:
        break;
    }
  }
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterMapLayer::asScriptCode() const {…}
 
QgsProcessingParameterMapLayer *QgsProcessingParameterMapLayer::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QList< int > types;
  QString def = definition;
  while ( true )
  {
    if ( def.startsWith( QLatin1String( "table" ), Qt::CaseInsensitive ) )
    {
      types << static_cast< int >( Qgis::ProcessingSourceType::Vector );
      def = def.mid( 6 );
      continue;
    }
    if ( def.startsWith( QLatin1String( "hasgeometry" ), Qt::CaseInsensitive ) )
    {
      types << static_cast< int >( Qgis::ProcessingSourceType::VectorAnyGeometry );
      def = def.mid( 12 );
      continue;
    }
    else if ( def.startsWith( QLatin1String( "point" ), Qt::CaseInsensitive ) )
    {
      types << static_cast< int >( Qgis::ProcessingSourceType::VectorPoint );
      def = def.mid( 6 );
      continue;
    }
    else if ( def.startsWith( QLatin1String( "line" ), Qt::CaseInsensitive ) )
    {
      types << static_cast< int >( Qgis::ProcessingSourceType::VectorLine );
      def = def.mid( 5 );
      continue;
    }
    else if ( def.startsWith( QLatin1String( "polygon" ), Qt::CaseInsensitive ) )
    {
      types << static_cast< int >( Qgis::ProcessingSourceType::VectorPolygon );
      def = def.mid( 8 );
      continue;
    }
    else if ( def.startsWith( QLatin1String( "raster" ), Qt::CaseInsensitive ) )
    {
      types << static_cast< int >( Qgis::ProcessingSourceType::Raster );
      def = def.mid( 7 );
      continue;
    }
    else if ( def.startsWith( QLatin1String( "mesh" ), Qt::CaseInsensitive ) )
    {
      types << static_cast< int >( Qgis::ProcessingSourceType::Mesh );
      def = def.mid( 5 );
      continue;
    }
    else if ( def.startsWith( QLatin1String( "plugin" ), Qt::CaseInsensitive ) )
    {
      types << static_cast< int >( Qgis::ProcessingSourceType::Plugin );
      def = def.mid( 7 );
      continue;
    }
    else if ( def.startsWith( QLatin1String( "pointcloud" ), Qt::CaseInsensitive ) )
    {
      types << static_cast< int >( Qgis::ProcessingSourceType::PointCloud );
      def = def.mid( 11 );
      continue;
    }
    else if ( def.startsWith( QLatin1String( "annotation" ), Qt::CaseInsensitive ) )
    {
      types << static_cast< int >( Qgis::ProcessingSourceType::Annotation );
      def = def.mid( 11 );
      continue;
    }
    break;
  }
 
  return new QgsProcessingParameterMapLayer( name, description, def.isEmpty() ? QVariant() : def, isOptional, types );
}
QgsProcessingParameterMapLayer *QgsProcessingParameterMapLayer::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QString QgsProcessingParameterMapLayer::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterMapLayer('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1" ).arg( valueAsPythonString( mDefault, c ) );
 
      if ( !mDataTypes.empty() )
      {
        QStringList options;
        options.reserve( mDataTypes.size() );
        for ( const int t : mDataTypes )
          options << QStringLiteral( "QgsProcessing.%1" ).arg( QgsProcessing::sourceTypeToString( static_cast< Qgis::ProcessingSourceType >( t ) ) );
        code += QStringLiteral( ", types=[%1])" ).arg( options.join( ',' ) );
      }
      else
      {
        code += QLatin1Char( ')' );
      }
 
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterMapLayer::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QVariantMap QgsProcessingParameterMapLayer::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  QVariantList types;
  for ( const int type : mDataTypes )
  {
    types << type;
  }
  map.insert( QStringLiteral( "data_types" ), types );
  return map;
}
QVariantMap QgsProcessingParameterMapLayer::toVariantMap() const {…}
 
bool QgsProcessingParameterMapLayer::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mDataTypes.clear();
  const QVariantList values = map.value( QStringLiteral( "data_types" ) ).toList();
  for ( const QVariant &val : values )
  {
    mDataTypes << val.toInt();
  }
  return true;
}
bool QgsProcessingParameterMapLayer::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterExtent::QgsProcessingParameterExtent( const QString &name, const QString &description, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
{
 
}
QgsProcessingParameterExtent::QgsProcessingParameterExtent( const QString &name, const QString &description, const QVariant &defaultValue, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterExtent::clone() const
{
  return new QgsProcessingParameterExtent( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterExtent::clone() const {…}
 
bool QgsProcessingParameterExtent::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const
{
  QVariant input = v;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
  {
    return true;
  }
  else if ( input.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    return true;
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  if ( input.userType() == qMetaTypeId<QgsRectangle>() )
  {
    const QgsRectangle r = input.value<QgsRectangle>();
    return !r.isNull();
  }
  if ( input.userType() == qMetaTypeId< QgsGeometry>() )
  {
    return true;
  }
  if ( input.userType() == qMetaTypeId<QgsReferencedRectangle>() )
  {
    const QgsReferencedRectangle r = input.value<QgsReferencedRectangle>();
    return !r.isNull();
  }
 
  // direct map layer value
  if ( qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( input ) ) )
    return true;
 
  if ( input.userType() != QMetaType::Type::QString || input.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( variantIsValidStringForExtent( input ) )
    return true;
 
  if ( !context )
  {
    // that's as far as we can get without a context
    return true;
  }
 
  // try as layer extent
  return QgsProcessingUtils::mapLayerFromString( input.toString(), *context );
}
bool QgsProcessingParameterExtent::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const {…}
 
bool QgsProcessingParameterExtent::variantIsValidStringForExtent( const QVariant &value )
{
  if ( value.userType() == QMetaType::Type::QString )
  {
    const thread_local QRegularExpression rx( QStringLiteral( "^(.*?)\\s*,\\s*(.*?)\\s*,\\s*(.*?)\\s*,\\s*(.*?)\\s*(?:\\[(.*)\\])?\\s*$" ) );
    const QRegularExpressionMatch match = rx.match( value.toString() );
    if ( match.hasMatch() )
    {
      bool xMinOk = false;
      ( void )match.captured( 1 ).toDouble( &xMinOk );
      bool xMaxOk = false;
      ( void )match.captured( 2 ).toDouble( &xMaxOk );
      bool yMinOk = false;
      ( void )match.captured( 3 ).toDouble( &yMinOk );
      bool yMaxOk = false;
      ( void )match.captured( 4 ).toDouble( &yMaxOk );
      if ( xMinOk && xMaxOk && yMinOk && yMaxOk )
        return true;
    }
  }
  return false;
}
 
QString QgsProcessingParameterExtent::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.userType() == qMetaTypeId<QgsRectangle>() )
  {
    const QgsRectangle r = value.value<QgsRectangle>();
    return QStringLiteral( "'%1, %3, %2, %4'" ).arg( qgsDoubleToString( r.xMinimum() ),
           qgsDoubleToString( r.yMinimum() ),
           qgsDoubleToString( r.xMaximum() ),
           qgsDoubleToString( r.yMaximum() ) );
  }
  else if ( value.userType() == qMetaTypeId<QgsReferencedRectangle>() )
  {
    const QgsReferencedRectangle r = value.value<QgsReferencedRectangle>();
    return QStringLiteral( "'%1, %3, %2, %4 [%5]'" ).arg( qgsDoubleToString( r.xMinimum() ),
           qgsDoubleToString( r.yMinimum() ),
           qgsDoubleToString( r.xMaximum() ),
           qgsDoubleToString( r.yMaximum() ),                                                                                                                             r.crs().authid() );
  }
  else if ( value.userType() == qMetaTypeId< QgsGeometry>() )
  {
    const QgsGeometry g = value.value<QgsGeometry>();
    if ( !g.isNull() )
    {
      const QString wkt = g.asWkt();
      return QStringLiteral( "QgsGeometry.fromWkt('%1')" ).arg( wkt );
    }
  }
  else if ( variantIsValidStringForExtent( value ) )
  {
    return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
  }
 
  QVariantMap p;
  p.insert( name(), value );
  QgsMapLayer *layer = QgsProcessingParameters::parameterAsLayer( this, p, context );
  if ( layer )
    return QgsProcessingUtils::stringToPythonLiteral( QgsProcessingUtils::layerToStringIdentifier( layer ) );
 
  return QgsProcessingParameterDefinition::valueAsPythonString( value, context );
}
QString QgsProcessingParameterExtent::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterExtent::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const
{
  if ( variantIsValidStringForExtent( value ) )
  {
    return value.toString();
  }
 
  return valueAsStringPrivate( value, context, ok, ValueAsStringFlag::AllowMapLayerValues );
}
QString QgsProcessingParameterExtent::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const {…}
 
QVariant QgsProcessingParameterExtent::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const
{
  if ( variantIsValidStringForExtent( value ) )
  {
    return value;
  }
 
  return valueAsJsonObjectPrivate( value, context, ValueAsStringFlag::AllowMapLayerValues );
}
QVariant QgsProcessingParameterExtent::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QgsProcessingParameterExtent *QgsProcessingParameterExtent::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterExtent( name, description, definition, isOptional );
}
QgsProcessingParameterExtent *QgsProcessingParameterExtent::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterPoint::QgsProcessingParameterPoint( const QString &name, const QString &description, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
{
 
}
QgsProcessingParameterPoint::QgsProcessingParameterPoint( const QString &name, const QString &description, const QVariant &defaultValue, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterPoint::clone() const
{
  return new QgsProcessingParameterPoint( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterPoint::clone() const {…}
 
bool QgsProcessingParameterPoint::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const
{
  QVariant input = v;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  if ( input.userType() == qMetaTypeId<QgsPointXY>() )
  {
    return true;
  }
  if ( input.userType() == qMetaTypeId<QgsReferencedPointXY>() )
  {
    return true;
  }
  if ( input.userType() == qMetaTypeId< QgsGeometry>() )
  {
    return true;
  }
 
  if ( input.userType() == QMetaType::Type::QString )
  {
    if ( input.toString().isEmpty() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
  }
 
  const thread_local QRegularExpression rx( QStringLiteral( "^\\s*\\(?\\s*(.*?)\\s*,\\s*(.*?)\\s*(?:\\[(.*)\\])?\\s*\\)?\\s*$" ) );
 
  const QRegularExpressionMatch match = rx.match( input.toString() );
  if ( match.hasMatch() )
  {
    bool xOk = false;
    ( void )match.captured( 1 ).toDouble( &xOk );
    bool yOk = false;
    ( void )match.captured( 2 ).toDouble( &yOk );
    return xOk && yOk;
  }
  else
    return false;
}
bool QgsProcessingParameterPoint::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterPoint::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.userType() == qMetaTypeId<QgsPointXY>() )
  {
    const QgsPointXY r = value.value<QgsPointXY>();
    return QStringLiteral( "'%1,%2'" ).arg( qgsDoubleToString( r.x() ),
                                            qgsDoubleToString( r.y() ) );
  }
  else if ( value.userType() == qMetaTypeId<QgsReferencedPointXY>() )
  {
    const QgsReferencedPointXY r = value.value<QgsReferencedPointXY>();
    return QStringLiteral( "'%1,%2 [%3]'" ).arg( qgsDoubleToString( r.x() ),
           qgsDoubleToString( r.y() ),
           r.crs().authid() );
  }
  else if ( value.userType() == qMetaTypeId< QgsGeometry>() )
  {
    const QgsGeometry g = value.value<QgsGeometry>();
    if ( !g.isNull() )
    {
      const QString wkt = g.asWkt();
      return QStringLiteral( "QgsGeometry.fromWkt('%1')" ).arg( wkt );
    }
  }
 
  return QgsProcessingParameterDefinition::valueAsPythonString( value, context );
}
QString QgsProcessingParameterPoint::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QgsProcessingParameterPoint *QgsProcessingParameterPoint::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterPoint( name, description, definition, isOptional );
}
QgsProcessingParameterPoint *QgsProcessingParameterPoint::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterGeometry::QgsProcessingParameterGeometry( const QString &name, const QString &description,
    const QVariant &defaultValue, bool optional, const QList<int> &geometryTypes, bool allowMultipart )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional ),
    mGeomTypes( geometryTypes ),
    mAllowMultipart( allowMultipart )
{
 
}
QgsProcessingParameterGeometry::QgsProcessingParameterGeometry( const QString &name, const QString &description, {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterGeometry::clone() const
{
  return new QgsProcessingParameterGeometry( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterGeometry::clone() const {…}
 
bool QgsProcessingParameterGeometry::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const
{
  QVariant input = v;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  const bool anyTypeAllowed = mGeomTypes.isEmpty() || mGeomTypes.contains( static_cast< int >( Qgis::GeometryType::Unknown ) );
 
  if ( input.userType() == qMetaTypeId< QgsGeometry>() )
  {
    return ( anyTypeAllowed || mGeomTypes.contains( static_cast< int >( input.value<QgsGeometry>().type() ) ) ) &&
           ( mAllowMultipart || !input.value<QgsGeometry>().isMultipart() );
  }
 
  if ( input.userType() == qMetaTypeId<QgsReferencedGeometry>() )
  {
    return ( anyTypeAllowed || mGeomTypes.contains( static_cast<int>( input.value<QgsReferencedGeometry>().type() ) ) ) &&
           ( mAllowMultipart || !input.value<QgsReferencedGeometry>().isMultipart() );
  }
 
  if ( input.userType() == qMetaTypeId<QgsPointXY>() )
  {
    return anyTypeAllowed || mGeomTypes.contains( static_cast< int >( Qgis::GeometryType::Point ) );
  }
 
  if ( input.userType() == qMetaTypeId<QgsRectangle>() )
  {
    return anyTypeAllowed || mGeomTypes.contains( static_cast< int >( Qgis::GeometryType::Polygon ) );
  }
 
  if ( input.userType() == qMetaTypeId<QgsReferencedPointXY>() )
  {
    return anyTypeAllowed || mGeomTypes.contains( static_cast< int >( Qgis::GeometryType::Point ) );
  }
 
  if ( input.userType() == qMetaTypeId<QgsReferencedRectangle>() )
  {
    return anyTypeAllowed || mGeomTypes.contains( static_cast< int >( Qgis::GeometryType::Polygon ) );
  }
 
  if ( input.userType() == QMetaType::Type::QString )
  {
    if ( input.toString().isEmpty() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
  }
 
  // Match against EWKT
  const thread_local QRegularExpression rx( QStringLiteral( "^\\s*(?:CRS=(.*);)?(.*?)$" ) );
 
  const QRegularExpressionMatch match = rx.match( input.toString() );
  if ( match.hasMatch() )
  {
    const QgsGeometry g = QgsGeometry::fromWkt( match.captured( 2 ) );
    if ( ! g.isNull() )
    {
      return ( anyTypeAllowed || mGeomTypes.contains( static_cast< int >( g.type() ) ) ) && ( mAllowMultipart || !g.isMultipart() );
    }
    else
    {
      QgsMessageLog::logMessage( QObject::tr( "Error creating geometry: \"%1\"" ).arg( g.lastError() ), QObject::tr( "Processing" ) );
    }
  }
  return false;
}
bool QgsProcessingParameterGeometry::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterGeometry::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const
{
  auto asPythonString = []( const QgsGeometry & g, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() )
  {
    if ( !crs.isValid() )
      return QgsProcessingUtils::stringToPythonLiteral( g.asWkt() );
    else
      return QgsProcessingUtils::stringToPythonLiteral( QStringLiteral( "CRS=%1;%2" ).arg( crs.authid().isEmpty() ? crs.toWkt( Qgis::CrsWktVariant::Preferred ) : crs.authid(), g.asWkt() ) );
  };
 
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression(%1)" ).arg( QgsProcessingUtils::stringToPythonLiteral( value.value< QgsProperty >().asExpression() ) );
 
  if ( value.userType() == qMetaTypeId< QgsGeometry>() )
  {
    const QgsGeometry g = value.value<QgsGeometry>();
    if ( !g.isNull() )
      return asPythonString( g );
  }
 
  if ( value.userType() == qMetaTypeId<QgsReferencedGeometry>() )
  {
    const QgsReferencedGeometry g = value.value<QgsReferencedGeometry>();
    if ( !g.isNull() )
      return asPythonString( g, g.crs() );
  }
 
  if ( value.userType() == qMetaTypeId<QgsPointXY>() )
  {
    const QgsGeometry g = QgsGeometry::fromPointXY( value.value<QgsPointXY>() );
    if ( !g.isNull() )
      return asPythonString( g );
  }
 
  if ( value.userType() == qMetaTypeId<QgsReferencedPointXY>() )
  {
    const QgsReferencedGeometry g = QgsReferencedGeometry::fromReferencedPointXY( value.value<QgsReferencedPointXY>() );
    if ( !g.isNull() )
      return asPythonString( g, g.crs() );
  }
 
  if ( value.userType() == qMetaTypeId<QgsRectangle>() )
  {
    const QgsGeometry g = QgsGeometry::fromRect( value.value<QgsRectangle>() );
    if ( !g.isNull() )
      return asPythonString( g );
  }
 
  if ( value.userType() == qMetaTypeId<QgsReferencedRectangle>() )
  {
    const QgsReferencedGeometry g = QgsReferencedGeometry::fromReferencedRect( value.value<QgsReferencedRectangle>() );
    if ( !g.isNull() )
      return asPythonString( g, g.crs() );
  }
 
  return QgsProcessingParameterDefinition::valueAsPythonString( value, context );
}
QString QgsProcessingParameterGeometry::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterGeometry::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += type() + ' ';
 
  for ( const int type : mGeomTypes )
  {
    switch ( static_cast<Qgis::GeometryType>( type ) )
    {
      case Qgis::GeometryType::Point:
        code += QLatin1String( "point " );
        break;
 
      case Qgis::GeometryType::Line:
        code += QLatin1String( "line " );
        break;
 
      case Qgis::GeometryType::Polygon:
        code += QLatin1String( "polygon " );
        break;
 
      default:
        code += QLatin1String( "unknown " );
        break;
    }
  }
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterGeometry::asScriptCode() const {…}
 
QString QgsProcessingParameterGeometry::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterGeometry('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      if ( !mGeomTypes.empty() )
      {
        auto geomTypeToString = []( Qgis::GeometryType t ) -> QString
        {
          switch ( t )
          {
            case Qgis::GeometryType::Point:
              return QStringLiteral( "PointGeometry" );
 
            case Qgis::GeometryType::Line:
              return QStringLiteral( "LineGeometry" );
 
            case Qgis::GeometryType::Polygon:
              return QStringLiteral( "PolygonGeometry" );
 
            case Qgis::GeometryType::Unknown:
              return QStringLiteral( "UnknownGeometry" );
 
            case Qgis::GeometryType::Null:
              return QStringLiteral( "NullGeometry" );
          }
          return QString();
        };
 
        QStringList options;
        options.reserve( mGeomTypes.size() );
        for ( const int type : mGeomTypes )
        {
          options << QStringLiteral( " QgsWkbTypes.%1" ).arg( geomTypeToString( static_cast<Qgis::GeometryType>( type ) ) );
        }
        code += QStringLiteral( ", geometryTypes=[%1 ]" ).arg( options.join( ',' ) );
      }
 
      if ( ! mAllowMultipart )
      {
        code += QLatin1String( ", allowMultipart=False" );
      }
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterGeometry::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QVariantMap QgsProcessingParameterGeometry::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  QVariantList types;
  for ( const int type : mGeomTypes )
  {
    types << type;
  }
  map.insert( QStringLiteral( "geometrytypes" ), types );
  map.insert( QStringLiteral( "multipart" ), mAllowMultipart );
  return map;
}
QVariantMap QgsProcessingParameterGeometry::toVariantMap() const {…}
 
bool QgsProcessingParameterGeometry::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mGeomTypes.clear();
  const QVariantList values = map.value( QStringLiteral( "geometrytypes" ) ).toList();
  for ( const QVariant &val : values )
  {
    mGeomTypes << val.toInt();
  }
  mAllowMultipart = map.value( QStringLiteral( "multipart" ) ).toBool();
  return true;
}
bool QgsProcessingParameterGeometry::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterGeometry *QgsProcessingParameterGeometry::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterGeometry( name, description, definition, isOptional );
}
QgsProcessingParameterGeometry *QgsProcessingParameterGeometry::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterFile::QgsProcessingParameterFile( const QString &name, const QString &description, Qgis::ProcessingFileParameterBehavior behavior, const QString &extension, const QVariant &defaultValue, bool optional, const QString &fileFilter )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mBehavior( behavior )
  , mExtension( fileFilter.isEmpty() ? extension : QString() )
  , mFileFilter( fileFilter.isEmpty() && extension.isEmpty() ? QObject::tr( "All files (*.*)" ) : fileFilter )
{
 
}
QgsProcessingParameterFile::QgsProcessingParameterFile( const QString &name, const QString &description, Qgis::ProcessingFileParameterBehavior behavior, const QString &extension, const QVariant &defaultValue, bool optional, const QString &fileFilter ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterFile::clone() const
{
  return new QgsProcessingParameterFile( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterFile::clone() const {…}
 
bool QgsProcessingParameterFile::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const
{
  QVariant input = v;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  const QString string = input.toString().trimmed();
 
  if ( input.userType() != QMetaType::Type::QString || string.isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  switch ( mBehavior )
  {
    case Qgis::ProcessingFileParameterBehavior::File:
    {
      if ( !mExtension.isEmpty() )
      {
        return string.endsWith( mExtension, Qt::CaseInsensitive );
      }
      else if ( !mFileFilter.isEmpty() )
      {
        return QgsFileUtils::fileMatchesFilter( string, mFileFilter );
      }
      else
      {
        return true;
      }
    }
 
    case Qgis::ProcessingFileParameterBehavior::Folder:
      return true;
  }
  return true;
}
bool QgsProcessingParameterFile::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterFile::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += ( mBehavior == Qgis::ProcessingFileParameterBehavior::File ? QStringLiteral( "file" ) : QStringLiteral( "folder" ) ) + ' ';
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterFile::asScriptCode() const {…}
 
QString QgsProcessingParameterFile::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
 
      QString code = QStringLiteral( "QgsProcessingParameterFile('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
      code += QStringLiteral( ", behavior=%1" ).arg( mBehavior == Qgis::ProcessingFileParameterBehavior::File ? QStringLiteral( "QgsProcessingParameterFile.File" ) : QStringLiteral( "QgsProcessingParameterFile.Folder" ) );
      if ( !mExtension.isEmpty() )
        code += QStringLiteral( ", extension='%1'" ).arg( mExtension );
      if ( !mFileFilter.isEmpty() )
        code += QStringLiteral( ", fileFilter='%1'" ).arg( mFileFilter );
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterFile::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QString QgsProcessingParameterFile::createFileFilter() const
{
  switch ( mBehavior )
  {
    case Qgis::ProcessingFileParameterBehavior::File:
    {
      if ( !mFileFilter.isEmpty() )
        return mFileFilter != QObject::tr( "All files (*.*)" ) ? mFileFilter + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" ) : mFileFilter;
      else if ( !mExtension.isEmpty() )
        return QObject::tr( "%1 files" ).arg( mExtension.toUpper() ) + QStringLiteral( " (*." ) + mExtension.toLower() +  QStringLiteral( ");;" ) + QObject::tr( "All files (*.*)" );
      else
        return QObject::tr( "All files (*.*)" );
    }
 
    case Qgis::ProcessingFileParameterBehavior::Folder:
      return QString();
  }
  return QString();
}
QString QgsProcessingParameterFile::createFileFilter() const {…}
 
void QgsProcessingParameterFile::setExtension( const QString &extension )
{
  mExtension = extension;
  mFileFilter.clear();
}
void QgsProcessingParameterFile::setExtension( const QString &extension ) {…}
 
QString QgsProcessingParameterFile::fileFilter() const
{
  return mFileFilter;
}
QString QgsProcessingParameterFile::fileFilter() const {…}
 
void QgsProcessingParameterFile::setFileFilter( const QString &filter )
{
  mFileFilter = filter;
  mExtension.clear();
}
void QgsProcessingParameterFile::setFileFilter( const QString &filter ) {…}
 
QVariantMap QgsProcessingParameterFile::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "behavior" ), static_cast< int >( mBehavior ) );
  map.insert( QStringLiteral( "extension" ), mExtension );
  map.insert( QStringLiteral( "filefilter" ), mFileFilter );
  return map;
}
QVariantMap QgsProcessingParameterFile::toVariantMap() const {…}
 
bool QgsProcessingParameterFile::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mBehavior = static_cast< Qgis::ProcessingFileParameterBehavior >( map.value( QStringLiteral( "behavior" ) ).toInt() );
  mExtension = map.value( QStringLiteral( "extension" ) ).toString();
  mFileFilter = map.value( QStringLiteral( "filefilter" ) ).toString();
  return true;
}
bool QgsProcessingParameterFile::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterFile *QgsProcessingParameterFile::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition, Qgis::ProcessingFileParameterBehavior behavior )
{
  return new QgsProcessingParameterFile( name, description, behavior, QString(), definition, isOptional );
}
QgsProcessingParameterFile *QgsProcessingParameterFile::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition, Qgis::ProcessingFileParameterBehavior behavior ) {…}
 
QgsProcessingParameterMatrix::QgsProcessingParameterMatrix( const QString &name, const QString &description, int numberRows, bool fixedNumberRows, const QStringList &headers, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mHeaders( headers )
  , mNumberRows( numberRows )
  , mFixedNumberRows( fixedNumberRows )
{
 
}
QgsProcessingParameterMatrix::QgsProcessingParameterMatrix( const QString &name, const QString &description, int numberRows, bool fixedNumberRows, const QStringList &headers, const QVariant &defaultValue, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterMatrix::clone() const
{
  return new QgsProcessingParameterMatrix( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterMatrix::clone() const {…}
 
bool QgsProcessingParameterMatrix::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const
{
  QVariant input = v;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == QMetaType::Type::QString )
  {
    if ( input.toString().isEmpty() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
    return true;
  }
  else if ( input.userType() == QMetaType::Type::QVariantList )
  {
    if ( input.toList().isEmpty() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
    return true;
  }
  else if ( input.userType() == QMetaType::Type::Double || input.userType() == QMetaType::Type::Int )
  {
    return true;
  }
 
  return false;
}
bool QgsProcessingParameterMatrix::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterMatrix::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  QVariantMap p;
  p.insert( name(), value );
  const QVariantList list = QgsProcessingParameters::parameterAsMatrix( this, p, context );
 
  return QgsProcessingUtils::variantToPythonLiteral( list );
}
QString QgsProcessingParameterMatrix::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterMatrix::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterMatrix('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
      code += QStringLiteral( ", numberRows=%1" ).arg( mNumberRows );
      code += QStringLiteral( ", hasFixedNumberRows=%1" ).arg( mFixedNumberRows ? QStringLiteral( "True" ) : QStringLiteral( "False" ) );
 
      QStringList headers;
      headers.reserve( mHeaders.size() );
      for ( const QString &h : mHeaders )
        headers << QgsProcessingUtils::stringToPythonLiteral( h );
      code += QStringLiteral( ", headers=[%1]" ).arg( headers.join( ',' ) );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterMatrix::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QStringList QgsProcessingParameterMatrix::headers() const
{
  return mHeaders;
}
QStringList QgsProcessingParameterMatrix::headers() const {…}
 
void QgsProcessingParameterMatrix::setHeaders( const QStringList &headers )
{
  mHeaders = headers;
}
void QgsProcessingParameterMatrix::setHeaders( const QStringList &headers ) {…}
 
int QgsProcessingParameterMatrix::numberRows() const
{
  return mNumberRows;
}
int QgsProcessingParameterMatrix::numberRows() const {…}
 
void QgsProcessingParameterMatrix::setNumberRows( int numberRows )
{
  mNumberRows = numberRows;
}
void QgsProcessingParameterMatrix::setNumberRows( int numberRows ) {…}
 
bool QgsProcessingParameterMatrix::hasFixedNumberRows() const
{
  return mFixedNumberRows;
}
bool QgsProcessingParameterMatrix::hasFixedNumberRows() const {…}
 
void QgsProcessingParameterMatrix::setHasFixedNumberRows( bool fixedNumberRows )
{
  mFixedNumberRows = fixedNumberRows;
}
void QgsProcessingParameterMatrix::setHasFixedNumberRows( bool fixedNumberRows ) {…}
 
QVariantMap QgsProcessingParameterMatrix::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "headers" ), mHeaders );
  map.insert( QStringLiteral( "rows" ), mNumberRows );
  map.insert( QStringLiteral( "fixed_number_rows" ), mFixedNumberRows );
  return map;
}
QVariantMap QgsProcessingParameterMatrix::toVariantMap() const {…}
 
bool QgsProcessingParameterMatrix::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mHeaders = map.value( QStringLiteral( "headers" ) ).toStringList();
  mNumberRows = map.value( QStringLiteral( "rows" ) ).toInt();
  mFixedNumberRows = map.value( QStringLiteral( "fixed_number_rows" ) ).toBool();
  return true;
}
bool QgsProcessingParameterMatrix::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterMatrix *QgsProcessingParameterMatrix::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterMatrix( name, description, 0, false, QStringList(), definition.isEmpty() ? QVariant() : definition, isOptional );
}
QgsProcessingParameterMatrix *QgsProcessingParameterMatrix::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterMultipleLayers::QgsProcessingParameterMultipleLayers( const QString &name, const QString &description, Qgis::ProcessingSourceType layerType, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mLayerType( layerType )
{
 
}
QgsProcessingParameterMultipleLayers::QgsProcessingParameterMultipleLayers( const QString &name, const QString &description, Qgis::ProcessingSourceType layerType, const QVariant &defaultValue, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterMultipleLayers::clone() const
{
  return new QgsProcessingParameterMultipleLayers( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterMultipleLayers::clone() const {…}
 
bool QgsProcessingParameterMultipleLayers::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const
{
  QVariant input = v;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( mLayerType != Qgis::ProcessingSourceType::File )
  {
    if ( qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( input ) ) )
    {
      return true;
    }
  }
 
  if ( input.userType() == QMetaType::Type::QString )
  {
    if ( input.toString().isEmpty() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    if ( mMinimumNumberInputs > 1 )
      return false;
 
    if ( !context )
      return true;
 
    if ( mLayerType != Qgis::ProcessingSourceType::File )
      return QgsProcessingUtils::mapLayerFromString( input.toString(), *context, true, QgsProcessingUtils::LayerHint::UnknownType, QgsProcessing::LayerOptionsFlag::SkipIndexGeneration );
    else
      return true;
  }
  else if ( input.userType() == QMetaType::Type::QVariantList )
  {
    if ( input.toList().count() < mMinimumNumberInputs )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    if ( mMinimumNumberInputs > input.toList().count() )
      return false;
 
    if ( !context )
      return true;
 
    if ( mLayerType != Qgis::ProcessingSourceType::File )
    {
      const auto constToList = input.toList();
      for ( const QVariant &v : constToList )
      {
        if ( qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( v ) ) )
          continue;
 
        if ( !QgsProcessingUtils::mapLayerFromString( v.toString(), *context, true, QgsProcessingUtils::LayerHint::UnknownType, QgsProcessing::LayerOptionsFlag::SkipIndexGeneration ) )
          return false;
      }
    }
    return true;
  }
  else if ( input.userType() == QMetaType::Type::QStringList )
  {
    if ( input.toStringList().count() < mMinimumNumberInputs )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    if ( mMinimumNumberInputs > input.toStringList().count() )
      return false;
 
    if ( !context )
      return true;
 
    if ( mLayerType != Qgis::ProcessingSourceType::File )
    {
      const auto constToStringList = input.toStringList();
      for ( const QString &v : constToStringList )
      {
        if ( !QgsProcessingUtils::mapLayerFromString( v, *context, true, QgsProcessingUtils::LayerHint::UnknownType, QgsProcessing::LayerOptionsFlag::SkipIndexGeneration ) )
          return false;
      }
    }
    return true;
  }
  return false;
}
bool QgsProcessingParameterMultipleLayers::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const {…}
 
QString QgsProcessingParameterMultipleLayers::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( mLayerType == Qgis::ProcessingSourceType::File )
  {
    QStringList parts;
    if ( value.userType() == QMetaType::Type::QStringList )
    {
      const QStringList list = value.toStringList();
      parts.reserve( list.count() );
      for ( const QString &v : list )
        parts <<  QgsProcessingUtils::stringToPythonLiteral( v );
    }
    else if ( value.userType() == QMetaType::Type::QVariantList )
    {
      const QVariantList list = value.toList();
      parts.reserve( list.count() );
      for ( const QVariant &v : list )
        parts <<  QgsProcessingUtils::stringToPythonLiteral( v.toString() );
    }
    if ( !parts.isEmpty() )
      return parts.join( ',' ).prepend( '[' ).append( ']' );
  }
  else
  {
    QVariantMap p;
    p.insert( name(), value );
    const QList<QgsMapLayer *> list = QgsProcessingParameters::parameterAsLayerList( this, p, context, QgsProcessing::LayerOptionsFlag::SkipIndexGeneration );
    if ( !list.isEmpty() )
    {
      QStringList parts;
      parts.reserve( list.count() );
      for ( const QgsMapLayer *layer : list )
      {
        parts << QgsProcessingUtils::stringToPythonLiteral( QgsProcessingUtils::layerToStringIdentifier( layer ) );
      }
      return parts.join( ',' ).prepend( '[' ).append( ']' );
    }
  }
 
  return QgsProcessingParameterDefinition::valueAsPythonString( value, context );
}
QString QgsProcessingParameterMultipleLayers::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterMultipleLayers::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const
{
  return valueAsStringPrivate( value, context, ok, ValueAsStringFlag::AllowMapLayerValues );
}
QString QgsProcessingParameterMultipleLayers::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const {…}
 
QVariant QgsProcessingParameterMultipleLayers::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const
{
  return valueAsJsonObjectPrivate( value, context, ValueAsStringFlag::AllowMapLayerValues );
}
QVariant QgsProcessingParameterMultipleLayers::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterMultipleLayers::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  switch ( mLayerType )
  {
    case Qgis::ProcessingSourceType::Raster:
      code += QLatin1String( "multiple raster" );
      break;
 
    case Qgis::ProcessingSourceType::File:
      code += QLatin1String( "multiple file" );
      break;
 
    default:
      code += QLatin1String( "multiple vector" );
      break;
  }
  code += ' ';
  if ( mDefault.userType() == QMetaType::Type::QVariantList )
  {
    QStringList parts;
    const auto constToList = mDefault.toList();
    for ( const QVariant &var : constToList )
    {
      parts << var.toString();
    }
    code += parts.join( ',' );
  }
  else if ( mDefault.userType() == QMetaType::Type::QStringList )
  {
    code += mDefault.toStringList().join( ',' );
  }
  else
  {
    code += mDefault.toString();
  }
  return code.trimmed();
}
QString QgsProcessingParameterMultipleLayers::asScriptCode() const {…}
 
QString QgsProcessingParameterMultipleLayers::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterMultipleLayers('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      const QString layerType = QStringLiteral( "QgsProcessing.%1" ).arg( QgsProcessing::sourceTypeToString( mLayerType ) );
 
      code += QStringLiteral( ", layerType=%1" ).arg( layerType );
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterMultipleLayers::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QString QgsProcessingParameterMultipleLayers::createFileFilter() const
{
  switch ( mLayerType )
  {
    case Qgis::ProcessingSourceType::File:
      return QObject::tr( "All files (*.*)" );
 
    case Qgis::ProcessingSourceType::Raster:
      return QgsProviderRegistry::instance()->fileRasterFilters() + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
 
    case Qgis::ProcessingSourceType::Vector:
    case Qgis::ProcessingSourceType::VectorAnyGeometry:
    case Qgis::ProcessingSourceType::VectorPoint:
    case Qgis::ProcessingSourceType::VectorLine:
    case Qgis::ProcessingSourceType::VectorPolygon:
      return QgsProviderRegistry::instance()->fileVectorFilters() + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
 
    case Qgis::ProcessingSourceType::Mesh:
      return QgsProviderRegistry::instance()->fileMeshFilters() + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
 
    case Qgis::ProcessingSourceType::PointCloud:
      return QgsProviderRegistry::instance()->filePointCloudFilters() + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
 
    case Qgis::ProcessingSourceType::MapLayer:
    case Qgis::ProcessingSourceType::Plugin:
    case Qgis::ProcessingSourceType::Annotation:
    case Qgis::ProcessingSourceType::VectorTile:
      return createAllMapLayerFileFilter();
  }
  return QString();
}
QString QgsProcessingParameterMultipleLayers::createFileFilter() const {…}
 
Qgis::ProcessingSourceType QgsProcessingParameterMultipleLayers::layerType() const
{
  return mLayerType;
}
Qgis::ProcessingSourceType QgsProcessingParameterMultipleLayers::layerType() const {…}
 
void QgsProcessingParameterMultipleLayers::setLayerType( Qgis::ProcessingSourceType type )
{
  mLayerType = type;
}
void QgsProcessingParameterMultipleLayers::setLayerType( Qgis::ProcessingSourceType type ) {…}
 
int QgsProcessingParameterMultipleLayers::minimumNumberInputs() const
{
  return mMinimumNumberInputs;
}
int QgsProcessingParameterMultipleLayers::minimumNumberInputs() const {…}
 
void QgsProcessingParameterMultipleLayers::setMinimumNumberInputs( int minimumNumberInputs )
{
  if ( mMinimumNumberInputs >= 1 || !( flags() & Qgis::ProcessingParameterFlag::Optional ) )
    mMinimumNumberInputs = minimumNumberInputs;
}
void QgsProcessingParameterMultipleLayers::setMinimumNumberInputs( int minimumNumberInputs ) {…}
 
QVariantMap QgsProcessingParameterMultipleLayers::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "layer_type" ), static_cast< int >( mLayerType ) );
  map.insert( QStringLiteral( "min_inputs" ), mMinimumNumberInputs );
  return map;
}
QVariantMap QgsProcessingParameterMultipleLayers::toVariantMap() const {…}
 
bool QgsProcessingParameterMultipleLayers::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mLayerType = static_cast< Qgis::ProcessingSourceType >( map.value( QStringLiteral( "layer_type" ) ).toInt() );
  mMinimumNumberInputs = map.value( QStringLiteral( "min_inputs" ) ).toInt();
  return true;
}
bool QgsProcessingParameterMultipleLayers::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterMultipleLayers *QgsProcessingParameterMultipleLayers::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString type = definition;
  QString defaultVal;
  const thread_local QRegularExpression re( QStringLiteral( "(.*?)\\s+(.*)" ) );
  const QRegularExpressionMatch m = re.match( definition );
  if ( m.hasMatch() )
  {
    type = m.captured( 1 ).toLower().trimmed();
    defaultVal = m.captured( 2 );
  }
  Qgis::ProcessingSourceType layerType = Qgis::ProcessingSourceType::VectorAnyGeometry;
  if ( type == QLatin1String( "vector" ) )
    layerType = Qgis::ProcessingSourceType::VectorAnyGeometry;
  else if ( type == QLatin1String( "raster" ) )
    layerType = Qgis::ProcessingSourceType::Raster;
  else if ( type == QLatin1String( "file" ) )
    layerType = Qgis::ProcessingSourceType::File;
  return new QgsProcessingParameterMultipleLayers( name, description, layerType, defaultVal.isEmpty() ? QVariant() : defaultVal, isOptional );
}
QgsProcessingParameterMultipleLayers *QgsProcessingParameterMultipleLayers::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterNumber::QgsProcessingParameterNumber( const QString &name, const QString &description, Qgis::ProcessingNumberParameterType type, const QVariant &defaultValue, bool optional, double minValue, double maxValue )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mMin( minValue )
  , mMax( maxValue )
  , mDataType( type )
{
  if ( mMin >= mMax )
  {
    QgsMessageLog::logMessage( QObject::tr( "Invalid number parameter \"%1\": min value %2 is >= max value %3!" ).arg( name ).arg( mMin ).arg( mMax ), QObject::tr( "Processing" ) );
  }
}
QgsProcessingParameterNumber::QgsProcessingParameterNumber( const QString &name, const QString &description, Qgis::ProcessingNumberParameterType type, const QVariant &defaultValue, bool optional, double minValue, double maxValue ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterNumber::clone() const
{
  return new QgsProcessingParameterNumber( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterNumber::clone() const {…}
 
bool QgsProcessingParameterNumber::checkValueIsAcceptable( const QVariant &value, QgsProcessingContext * ) const
{
  QVariant input = value;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  bool ok = false;
  const double res = input.toDouble( &ok );
  if ( !ok )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  return !( res < mMin || res > mMax );
}
bool QgsProcessingParameterNumber::checkValueIsAcceptable( const QVariant &value, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterNumber::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  return value.toString();
}
QString QgsProcessingParameterNumber::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterNumber::toolTip() const
{
  QString text = QgsProcessingParameterDefinition::toolTip();
  QStringList parts;
  if ( mMin > std::numeric_limits<double>::lowest() + 1 )
    parts << QObject::tr( "Minimum value: %1" ).arg( mMin );
  if ( mMax < std::numeric_limits<double>::max() )
    parts << QObject::tr( "Maximum value: %1" ).arg( mMax );
  if ( mDefault.isValid() )
    parts << QObject::tr( "Default value: %1" ).arg( mDataType == Qgis::ProcessingNumberParameterType::Integer ? mDefault.toInt() : mDefault.toDouble() );
  const QString extra = parts.join( QLatin1String( "<br />" ) );
  if ( !extra.isEmpty() )
    text += QStringLiteral( "<p>%1</p>" ).arg( extra );
  return text;
}
QString QgsProcessingParameterNumber::toolTip() const {…}
 
QString QgsProcessingParameterNumber::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterNumber('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", type=%1" ).arg( mDataType == Qgis::ProcessingNumberParameterType::Integer ? QStringLiteral( "QgsProcessingParameterNumber.Integer" ) : QStringLiteral( "QgsProcessingParameterNumber.Double" ) );
 
      if ( mMin != std::numeric_limits<double>::lowest() + 1 )
        code += QStringLiteral( ", minValue=%1" ).arg( mMin );
      if ( mMax != std::numeric_limits<double>::max() )
        code += QStringLiteral( ", maxValue=%1" ).arg( mMax );
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterNumber::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
double QgsProcessingParameterNumber::minimum() const
{
  return mMin;
}
double QgsProcessingParameterNumber::minimum() const {…}
 
void QgsProcessingParameterNumber::setMinimum( double min )
{
  mMin = min;
}
void QgsProcessingParameterNumber::setMinimum( double min ) {…}
 
double QgsProcessingParameterNumber::maximum() const
{
  return mMax;
}
double QgsProcessingParameterNumber::maximum() const {…}
 
void QgsProcessingParameterNumber::setMaximum( double max )
{
  mMax = max;
}
void QgsProcessingParameterNumber::setMaximum( double max ) {…}
 
Qgis::ProcessingNumberParameterType QgsProcessingParameterNumber::dataType() const
{
  return mDataType;
}
Qgis::ProcessingNumberParameterType QgsProcessingParameterNumber::dataType() const {…}
 
void QgsProcessingParameterNumber::setDataType( Qgis::ProcessingNumberParameterType dataType )
{
  mDataType = dataType;
}
void QgsProcessingParameterNumber::setDataType( Qgis::ProcessingNumberParameterType dataType ) {…}
 
QVariantMap QgsProcessingParameterNumber::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "min" ), mMin );
  map.insert( QStringLiteral( "max" ), mMax );
  map.insert( QStringLiteral( "data_type" ), static_cast< int >( mDataType ) );
  return map;
}
QVariantMap QgsProcessingParameterNumber::toVariantMap() const {…}
 
bool QgsProcessingParameterNumber::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mMin = map.value( QStringLiteral( "min" ) ).toDouble();
  mMax = map.value( QStringLiteral( "max" ) ).toDouble();
  mDataType = static_cast< Qgis::ProcessingNumberParameterType >( map.value( QStringLiteral( "data_type" ) ).toInt() );
  return true;
}
bool QgsProcessingParameterNumber::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterNumber *QgsProcessingParameterNumber::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterNumber( name, description, Qgis::ProcessingNumberParameterType::Double, definition.isEmpty() ? QVariant()
         : ( definition.toLower().trimmed() == QLatin1String( "none" ) ? QVariant() : definition ), isOptional );
}
QgsProcessingParameterNumber *QgsProcessingParameterNumber::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterRange::QgsProcessingParameterRange( const QString &name, const QString &description, Qgis::ProcessingNumberParameterType type, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mDataType( type )
{
 
}
QgsProcessingParameterRange::QgsProcessingParameterRange( const QString &name, const QString &description, Qgis::ProcessingNumberParameterType type, const QVariant &defaultValue, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterRange::clone() const
{
  return new QgsProcessingParameterRange( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterRange::clone() const {…}
 
bool QgsProcessingParameterRange::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const
{
  QVariant input = v;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  if ( input.userType() == QMetaType::Type::QString )
  {
    const QStringList list = input.toString().split( ',' );
    if ( list.count() != 2 )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
    bool ok = false;
    list.at( 0 ).toDouble( &ok );
    bool ok2 = false;
    list.at( 1 ).toDouble( &ok2 );
    if ( !ok || !ok2 )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
    return true;
  }
  else if ( input.userType() == QMetaType::Type::QVariantList )
  {
    if ( input.toList().count() != 2 )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    bool ok = false;
    input.toList().at( 0 ).toDouble( &ok );
    bool ok2 = false;
    input.toList().at( 1 ).toDouble( &ok2 );
    if ( !ok || !ok2 )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
    return true;
  }
 
  return false;
}
bool QgsProcessingParameterRange::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterRange::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  QVariantMap p;
  p.insert( name(), value );
  const QList< double > parts = QgsProcessingParameters::parameterAsRange( this, p, context );
 
  QStringList stringParts;
  const auto constParts = parts;
  for ( const double v : constParts )
  {
    stringParts << QString::number( v );
  }
  return stringParts.join( ',' ).prepend( '[' ).append( ']' );
}
QString QgsProcessingParameterRange::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterRange::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterRange('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", type=%1" ).arg( mDataType == Qgis::ProcessingNumberParameterType::Integer ? QStringLiteral( "QgsProcessingParameterNumber.Integer" ) : QStringLiteral( "QgsProcessingParameterNumber.Double" ) );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterRange::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
Qgis::ProcessingNumberParameterType QgsProcessingParameterRange::dataType() const
{
  return mDataType;
}
Qgis::ProcessingNumberParameterType QgsProcessingParameterRange::dataType() const {…}
 
void QgsProcessingParameterRange::setDataType( Qgis::ProcessingNumberParameterType dataType )
{
  mDataType = dataType;
}
void QgsProcessingParameterRange::setDataType( Qgis::ProcessingNumberParameterType dataType ) {…}
 
QVariantMap QgsProcessingParameterRange::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "data_type" ), static_cast< int >( mDataType ) );
  return map;
}
QVariantMap QgsProcessingParameterRange::toVariantMap() const {…}
 
bool QgsProcessingParameterRange::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mDataType = static_cast< Qgis::ProcessingNumberParameterType >( map.value( QStringLiteral( "data_type" ) ).toInt() );
  return true;
}
bool QgsProcessingParameterRange::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterRange *QgsProcessingParameterRange::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterRange( name, description, Qgis::ProcessingNumberParameterType::Double, definition.isEmpty() ? QVariant()
                                          : ( definition.toLower().trimmed() == QLatin1String( "none" ) ? QVariant() : definition ), isOptional );
}
QgsProcessingParameterRange *QgsProcessingParameterRange::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterRasterLayer::QgsProcessingParameterRasterLayer( const QString &name, const QString &description, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
{
 
}
QgsProcessingParameterRasterLayer::QgsProcessingParameterRasterLayer( const QString &name, const QString &description, const QVariant &defaultValue, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterRasterLayer::clone() const
{
  return new QgsProcessingParameterRasterLayer( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterRasterLayer::clone() const {…}
 
bool QgsProcessingParameterRasterLayer::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const
{
  QVariant input = v;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  if ( qobject_cast< QgsRasterLayer * >( qvariant_cast<QObject *>( input ) ) )
    return true;
 
  if ( input.userType() != QMetaType::Type::QString || input.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( !context )
  {
    // that's as far as we can get without a context
    return true;
  }
 
  // try to load as layer
  if ( QgsProcessingUtils::mapLayerFromString( input.toString(), *context, true, QgsProcessingUtils::LayerHint::Raster ) )
    return true;
 
  return false;
}
bool QgsProcessingParameterRasterLayer::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const {…}
 
QString QgsProcessingParameterRasterLayer::valueAsPythonString( const QVariant &val, QgsProcessingContext &context ) const
{
  if ( !val.isValid() )
    return QStringLiteral( "None" );
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( val.value< QgsProperty >().asExpression() );
 
  QVariantMap p;
  p.insert( name(), val );
  QgsRasterLayer *layer = QgsProcessingParameters::parameterAsRasterLayer( this, p, context );
  return layer ? QgsProcessingUtils::stringToPythonLiteral( QgsProcessingUtils::layerToStringIdentifier( layer ) )
         : QgsProcessingUtils::stringToPythonLiteral( val.toString() );
}
QString QgsProcessingParameterRasterLayer::valueAsPythonString( const QVariant &val, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterRasterLayer::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const
{
  return valueAsStringPrivate( value, context, ok, ValueAsStringFlag::AllowMapLayerValues );
}
QString QgsProcessingParameterRasterLayer::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const {…}
 
QVariant QgsProcessingParameterRasterLayer::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const
{
  return valueAsJsonObjectPrivate( value, context, ValueAsStringFlag::AllowMapLayerValues );
}
QVariant QgsProcessingParameterRasterLayer::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterRasterLayer::createFileFilter() const
{
  return QgsProviderRegistry::instance()->fileRasterFilters() + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
}
QString QgsProcessingParameterRasterLayer::createFileFilter() const {…}
 
QgsProcessingParameterRasterLayer *QgsProcessingParameterRasterLayer::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterRasterLayer( name, description, definition.isEmpty() ? QVariant() : definition, isOptional );
}
QgsProcessingParameterRasterLayer *QgsProcessingParameterRasterLayer::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterEnum::QgsProcessingParameterEnum( const QString &name, const QString &description, const QStringList &options, bool allowMultiple, const QVariant &defaultValue, bool optional, bool usesStaticStrings )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mOptions( options )
  , mAllowMultiple( allowMultiple )
  , mUsesStaticStrings( usesStaticStrings )
{
 
}
QgsProcessingParameterEnum::QgsProcessingParameterEnum( const QString &name, const QString &description, const QStringList &options, bool allowMultiple, const QVariant &defaultValue, bool optional, bool usesStaticStrings ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterEnum::clone() const
{
  return new QgsProcessingParameterEnum( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterEnum::clone() const {…}
 
bool QgsProcessingParameterEnum::checkValueIsAcceptable( const QVariant &value, QgsProcessingContext * ) const
{
  QVariant input = value;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  if ( mUsesStaticStrings )
  {
    if ( input.userType() == QMetaType::Type::QVariantList )
    {
      if ( !mAllowMultiple )
        return false;
 
      const QVariantList values = input.toList();
      if ( values.empty() && !( mFlags & Qgis::ProcessingParameterFlag::Optional ) )
        return false;
 
      for ( const QVariant &val : values )
      {
        if ( !mOptions.contains( val.toString() ) )
          return false;
      }
 
      return true;
    }
    else if ( input.userType() == QMetaType::Type::QStringList )
    {
      if ( !mAllowMultiple )
        return false;
 
      const QStringList values = input.toStringList();
 
      if ( values.empty() && !( mFlags & Qgis::ProcessingParameterFlag::Optional ) )
        return false;
 
      if ( values.count() > 1 && !mAllowMultiple )
        return false;
 
      for ( const QString &val : values )
      {
        if ( !mOptions.contains( val ) )
          return false;
      }
      return true;
    }
    else if ( input.userType() == QMetaType::Type::QString )
    {
      const QStringList parts = input.toString().split( ',' );
      if ( parts.count() > 1 && !mAllowMultiple )
        return false;
 
      const auto constParts = parts;
      for ( const QString &part : constParts )
      {
        if ( !mOptions.contains( part ) )
          return false;
      }
      return true;
    }
  }
  else
  {
    if ( input.userType() == QMetaType::Type::QVariantList )
    {
      if ( !mAllowMultiple )
        return false;
 
      const QVariantList values = input.toList();
      if ( values.empty() && !( mFlags & Qgis::ProcessingParameterFlag::Optional ) )
        return false;
 
      for ( const QVariant &val : values )
      {
        bool ok = false;
        const int res = val.toInt( &ok );
        if ( !ok )
          return false;
        else if ( res < 0 || res >= mOptions.count() )
          return false;
      }
 
      return true;
    }
    else if ( input.userType() == QMetaType::Type::QString )
    {
      const QStringList parts = input.toString().split( ',' );
      if ( parts.count() > 1 && !mAllowMultiple )
        return false;
 
      const auto constParts = parts;
      for ( const QString &part : constParts )
      {
        bool ok = false;
        const int res = part.toInt( &ok );
        if ( !ok )
          return false;
        else if ( res < 0 || res >= mOptions.count() )
          return false;
      }
      return true;
    }
    else if ( input.userType() == QMetaType::Type::Int || input.userType() == QMetaType::Type::Double )
    {
      bool ok = false;
      const int res = input.toInt( &ok );
      if ( !ok )
        return false;
      else if ( res >= 0 && res < mOptions.count() )
        return true;
    }
  }
 
  return false;
}
bool QgsProcessingParameterEnum::checkValueIsAcceptable( const QVariant &value, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterEnum::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( mUsesStaticStrings )
  {
    if ( value.userType() == QMetaType::Type::QVariantList || value.userType() == QMetaType::Type::QStringList )
    {
      QStringList parts;
      const QStringList constList = value.toStringList();
      for ( const QString &val : constList )
      {
        parts << QgsProcessingUtils::stringToPythonLiteral( val );
      }
      return parts.join( ',' ).prepend( '[' ).append( ']' );
    }
    else if ( value.userType() == QMetaType::Type::QString )
    {
      QStringList parts;
      const QStringList constList = value.toString().split( ',' );
      if ( constList.count() > 1 )
      {
        for ( const QString &val : constList )
        {
          parts << QgsProcessingUtils::stringToPythonLiteral( val );
        }
        return parts.join( ',' ).prepend( '[' ).append( ']' );
      }
    }
 
    return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
  }
  else
  {
    if ( value.userType() == QMetaType::Type::QVariantList )
    {
      QStringList parts;
      const auto constToList = value.toList();
      for ( const QVariant &val : constToList )
      {
        parts << QString::number( static_cast< int >( val.toDouble() ) );
      }
      return parts.join( ',' ).prepend( '[' ).append( ']' );
    }
    else if ( value.userType() == QMetaType::Type::QString )
    {
      const QStringList parts = value.toString().split( ',' );
      if ( parts.count() > 1 )
      {
        return parts.join( ',' ).prepend( '[' ).append( ']' );
      }
    }
 
    return QString::number( static_cast< int >( value.toDouble() ) );
  }
}
QString QgsProcessingParameterEnum::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterEnum::valueAsPythonComment( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QString();
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QString();
 
  if ( mUsesStaticStrings )
  {
    return QString();
  }
  else
  {
    if ( value.userType() == QMetaType::Type::QVariantList )
    {
      QStringList parts;
      const QVariantList toList = value.toList();
      parts.reserve( toList.size() );
      for ( const QVariant &val : toList )
      {
        parts << mOptions.value( static_cast< int >( val.toDouble() ) );
      }
      return parts.join( ',' );
    }
    else if ( value.userType() == QMetaType::Type::QString )
    {
      const QStringList parts = value.toString().split( ',' );
      QStringList comments;
      if ( parts.count() > 1 )
      {
        for ( const QString &part : parts )
        {
          bool ok = false;
          const int val = part.toInt( &ok );
          if ( ok )
            comments << mOptions.value( val );
        }
        return comments.join( ',' );
      }
    }
 
    return mOptions.value( static_cast< int >( value.toDouble() ) );
  }
}
QString QgsProcessingParameterEnum::valueAsPythonComment( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterEnum::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "enum " );
 
  if ( mAllowMultiple )
    code += QLatin1String( "multiple " );
 
  if ( mUsesStaticStrings )
    code += QLatin1String( "static " );
 
  code += mOptions.join( ';' ) + ' ';
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterEnum::asScriptCode() const {…}
 
QString QgsProcessingParameterEnum::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterEnum('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      QStringList options;
      options.reserve( mOptions.size() );
      for ( const QString &o : mOptions )
        options << QgsProcessingUtils::stringToPythonLiteral( o );
      code += QStringLiteral( ", options=[%1]" ).arg( options.join( ',' ) );
 
      code += QStringLiteral( ", allowMultiple=%1" ).arg( mAllowMultiple ? QStringLiteral( "True" ) : QStringLiteral( "False" ) );
 
      code += QStringLiteral( ", usesStaticStrings=%1" ).arg( mUsesStaticStrings ? QStringLiteral( "True" ) : QStringLiteral( "False" ) );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
 
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterEnum::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QStringList QgsProcessingParameterEnum::options() const
{
  return mOptions;
}
QStringList QgsProcessingParameterEnum::options() const {…}
 
void QgsProcessingParameterEnum::setOptions( const QStringList &options )
{
  mOptions = options;
}
void QgsProcessingParameterEnum::setOptions( const QStringList &options ) {…}
 
bool QgsProcessingParameterEnum::allowMultiple() const
{
  return mAllowMultiple;
}
bool QgsProcessingParameterEnum::allowMultiple() const {…}
 
void QgsProcessingParameterEnum::setAllowMultiple( bool allowMultiple )
{
  mAllowMultiple = allowMultiple;
}
void QgsProcessingParameterEnum::setAllowMultiple( bool allowMultiple ) {…}
 
bool QgsProcessingParameterEnum::usesStaticStrings() const
{
  return mUsesStaticStrings;
}
bool QgsProcessingParameterEnum::usesStaticStrings() const {…}
 
void QgsProcessingParameterEnum::setUsesStaticStrings( bool usesStaticStrings )
{
  mUsesStaticStrings = usesStaticStrings;
}
void QgsProcessingParameterEnum::setUsesStaticStrings( bool usesStaticStrings ) {…}
 
QVariantMap QgsProcessingParameterEnum::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "options" ), mOptions );
  map.insert( QStringLiteral( "allow_multiple" ), mAllowMultiple );
  map.insert( QStringLiteral( "uses_static_strings" ), mUsesStaticStrings );
  return map;
}
QVariantMap QgsProcessingParameterEnum::toVariantMap() const {…}
 
bool QgsProcessingParameterEnum::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mOptions = map.value( QStringLiteral( "options" ) ).toStringList();
  mAllowMultiple = map.value( QStringLiteral( "allow_multiple" ) ).toBool();
  mUsesStaticStrings = map.value( QStringLiteral( "uses_static_strings" ) ).toBool();
  return true;
}
bool QgsProcessingParameterEnum::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterEnum *QgsProcessingParameterEnum::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString defaultVal;
  QString def = definition;
 
  bool multiple = false;
  if ( def.startsWith( QLatin1String( "multiple" ), Qt::CaseInsensitive ) )
  {
    multiple = true;
    def = def.mid( 9 );
  }
 
  bool staticStrings = false;
  if ( def.startsWith( QLatin1String( "static" ), Qt::CaseInsensitive ) )
  {
    staticStrings = true;
    def = def.mid( 7 );
  }
 
  const thread_local QRegularExpression re( QStringLiteral( "(.*)\\s+(.*?)$" ) );
  const QRegularExpressionMatch m = re.match( def );
  QString values = def;
  if ( m.hasMatch() )
  {
    values = m.captured( 1 ).trimmed();
    defaultVal = m.captured( 2 );
  }
 
  return new QgsProcessingParameterEnum( name, description, values.split( ';' ), multiple, defaultVal.isEmpty() ? QVariant() : defaultVal, isOptional, staticStrings );
}
QgsProcessingParameterEnum *QgsProcessingParameterEnum::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterString::QgsProcessingParameterString( const QString &name, const QString &description, const QVariant &defaultValue, bool multiLine, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mMultiLine( multiLine )
{
 
}
QgsProcessingParameterString::QgsProcessingParameterString( const QString &name, const QString &description, const QVariant &defaultValue, bool multiLine, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterString::clone() const
{
  return new QgsProcessingParameterString( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterString::clone() const {…}
 
QString QgsProcessingParameterString::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( QgsVariantUtils::isNull( value ) )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  const QString s = value.toString();
  return QgsProcessingUtils::stringToPythonLiteral( s );
}
QString QgsProcessingParameterString::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterString::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "string " );
 
  if ( mMultiLine )
    code += QLatin1String( "long " );
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterString::asScriptCode() const {…}
 
QString QgsProcessingParameterString::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterString('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
      code += QStringLiteral( ", multiLine=%1" ).arg( mMultiLine ? QStringLiteral( "True" ) : QStringLiteral( "False" ) );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterString::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
bool QgsProcessingParameterString::multiLine() const
{
  return mMultiLine;
}
bool QgsProcessingParameterString::multiLine() const {…}
 
void QgsProcessingParameterString::setMultiLine( bool multiLine )
{
  mMultiLine = multiLine;
}
void QgsProcessingParameterString::setMultiLine( bool multiLine ) {…}
 
QVariantMap QgsProcessingParameterString::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "multiline" ), mMultiLine );
  return map;
}
QVariantMap QgsProcessingParameterString::toVariantMap() const {…}
 
bool QgsProcessingParameterString::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mMultiLine = map.value( QStringLiteral( "multiline" ) ).toBool();
  return true;
}
bool QgsProcessingParameterString::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterString *QgsProcessingParameterString::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString def = definition;
  bool multiLine = false;
  if ( def.startsWith( QLatin1String( "long" ), Qt::CaseInsensitive ) )
  {
    multiLine = true;
    def = def.mid( 5 );
  }
 
  if ( def.startsWith( '"' ) || def.startsWith( '\'' ) )
    def = def.mid( 1 );
  if ( def.endsWith( '"' ) || def.endsWith( '\'' ) )
    def.chop( 1 );
 
  QVariant defaultValue = def;
  if ( def == QLatin1String( "None" ) )
    defaultValue = QVariant();
 
  return new QgsProcessingParameterString( name, description, defaultValue, multiLine, isOptional );
}
QgsProcessingParameterString *QgsProcessingParameterString::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
//
// QgsProcessingParameterAuthConfig
//
 
QgsProcessingParameterAuthConfig::QgsProcessingParameterAuthConfig( const QString &name, const QString &description, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
{
 
}
QgsProcessingParameterAuthConfig::QgsProcessingParameterAuthConfig( const QString &name, const QString &description, const QVariant &defaultValue, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterAuthConfig::clone() const
{
  return new QgsProcessingParameterAuthConfig( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterAuthConfig::clone() const {…}
 
QString QgsProcessingParameterAuthConfig::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  const QString s = value.toString();
  return QgsProcessingUtils::stringToPythonLiteral( s );
}
QString QgsProcessingParameterAuthConfig::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterAuthConfig::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "authcfg " );
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterAuthConfig::asScriptCode() const {…}
 
QgsProcessingParameterAuthConfig *QgsProcessingParameterAuthConfig::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString def = definition;
 
  if ( def.startsWith( '"' ) || def.startsWith( '\'' ) )
    def = def.mid( 1 );
  if ( def.endsWith( '"' ) || def.endsWith( '\'' ) )
    def.chop( 1 );
 
  QVariant defaultValue = def;
  if ( def == QLatin1String( "None" ) )
    defaultValue = QVariant();
 
  return new QgsProcessingParameterAuthConfig( name, description, defaultValue, isOptional );
}
QgsProcessingParameterAuthConfig *QgsProcessingParameterAuthConfig::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
 
//
// QgsProcessingParameterExpression
//
 
QgsProcessingParameterExpression::QgsProcessingParameterExpression( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentLayerParameterName, bool optional, Qgis::ExpressionType type )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mParentLayerParameterName( parentLayerParameterName )
  , mExpressionType( type )
{
 
}
QgsProcessingParameterExpression::QgsProcessingParameterExpression( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentLayerParameterName, bool optional, Qgis::ExpressionType type ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterExpression::clone() const
{
  return new QgsProcessingParameterExpression( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterExpression::clone() const {…}
 
QString QgsProcessingParameterExpression::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  const QString s = value.toString();
  return QgsProcessingUtils::stringToPythonLiteral( s );
}
QString QgsProcessingParameterExpression::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QStringList QgsProcessingParameterExpression::dependsOnOtherParameters() const
{
  QStringList depends;
  if ( !mParentLayerParameterName.isEmpty() )
    depends << mParentLayerParameterName;
  return depends;
}
QStringList QgsProcessingParameterExpression::dependsOnOtherParameters() const {…}
 
QString QgsProcessingParameterExpression::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterExpression('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", parentLayerParameterName='%1'" ).arg( mParentLayerParameterName );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1" ).arg( valueAsPythonString( mDefault, c ) );
 
 
      switch ( mExpressionType )
      {
        case Qgis::ExpressionType::PointCloud:
          code += QLatin1String( ", type=Qgis.ExpressionType.PointCloud)" );
          break;
        case Qgis::ExpressionType::RasterCalculator:
          code += QLatin1String( ", type=Qgis.ExpressionType.RasterCalculator)" );
          break;
        default:
          code += QLatin1Char( ')' );
          break;
      }
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterExpression::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QString QgsProcessingParameterExpression::parentLayerParameterName() const
{
  return mParentLayerParameterName;
}
QString QgsProcessingParameterExpression::parentLayerParameterName() const {…}
 
void QgsProcessingParameterExpression::setParentLayerParameterName( const QString &parentLayerParameterName )
{
  mParentLayerParameterName = parentLayerParameterName;
}
void QgsProcessingParameterExpression::setParentLayerParameterName( const QString &parentLayerParameterName ) {…}
 
Qgis::ExpressionType QgsProcessingParameterExpression::expressionType() const
{
  return mExpressionType;
}
Qgis::ExpressionType QgsProcessingParameterExpression::expressionType() const {…}
 
void QgsProcessingParameterExpression::setExpressionType( Qgis::ExpressionType expressionType )
{
  mExpressionType = expressionType;
}
void QgsProcessingParameterExpression::setExpressionType( Qgis::ExpressionType expressionType ) {…}
 
QVariantMap QgsProcessingParameterExpression::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "parent_layer" ), mParentLayerParameterName );
  map.insert( QStringLiteral( "expression_type" ), static_cast< int >( mExpressionType ) );
  return map;
}
QVariantMap QgsProcessingParameterExpression::toVariantMap() const {…}
 
bool QgsProcessingParameterExpression::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mParentLayerParameterName = map.value( QStringLiteral( "parent_layer" ) ).toString();
  mExpressionType = static_cast< Qgis::ExpressionType >( map.value( QStringLiteral( "expression_type" ) ).toInt() );
  return true;
}
bool QgsProcessingParameterExpression::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterExpression *QgsProcessingParameterExpression::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterExpression( name, description, definition, QString(), isOptional, Qgis::ExpressionType::Qgis );
}
QgsProcessingParameterExpression *QgsProcessingParameterExpression::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
 
QgsProcessingParameterVectorLayer::QgsProcessingParameterVectorLayer( const QString &name, const QString &description, const QList<int> &types, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , QgsProcessingParameterLimitedDataTypes( types )
{
 
}
QgsProcessingParameterVectorLayer::QgsProcessingParameterVectorLayer( const QString &name, const QString &description, const QList<int> &types, const QVariant &defaultValue, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterVectorLayer::clone() const
{
  return new QgsProcessingParameterVectorLayer( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterVectorLayer::clone() const {…}
 
bool QgsProcessingParameterVectorLayer::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const
{
  QVariant var = v;
  if ( !var.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    var = defaultValue();
  }
 
  if ( var.userType() == qMetaTypeId<QgsProperty>() )
  {
    const QgsProperty p = var.value< QgsProperty >();
    if ( p.propertyType() == Qgis::PropertyType::Static )
    {
      var = p.staticValue();
    }
    else
    {
      return true;
    }
  }
 
  if ( qobject_cast< QgsVectorLayer * >( qvariant_cast<QObject *>( var ) ) )
    return true;
 
  if ( var.userType() != QMetaType::Type::QString || var.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( !context )
  {
    // that's as far as we can get without a context
    return true;
  }
 
  // try to load as layer
  if ( QgsProcessingUtils::mapLayerFromString( var.toString(), *context, true, QgsProcessingUtils::LayerHint::Vector ) )
    return true;
 
  return false;
}
bool QgsProcessingParameterVectorLayer::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const {…}
 
QString QgsProcessingParameterVectorLayer::valueAsPythonString( const QVariant &val, QgsProcessingContext &context ) const
{
  if ( !val.isValid() )
    return QStringLiteral( "None" );
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( val.value< QgsProperty >().asExpression() );
 
  QVariantMap p;
  p.insert( name(), val );
  QgsVectorLayer *layer = QgsProcessingParameters::parameterAsVectorLayer( this, p, context );
  return layer ? QgsProcessingUtils::stringToPythonLiteral( QgsProcessingUtils::layerToStringIdentifier( layer ) )
         : QgsProcessingUtils::stringToPythonLiteral( val.toString() );
}
QString QgsProcessingParameterVectorLayer::valueAsPythonString( const QVariant &val, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterVectorLayer::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const
{
  return valueAsStringPrivate( value, context, ok, ValueAsStringFlag::AllowMapLayerValues );
}
QString QgsProcessingParameterVectorLayer::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const {…}
 
QVariant QgsProcessingParameterVectorLayer::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const
{
  return valueAsJsonObjectPrivate( value, context, ValueAsStringFlag::AllowMapLayerValues );
}
QVariant QgsProcessingParameterVectorLayer::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterVectorLayer::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterVectorLayer('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      if ( !mDataTypes.empty() )
      {
        QStringList options;
        for ( const int t : mDataTypes )
          options << QStringLiteral( "QgsProcessing.%1" ).arg( QgsProcessing::sourceTypeToString( static_cast< Qgis::ProcessingSourceType >( t ) ) );
        code += QStringLiteral( ", types=[%1]" ).arg( options.join( ',' ) );
      }
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterVectorLayer::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QString QgsProcessingParameterVectorLayer::createFileFilter() const
{
  return QgsProviderRegistry::instance()->fileVectorFilters() + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
}
QString QgsProcessingParameterVectorLayer::createFileFilter() const {…}
 
QList<int> QgsProcessingParameterLimitedDataTypes::dataTypes() const
{
  return mDataTypes;
}
QList<int> QgsProcessingParameterLimitedDataTypes::dataTypes() const {…}
 
void QgsProcessingParameterLimitedDataTypes::setDataTypes( const QList<int> &types )
{
  mDataTypes = types;
}
void QgsProcessingParameterLimitedDataTypes::setDataTypes( const QList<int> &types ) {…}
 
QVariantMap QgsProcessingParameterVectorLayer::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  QVariantList types;
  for ( const int type : mDataTypes )
  {
    types << type;
  }
  map.insert( QStringLiteral( "data_types" ), types );
  return map;
}
QVariantMap QgsProcessingParameterVectorLayer::toVariantMap() const {…}
 
bool QgsProcessingParameterVectorLayer::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mDataTypes.clear();
  const QVariantList values = map.value( QStringLiteral( "data_types" ) ).toList();
  for ( const QVariant &val : values )
  {
    mDataTypes << val.toInt();
  }
  return true;
}
bool QgsProcessingParameterVectorLayer::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterVectorLayer *QgsProcessingParameterVectorLayer::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterVectorLayer( name, description, QList< int>(),  definition.isEmpty() ? QVariant() : definition, isOptional );
}
QgsProcessingParameterVectorLayer *QgsProcessingParameterVectorLayer::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterMeshLayer::QgsProcessingParameterMeshLayer( const QString &name, const QString &description,
    const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
{
 
}
QgsProcessingParameterMeshLayer::QgsProcessingParameterMeshLayer( const QString &name, const QString &description, {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterMeshLayer::clone() const
{
  return new QgsProcessingParameterMeshLayer( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterMeshLayer::clone() const {…}
 
bool QgsProcessingParameterMeshLayer::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const
{
  QVariant var = v;
 
  if ( !var.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    var = defaultValue();
  }
 
  if ( var.userType() == qMetaTypeId<QgsProperty>() )
  {
    const QgsProperty p = var.value< QgsProperty >();
    if ( p.propertyType() == Qgis::PropertyType::Static )
    {
      var = p.staticValue();
    }
    else
    {
      return true;
    }
  }
 
  if ( qobject_cast< QgsMeshLayer * >( qvariant_cast<QObject *>( var ) ) )
    return true;
 
  if ( var.userType() != QMetaType::Type::QString || var.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( !context )
  {
    // that's as far as we can get without a context
    return true;
  }
 
  // try to load as layer
  if ( QgsProcessingUtils::mapLayerFromString( var.toString(), *context, true, QgsProcessingUtils::LayerHint::Mesh ) )
    return true;
 
  return false;
}
bool QgsProcessingParameterMeshLayer::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const {…}
 
QString QgsProcessingParameterMeshLayer::valueAsPythonString( const QVariant &val, QgsProcessingContext &context ) const
{
  if ( !val.isValid() )
    return QStringLiteral( "None" );
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( val.value< QgsProperty >().asExpression() );
 
  QVariantMap p;
  p.insert( name(), val );
  QgsMeshLayer *layer = QgsProcessingParameters::parameterAsMeshLayer( this, p, context );
  return layer ? QgsProcessingUtils::stringToPythonLiteral( QgsProcessingUtils::layerToStringIdentifier( layer ) )
         : QgsProcessingUtils::stringToPythonLiteral( val.toString() );
}
QString QgsProcessingParameterMeshLayer::valueAsPythonString( const QVariant &val, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterMeshLayer::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const
{
  return valueAsStringPrivate( value, context, ok, ValueAsStringFlag::AllowMapLayerValues );
}
QString QgsProcessingParameterMeshLayer::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const {…}
 
QVariant QgsProcessingParameterMeshLayer::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const
{
  return valueAsJsonObjectPrivate( value, context, ValueAsStringFlag::AllowMapLayerValues );
}
QVariant QgsProcessingParameterMeshLayer::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterMeshLayer::createFileFilter() const
{
  return QgsProviderRegistry::instance()->fileMeshFilters() + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
}
QString QgsProcessingParameterMeshLayer::createFileFilter() const {…}
 
QgsProcessingParameterMeshLayer *QgsProcessingParameterMeshLayer::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterMeshLayer( name, description,  definition.isEmpty() ? QVariant() : definition, isOptional );
}
QgsProcessingParameterMeshLayer *QgsProcessingParameterMeshLayer::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterField::QgsProcessingParameterField( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentLayerParameterName, Qgis::ProcessingFieldParameterDataType type, bool allowMultiple, bool optional, bool defaultToAllFields )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mParentLayerParameterName( parentLayerParameterName )
  , mDataType( type )
  , mAllowMultiple( allowMultiple )
  , mDefaultToAllFields( defaultToAllFields )
{
 
}
QgsProcessingParameterField::QgsProcessingParameterField( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentLayerParameterName, Qgis::ProcessingFieldParameterDataType type, bool allowMultiple, bool optional, bool defaultToAllFields ) {…}
 
 
QgsProcessingParameterDefinition *QgsProcessingParameterField::clone() const
{
  return new QgsProcessingParameterField( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterField::clone() const {…}
 
bool QgsProcessingParameterField::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const
{
  QVariant input = v;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  if ( input.userType() == QMetaType::Type::QVariantList || input.userType() == QMetaType::Type::QStringList )
  {
    if ( !mAllowMultiple )
      return false;
 
    if ( input.toList().isEmpty() && !( mFlags & Qgis::ProcessingParameterFlag::Optional ) )
      return false;
  }
  else if ( input.userType() == QMetaType::Type::QString )
  {
    if ( input.toString().isEmpty() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    const QStringList parts = input.toString().split( ';' );
    if ( parts.count() > 1 && !mAllowMultiple )
      return false;
  }
  else
  {
    if ( input.toString().isEmpty() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
  }
  return true;
}
bool QgsProcessingParameterField::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterField::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.userType() == QMetaType::Type::QVariantList )
  {
    QStringList parts;
    const auto constToList = value.toList();
    for ( const QVariant &val : constToList )
    {
      parts << QgsProcessingUtils::stringToPythonLiteral( val.toString() );
    }
    return parts.join( ',' ).prepend( '[' ).append( ']' );
  }
  else if ( value.userType() == QMetaType::Type::QStringList )
  {
    QStringList parts;
    const auto constToStringList = value.toStringList();
    for ( const QString &s : constToStringList )
    {
      parts << QgsProcessingUtils::stringToPythonLiteral( s );
    }
    return parts.join( ',' ).prepend( '[' ).append( ']' );
  }
 
  return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
}
QString QgsProcessingParameterField::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterField::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "field " );
 
  switch ( mDataType )
  {
    case Qgis::ProcessingFieldParameterDataType::Numeric:
      code += QLatin1String( "numeric " );
      break;
 
    case Qgis::ProcessingFieldParameterDataType::String:
      code += QLatin1String( "string " );
      break;
 
    case Qgis::ProcessingFieldParameterDataType::DateTime:
      code += QLatin1String( "datetime " );
      break;
 
    case Qgis::ProcessingFieldParameterDataType::Binary:
      code += QLatin1String( "binary " );
      break;
 
    case Qgis::ProcessingFieldParameterDataType::Boolean:
      code += QLatin1String( "boolean " );
      break;
 
    case Qgis::ProcessingFieldParameterDataType::Any:
      break;
  }
 
  if ( mAllowMultiple )
    code += QLatin1String( "multiple " );
 
  if ( mDefaultToAllFields )
    code += QLatin1String( "default_to_all_fields " );
 
  code += mParentLayerParameterName + ' ';
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterField::asScriptCode() const {…}
 
QString QgsProcessingParameterField::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterField('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      QString dataType;
      switch ( mDataType )
      {
        case Qgis::ProcessingFieldParameterDataType::Any:
          dataType = QStringLiteral( "QgsProcessingParameterField.Any" );
          break;
 
        case Qgis::ProcessingFieldParameterDataType::Numeric:
          dataType = QStringLiteral( "QgsProcessingParameterField.Numeric" );
          break;
 
        case Qgis::ProcessingFieldParameterDataType::String:
          dataType = QStringLiteral( "QgsProcessingParameterField.String" );
          break;
 
        case Qgis::ProcessingFieldParameterDataType::DateTime:
          dataType = QStringLiteral( "QgsProcessingParameterField.DateTime" );
          break;
 
        case Qgis::ProcessingFieldParameterDataType::Binary:
          dataType = QStringLiteral( "QgsProcessingParameterField.Binary" );
          break;
 
        case Qgis::ProcessingFieldParameterDataType::Boolean:
          dataType = QStringLiteral( "QgsProcessingParameterField.Boolean" );
          break;
      }
      code += QStringLiteral( ", type=%1" ).arg( dataType );
 
      code += QStringLiteral( ", parentLayerParameterName='%1'" ).arg( mParentLayerParameterName );
      code += QStringLiteral( ", allowMultiple=%1" ).arg( mAllowMultiple ? QStringLiteral( "True" ) : QStringLiteral( "False" ) );
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1" ).arg( valueAsPythonString( mDefault, c ) );
 
      if ( mDefaultToAllFields )
        code += QLatin1String( ", defaultToAllFields=True" );
 
      code += ')';
 
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterField::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QStringList QgsProcessingParameterField::dependsOnOtherParameters() const
{
  QStringList depends;
  if ( !mParentLayerParameterName.isEmpty() )
    depends << mParentLayerParameterName;
  return depends;
}
QStringList QgsProcessingParameterField::dependsOnOtherParameters() const {…}
 
QString QgsProcessingParameterField::parentLayerParameterName() const
{
  return mParentLayerParameterName;
}
QString QgsProcessingParameterField::parentLayerParameterName() const {…}
 
void QgsProcessingParameterField::setParentLayerParameterName( const QString &parentLayerParameterName )
{
  mParentLayerParameterName = parentLayerParameterName;
}
void QgsProcessingParameterField::setParentLayerParameterName( const QString &parentLayerParameterName ) {…}
 
Qgis::ProcessingFieldParameterDataType QgsProcessingParameterField::dataType() const
{
  return mDataType;
}
Qgis::ProcessingFieldParameterDataType QgsProcessingParameterField::dataType() const {…}
 
void QgsProcessingParameterField::setDataType( Qgis::ProcessingFieldParameterDataType dataType )
{
  mDataType = dataType;
}
void QgsProcessingParameterField::setDataType( Qgis::ProcessingFieldParameterDataType dataType ) {…}
 
bool QgsProcessingParameterField::allowMultiple() const
{
  return mAllowMultiple;
}
bool QgsProcessingParameterField::allowMultiple() const {…}
 
void QgsProcessingParameterField::setAllowMultiple( bool allowMultiple )
{
  mAllowMultiple = allowMultiple;
}
void QgsProcessingParameterField::setAllowMultiple( bool allowMultiple ) {…}
 
bool QgsProcessingParameterField::defaultToAllFields() const
{
  return mDefaultToAllFields;
}
bool QgsProcessingParameterField::defaultToAllFields() const {…}
 
void QgsProcessingParameterField::setDefaultToAllFields( bool enabled )
{
  mDefaultToAllFields = enabled;
}
void QgsProcessingParameterField::setDefaultToAllFields( bool enabled ) {…}
 
QVariantMap QgsProcessingParameterField::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "parent_layer" ), mParentLayerParameterName );
  map.insert( QStringLiteral( "data_type" ), static_cast< int >( mDataType ) );
  map.insert( QStringLiteral( "allow_multiple" ), mAllowMultiple );
  map.insert( QStringLiteral( "default_to_all_fields" ), mDefaultToAllFields );
  return map;
}
QVariantMap QgsProcessingParameterField::toVariantMap() const {…}
 
bool QgsProcessingParameterField::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mParentLayerParameterName = map.value( QStringLiteral( "parent_layer" ) ).toString();
  mDataType = static_cast< Qgis::ProcessingFieldParameterDataType >( map.value( QStringLiteral( "data_type" ) ).toInt() );
  mAllowMultiple = map.value( QStringLiteral( "allow_multiple" ) ).toBool();
  mDefaultToAllFields = map.value( QStringLiteral( "default_to_all_fields" ) ).toBool();
  return true;
}
bool QgsProcessingParameterField::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterField *QgsProcessingParameterField::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString parent;
  Qgis::ProcessingFieldParameterDataType type = Qgis::ProcessingFieldParameterDataType::Any;
  bool allowMultiple = false;
  bool defaultToAllFields = false;
  QString def = definition;
 
  if ( def.startsWith( QLatin1String( "numeric " ), Qt::CaseInsensitive ) )
  {
    type = Qgis::ProcessingFieldParameterDataType::Numeric;
    def = def.mid( 8 );
  }
  else if ( def.startsWith( QLatin1String( "string " ), Qt::CaseInsensitive ) )
  {
    type = Qgis::ProcessingFieldParameterDataType::String;
    def = def.mid( 7 );
  }
  else if ( def.startsWith( QLatin1String( "datetime " ), Qt::CaseInsensitive ) )
  {
    type = Qgis::ProcessingFieldParameterDataType::DateTime;
    def = def.mid( 9 );
  }
  else if ( def.startsWith( QLatin1String( "binary " ), Qt::CaseInsensitive ) )
  {
    type = Qgis::ProcessingFieldParameterDataType::Binary;
    def = def.mid( 7 );
  }
  else if ( def.startsWith( QLatin1String( "boolean " ), Qt::CaseInsensitive ) )
  {
    type = Qgis::ProcessingFieldParameterDataType::Boolean;
    def = def.mid( 8 );
  }
 
  if ( def.startsWith( QLatin1String( "multiple" ), Qt::CaseInsensitive ) )
  {
    allowMultiple = true;
    def = def.mid( 8 ).trimmed();
  }
 
  if ( def.startsWith( QLatin1String( "default_to_all_fields" ), Qt::CaseInsensitive ) )
  {
    defaultToAllFields = true;
    def = def.mid( 21 ).trimmed();
  }
 
  const thread_local QRegularExpression re( QStringLiteral( "(.*?)\\s+(.*)$" ) );
  const QRegularExpressionMatch m = re.match( def );
  if ( m.hasMatch() )
  {
    parent = m.captured( 1 ).trimmed();
    def = m.captured( 2 );
  }
  else
  {
    parent = def;
    def.clear();
  }
 
  return new QgsProcessingParameterField( name, description, def.isEmpty() ? QVariant() : def, parent, type, allowMultiple, isOptional, defaultToAllFields );
}
QgsProcessingParameterField *QgsProcessingParameterField::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterFeatureSource::QgsProcessingParameterFeatureSource( const QString &name, const QString &description, const QList<int> &types, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , QgsProcessingParameterLimitedDataTypes( types )
{
 
}
QgsProcessingParameterFeatureSource::QgsProcessingParameterFeatureSource( const QString &name, const QString &description, const QList<int> &types, const QVariant &defaultValue, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterFeatureSource::clone() const
{
  return new QgsProcessingParameterFeatureSource( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterFeatureSource::clone() const {…}
 
bool QgsProcessingParameterFeatureSource::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context ) const
{
  QVariant var = input;
  if ( !var.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    var = defaultValue();
  }
 
  if ( var.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
  {
    const QgsProcessingFeatureSourceDefinition fromVar = qvariant_cast<QgsProcessingFeatureSourceDefinition>( var );
    var = fromVar.source;
  }
  else if ( var.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    // input is a QgsProcessingOutputLayerDefinition - get extra properties from it
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( var );
    var = fromVar.sink;
  }
 
  if ( var.userType() == qMetaTypeId<QgsProperty>() )
  {
    const QgsProperty p = var.value< QgsProperty >();
    if ( p.propertyType() == Qgis::PropertyType::Static )
    {
      var = p.staticValue();
    }
    else
    {
      return true;
    }
  }
  if ( qobject_cast< QgsVectorLayer * >( qvariant_cast<QObject *>( input ) ) )
  {
    return true;
  }
 
  if ( var.userType() != QMetaType::Type::QString || var.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( !context )
  {
    // that's as far as we can get without a context
    return true;
  }
 
  // try to load as layer
  if ( QgsProcessingUtils::mapLayerFromString( var.toString(), *context, true, QgsProcessingUtils::LayerHint::Vector ) )
    return true;
 
  return false;
}
bool QgsProcessingParameterFeatureSource::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context ) const {…}
 
QString QgsProcessingParameterFeatureSource::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression(%1)" ).arg( QgsProcessingUtils::stringToPythonLiteral( value.value< QgsProperty >().asExpression() ) );
 
  if ( value.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
  {
    const QgsProcessingFeatureSourceDefinition fromVar = qvariant_cast<QgsProcessingFeatureSourceDefinition>( value );
    QString geometryCheckString;
    switch ( fromVar.geometryCheck )
    {
      case Qgis::InvalidGeometryCheck::NoCheck:
        geometryCheckString = QStringLiteral( "QgsFeatureRequest.GeometryNoCheck" );
        break;
 
      case Qgis::InvalidGeometryCheck::SkipInvalid:
        geometryCheckString = QStringLiteral( "QgsFeatureRequest.GeometrySkipInvalid" );
        break;
 
      case Qgis::InvalidGeometryCheck::AbortOnInvalid:
        geometryCheckString = QStringLiteral( "QgsFeatureRequest.GeometryAbortOnInvalid" );
        break;
    }
 
    QStringList flags;
    QString flagString;
    if ( fromVar.flags & Qgis::ProcessingFeatureSourceDefinitionFlag::OverrideDefaultGeometryCheck )
      flags << QStringLiteral( "QgsProcessingFeatureSourceDefinition.FlagOverrideDefaultGeometryCheck" );
    if ( fromVar.flags & Qgis::ProcessingFeatureSourceDefinitionFlag::CreateIndividualOutputPerInputFeature )
      flags << QStringLiteral( "QgsProcessingFeatureSourceDefinition.FlagCreateIndividualOutputPerInputFeature" );
    if ( !flags.empty() )
      flagString = flags.join( QLatin1String( " | " ) );
 
    if ( fromVar.source.propertyType() == Qgis::PropertyType::Static )
    {
      QString layerString = fromVar.source.staticValue().toString();
      // prefer to use layer source instead of id if possible (since it's persistent)
      if ( QgsVectorLayer *layer = qobject_cast< QgsVectorLayer * >( QgsProcessingUtils::mapLayerFromString( layerString, context, true, QgsProcessingUtils::LayerHint::Vector ) ) )
        layerString = layer->source();
 
      if ( fromVar.selectedFeaturesOnly || fromVar.featureLimit != -1 || fromVar.flags || !fromVar.filterExpression.isEmpty() )
      {
        return QStringLiteral( "QgsProcessingFeatureSourceDefinition(%1, selectedFeaturesOnly=%2, featureLimit=%3%4%6, geometryCheck=%5)" ).arg( QgsProcessingUtils::stringToPythonLiteral( layerString ),
               fromVar.selectedFeaturesOnly ? QStringLiteral( "True" ) : QStringLiteral( "False" ),
               QString::number( fromVar.featureLimit ),
               flagString.isEmpty() ? QString() : ( QStringLiteral( ", flags=%1" ).arg( flagString ) ),
               geometryCheckString,
               fromVar.filterExpression.isEmpty() ? QString() : ( QStringLiteral( ", filterExpression=%1" ).arg( QgsProcessingUtils::stringToPythonLiteral( fromVar.filterExpression ) ) ) );
      }
      else
      {
        return QgsProcessingUtils::stringToPythonLiteral( layerString );
      }
    }
    else
    {
      if ( fromVar.selectedFeaturesOnly || fromVar.featureLimit != -1 || fromVar.flags || !fromVar.filterExpression.isEmpty() )
      {
        return QStringLiteral( "QgsProcessingFeatureSourceDefinition(QgsProperty.fromExpression(%1), selectedFeaturesOnly=%2, featureLimit=%3%4%6, geometryCheck=%5)" )
               .arg( QgsProcessingUtils::stringToPythonLiteral( fromVar.source.asExpression() ),
                     fromVar.selectedFeaturesOnly ? QStringLiteral( "True" ) : QStringLiteral( "False" ),
                     QString::number( fromVar.featureLimit ),
                     flagString.isEmpty() ? QString() : ( QStringLiteral( ", flags=%1" ).arg( flagString ) ),
                     geometryCheckString,
                     fromVar.filterExpression.isEmpty() ? QString() : ( QStringLiteral( ", filterExpression=%1" ).arg( QgsProcessingUtils::stringToPythonLiteral( fromVar.filterExpression ) ) ) );
      }
      else
      {
        return QStringLiteral( "QgsProperty.fromExpression(%1)" ).arg( QgsProcessingUtils::stringToPythonLiteral( fromVar.source.asExpression() ) );
      }
    }
  }
  else if ( QgsVectorLayer *layer = qobject_cast< QgsVectorLayer * >( qvariant_cast<QObject *>( value ) ) )
  {
    return QgsProcessingUtils::stringToPythonLiteral( layer->source() );
  }
 
  QString layerString = value.toString();
 
  // prefer to use layer source if possible (since it's persistent)
  if ( QgsVectorLayer *layer = qobject_cast< QgsVectorLayer * >( QgsProcessingUtils::mapLayerFromString( layerString, context, true, QgsProcessingUtils::LayerHint::Vector ) ) )
    layerString = layer->providerType() != QLatin1String( "ogr" ) && layer->providerType() != QLatin1String( "gdal" ) && layer->providerType() != QLatin1String( "mdal" ) ? QgsProcessingUtils::encodeProviderKeyAndUri( layer->providerType(), layer->source() ) : layer->source();
 
  return QgsProcessingUtils::stringToPythonLiteral( layerString );
}
QString QgsProcessingParameterFeatureSource::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterFeatureSource::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const
{
  return valueAsStringPrivate( value, context, ok, ValueAsStringFlag::AllowMapLayerValues );
}
QString QgsProcessingParameterFeatureSource::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const {…}
 
QVariant QgsProcessingParameterFeatureSource::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const
{
  return valueAsJsonObjectPrivate( value, context, ValueAsStringFlag::AllowMapLayerValues );
}
QVariant QgsProcessingParameterFeatureSource::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterFeatureSource::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "source " );
 
  for ( const int type : mDataTypes )
  {
    switch ( static_cast< Qgis::ProcessingSourceType >( type ) )
    {
      case Qgis::ProcessingSourceType::VectorPoint:
        code += QLatin1String( "point " );
        break;
 
      case Qgis::ProcessingSourceType::VectorLine:
        code += QLatin1String( "line " );
        break;
 
      case Qgis::ProcessingSourceType::VectorPolygon:
        code += QLatin1String( "polygon " );
        break;
 
      default:
        break;
    }
  }
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterFeatureSource::asScriptCode() const {…}
 
QString QgsProcessingParameterFeatureSource::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterFeatureSource('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      if ( !mDataTypes.empty() )
      {
        QStringList options;
        options.reserve( mDataTypes.size() );
        for ( const int t : mDataTypes )
          options << QStringLiteral( "QgsProcessing.%1" ).arg( QgsProcessing::sourceTypeToString( static_cast< Qgis::ProcessingSourceType >( t ) ) );
        code += QStringLiteral( ", types=[%1]" ).arg( options.join( ',' ) );
      }
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterFeatureSource::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QString QgsProcessingParameterFeatureSource::createFileFilter() const
{
  return QgsProviderRegistry::instance()->fileVectorFilters() + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
}
QString QgsProcessingParameterFeatureSource::createFileFilter() const {…}
 
QgsProcessingParameterLimitedDataTypes::QgsProcessingParameterLimitedDataTypes( const QList<int> &types )
  : mDataTypes( types )
{
 
}
QgsProcessingParameterLimitedDataTypes::QgsProcessingParameterLimitedDataTypes( const QList<int> &types ) {…}
 
QVariantMap QgsProcessingParameterFeatureSource::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  QVariantList types;
  for ( const int type : mDataTypes )
  {
    types << type;
  }
  map.insert( QStringLiteral( "data_types" ), types );
  return map;
}
QVariantMap QgsProcessingParameterFeatureSource::toVariantMap() const {…}
 
bool QgsProcessingParameterFeatureSource::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mDataTypes.clear();
  const QVariantList values = map.value( QStringLiteral( "data_types" ) ).toList();
  for ( const QVariant &val : values )
  {
    mDataTypes << val.toInt();
  }
  return true;
}
bool QgsProcessingParameterFeatureSource::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterFeatureSource *QgsProcessingParameterFeatureSource::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QList< int > types;
  QString def = definition;
  while ( true )
  {
    if ( def.startsWith( QLatin1String( "point" ), Qt::CaseInsensitive ) )
    {
      types << static_cast< int >( Qgis::ProcessingSourceType::VectorPoint );
      def = def.mid( 6 );
      continue;
    }
    else if ( def.startsWith( QLatin1String( "line" ), Qt::CaseInsensitive ) )
    {
      types << static_cast< int >( Qgis::ProcessingSourceType::VectorLine );
      def = def.mid( 5 );
      continue;
    }
    else if ( def.startsWith( QLatin1String( "polygon" ), Qt::CaseInsensitive ) )
    {
      types << static_cast< int >( Qgis::ProcessingSourceType::VectorPolygon );
      def = def.mid( 8 );
      continue;
    }
    break;
  }
 
  return new QgsProcessingParameterFeatureSource( name, description, types, def.isEmpty() ? QVariant() : def, isOptional );
}
QgsProcessingParameterFeatureSource *QgsProcessingParameterFeatureSource::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterFeatureSink::QgsProcessingParameterFeatureSink( const QString &name, const QString &description, Qgis::ProcessingSourceType type, const QVariant &defaultValue, bool optional, bool createByDefault, bool supportsAppend )
  : QgsProcessingDestinationParameter( name, description, defaultValue, optional, createByDefault )
  , mDataType( type )
  , mSupportsAppend( supportsAppend )
{
}
QgsProcessingParameterFeatureSink::QgsProcessingParameterFeatureSink( const QString &name, const QString &description, Qgis::ProcessingSourceType type, const QVariant &defaultValue, bool optional, bool createByDefault, bool supportsAppend ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterFeatureSink::clone() const
{
  return new QgsProcessingParameterFeatureSink( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterFeatureSink::clone() const {…}
 
bool QgsProcessingParameterFeatureSink::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const
{
  QVariant var = input;
  if ( !var.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    var = defaultValue();
  }
 
  if ( var.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( var );
    var = fromVar.sink;
  }
 
  if ( var.userType() == qMetaTypeId<QgsProperty>() )
  {
    const QgsProperty p = var.value< QgsProperty >();
    if ( p.propertyType() == Qgis::PropertyType::Static )
    {
      var = p.staticValue();
    }
    else
    {
      return true;
    }
  }
 
  if ( var.userType() != QMetaType::Type::QString )
    return false;
 
  if ( var.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  return true;
}
bool QgsProcessingParameterFeatureSink::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterFeatureSink::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( value );
    if ( fromVar.sink.propertyType() == Qgis::PropertyType::Static )
    {
      return QgsProcessingUtils::stringToPythonLiteral( fromVar.sink.staticValue().toString() );
    }
    else
    {
      return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( fromVar.sink.asExpression() );
    }
  }
 
  return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
}
QString QgsProcessingParameterFeatureSink::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterFeatureSink::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "sink " );
 
  switch ( mDataType )
  {
    case Qgis::ProcessingSourceType::VectorPoint:
      code += QLatin1String( "point " );
      break;
 
    case Qgis::ProcessingSourceType::VectorLine:
      code += QLatin1String( "line " );
      break;
 
    case Qgis::ProcessingSourceType::VectorPolygon:
      code += QLatin1String( "polygon " );
      break;
 
    case Qgis::ProcessingSourceType::Vector:
      code += QLatin1String( "table " );
      break;
 
    default:
      break;
  }
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterFeatureSink::asScriptCode() const {…}
 
QgsProcessingOutputDefinition *QgsProcessingParameterFeatureSink::toOutputDefinition() const
{
  return new QgsProcessingOutputVectorLayer( name(), description(), mDataType );
}
QgsProcessingOutputDefinition *QgsProcessingParameterFeatureSink::toOutputDefinition() const {…}
 
QString QgsProcessingParameterFeatureSink::defaultFileExtension() const
{
  if ( auto *lOriginalProvider = originalProvider() )
  {
    return lOriginalProvider->defaultVectorFileExtension( hasGeometry() );
  }
  else if ( QgsProcessingProvider *p = provider() )
  {
    return p->defaultVectorFileExtension( hasGeometry() );
  }
  else
  {
    if ( hasGeometry() )
    {
      return QgsProcessingUtils::defaultVectorExtension();
    }
    else
    {
      return QStringLiteral( "dbf" );
    }
  }
}
QString QgsProcessingParameterFeatureSink::defaultFileExtension() const {…}
 
QString QgsProcessingParameterFeatureSink::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterFeatureSink('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", type=QgsProcessing.%1" ).arg( QgsProcessing::sourceTypeToString( mDataType ) );
 
      code += QStringLiteral( ", createByDefault=%1" ).arg( createByDefault() ? QStringLiteral( "True" ) : QStringLiteral( "False" ) );
      if ( mSupportsAppend )
        code += QLatin1String( ", supportsAppend=True" );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterFeatureSink::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QString QgsProcessingParameterFeatureSink::createFileFilter() const
{
  const QStringList exts = supportedOutputVectorLayerExtensions();
  QStringList filters;
  for ( const QString &ext : exts )
  {
    filters << QObject::tr( "%1 files (*.%2)" ).arg( ext.toUpper(), ext.toLower() );
  }
  return filters.join( QLatin1String( ";;" ) ) + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
 
}
QString QgsProcessingParameterFeatureSink::createFileFilter() const {…}
 
QStringList QgsProcessingParameterFeatureSink::supportedOutputVectorLayerExtensions() const
{
  if ( auto *lOriginalProvider = originalProvider() )
  {
    if ( hasGeometry() )
      return lOriginalProvider->supportedOutputVectorLayerExtensions();
    else
      return lOriginalProvider->supportedOutputTableExtensions();
  }
  else if ( QgsProcessingProvider *p = provider() )
  {
    if ( hasGeometry() )
      return p->supportedOutputVectorLayerExtensions();
    else
      return p->supportedOutputTableExtensions();
  }
  else
  {
    return QgsVectorFileWriter::supportedFormatExtensions();
  }
}
QStringList QgsProcessingParameterFeatureSink::supportedOutputVectorLayerExtensions() const {…}
 
Qgis::ProcessingSourceType QgsProcessingParameterFeatureSink::dataType() const
{
  return mDataType;
}
Qgis::ProcessingSourceType QgsProcessingParameterFeatureSink::dataType() const {…}
 
bool QgsProcessingParameterFeatureSink::hasGeometry() const
{
  switch ( mDataType )
  {
    case Qgis::ProcessingSourceType::MapLayer:
    case Qgis::ProcessingSourceType::VectorAnyGeometry:
    case Qgis::ProcessingSourceType::VectorPoint:
    case Qgis::ProcessingSourceType::VectorLine:
    case Qgis::ProcessingSourceType::VectorPolygon:
    case Qgis::ProcessingSourceType::VectorTile:
      return true;
 
    case Qgis::ProcessingSourceType::Raster:
    case Qgis::ProcessingSourceType::File:
    case Qgis::ProcessingSourceType::Vector:
    case Qgis::ProcessingSourceType::Mesh:
    case Qgis::ProcessingSourceType::Plugin:
    case Qgis::ProcessingSourceType::PointCloud:
    case Qgis::ProcessingSourceType::Annotation:
      return false;
  }
  return true;
}
bool QgsProcessingParameterFeatureSink::hasGeometry() const {…}
 
void QgsProcessingParameterFeatureSink::setDataType( Qgis::ProcessingSourceType type )
{
  mDataType = type;
}
void QgsProcessingParameterFeatureSink::setDataType( Qgis::ProcessingSourceType type ) {…}
 
QVariantMap QgsProcessingParameterFeatureSink::toVariantMap() const
{
  QVariantMap map = QgsProcessingDestinationParameter::toVariantMap();
  map.insert( QStringLiteral( "data_type" ), static_cast< int >( mDataType ) );
  map.insert( QStringLiteral( "supports_append" ), mSupportsAppend );
  return map;
}
QVariantMap QgsProcessingParameterFeatureSink::toVariantMap() const {…}
 
bool QgsProcessingParameterFeatureSink::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingDestinationParameter::fromVariantMap( map );
  mDataType = static_cast< Qgis::ProcessingSourceType >( map.value( QStringLiteral( "data_type" ) ).toInt() );
  mSupportsAppend = map.value( QStringLiteral( "supports_append" ), false ).toBool();
  return true;
}
bool QgsProcessingParameterFeatureSink::fromVariantMap( const QVariantMap &map ) {…}
 
QString QgsProcessingParameterFeatureSink::generateTemporaryDestination( const QgsProcessingContext *context ) const
{
  if ( supportsNonFileBasedOutput() )
    return QStringLiteral( "memory:%1" ).arg( description() );
  else
    return QgsProcessingDestinationParameter::generateTemporaryDestination( context );
}
QString QgsProcessingParameterFeatureSink::generateTemporaryDestination( const QgsProcessingContext *context ) const {…}
 
QgsProcessingParameterFeatureSink *QgsProcessingParameterFeatureSink::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  Qgis::ProcessingSourceType type = Qgis::ProcessingSourceType::VectorAnyGeometry;
  QString def = definition;
  if ( def.startsWith( QLatin1String( "point" ), Qt::CaseInsensitive ) )
  {
    type = Qgis::ProcessingSourceType::VectorPoint;
    def = def.mid( 6 );
  }
  else if ( def.startsWith( QLatin1String( "line" ), Qt::CaseInsensitive ) )
  {
    type = Qgis::ProcessingSourceType::VectorLine;
    def = def.mid( 5 );
  }
  else if ( def.startsWith( QLatin1String( "polygon" ), Qt::CaseInsensitive ) )
  {
    type = Qgis::ProcessingSourceType::VectorPolygon;
    def = def.mid( 8 );
  }
  else if ( def.startsWith( QLatin1String( "table" ), Qt::CaseInsensitive ) )
  {
    type = Qgis::ProcessingSourceType::Vector;
    def = def.mid( 6 );
  }
 
  return new QgsProcessingParameterFeatureSink( name, description, type, definition.trimmed().isEmpty() ? QVariant() : definition, isOptional );
}
QgsProcessingParameterFeatureSink *QgsProcessingParameterFeatureSink::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
bool QgsProcessingParameterFeatureSink::supportsAppend() const
{
  return mSupportsAppend;
}
bool QgsProcessingParameterFeatureSink::supportsAppend() const {…}
 
void QgsProcessingParameterFeatureSink::setSupportsAppend( bool supportsAppend )
{
  mSupportsAppend = supportsAppend;
}
void QgsProcessingParameterFeatureSink::setSupportsAppend( bool supportsAppend ) {…}
 
QgsProcessingParameterRasterDestination::QgsProcessingParameterRasterDestination( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, bool createByDefault )
  : QgsProcessingDestinationParameter( name, description, defaultValue, optional, createByDefault )
{
}
QgsProcessingParameterRasterDestination::QgsProcessingParameterRasterDestination( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, bool createByDefault ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterRasterDestination::clone() const
{
  return new QgsProcessingParameterRasterDestination( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterRasterDestination::clone() const {…}
 
bool QgsProcessingParameterRasterDestination::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const
{
  QVariant var = input;
  if ( !var.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    var = defaultValue();
  }
 
  if ( var.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( var );
    var = fromVar.sink;
  }
 
  if ( var.userType() == qMetaTypeId<QgsProperty>() )
  {
    const QgsProperty p = var.value< QgsProperty >();
    if ( p.propertyType() == Qgis::PropertyType::Static )
    {
      var = p.staticValue();
    }
    else
    {
      return true;
    }
  }
 
  if ( var.userType() != QMetaType::Type::QString )
    return false;
 
  if ( var.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  return true;
}
bool QgsProcessingParameterRasterDestination::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterRasterDestination::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( value );
    if ( fromVar.sink.propertyType() == Qgis::PropertyType::Static )
    {
      return QgsProcessingUtils::stringToPythonLiteral( fromVar.sink.staticValue().toString() );
    }
    else
    {
      return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( fromVar.sink.asExpression() );
    }
  }
 
  return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
}
QString QgsProcessingParameterRasterDestination::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QgsProcessingOutputDefinition *QgsProcessingParameterRasterDestination::toOutputDefinition() const
{
  return new QgsProcessingOutputRasterLayer( name(), description() );
}
QgsProcessingOutputDefinition *QgsProcessingParameterRasterDestination::toOutputDefinition() const {…}
 
QString QgsProcessingParameterRasterDestination::defaultFileExtension() const
{
  if ( auto *lOriginalProvider = originalProvider() )
  {
    return lOriginalProvider->defaultRasterFileExtension();
  }
  else if ( QgsProcessingProvider *p = provider() )
  {
    return p->defaultRasterFileExtension();
  }
  else
  {
    return QgsProcessingUtils::defaultRasterExtension();
  }
}
QString QgsProcessingParameterRasterDestination::defaultFileExtension() const {…}
 
QString QgsProcessingParameterRasterDestination::createFileFilter() const
{
  const QStringList exts = supportedOutputRasterLayerExtensions();
  QStringList filters;
  for ( const QString &ext : exts )
  {
    filters << QObject::tr( "%1 files (*.%2)" ).arg( ext.toUpper(), ext.toLower() );
  }
  return filters.join( QLatin1String( ";;" ) ) + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
}
QString QgsProcessingParameterRasterDestination::createFileFilter() const {…}
 
QStringList QgsProcessingParameterRasterDestination::supportedOutputRasterLayerExtensions() const
{
  if ( auto *lOriginalProvider = originalProvider() )
  {
    return lOriginalProvider->supportedOutputRasterLayerExtensions();
  }
  else if ( QgsProcessingProvider *p = provider() )
  {
    return p->supportedOutputRasterLayerExtensions();
  }
  else
  {
    return QgsRasterFileWriter::supportedFormatExtensions();
  }
}
QStringList QgsProcessingParameterRasterDestination::supportedOutputRasterLayerExtensions() const {…}
 
QgsProcessingParameterRasterDestination *QgsProcessingParameterRasterDestination::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterRasterDestination( name, description, definition.isEmpty() ? QVariant() : definition, isOptional );
}
QgsProcessingParameterRasterDestination *QgsProcessingParameterRasterDestination::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
 
QgsProcessingParameterFileDestination::QgsProcessingParameterFileDestination( const QString &name, const QString &description, const QString &fileFilter, const QVariant &defaultValue, bool optional, bool createByDefault )
  : QgsProcessingDestinationParameter( name, description, defaultValue, optional, createByDefault )
  , mFileFilter( fileFilter.isEmpty() ? QObject::tr( "All files (*.*)" ) : fileFilter )
{
 
}
QgsProcessingParameterFileDestination::QgsProcessingParameterFileDestination( const QString &name, const QString &description, const QString &fileFilter, const QVariant &defaultValue, bool optional, bool createByDefault ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterFileDestination::clone() const
{
  return new QgsProcessingParameterFileDestination( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterFileDestination::clone() const {…}
 
bool QgsProcessingParameterFileDestination::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const
{
  QVariant var = input;
  if ( !var.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    var = defaultValue();
  }
 
  if ( var.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( var );
    var = fromVar.sink;
  }
 
  if ( var.userType() == qMetaTypeId<QgsProperty>() )
  {
    const QgsProperty p = var.value< QgsProperty >();
    if ( p.propertyType() == Qgis::PropertyType::Static )
    {
      var = p.staticValue();
    }
    else
    {
      return true;
    }
  }
 
  if ( var.userType() != QMetaType::Type::QString )
    return false;
 
  if ( var.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  // possible enhancement - check that value is compatible with file filter?
 
  return true;
}
bool QgsProcessingParameterFileDestination::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterFileDestination::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( value );
    if ( fromVar.sink.propertyType() == Qgis::PropertyType::Static )
    {
      return QgsProcessingUtils::stringToPythonLiteral( fromVar.sink.staticValue().toString() );
    }
    else
    {
      return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( fromVar.sink.asExpression() );
    }
  }
 
  return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
}
QString QgsProcessingParameterFileDestination::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QgsProcessingOutputDefinition *QgsProcessingParameterFileDestination::toOutputDefinition() const
{
  if ( !mFileFilter.isEmpty() && mFileFilter.contains( QStringLiteral( "htm" ), Qt::CaseInsensitive ) )
  {
    return new QgsProcessingOutputHtml( name(), description() );
  }
  else
  {
    return new QgsProcessingOutputFile( name(), description() );
  }
}
QgsProcessingOutputDefinition *QgsProcessingParameterFileDestination::toOutputDefinition() const {…}
 
QString QgsProcessingParameterFileDestination::defaultFileExtension() const
{
  if ( mFileFilter.isEmpty() || mFileFilter == QObject::tr( "All files (*.*)" ) )
    return QStringLiteral( "file" );
 
  // get first extension from filter
  const thread_local QRegularExpression rx( QStringLiteral( ".*?\\(\\*\\.([a-zA-Z0-9._]+).*" ) );
  const QRegularExpressionMatch match = rx.match( mFileFilter );
  if ( !match.hasMatch() )
    return QStringLiteral( "file" );
 
  return match.captured( 1 );
}
QString QgsProcessingParameterFileDestination::defaultFileExtension() const {…}
 
QString QgsProcessingParameterFileDestination::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterFileDestination('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", fileFilter=%1" ).arg( QgsProcessingUtils::stringToPythonLiteral( mFileFilter ) );
 
      code += QStringLiteral( ", createByDefault=%1" ).arg( createByDefault() ? QStringLiteral( "True" ) : QStringLiteral( "False" ) );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterFileDestination::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QString QgsProcessingParameterFileDestination::createFileFilter() const
{
  return ( fileFilter().isEmpty() ? QString() : fileFilter() + QStringLiteral( ";;" ) ) + QObject::tr( "All files (*.*)" );
}
QString QgsProcessingParameterFileDestination::createFileFilter() const {…}
 
QString QgsProcessingParameterFileDestination::fileFilter() const
{
  return mFileFilter;
}
QString QgsProcessingParameterFileDestination::fileFilter() const {…}
 
void QgsProcessingParameterFileDestination::setFileFilter( const QString &fileFilter )
{
  mFileFilter = fileFilter;
}
void QgsProcessingParameterFileDestination::setFileFilter( const QString &fileFilter ) {…}
 
QVariantMap QgsProcessingParameterFileDestination::toVariantMap() const
{
  QVariantMap map = QgsProcessingDestinationParameter::toVariantMap();
  map.insert( QStringLiteral( "file_filter" ), mFileFilter );
  return map;
}
QVariantMap QgsProcessingParameterFileDestination::toVariantMap() const {…}
 
bool QgsProcessingParameterFileDestination::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingDestinationParameter::fromVariantMap( map );
  mFileFilter = map.value( QStringLiteral( "file_filter" ) ).toString();
  return true;
 
}
bool QgsProcessingParameterFileDestination::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterFileDestination *QgsProcessingParameterFileDestination::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterFileDestination( name, description, QString(), definition.isEmpty() ? QVariant() : definition, isOptional );
}
QgsProcessingParameterFileDestination *QgsProcessingParameterFileDestination::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterFolderDestination::QgsProcessingParameterFolderDestination( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, bool createByDefault )
  : QgsProcessingDestinationParameter( name, description, defaultValue, optional, createByDefault )
{}
QgsProcessingParameterFolderDestination::QgsProcessingParameterFolderDestination( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, bool createByDefault ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterFolderDestination::clone() const
{
  return new QgsProcessingParameterFolderDestination( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterFolderDestination::clone() const {…}
 
bool QgsProcessingParameterFolderDestination::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const
{
  QVariant var = input;
  if ( !var.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    var = defaultValue();
  }
 
  if ( var.userType() == qMetaTypeId<QgsProperty>() )
  {
    const QgsProperty p = var.value< QgsProperty >();
    if ( p.propertyType() == Qgis::PropertyType::Static )
    {
      var = p.staticValue();
    }
    else
    {
      return true;
    }
  }
 
  if ( var.userType() != QMetaType::Type::QString )
    return false;
 
  if ( var.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  return true;
}
bool QgsProcessingParameterFolderDestination::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const {…}
 
QgsProcessingOutputDefinition *QgsProcessingParameterFolderDestination::toOutputDefinition() const
{
  return new QgsProcessingOutputFolder( name(), description() );
}
QgsProcessingOutputDefinition *QgsProcessingParameterFolderDestination::toOutputDefinition() const {…}
 
QString QgsProcessingParameterFolderDestination::defaultFileExtension() const
{
  return QString();
}
QString QgsProcessingParameterFolderDestination::defaultFileExtension() const {…}
 
QgsProcessingParameterFolderDestination *QgsProcessingParameterFolderDestination::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterFolderDestination( name, description, definition.isEmpty() ? QVariant() : definition, isOptional );
}
QgsProcessingParameterFolderDestination *QgsProcessingParameterFolderDestination::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingDestinationParameter::QgsProcessingDestinationParameter( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, bool createByDefault )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mCreateByDefault( createByDefault )
{
 
}
QgsProcessingDestinationParameter::QgsProcessingDestinationParameter( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, bool createByDefault ) {…}
 
QVariantMap QgsProcessingDestinationParameter::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "supports_non_file_outputs" ), mSupportsNonFileBasedOutputs );
  map.insert( QStringLiteral( "create_by_default" ), mCreateByDefault );
  return map;
}
QVariantMap QgsProcessingDestinationParameter::toVariantMap() const {…}
 
bool QgsProcessingDestinationParameter::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mSupportsNonFileBasedOutputs = map.value( QStringLiteral( "supports_non_file_outputs" ) ).toBool();
  mCreateByDefault = map.value( QStringLiteral( "create_by_default" ), QStringLiteral( "1" ) ).toBool();
  return true;
}
bool QgsProcessingDestinationParameter::fromVariantMap( const QVariantMap &map ) {…}
 
QString QgsProcessingDestinationParameter::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      // base class method is probably not much use
      if ( QgsProcessingParameterType *t = QgsApplication::processingRegistry()->parameterType( type() ) )
      {
        QString code = t->className() + QStringLiteral( "('%1', %2" )
                       .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
        if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
          code += QLatin1String( ", optional=True" );
 
        code += QStringLiteral( ", createByDefault=%1" ).arg( mCreateByDefault ? QStringLiteral( "True" ) : QStringLiteral( "False" ) );
 
        QgsProcessingContext c;
        code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
        return code;
      }
      break;
    }
  }
  // oh well, we tried
  return QString();
}
QString QgsProcessingDestinationParameter::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QString QgsProcessingDestinationParameter::createFileFilter() const
{
  return QObject::tr( "Default extension" ) + QStringLiteral( " (*." ) + defaultFileExtension() + ')';
}
QString QgsProcessingDestinationParameter::createFileFilter() const {…}
 
QString QgsProcessingDestinationParameter::generateTemporaryDestination( const QgsProcessingContext *context ) const
{
  // sanitize name to avoid multiple . in the filename. E.g. when name() contain
  // backend command name having a "." inside as in case of grass commands
  const thread_local QRegularExpression rx( QStringLiteral( "[.]" ) );
  QString sanitizedName = name();
  sanitizedName.replace( rx, QStringLiteral( "_" ) );
 
  if ( defaultFileExtension().isEmpty() )
  {
    return QgsProcessingUtils::generateTempFilename( sanitizedName, context );
  }
  else
  {
    return QgsProcessingUtils::generateTempFilename( sanitizedName + '.' + defaultFileExtension(), context );
  }
}
QString QgsProcessingDestinationParameter::generateTemporaryDestination( const QgsProcessingContext *context ) const {…}
 
bool QgsProcessingDestinationParameter::isSupportedOutputValue( const QVariant &value, QgsProcessingContext &context, QString &error ) const
{
  if ( auto *lOriginalProvider = originalProvider() )
    return lOriginalProvider->isSupportedOutputValue( value, this, context, error );
  else if ( provider() )
    return provider()->isSupportedOutputValue( value, this, context, error );
 
  return true;
}
bool QgsProcessingDestinationParameter::isSupportedOutputValue( const QVariant &value, QgsProcessingContext &context, QString &error ) const {…}
 
bool QgsProcessingDestinationParameter::createByDefault() const
{
  return mCreateByDefault;
}
bool QgsProcessingDestinationParameter::createByDefault() const {…}
 
void QgsProcessingDestinationParameter::setCreateByDefault( bool createByDefault )
{
  mCreateByDefault = createByDefault;
}
void QgsProcessingDestinationParameter::setCreateByDefault( bool createByDefault ) {…}
 
QgsProcessingParameterVectorDestination::QgsProcessingParameterVectorDestination( const QString &name, const QString &description, Qgis::ProcessingSourceType type, const QVariant &defaultValue, bool optional, bool createByDefault )
  : QgsProcessingDestinationParameter( name, description, defaultValue, optional, createByDefault )
  , mDataType( type )
{
 
}
QgsProcessingParameterVectorDestination::QgsProcessingParameterVectorDestination( const QString &name, const QString &description, Qgis::ProcessingSourceType type, const QVariant &defaultValue, bool optional, bool createByDefault ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterVectorDestination::clone() const
{
  return new QgsProcessingParameterVectorDestination( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterVectorDestination::clone() const {…}
 
bool QgsProcessingParameterVectorDestination::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const
{
  QVariant var = input;
  if ( !var.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    var = defaultValue();
  }
 
  if ( var.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( var );
    var = fromVar.sink;
  }
 
  if ( var.userType() == qMetaTypeId<QgsProperty>() )
  {
    const QgsProperty p = var.value< QgsProperty >();
    if ( p.propertyType() == Qgis::PropertyType::Static )
    {
      var = p.staticValue();
    }
    else
    {
      return true;
    }
  }
 
  if ( var.userType() != QMetaType::Type::QString )
    return false;
 
  if ( var.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  return true;
}
bool QgsProcessingParameterVectorDestination::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterVectorDestination::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( value );
    if ( fromVar.sink.propertyType() == Qgis::PropertyType::Static )
    {
      return QgsProcessingUtils::stringToPythonLiteral( fromVar.sink.staticValue().toString() );
    }
    else
    {
      return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( fromVar.sink.asExpression() );
    }
  }
 
  return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
}
QString QgsProcessingParameterVectorDestination::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterVectorDestination::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "vectorDestination " );
 
  switch ( mDataType )
  {
    case Qgis::ProcessingSourceType::VectorPoint:
      code += QLatin1String( "point " );
      break;
 
    case Qgis::ProcessingSourceType::VectorLine:
      code += QLatin1String( "line " );
      break;
 
    case Qgis::ProcessingSourceType::VectorPolygon:
      code += QLatin1String( "polygon " );
      break;
 
    default:
      break;
  }
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterVectorDestination::asScriptCode() const {…}
 
QgsProcessingOutputDefinition *QgsProcessingParameterVectorDestination::toOutputDefinition() const
{
  return new QgsProcessingOutputVectorLayer( name(), description(), mDataType );
}
QgsProcessingOutputDefinition *QgsProcessingParameterVectorDestination::toOutputDefinition() const {…}
 
QString QgsProcessingParameterVectorDestination::defaultFileExtension() const
{
  if ( auto *lOriginalProvider = originalProvider() )
  {
    return lOriginalProvider->defaultVectorFileExtension( hasGeometry() );
  }
  else if ( QgsProcessingProvider *p = provider() )
  {
    return p->defaultVectorFileExtension( hasGeometry() );
  }
  else
  {
    if ( hasGeometry() )
    {
      return QgsProcessingUtils::defaultVectorExtension();
    }
    else
    {
      return QStringLiteral( "dbf" );
    }
  }
}
QString QgsProcessingParameterVectorDestination::defaultFileExtension() const {…}
 
QString QgsProcessingParameterVectorDestination::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterVectorDestination('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", type=QgsProcessing.%1" ).arg( QgsProcessing::sourceTypeToString( mDataType ) );
 
      code += QStringLiteral( ", createByDefault=%1" ).arg( createByDefault() ? QStringLiteral( "True" ) : QStringLiteral( "False" ) );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterVectorDestination::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QString QgsProcessingParameterVectorDestination::createFileFilter() const
{
  const QStringList exts = supportedOutputVectorLayerExtensions();
  QStringList filters;
  for ( const QString &ext : exts )
  {
    filters << QObject::tr( "%1 files (*.%2)" ).arg( ext.toUpper(), ext.toLower() );
  }
  return filters.join( QLatin1String( ";;" ) ) + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
}
QString QgsProcessingParameterVectorDestination::createFileFilter() const {…}
 
QStringList QgsProcessingParameterVectorDestination::supportedOutputVectorLayerExtensions() const
{
  if ( auto *lOriginalProvider = originalProvider() )
  {
    if ( hasGeometry() )
      return lOriginalProvider->supportedOutputVectorLayerExtensions();
    else
      return lOriginalProvider->supportedOutputTableExtensions();
  }
  else if ( QgsProcessingProvider *p = provider() )
  {
    if ( hasGeometry() )
      return p->supportedOutputVectorLayerExtensions();
    else
      return p->supportedOutputTableExtensions();
  }
  else
  {
    return QgsVectorFileWriter::supportedFormatExtensions();
  }
}
QStringList QgsProcessingParameterVectorDestination::supportedOutputVectorLayerExtensions() const {…}
 
Qgis::ProcessingSourceType QgsProcessingParameterVectorDestination::dataType() const
{
  return mDataType;
}
Qgis::ProcessingSourceType QgsProcessingParameterVectorDestination::dataType() const {…}
 
bool QgsProcessingParameterVectorDestination::hasGeometry() const
{
  switch ( mDataType )
  {
    case Qgis::ProcessingSourceType::MapLayer:
    case Qgis::ProcessingSourceType::VectorAnyGeometry:
    case Qgis::ProcessingSourceType::VectorPoint:
    case Qgis::ProcessingSourceType::VectorLine:
    case Qgis::ProcessingSourceType::VectorPolygon:
    case Qgis::ProcessingSourceType::VectorTile:
      return true;
 
    case Qgis::ProcessingSourceType::Raster:
    case Qgis::ProcessingSourceType::File:
    case Qgis::ProcessingSourceType::Vector:
    case Qgis::ProcessingSourceType::Mesh:
    case Qgis::ProcessingSourceType::Plugin:
    case Qgis::ProcessingSourceType::PointCloud:
    case Qgis::ProcessingSourceType::Annotation:
      return false;
  }
  return true;
}
bool QgsProcessingParameterVectorDestination::hasGeometry() const {…}
 
void QgsProcessingParameterVectorDestination::setDataType( Qgis::ProcessingSourceType type )
{
  mDataType = type;
}
void QgsProcessingParameterVectorDestination::setDataType( Qgis::ProcessingSourceType type ) {…}
 
QVariantMap QgsProcessingParameterVectorDestination::toVariantMap() const
{
  QVariantMap map = QgsProcessingDestinationParameter::toVariantMap();
  map.insert( QStringLiteral( "data_type" ), static_cast< int >( mDataType ) );
  return map;
}
QVariantMap QgsProcessingParameterVectorDestination::toVariantMap() const {…}
 
bool QgsProcessingParameterVectorDestination::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingDestinationParameter::fromVariantMap( map );
  mDataType = static_cast< Qgis::ProcessingSourceType >( map.value( QStringLiteral( "data_type" ) ).toInt() );
  return true;
}
bool QgsProcessingParameterVectorDestination::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterVectorDestination *QgsProcessingParameterVectorDestination::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  Qgis::ProcessingSourceType type = Qgis::ProcessingSourceType::VectorAnyGeometry;
  QString def = definition;
  if ( def.startsWith( QLatin1String( "point" ), Qt::CaseInsensitive ) )
  {
    type = Qgis::ProcessingSourceType::VectorPoint;
    def = def.mid( 6 );
  }
  else if ( def.startsWith( QLatin1String( "line" ), Qt::CaseInsensitive ) )
  {
    type = Qgis::ProcessingSourceType::VectorLine;
    def = def.mid( 5 );
  }
  else if ( def.startsWith( QLatin1String( "polygon" ), Qt::CaseInsensitive ) )
  {
    type = Qgis::ProcessingSourceType::VectorPolygon;
    def = def.mid( 8 );
  }
 
  return new QgsProcessingParameterVectorDestination( name, description, type, definition.isEmpty() ? QVariant() : definition, isOptional );
}
QgsProcessingParameterVectorDestination *QgsProcessingParameterVectorDestination::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterBand::QgsProcessingParameterBand( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentLayerParameterName, bool optional, bool allowMultiple )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mParentLayerParameterName( parentLayerParameterName )
  , mAllowMultiple( allowMultiple )
{
 
}
QgsProcessingParameterBand::QgsProcessingParameterBand( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentLayerParameterName, bool optional, bool allowMultiple ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterBand::clone() const
{
  return new QgsProcessingParameterBand( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterBand::clone() const {…}
 
bool QgsProcessingParameterBand::checkValueIsAcceptable( const QVariant &value, QgsProcessingContext * ) const
{
  QVariant input = value;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  if ( input.userType() == QMetaType::Type::QVariantList || input.userType() == QMetaType::Type::QStringList )
  {
    if ( !mAllowMultiple )
      return false;
 
    if ( input.toList().isEmpty() && !( mFlags & Qgis::ProcessingParameterFlag::Optional ) )
      return false;
  }
  else
  {
    bool ok = false;
    const double res = input.toInt( &ok );
    Q_UNUSED( res )
    if ( !ok )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
  }
  return true;
}
bool QgsProcessingParameterBand::checkValueIsAcceptable( const QVariant &value, QgsProcessingContext * ) const {…}
 
bool QgsProcessingParameterBand::allowMultiple() const
{
  return mAllowMultiple;
}
bool QgsProcessingParameterBand::allowMultiple() const {…}
 
void QgsProcessingParameterBand::setAllowMultiple( bool allowMultiple )
{
  mAllowMultiple = allowMultiple;
}
void QgsProcessingParameterBand::setAllowMultiple( bool allowMultiple ) {…}
 
QString QgsProcessingParameterBand::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.userType() == QMetaType::Type::QVariantList )
  {
    QStringList parts;
    const QVariantList values = value.toList();
    for ( auto it = values.constBegin(); it != values.constEnd(); ++it )
    {
      parts << QString::number( static_cast< int >( it->toDouble() ) );
    }
    return parts.join( ',' ).prepend( '[' ).append( ']' );
  }
  else if ( value.userType() == QMetaType::Type::QStringList )
  {
    QStringList parts;
    const QStringList values = value.toStringList();
    for ( auto it = values.constBegin(); it != values.constEnd(); ++it )
    {
      parts << QString::number( static_cast< int >( it->toDouble() ) );
    }
    return parts.join( ',' ).prepend( '[' ).append( ']' );
  }
 
  return value.toString();
}
QString QgsProcessingParameterBand::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterBand::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "band " );
 
  if ( mAllowMultiple )
    code += QLatin1String( "multiple " );
 
  code += mParentLayerParameterName + ' ';
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterBand::asScriptCode() const {…}
 
QStringList QgsProcessingParameterBand::dependsOnOtherParameters() const
{
  QStringList depends;
  if ( !mParentLayerParameterName.isEmpty() )
    depends << mParentLayerParameterName;
  return depends;
}
QStringList QgsProcessingParameterBand::dependsOnOtherParameters() const {…}
 
QString QgsProcessingParameterBand::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterBand('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", parentLayerParameterName='%1'" ).arg( mParentLayerParameterName );
      code += QStringLiteral( ", allowMultiple=%1" ).arg( mAllowMultiple ? QStringLiteral( "True" ) : QStringLiteral( "False" ) );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterBand::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QString QgsProcessingParameterBand::parentLayerParameterName() const
{
  return mParentLayerParameterName;
}
QString QgsProcessingParameterBand::parentLayerParameterName() const {…}
 
void QgsProcessingParameterBand::setParentLayerParameterName( const QString &parentLayerParameterName )
{
  mParentLayerParameterName = parentLayerParameterName;
}
void QgsProcessingParameterBand::setParentLayerParameterName( const QString &parentLayerParameterName ) {…}
 
QVariantMap QgsProcessingParameterBand::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "parent_layer" ), mParentLayerParameterName );
  map.insert( QStringLiteral( "allow_multiple" ), mAllowMultiple );
  return map;
}
QVariantMap QgsProcessingParameterBand::toVariantMap() const {…}
 
bool QgsProcessingParameterBand::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mParentLayerParameterName = map.value( QStringLiteral( "parent_layer" ) ).toString();
  mAllowMultiple = map.value( QStringLiteral( "allow_multiple" ) ).toBool();
  return true;
}
bool QgsProcessingParameterBand::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterBand *QgsProcessingParameterBand::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString parent;
  QString def = definition;
  bool allowMultiple = false;
 
  if ( def.startsWith( QLatin1String( "multiple" ), Qt::CaseInsensitive ) )
  {
    allowMultiple = true;
    def = def.mid( 8 ).trimmed();
  }
 
  const thread_local QRegularExpression re( QStringLiteral( "(.*?)\\s+(.*)$" ) );
  const QRegularExpressionMatch m = re.match( def );
  if ( m.hasMatch() )
  {
    parent = m.captured( 1 ).trimmed();
    def = m.captured( 2 );
  }
  else
  {
    parent = def;
    def.clear();
  }
 
  return new QgsProcessingParameterBand( name, description, def.isEmpty() ? QVariant() : def, parent, isOptional, allowMultiple );
}
QgsProcessingParameterBand *QgsProcessingParameterBand::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
//
// QgsProcessingParameterDistance
//
 
QgsProcessingParameterDistance::QgsProcessingParameterDistance( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentParameterName, bool optional, double minValue, double maxValue )
  : QgsProcessingParameterNumber( name, description, Qgis::ProcessingNumberParameterType::Double, defaultValue, optional, minValue, maxValue )
  , mParentParameterName( parentParameterName )
{
 
}
QgsProcessingParameterDistance::QgsProcessingParameterDistance( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentParameterName, bool optional, double minValue, double maxValue ) {…}
 
QgsProcessingParameterDistance *QgsProcessingParameterDistance::clone() const
{
  return new QgsProcessingParameterDistance( *this );
}
QgsProcessingParameterDistance *QgsProcessingParameterDistance::clone() const {…}
 
QString QgsProcessingParameterDistance::type() const
{
  return typeName();
}
QString QgsProcessingParameterDistance::type() const {…}
 
QStringList QgsProcessingParameterDistance::dependsOnOtherParameters() const
{
  QStringList depends;
  if ( !mParentParameterName.isEmpty() )
    depends << mParentParameterName;
  return depends;
}
QStringList QgsProcessingParameterDistance::dependsOnOtherParameters() const {…}
 
QString QgsProcessingParameterDistance::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterDistance('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", parentParameterName='%1'" ).arg( mParentParameterName );
 
      if ( minimum() != std::numeric_limits<double>::lowest() + 1 )
        code += QStringLiteral( ", minValue=%1" ).arg( minimum() );
      if ( maximum() != std::numeric_limits<double>::max() )
        code += QStringLiteral( ", maxValue=%1" ).arg( maximum() );
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterDistance::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QString QgsProcessingParameterDistance::parentParameterName() const
{
  return mParentParameterName;
}
QString QgsProcessingParameterDistance::parentParameterName() const {…}
 
void QgsProcessingParameterDistance::setParentParameterName( const QString &parentParameterName )
{
  mParentParameterName = parentParameterName;
}
void QgsProcessingParameterDistance::setParentParameterName( const QString &parentParameterName ) {…}
 
QVariantMap QgsProcessingParameterDistance::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterNumber::toVariantMap();
  map.insert( QStringLiteral( "parent" ), mParentParameterName );
  map.insert( QStringLiteral( "default_unit" ), static_cast< int >( mDefaultUnit ) );
  return map;
}
QVariantMap QgsProcessingParameterDistance::toVariantMap() const {…}
 
bool QgsProcessingParameterDistance::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterNumber::fromVariantMap( map );
  mParentParameterName = map.value( QStringLiteral( "parent" ) ).toString();
  mDefaultUnit = static_cast< Qgis::DistanceUnit>( map.value( QStringLiteral( "default_unit" ), static_cast< int >( Qgis::DistanceUnit::Unknown ) ).toInt() );
  return true;
}
bool QgsProcessingParameterDistance::fromVariantMap( const QVariantMap &map ) {…}
 
 
 
//
// QgsProcessingParameterArea
//
 
QgsProcessingParameterArea::QgsProcessingParameterArea( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentParameterName, bool optional, double minValue, double maxValue )
  : QgsProcessingParameterNumber( name, description, Qgis::ProcessingNumberParameterType::Double, defaultValue, optional, minValue, maxValue )
  , mParentParameterName( parentParameterName )
{
 
}
QgsProcessingParameterArea::QgsProcessingParameterArea( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentParameterName, bool optional, double minValue, double maxValue ) {…}
 
QgsProcessingParameterArea *QgsProcessingParameterArea::clone() const
{
  return new QgsProcessingParameterArea( *this );
}
QgsProcessingParameterArea *QgsProcessingParameterArea::clone() const {…}
 
QString QgsProcessingParameterArea::type() const
{
  return typeName();
}
QString QgsProcessingParameterArea::type() const {…}
 
QStringList QgsProcessingParameterArea::dependsOnOtherParameters() const
{
  QStringList depends;
  if ( !mParentParameterName.isEmpty() )
    depends << mParentParameterName;
  return depends;
}
QStringList QgsProcessingParameterArea::dependsOnOtherParameters() const {…}
 
QString QgsProcessingParameterArea::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterArea('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", parentParameterName='%1'" ).arg( mParentParameterName );
 
      if ( minimum() != 0 )
        code += QStringLiteral( ", minValue=%1" ).arg( minimum() );
      if ( maximum() != std::numeric_limits<double>::max() )
        code += QStringLiteral( ", maxValue=%1" ).arg( maximum() );
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterArea::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QString QgsProcessingParameterArea::parentParameterName() const
{
  return mParentParameterName;
}
QString QgsProcessingParameterArea::parentParameterName() const {…}
 
void QgsProcessingParameterArea::setParentParameterName( const QString &parentParameterName )
{
  mParentParameterName = parentParameterName;
}
void QgsProcessingParameterArea::setParentParameterName( const QString &parentParameterName ) {…}
 
QVariantMap QgsProcessingParameterArea::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterNumber::toVariantMap();
  map.insert( QStringLiteral( "parent" ), mParentParameterName );
  map.insert( QStringLiteral( "default_unit" ), qgsEnumValueToKey( mDefaultUnit ) );
  return map;
}
QVariantMap QgsProcessingParameterArea::toVariantMap() const {…}
 
bool QgsProcessingParameterArea::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterNumber::fromVariantMap( map );
  mParentParameterName = map.value( QStringLiteral( "parent" ) ).toString();
  mDefaultUnit = qgsEnumKeyToValue( map.value( QStringLiteral( "default_unit" ) ).toString(), Qgis::AreaUnit::Unknown );
  return true;
}
bool QgsProcessingParameterArea::fromVariantMap( const QVariantMap &map ) {…}
 
 
 
//
// QgsProcessingParameterVolume
//
 
QgsProcessingParameterVolume::QgsProcessingParameterVolume( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentParameterName, bool optional, double minValue, double maxValue )
  : QgsProcessingParameterNumber( name, description, Qgis::ProcessingNumberParameterType::Double, defaultValue, optional, minValue, maxValue )
  , mParentParameterName( parentParameterName )
{
 
}
QgsProcessingParameterVolume::QgsProcessingParameterVolume( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentParameterName, bool optional, double minValue, double maxValue ) {…}
 
QgsProcessingParameterVolume *QgsProcessingParameterVolume::clone() const
{
  return new QgsProcessingParameterVolume( *this );
}
QgsProcessingParameterVolume *QgsProcessingParameterVolume::clone() const {…}
 
QString QgsProcessingParameterVolume::type() const
{
  return typeName();
}
QString QgsProcessingParameterVolume::type() const {…}
 
QStringList QgsProcessingParameterVolume::dependsOnOtherParameters() const
{
  QStringList depends;
  if ( !mParentParameterName.isEmpty() )
    depends << mParentParameterName;
  return depends;
}
QStringList QgsProcessingParameterVolume::dependsOnOtherParameters() const {…}
 
QString QgsProcessingParameterVolume::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterVolume('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", parentParameterName='%1'" ).arg( mParentParameterName );
 
      if ( minimum() != 0 )
        code += QStringLiteral( ", minValue=%1" ).arg( minimum() );
      if ( maximum() != std::numeric_limits<double>::max() )
        code += QStringLiteral( ", maxValue=%1" ).arg( maximum() );
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterVolume::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QString QgsProcessingParameterVolume::parentParameterName() const
{
  return mParentParameterName;
}
QString QgsProcessingParameterVolume::parentParameterName() const {…}
 
void QgsProcessingParameterVolume::setParentParameterName( const QString &parentParameterName )
{
  mParentParameterName = parentParameterName;
}
void QgsProcessingParameterVolume::setParentParameterName( const QString &parentParameterName ) {…}
 
QVariantMap QgsProcessingParameterVolume::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterNumber::toVariantMap();
  map.insert( QStringLiteral( "parent" ), mParentParameterName );
  map.insert( QStringLiteral( "default_unit" ), qgsEnumValueToKey( mDefaultUnit ) );
  return map;
}
QVariantMap QgsProcessingParameterVolume::toVariantMap() const {…}
 
bool QgsProcessingParameterVolume::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterNumber::fromVariantMap( map );
  mParentParameterName = map.value( QStringLiteral( "parent" ) ).toString();
  mDefaultUnit = qgsEnumKeyToValue( map.value( QStringLiteral( "default_unit" ) ).toString(), Qgis::VolumeUnit::Unknown );
  return true;
}
bool QgsProcessingParameterVolume::fromVariantMap( const QVariantMap &map ) {…}
 
 
//
// QgsProcessingParameterDuration
//
 
QgsProcessingParameterDuration::QgsProcessingParameterDuration( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, double minValue, double maxValue )
  : QgsProcessingParameterNumber( name, description, Qgis::ProcessingNumberParameterType::Double, defaultValue, optional, minValue, maxValue )
{
}
QgsProcessingParameterDuration::QgsProcessingParameterDuration( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, double minValue, double maxValue ) {…}
 
QgsProcessingParameterDuration *QgsProcessingParameterDuration::clone() const
{
  return new QgsProcessingParameterDuration( *this );
}
QgsProcessingParameterDuration *QgsProcessingParameterDuration::clone() const {…}
 
QString QgsProcessingParameterDuration::type() const
{
  return typeName();
}
QString QgsProcessingParameterDuration::type() const {…}
 
QString QgsProcessingParameterDuration::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterDuration('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      if ( minimum() != std::numeric_limits<double>::lowest() + 1 )
        code += QStringLiteral( ", minValue=%1" ).arg( minimum() );
      if ( maximum() != std::numeric_limits<double>::max() )
        code += QStringLiteral( ", maxValue=%1" ).arg( maximum() );
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterDuration::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QVariantMap QgsProcessingParameterDuration::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterNumber::toVariantMap();
  map.insert( QStringLiteral( "default_unit" ), static_cast< int >( mDefaultUnit ) );
  return map;
}
QVariantMap QgsProcessingParameterDuration::toVariantMap() const {…}
 
bool QgsProcessingParameterDuration::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterNumber::fromVariantMap( map );
  mDefaultUnit = static_cast< Qgis::TemporalUnit>( map.value( QStringLiteral( "default_unit" ), static_cast< int >( Qgis::TemporalUnit::Days ) ).toInt() );
  return true;
}
bool QgsProcessingParameterDuration::fromVariantMap( const QVariantMap &map ) {…}
 
 
//
// QgsProcessingParameterScale
//
 
QgsProcessingParameterScale::QgsProcessingParameterScale( const QString &name, const QString &description, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterNumber( name, description, Qgis::ProcessingNumberParameterType::Double, defaultValue, optional )
{
 
}
QgsProcessingParameterScale::QgsProcessingParameterScale( const QString &name, const QString &description, const QVariant &defaultValue, bool optional ) {…}
 
QgsProcessingParameterScale *QgsProcessingParameterScale::clone() const
{
  return new QgsProcessingParameterScale( *this );
}
QgsProcessingParameterScale *QgsProcessingParameterScale::clone() const {…}
 
QString QgsProcessingParameterScale::type() const
{
  return typeName();
}
QString QgsProcessingParameterScale::type() const {…}
 
QString QgsProcessingParameterScale::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterScale('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterScale::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QgsProcessingParameterScale *QgsProcessingParameterScale::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) // cppcheck-suppress duplInheritedMember
{
  return new QgsProcessingParameterScale( name, description, definition.isEmpty() ? QVariant()
                                          : ( definition.toLower().trimmed() == QLatin1String( "none" ) ? QVariant() : definition ), isOptional );
}
QgsProcessingParameterScale *QgsProcessingParameterScale::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) // cppcheck-suppress duplInheritedMember {…}
 
 
//
// QgsProcessingParameterLayout
//
 
QgsProcessingParameterLayout::QgsProcessingParameterLayout( const QString &name, const QString &description, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
{}
QgsProcessingParameterLayout::QgsProcessingParameterLayout( const QString &name, const QString &description, const QVariant &defaultValue, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterLayout::clone() const
{
  return new QgsProcessingParameterLayout( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterLayout::clone() const {…}
 
QString QgsProcessingParameterLayout::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( QgsVariantUtils::isNull( value ) )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  const QString s = value.toString();
  return QgsProcessingUtils::stringToPythonLiteral( s );
}
QString QgsProcessingParameterLayout::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterLayout::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "layout " );
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterLayout::asScriptCode() const {…}
 
QString QgsProcessingParameterLayout::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterLayout('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterLayout::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QgsProcessingParameterLayout *QgsProcessingParameterLayout::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString def = definition;
 
  if ( def.startsWith( '"' ) || def.startsWith( '\'' ) )
    def = def.mid( 1 );
  if ( def.endsWith( '"' ) || def.endsWith( '\'' ) )
    def.chop( 1 );
 
  QVariant defaultValue = def;
  if ( def == QLatin1String( "None" ) )
    defaultValue = QVariant();
 
  return new QgsProcessingParameterLayout( name, description, defaultValue, isOptional );
}
QgsProcessingParameterLayout *QgsProcessingParameterLayout::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
 
//
// QString mParentLayerParameterName;
//
 
QgsProcessingParameterLayoutItem::QgsProcessingParameterLayoutItem( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentLayoutParameterName, int itemType, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mParentLayoutParameterName( parentLayoutParameterName )
  , mItemType( itemType )
{
 
}
QgsProcessingParameterLayoutItem::QgsProcessingParameterLayoutItem( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentLayoutParameterName, int itemType, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterLayoutItem::clone() const
{
  return new QgsProcessingParameterLayoutItem( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterLayoutItem::clone() const {…}
 
QString QgsProcessingParameterLayoutItem::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( QgsVariantUtils::isNull( value ) )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  const QString s = value.toString();
  return QgsProcessingUtils::stringToPythonLiteral( s );
}
QString QgsProcessingParameterLayoutItem::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterLayoutItem::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "layoutitem " );
  if ( mItemType >= 0 )
    code += QString::number( mItemType ) + ' ';
 
  code += mParentLayoutParameterName + ' ';
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterLayoutItem::asScriptCode() const {…}
 
QString QgsProcessingParameterLayoutItem::asPythonString( QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterLayoutItem('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      if ( mItemType >= 0 )
        code += QStringLiteral( ", itemType=%1" ).arg( mItemType );
 
      code += QStringLiteral( ", parentLayoutParameterName='%1'" ).arg( mParentLayoutParameterName );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterLayoutItem::asPythonString( QgsProcessing::PythonOutputType outputType ) const {…}
 
QVariantMap QgsProcessingParameterLayoutItem::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "parent_layout" ), mParentLayoutParameterName );
  map.insert( QStringLiteral( "item_type" ), mItemType );
  return map;
}
QVariantMap QgsProcessingParameterLayoutItem::toVariantMap() const {…}
 
bool QgsProcessingParameterLayoutItem::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mParentLayoutParameterName = map.value( QStringLiteral( "parent_layout" ) ).toString();
  mItemType = map.value( QStringLiteral( "item_type" ) ).toInt();
  return true;
}
bool QgsProcessingParameterLayoutItem::fromVariantMap( const QVariantMap &map ) {…}
 
QStringList QgsProcessingParameterLayoutItem::dependsOnOtherParameters() const
{
  QStringList depends;
  if ( !mParentLayoutParameterName.isEmpty() )
    depends << mParentLayoutParameterName;
  return depends;
}
QStringList QgsProcessingParameterLayoutItem::dependsOnOtherParameters() const {…}
 
QgsProcessingParameterLayoutItem *QgsProcessingParameterLayoutItem::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString parent;
  QString def = definition;
  int itemType = -1;
  const thread_local QRegularExpression re( QStringLiteral( "(\\d+)?\\s*(.*?)\\s+(.*)$" ) );
  const QRegularExpressionMatch m = re.match( def );
  if ( m.hasMatch() )
  {
    itemType = m.captured( 1 ).trimmed().isEmpty() ? -1 : m.captured( 1 ).trimmed().toInt();
    parent = m.captured( 2 ).trimmed().isEmpty() ? m.captured( 3 ).trimmed() : m.captured( 2 ).trimmed();
    def = !m.captured( 2 ).trimmed().isEmpty() ? m.captured( 3 ) : QString();
  }
  else
  {
    parent = def;
    def.clear();
  }
 
  return new QgsProcessingParameterLayoutItem( name, description, def.isEmpty() ? QVariant() : def, parent, itemType, isOptional );
}
QgsProcessingParameterLayoutItem *QgsProcessingParameterLayoutItem::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QString QgsProcessingParameterLayoutItem::parentLayoutParameterName() const
{
  return mParentLayoutParameterName;
}
QString QgsProcessingParameterLayoutItem::parentLayoutParameterName() const {…}
 
void QgsProcessingParameterLayoutItem::setParentLayoutParameterName( const QString &name )
{
  mParentLayoutParameterName = name;
}
void QgsProcessingParameterLayoutItem::setParentLayoutParameterName( const QString &name ) {…}
 
int QgsProcessingParameterLayoutItem::itemType() const
{
  return mItemType;
}
int QgsProcessingParameterLayoutItem::itemType() const {…}
 
void QgsProcessingParameterLayoutItem::setItemType( int type )
{
  mItemType = type;
}
void QgsProcessingParameterLayoutItem::setItemType( int type ) {…}
 
//
// QgsProcessingParameterColor
//
 
QgsProcessingParameterColor::QgsProcessingParameterColor( const QString &name, const QString &description, const QVariant &defaultValue, bool opacityEnabled, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mAllowOpacity( opacityEnabled )
{
 
}
QgsProcessingParameterColor::QgsProcessingParameterColor( const QString &name, const QString &description, const QVariant &defaultValue, bool opacityEnabled, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterColor::clone() const
{
  return new QgsProcessingParameterColor( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterColor::clone() const {…}
 
QString QgsProcessingParameterColor::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( QgsVariantUtils::isNull( value ) )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.canConvert< QColor >() && !value.value< QColor >().isValid() )
    return QStringLiteral( "QColor()" );
 
  if ( value.canConvert< QColor >() )
  {
    const QColor c = value.value< QColor >();
    if ( !mAllowOpacity || c.alpha() == 255 )
      return QStringLiteral( "QColor(%1, %2, %3)" ).arg( c.red() ).arg( c.green() ).arg( c.blue() );
    else
      return QStringLiteral( "QColor(%1, %2, %3, %4)" ).arg( c.red() ).arg( c.green() ).arg( c.blue() ).arg( c.alpha() );
  }
 
  const QString s = value.toString();
  return QgsProcessingUtils::stringToPythonLiteral( s );
}
QString QgsProcessingParameterColor::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterColor::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "color " );
 
  if ( mAllowOpacity )
    code += QLatin1String( "withopacity " );
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterColor::asScriptCode() const {…}
 
QString QgsProcessingParameterColor::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterColor('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", opacityEnabled=%1" ).arg( mAllowOpacity ? QStringLiteral( "True" ) : QStringLiteral( "False" ) );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterColor::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
bool QgsProcessingParameterColor::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const
{
  if ( !input.isValid() && ( mDefault.isValid() && ( !mDefault.toString().isEmpty() || mDefault.value< QColor >().isValid() ) ) )
    return true;
 
  if ( !input.isValid() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( input.userType() == QMetaType::Type::QColor )
  {
    return true;
  }
  else if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  if ( input.userType() != QMetaType::Type::QString || input.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  bool containsAlpha = false;
  return QgsSymbolLayerUtils::parseColorWithAlpha( input.toString(), containsAlpha ).isValid();
}
bool QgsProcessingParameterColor::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const {…}
 
QVariantMap QgsProcessingParameterColor::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "opacityEnabled" ), mAllowOpacity );
  return map;
}
QVariantMap QgsProcessingParameterColor::toVariantMap() const {…}
 
bool QgsProcessingParameterColor::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mAllowOpacity = map.value( QStringLiteral( "opacityEnabled" ) ).toBool();
  return true;
}
bool QgsProcessingParameterColor::fromVariantMap( const QVariantMap &map ) {…}
 
bool QgsProcessingParameterColor::opacityEnabled() const
{
  return mAllowOpacity;
}
bool QgsProcessingParameterColor::opacityEnabled() const {…}
 
void QgsProcessingParameterColor::setOpacityEnabled( bool enabled )
{
  mAllowOpacity = enabled;
}
void QgsProcessingParameterColor::setOpacityEnabled( bool enabled ) {…}
 
QgsProcessingParameterColor *QgsProcessingParameterColor::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString def = definition;
 
  bool allowOpacity = false;
  if ( def.startsWith( QLatin1String( "withopacity" ), Qt::CaseInsensitive ) )
  {
    allowOpacity = true;
    def = def.mid( 12 );
  }
 
  if ( def.startsWith( '"' ) || def.startsWith( '\'' ) )
    def = def.mid( 1 );
  if ( def.endsWith( '"' ) || def.endsWith( '\'' ) )
    def.chop( 1 );
 
  QVariant defaultValue = def;
  if ( def == QLatin1String( "None" ) || def.isEmpty() )
    defaultValue = QVariant();
 
  return new QgsProcessingParameterColor( name, description, defaultValue, allowOpacity, isOptional );
}
QgsProcessingParameterColor *QgsProcessingParameterColor::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
//
// QgsProcessingParameterCoordinateOperation
//
QgsProcessingParameterCoordinateOperation::QgsProcessingParameterCoordinateOperation( const QString &name, const QString &description, const QVariant &defaultValue, const QString &sourceCrsParameterName, const QString &destinationCrsParameterName, const QVariant &staticSourceCrs, const QVariant &staticDestinationCrs, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mSourceParameterName( sourceCrsParameterName )
  , mDestParameterName( destinationCrsParameterName )
  , mSourceCrs( staticSourceCrs )
  , mDestCrs( staticDestinationCrs )
{
 
}
QgsProcessingParameterCoordinateOperation::QgsProcessingParameterCoordinateOperation( const QString &name, const QString &description, const QVariant &defaultValue, const QString &sourceCrsParameterName, const QString &destinationCrsParameterName, const QVariant &staticSourceCrs, const QVariant &staticDestinationCrs, bool optional ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterCoordinateOperation::clone() const
{
  return new QgsProcessingParameterCoordinateOperation( * this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterCoordinateOperation::clone() const {…}
 
QString QgsProcessingParameterCoordinateOperation::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const
{
  return valueAsPythonStringPrivate( value, context, false );
}
QString QgsProcessingParameterCoordinateOperation::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterCoordinateOperation::valueAsPythonStringPrivate( const QVariant &value, QgsProcessingContext &context, bool allowNonStringValues ) const
{
  if ( QgsVariantUtils::isNull( value ) )
    return QStringLiteral( "None" );
 
  if ( allowNonStringValues && value.userType() == qMetaTypeId<QgsCoordinateReferenceSystem>() )
  {
    if ( !value.value< QgsCoordinateReferenceSystem >().isValid() )
      return QStringLiteral( "QgsCoordinateReferenceSystem()" );
    else
      return QStringLiteral( "QgsCoordinateReferenceSystem('%1')" ).arg( value.value< QgsCoordinateReferenceSystem >().authid() );
  }
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( allowNonStringValues )
  {
    QVariantMap p;
    p.insert( name(), value );
    QgsMapLayer *layer = QgsProcessingParameters::parameterAsLayer( this, p, context );
    if ( layer )
      return QgsProcessingUtils::stringToPythonLiteral( QgsProcessingUtils::layerToStringIdentifier( layer ) );
  }
 
  const QString s = value.toString();
  return QgsProcessingUtils::stringToPythonLiteral( s );
}
 
QString QgsProcessingParameterCoordinateOperation::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "coordinateoperation " );
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterCoordinateOperation::asScriptCode() const {…}
 
QString QgsProcessingParameterCoordinateOperation::asPythonString( QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QgsProcessingContext c;
      QString code = QStringLiteral( "QgsProcessingParameterCoordinateOperation('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
      if ( !mSourceParameterName.isEmpty() )
        code += QStringLiteral( ", sourceCrsParameterName=%1" ).arg( valueAsPythonStringPrivate( mSourceParameterName, c, false ) );
      if ( !mDestParameterName.isEmpty() )
        code += QStringLiteral( ", destinationCrsParameterName=%1" ).arg( valueAsPythonStringPrivate( mDestParameterName, c, false ) );
 
      if ( mSourceCrs.isValid() )
        code += QStringLiteral( ", staticSourceCrs=%1" ).arg( valueAsPythonStringPrivate( mSourceCrs, c, true ) );
      if ( mDestCrs.isValid() )
        code += QStringLiteral( ", staticDestinationCrs=%1" ).arg( valueAsPythonStringPrivate( mDestCrs, c, true ) );
 
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonStringPrivate( mDefault, c, false ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterCoordinateOperation::asPythonString( QgsProcessing::PythonOutputType outputType ) const {…}
 
QStringList QgsProcessingParameterCoordinateOperation::dependsOnOtherParameters() const
{
  QStringList res;
  if ( !mSourceParameterName.isEmpty() )
    res << mSourceParameterName;
  if ( !mDestParameterName.isEmpty() )
    res << mDestParameterName;
  return res;
}
QStringList QgsProcessingParameterCoordinateOperation::dependsOnOtherParameters() const {…}
 
QVariantMap QgsProcessingParameterCoordinateOperation::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "source_crs_parameter_name" ), mSourceParameterName );
  map.insert( QStringLiteral( "dest_crs_parameter_name" ), mDestParameterName );
  map.insert( QStringLiteral( "static_source_crs" ), mSourceCrs );
  map.insert( QStringLiteral( "static_dest_crs" ), mDestCrs );
  return map;
}
QVariantMap QgsProcessingParameterCoordinateOperation::toVariantMap() const {…}
 
bool QgsProcessingParameterCoordinateOperation::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mSourceParameterName = map.value( QStringLiteral( "source_crs_parameter_name" ) ).toString();
  mDestParameterName = map.value( QStringLiteral( "dest_crs_parameter_name" ) ).toString();
  mSourceCrs = map.value( QStringLiteral( "static_source_crs" ) );
  mDestCrs = map.value( QStringLiteral( "static_dest_crs" ) );
  return true;
}
bool QgsProcessingParameterCoordinateOperation::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterCoordinateOperation *QgsProcessingParameterCoordinateOperation::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString def = definition;
 
  if ( def.startsWith( '"' ) )
  {
    def = def.mid( 1 );
    if ( def.endsWith( '"' ) )
      def.chop( 1 );
  }
  else if ( def.startsWith( '\'' ) )
  {
    def = def.mid( 1 );
    if ( def.endsWith( '\'' ) )
      def.chop( 1 );
  }
 
  QVariant defaultValue = def;
  if ( def == QLatin1String( "None" ) )
    defaultValue = QVariant();
 
  return new QgsProcessingParameterCoordinateOperation( name, description, defaultValue, QString(), QString(), QVariant(), QVariant(), isOptional );
}
QgsProcessingParameterCoordinateOperation *QgsProcessingParameterCoordinateOperation::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
 
//
// QgsProcessingParameterMapTheme
//
 
QgsProcessingParameterMapTheme::QgsProcessingParameterMapTheme( const QString &name, const QString &description, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
{
 
}
QgsProcessingParameterMapTheme::QgsProcessingParameterMapTheme( const QString &name, const QString &description, const QVariant &defaultValue, bool optional ) {…}
 
 
QgsProcessingParameterDefinition *QgsProcessingParameterMapTheme::clone() const
{
  return new QgsProcessingParameterMapTheme( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterMapTheme::clone() const {…}
 
bool QgsProcessingParameterMapTheme::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const
{
  if ( !input.isValid() && !mDefault.isValid() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( ( input.userType() == QMetaType::Type::QString && input.toString().isEmpty() )
       || ( !input.isValid() && mDefault.userType() == QMetaType::Type::QString && mDefault.toString().isEmpty() ) )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  return true;
}
bool QgsProcessingParameterMapTheme::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterMapTheme::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
}
QString QgsProcessingParameterMapTheme::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterMapTheme::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "maptheme " );
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterMapTheme::asScriptCode() const {…}
 
QString QgsProcessingParameterMapTheme::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterMapTheme('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
 
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterMapTheme::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QVariantMap QgsProcessingParameterMapTheme::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  return map;
}
QVariantMap QgsProcessingParameterMapTheme::toVariantMap() const {…}
 
bool QgsProcessingParameterMapTheme::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  return true;
}
bool QgsProcessingParameterMapTheme::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterMapTheme *QgsProcessingParameterMapTheme::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString def = definition;
  if ( def.startsWith( '"' ) || def.startsWith( '\'' ) )
    def = def.mid( 1 );
  if ( def.endsWith( '"' ) || def.endsWith( '\'' ) )
    def.chop( 1 );
 
  QVariant defaultValue = def;
 
  if ( defaultValue == QLatin1String( "None" ) || defaultValue.toString().isEmpty() )
    defaultValue = QVariant();
 
  return new QgsProcessingParameterMapTheme( name, description, defaultValue, isOptional );
}
QgsProcessingParameterMapTheme *QgsProcessingParameterMapTheme::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
 
//
// QgsProcessingParameterDateTime
//
 
QgsProcessingParameterDateTime::QgsProcessingParameterDateTime( const QString &name, const QString &description, Qgis::ProcessingDateTimeParameterDataType type, const QVariant &defaultValue, bool optional, const QDateTime &minValue, const QDateTime &maxValue )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mMin( minValue )
  , mMax( maxValue )
  , mDataType( type )
{
  if ( mMin.isValid() && mMax.isValid() && mMin >= mMax )
  {
    QgsMessageLog::logMessage( QObject::tr( "Invalid datetime parameter \"%1\": min value %2 is >= max value %3!" ).arg( name, mMin.toString(), mMax.toString() ), QObject::tr( "Processing" ) );
  }
}
QgsProcessingParameterDateTime::QgsProcessingParameterDateTime( const QString &name, const QString &description, Qgis::ProcessingDateTimeParameterDataType type, const QVariant &defaultValue, bool optional, const QDateTime &minValue, const QDateTime &maxValue ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterDateTime::clone() const
{
  return new QgsProcessingParameterDateTime( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterDateTime::clone() const {…}
 
bool QgsProcessingParameterDateTime::checkValueIsAcceptable( const QVariant &value, QgsProcessingContext * ) const
{
  QVariant input = value;
  if ( !input.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  if ( input.userType() != QMetaType::Type::QDateTime && input.userType() != QMetaType::Type::QDate && input.userType() != QMetaType::Type::QTime && input.userType() != QMetaType::Type::QString )
    return false;
 
  if ( ( input.userType() == QMetaType::Type::QDateTime || input.userType() == QMetaType::Type::QDate ) && mDataType == Qgis::ProcessingDateTimeParameterDataType::Time )
    return false;
 
  if ( input.userType() == QMetaType::Type::QString )
  {
    const QString s = input.toString();
    if ( s.isEmpty() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = QDateTime::fromString( s, Qt::ISODate );
    if ( mDataType == Qgis::ProcessingDateTimeParameterDataType::Time )
    {
      if ( !input.toDateTime().isValid() )
        input = QTime::fromString( s );
      else
        input = input.toDateTime().time();
    }
  }
 
  if ( mDataType != Qgis::ProcessingDateTimeParameterDataType::Time )
  {
    const QDateTime res = input.toDateTime();
    return res.isValid() && ( res >= mMin || !mMin.isValid() ) && ( res <= mMax || !mMax.isValid() );
  }
  else
  {
    const QTime res = input.toTime();
    return res.isValid() && ( res >= mMin.time() || !mMin.isValid() ) && ( res <= mMax.time() || !mMax.isValid() );
  }
}
bool QgsProcessingParameterDateTime::checkValueIsAcceptable( const QVariant &value, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterDateTime::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.userType() == QMetaType::Type::QDateTime )
  {
    const QDateTime dt = value.toDateTime();
    if ( !dt.isValid() )
      return QStringLiteral( "QDateTime()" );
    else
      return QStringLiteral( "QDateTime(QDate(%1, %2, %3), QTime(%4, %5, %6))" ).arg( dt.date().year() )
             .arg( dt.date().month() )
             .arg( dt.date().day() )
             .arg( dt.time().hour() )
             .arg( dt.time().minute() )
             .arg( dt.time().second() );
  }
  else if ( value.userType() == QMetaType::Type::QDate )
  {
    const QDate dt = value.toDate();
    if ( !dt.isValid() )
      return QStringLiteral( "QDate()" );
    else
      return QStringLiteral( "QDate(%1, %2, %3)" ).arg( dt.year() )
             .arg( dt.month() )
             .arg( dt.day() );
  }
  else if ( value.userType() == QMetaType::Type::QTime )
  {
    const QTime dt = value.toTime();
    if ( !dt.isValid() )
      return QStringLiteral( "QTime()" );
    else
      return QStringLiteral( "QTime(%4, %5, %6)" )
             .arg( dt.hour() )
             .arg( dt.minute() )
             .arg( dt.second() );
  }
  return value.toString();
}
QString QgsProcessingParameterDateTime::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterDateTime::toolTip() const
{
  QString text = QgsProcessingParameterDefinition::toolTip();
  QStringList parts;
  if ( mMin.isValid() )
    parts << QObject::tr( "Minimum value: %1" ).arg( mMin.toString( Qt::ISODate ) );
  if ( mMax.isValid() )
    parts << QObject::tr( "Maximum value: %1" ).arg( mMax.toString( Qt::ISODate ) );
  if ( mDefault.isValid() )
    parts << QObject::tr( "Default value: %1" ).arg( mDataType == Qgis::ProcessingDateTimeParameterDataType::DateTime ? mDefault.toDateTime().toString( Qt::ISODate ) :
          ( mDataType == Qgis::ProcessingDateTimeParameterDataType::Date ? mDefault.toDate().toString( Qt::ISODate ) : mDefault.toTime( ).toString() ) );
  const QString extra = parts.join( QLatin1String( "<br />" ) );
  if ( !extra.isEmpty() )
    text += QStringLiteral( "<p>%1</p>" ).arg( extra );
  return text;
}
QString QgsProcessingParameterDateTime::toolTip() const {…}
 
QString QgsProcessingParameterDateTime::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterDateTime('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", type=%1" ).arg( mDataType == Qgis::ProcessingDateTimeParameterDataType::DateTime ? QStringLiteral( "QgsProcessingParameterDateTime.DateTime" )
              : mDataType == Qgis::ProcessingDateTimeParameterDataType::Date ? QStringLiteral( "QgsProcessingParameterDateTime.Date" )
              : QStringLiteral( "QgsProcessingParameterDateTime.Time" ) );
 
      QgsProcessingContext c;
      if ( mMin.isValid() )
        code += QStringLiteral( ", minValue=%1" ).arg( valueAsPythonString( mMin, c ) );
      if ( mMax.isValid() )
        code += QStringLiteral( ", maxValue=%1" ).arg( valueAsPythonString( mMax, c ) );
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterDateTime::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QDateTime QgsProcessingParameterDateTime::minimum() const
{
  return mMin;
}
QDateTime QgsProcessingParameterDateTime::minimum() const {…}
 
void QgsProcessingParameterDateTime::setMinimum( const QDateTime &min )
{
  mMin = min;
}
void QgsProcessingParameterDateTime::setMinimum( const QDateTime &min ) {…}
 
QDateTime QgsProcessingParameterDateTime::maximum() const
{
  return mMax;
}
QDateTime QgsProcessingParameterDateTime::maximum() const {…}
 
void QgsProcessingParameterDateTime::setMaximum( const QDateTime &max )
{
  mMax = max;
}
void QgsProcessingParameterDateTime::setMaximum( const QDateTime &max ) {…}
 
Qgis::ProcessingDateTimeParameterDataType QgsProcessingParameterDateTime::dataType() const
{
  return mDataType;
}
Qgis::ProcessingDateTimeParameterDataType QgsProcessingParameterDateTime::dataType() const {…}
 
void QgsProcessingParameterDateTime::setDataType( Qgis::ProcessingDateTimeParameterDataType dataType )
{
  mDataType = dataType;
}
void QgsProcessingParameterDateTime::setDataType( Qgis::ProcessingDateTimeParameterDataType dataType ) {…}
 
QVariantMap QgsProcessingParameterDateTime::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "min" ), mMin );
  map.insert( QStringLiteral( "max" ), mMax );
  map.insert( QStringLiteral( "data_type" ), static_cast< int >( mDataType ) );
  return map;
}
QVariantMap QgsProcessingParameterDateTime::toVariantMap() const {…}
 
bool QgsProcessingParameterDateTime::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mMin = map.value( QStringLiteral( "min" ) ).toDateTime();
  mMax = map.value( QStringLiteral( "max" ) ).toDateTime();
  mDataType = static_cast< Qgis::ProcessingDateTimeParameterDataType >( map.value( QStringLiteral( "data_type" ) ).toInt() );
  return true;
}
bool QgsProcessingParameterDateTime::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterDateTime *QgsProcessingParameterDateTime::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterDateTime( name, description, Qgis::ProcessingDateTimeParameterDataType::DateTime, definition.isEmpty() ? QVariant()
         : ( definition.toLower().trimmed() == QLatin1String( "none" ) ? QVariant() : definition ), isOptional );
}
QgsProcessingParameterDateTime *QgsProcessingParameterDateTime::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
 
 
//
// QgsProcessingParameterProviderConnection
//
 
QgsProcessingParameterProviderConnection::QgsProcessingParameterProviderConnection( const QString &name, const QString &description, const QString &provider, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mProviderId( provider )
{
 
}
QgsProcessingParameterProviderConnection::QgsProcessingParameterProviderConnection( const QString &name, const QString &description, const QString &provider, const QVariant &defaultValue, bool optional ) {…}
 
 
QgsProcessingParameterDefinition *QgsProcessingParameterProviderConnection::clone() const
{
  return new QgsProcessingParameterProviderConnection( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterProviderConnection::clone() const {…}
 
bool QgsProcessingParameterProviderConnection::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const
{
  if ( !input.isValid() && !mDefault.isValid() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( ( input.userType() == QMetaType::Type::QString && input.toString().isEmpty() )
       || ( !input.isValid() && mDefault.userType() == QMetaType::Type::QString && mDefault.toString().isEmpty() ) )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  return true;
}
bool QgsProcessingParameterProviderConnection::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterProviderConnection::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
}
QString QgsProcessingParameterProviderConnection::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterProviderConnection::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "providerconnection " );
  code += mProviderId + ' ';
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterProviderConnection::asScriptCode() const {…}
 
QString QgsProcessingParameterProviderConnection::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterProviderConnection('%1', %2, '%3'" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ), mProviderId );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1)" ).arg( valueAsPythonString( mDefault, c ) );
 
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterProviderConnection::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QVariantMap QgsProcessingParameterProviderConnection::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "provider" ), mProviderId );
  return map;
}
QVariantMap QgsProcessingParameterProviderConnection::toVariantMap() const {…}
 
bool QgsProcessingParameterProviderConnection::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mProviderId = map.value( QStringLiteral( "provider" ) ).toString();
  return true;
}
bool QgsProcessingParameterProviderConnection::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterProviderConnection *QgsProcessingParameterProviderConnection::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString def = definition;
  QString provider;
  if ( def.contains( ' ' ) )
  {
    provider = def.left( def.indexOf( ' ' ) );
    def = def.mid( def.indexOf( ' ' ) + 1 );
  }
  else
  {
    provider = def;
    def.clear();
  }
 
  if ( def.startsWith( '"' ) || def.startsWith( '\'' ) )
    def = def.mid( 1 );
  if ( def.endsWith( '"' ) || def.endsWith( '\'' ) )
    def.chop( 1 );
 
  QVariant defaultValue = def;
 
  if ( defaultValue == QLatin1String( "None" ) || defaultValue.toString().isEmpty() )
    defaultValue = QVariant();
 
  return new QgsProcessingParameterProviderConnection( name, description, provider, defaultValue, isOptional );
}
QgsProcessingParameterProviderConnection *QgsProcessingParameterProviderConnection::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
 
//
// QgsProcessingParameterDatabaseSchema
//
 
QgsProcessingParameterDatabaseSchema::QgsProcessingParameterDatabaseSchema( const QString &name, const QString &description, const QString &parentLayerParameterName, const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mParentConnectionParameterName( parentLayerParameterName )
{
 
}
QgsProcessingParameterDatabaseSchema::QgsProcessingParameterDatabaseSchema( const QString &name, const QString &description, const QString &parentLayerParameterName, const QVariant &defaultValue, bool optional ) {…}
 
 
QgsProcessingParameterDefinition *QgsProcessingParameterDatabaseSchema::clone() const
{
  return new QgsProcessingParameterDatabaseSchema( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterDatabaseSchema::clone() const {…}
 
bool QgsProcessingParameterDatabaseSchema::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const
{
  if ( !input.isValid() && !mDefault.isValid() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( ( input.userType() == QMetaType::Type::QString && input.toString().isEmpty() )
       || ( !input.isValid() && mDefault.userType() == QMetaType::Type::QString && mDefault.toString().isEmpty() ) )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  return true;
}
bool QgsProcessingParameterDatabaseSchema::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterDatabaseSchema::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
}
QString QgsProcessingParameterDatabaseSchema::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterDatabaseSchema::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "databaseschema " );
 
  code += mParentConnectionParameterName + ' ';
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterDatabaseSchema::asScriptCode() const {…}
 
QString QgsProcessingParameterDatabaseSchema::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterDatabaseSchema('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", connectionParameterName='%1'" ).arg( mParentConnectionParameterName );
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1" ).arg( valueAsPythonString( mDefault, c ) );
 
      code += ')';
 
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterDatabaseSchema::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QStringList QgsProcessingParameterDatabaseSchema::dependsOnOtherParameters() const
{
  QStringList depends;
  if ( !mParentConnectionParameterName.isEmpty() )
    depends << mParentConnectionParameterName;
  return depends;
}
QStringList QgsProcessingParameterDatabaseSchema::dependsOnOtherParameters() const {…}
 
QString QgsProcessingParameterDatabaseSchema::parentConnectionParameterName() const
{
  return mParentConnectionParameterName;
}
QString QgsProcessingParameterDatabaseSchema::parentConnectionParameterName() const {…}
 
void QgsProcessingParameterDatabaseSchema::setParentConnectionParameterName( const QString &name )
{
  mParentConnectionParameterName = name;
}
void QgsProcessingParameterDatabaseSchema::setParentConnectionParameterName( const QString &name ) {…}
 
QVariantMap QgsProcessingParameterDatabaseSchema::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "mParentConnectionParameterName" ), mParentConnectionParameterName );
  return map;
}
QVariantMap QgsProcessingParameterDatabaseSchema::toVariantMap() const {…}
 
bool QgsProcessingParameterDatabaseSchema::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mParentConnectionParameterName = map.value( QStringLiteral( "mParentConnectionParameterName" ) ).toString();
  return true;
}
bool QgsProcessingParameterDatabaseSchema::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterDatabaseSchema *QgsProcessingParameterDatabaseSchema::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString parent;
  QString def = definition;
 
  const thread_local QRegularExpression re( QStringLiteral( "(.*?)\\s+(.*)$" ) );
  const QRegularExpressionMatch m = re.match( def );
  if ( m.hasMatch() )
  {
    parent = m.captured( 1 ).trimmed();
    def = m.captured( 2 );
  }
  else
  {
    parent = def;
    def.clear();
  }
 
  return new QgsProcessingParameterDatabaseSchema( name, description, parent, def.isEmpty() ? QVariant() : def, isOptional );
}
QgsProcessingParameterDatabaseSchema *QgsProcessingParameterDatabaseSchema::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
//
// QgsProcessingParameterDatabaseTable
//
 
QgsProcessingParameterDatabaseTable::QgsProcessingParameterDatabaseTable( const QString &name, const QString &description,
    const QString &connectionParameterName,
    const QString &schemaParameterName,
    const QVariant &defaultValue, bool optional, bool allowNewTableNames )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mParentConnectionParameterName( connectionParameterName )
  , mParentSchemaParameterName( schemaParameterName )
  , mAllowNewTableNames( allowNewTableNames )
{
 
}
QgsProcessingParameterDatabaseTable::QgsProcessingParameterDatabaseTable( const QString &name, const QString &description, {…}
 
 
QgsProcessingParameterDefinition *QgsProcessingParameterDatabaseTable::clone() const
{
  return new QgsProcessingParameterDatabaseTable( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterDatabaseTable::clone() const {…}
 
bool QgsProcessingParameterDatabaseTable::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const
{
  if ( !input.isValid() && !mDefault.isValid() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( ( input.userType() == QMetaType::Type::QString && input.toString().isEmpty() )
       || ( !input.isValid() && mDefault.userType() == QMetaType::Type::QString && mDefault.toString().isEmpty() ) )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  return true;
}
bool QgsProcessingParameterDatabaseTable::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterDatabaseTable::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
}
QString QgsProcessingParameterDatabaseTable::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterDatabaseTable::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "databasetable " );
 
  code += ( mParentConnectionParameterName.isEmpty() ? QStringLiteral( "none" ) : mParentConnectionParameterName ) + ' ';
  code += ( mParentSchemaParameterName.isEmpty() ? QStringLiteral( "none" ) : mParentSchemaParameterName ) + ' ';
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterDatabaseTable::asScriptCode() const {…}
 
QString QgsProcessingParameterDatabaseTable::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterDatabaseTable('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      if ( mAllowNewTableNames )
        code += QLatin1String( ", allowNewTableNames=True" );
 
      code += QStringLiteral( ", connectionParameterName='%1'" ).arg( mParentConnectionParameterName );
      code += QStringLiteral( ", schemaParameterName='%1'" ).arg( mParentSchemaParameterName );
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1" ).arg( valueAsPythonString( mDefault, c ) );
 
      code += ')';
 
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterDatabaseTable::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QStringList QgsProcessingParameterDatabaseTable::dependsOnOtherParameters() const
{
  QStringList depends;
  if ( !mParentConnectionParameterName.isEmpty() )
    depends << mParentConnectionParameterName;
  if ( !mParentSchemaParameterName.isEmpty() )
    depends << mParentSchemaParameterName;
  return depends;
}
QStringList QgsProcessingParameterDatabaseTable::dependsOnOtherParameters() const {…}
 
QString QgsProcessingParameterDatabaseTable::parentConnectionParameterName() const
{
  return mParentConnectionParameterName;
}
QString QgsProcessingParameterDatabaseTable::parentConnectionParameterName() const {…}
 
void QgsProcessingParameterDatabaseTable::setParentConnectionParameterName( const QString &name )
{
  mParentConnectionParameterName = name;
}
void QgsProcessingParameterDatabaseTable::setParentConnectionParameterName( const QString &name ) {…}
 
QString QgsProcessingParameterDatabaseTable::parentSchemaParameterName() const
{
  return mParentSchemaParameterName;
}
QString QgsProcessingParameterDatabaseTable::parentSchemaParameterName() const {…}
 
void QgsProcessingParameterDatabaseTable::setParentSchemaParameterName( const QString &name )
{
  mParentSchemaParameterName = name;
}
void QgsProcessingParameterDatabaseTable::setParentSchemaParameterName( const QString &name ) {…}
 
QVariantMap QgsProcessingParameterDatabaseTable::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "mParentConnectionParameterName" ), mParentConnectionParameterName );
  map.insert( QStringLiteral( "mParentSchemaParameterName" ), mParentSchemaParameterName );
  map.insert( QStringLiteral( "mAllowNewTableNames" ), mAllowNewTableNames );
  return map;
}
QVariantMap QgsProcessingParameterDatabaseTable::toVariantMap() const {…}
 
bool QgsProcessingParameterDatabaseTable::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mParentConnectionParameterName = map.value( QStringLiteral( "mParentConnectionParameterName" ) ).toString();
  mParentSchemaParameterName = map.value( QStringLiteral( "mParentSchemaParameterName" ) ).toString();
  mAllowNewTableNames = map.value( QStringLiteral( "mAllowNewTableNames" ), false ).toBool();
  return true;
}
bool QgsProcessingParameterDatabaseTable::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterDatabaseTable *QgsProcessingParameterDatabaseTable::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString connection;
  QString schema;
  QString def = definition;
 
  const thread_local QRegularExpression re( QStringLiteral( "(.*?)\\s+(.*+)\\b\\s*(.*)$" ) );
  const QRegularExpressionMatch m = re.match( def );
  if ( m.hasMatch() )
  {
    connection = m.captured( 1 ).trimmed();
    if ( connection == QLatin1String( "none" ) )
      connection.clear();
    schema = m.captured( 2 ).trimmed();
    if ( schema == QLatin1String( "none" ) )
      schema.clear();
    def = m.captured( 3 );
  }
 
  return new QgsProcessingParameterDatabaseTable( name, description, connection, schema, def.isEmpty() ? QVariant() : def, isOptional );
}
QgsProcessingParameterDatabaseTable *QgsProcessingParameterDatabaseTable::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
bool QgsProcessingParameterDatabaseTable::allowNewTableNames() const
{
  return mAllowNewTableNames;
}
bool QgsProcessingParameterDatabaseTable::allowNewTableNames() const {…}
 
void QgsProcessingParameterDatabaseTable::setAllowNewTableNames( bool allowNewTableNames )
{
  mAllowNewTableNames = allowNewTableNames;
}
void QgsProcessingParameterDatabaseTable::setAllowNewTableNames( bool allowNewTableNames ) {…}
 
//
// QgsProcessingParameterPointCloudLayer
//
 
QgsProcessingParameterPointCloudLayer::QgsProcessingParameterPointCloudLayer( const QString &name, const QString &description,
    const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
{
}
QgsProcessingParameterPointCloudLayer::QgsProcessingParameterPointCloudLayer( const QString &name, const QString &description, {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterPointCloudLayer::clone() const
{
  return new QgsProcessingParameterPointCloudLayer( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterPointCloudLayer::clone() const {…}
 
bool QgsProcessingParameterPointCloudLayer::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const
{
  QVariant var = v;
 
  if ( !var.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    var = defaultValue();
  }
 
  if ( var.userType() == qMetaTypeId<QgsProperty>() )
  {
    const QgsProperty p = var.value< QgsProperty >();
    if ( p.propertyType() == Qgis::PropertyType::Static )
    {
      var = p.staticValue();
    }
    else
    {
      return true;
    }
  }
 
  if ( qobject_cast< QgsPointCloudLayer * >( qvariant_cast<QObject *>( var ) ) )
    return true;
 
  if ( var.userType() != QMetaType::Type::QString || var.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( !context )
  {
    // that's as far as we can get without a context
    return true;
  }
 
  // try to load as layer
  if ( QgsProcessingUtils::mapLayerFromString( var.toString(), *context, true, QgsProcessingUtils::LayerHint::PointCloud, QgsProcessing::LayerOptionsFlag::SkipIndexGeneration ) )
    return true;
 
  return false;
}
bool QgsProcessingParameterPointCloudLayer::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const {…}
 
QString QgsProcessingParameterPointCloudLayer::valueAsPythonString( const QVariant &val, QgsProcessingContext &context ) const
{
  if ( !val.isValid() )
    return QStringLiteral( "None" );
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( val.value< QgsProperty >().asExpression() );
 
  QVariantMap p;
  p.insert( name(), val );
  QgsPointCloudLayer *layer = QgsProcessingParameters::parameterAsPointCloudLayer( this, p, context, QgsProcessing::LayerOptionsFlag::SkipIndexGeneration );
  return layer ? QgsProcessingUtils::stringToPythonLiteral( QgsProcessingUtils::layerToStringIdentifier( layer ) )
         : QgsProcessingUtils::stringToPythonLiteral( val.toString() );
}
QString QgsProcessingParameterPointCloudLayer::valueAsPythonString( const QVariant &val, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterPointCloudLayer::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const
{
  return valueAsStringPrivate( value, context, ok, ValueAsStringFlag::AllowMapLayerValues );
}
QString QgsProcessingParameterPointCloudLayer::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const {…}
 
QVariant QgsProcessingParameterPointCloudLayer::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const
{
  return valueAsJsonObjectPrivate( value, context, ValueAsStringFlag::AllowMapLayerValues );
}
QVariant QgsProcessingParameterPointCloudLayer::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterPointCloudLayer::createFileFilter() const
{
  return QgsProviderRegistry::instance()->filePointCloudFilters() + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
}
QString QgsProcessingParameterPointCloudLayer::createFileFilter() const {…}
 
QgsProcessingParameterPointCloudLayer *QgsProcessingParameterPointCloudLayer::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterPointCloudLayer( name, description,  definition.isEmpty() ? QVariant() : definition, isOptional );
}
QgsProcessingParameterPointCloudLayer *QgsProcessingParameterPointCloudLayer::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
//
// QgsProcessingParameterAnnotationLayer
//
 
QgsProcessingParameterAnnotationLayer::QgsProcessingParameterAnnotationLayer( const QString &name, const QString &description,
    const QVariant &defaultValue, bool optional )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
{
}
QgsProcessingParameterAnnotationLayer::QgsProcessingParameterAnnotationLayer( const QString &name, const QString &description, {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterAnnotationLayer::clone() const
{
  return new QgsProcessingParameterAnnotationLayer( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterAnnotationLayer::clone() const {…}
 
bool QgsProcessingParameterAnnotationLayer::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const
{
  QVariant var = v;
  if ( !var.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    var = defaultValue();
  }
 
  if ( var.userType() == qMetaTypeId<QgsProperty>() )
  {
    const QgsProperty p = var.value< QgsProperty >();
    if ( p.propertyType() == Qgis::PropertyType::Static )
    {
      var = p.staticValue();
    }
    else
    {
      return true;
    }
  }
 
  if ( qobject_cast< QgsAnnotationLayer * >( qvariant_cast<QObject *>( var ) ) )
    return true;
 
  if ( var.userType() != QMetaType::Type::QString || var.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  if ( !context )
  {
    // that's as far as we can get without a context
    return true;
  }
 
  // try to load as layer
  if ( QgsProcessingUtils::mapLayerFromString( var.toString(), *context, true, QgsProcessingUtils::LayerHint::Annotation ) )
    return true;
 
  return false;
}
bool QgsProcessingParameterAnnotationLayer::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext *context ) const {…}
 
QString QgsProcessingParameterAnnotationLayer::valueAsPythonString( const QVariant &val, QgsProcessingContext &context ) const
{
  if ( !val.isValid() )
    return QStringLiteral( "None" );
 
  if ( val.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( val.value< QgsProperty >().asExpression() );
 
  QVariantMap p;
  p.insert( name(), val );
  QgsAnnotationLayer *layer = QgsProcessingParameters::parameterAsAnnotationLayer( this, p, context );
  return layer ? QgsProcessingUtils::stringToPythonLiteral( layer == context.project()->mainAnnotationLayer() ? QStringLiteral( "main" ) : layer->id() )
         : QgsProcessingUtils::stringToPythonLiteral( val.toString() );
}
QString QgsProcessingParameterAnnotationLayer::valueAsPythonString( const QVariant &val, QgsProcessingContext &context ) const {…}
 
QString QgsProcessingParameterAnnotationLayer::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const
{
  return valueAsStringPrivate( value, context, ok, ValueAsStringFlag::AllowMapLayerValues );
}
QString QgsProcessingParameterAnnotationLayer::valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok ) const {…}
 
QVariant QgsProcessingParameterAnnotationLayer::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const
{
  return valueAsJsonObjectPrivate( value, context, ValueAsStringFlag::AllowMapLayerValues );
}
QVariant QgsProcessingParameterAnnotationLayer::valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const {…}
 
QgsProcessingParameterAnnotationLayer *QgsProcessingParameterAnnotationLayer::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterAnnotationLayer( name, description,  definition.isEmpty() ? QVariant() : definition, isOptional );
}
QgsProcessingParameterAnnotationLayer *QgsProcessingParameterAnnotationLayer::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
QgsProcessingParameterPointCloudDestination::QgsProcessingParameterPointCloudDestination( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, bool createByDefault )
  : QgsProcessingDestinationParameter( name, description, defaultValue, optional, createByDefault )
{
}
QgsProcessingParameterPointCloudDestination::QgsProcessingParameterPointCloudDestination( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, bool createByDefault ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterPointCloudDestination::clone() const
{
  return new QgsProcessingParameterPointCloudDestination( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterPointCloudDestination::clone() const {…}
 
bool QgsProcessingParameterPointCloudDestination::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const
{
  QVariant var = input;
  if ( !var.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    var = defaultValue();
  }
 
  if ( var.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( var );
    var = fromVar.sink;
  }
 
  if ( var.userType() == qMetaTypeId<QgsProperty>() )
  {
    const QgsProperty p = var.value< QgsProperty >();
    if ( p.propertyType() == Qgis::PropertyType::Static )
    {
      var = p.staticValue();
    }
    else
    {
      return true;
    }
  }
 
  if ( var.userType() != QMetaType::Type::QString )
    return false;
 
  if ( var.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  return true;
}
bool QgsProcessingParameterPointCloudDestination::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterPointCloudDestination::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( value );
    if ( fromVar.sink.propertyType() == Qgis::PropertyType::Static )
    {
      return QgsProcessingUtils::stringToPythonLiteral( fromVar.sink.staticValue().toString() );
    }
    else
    {
      return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( fromVar.sink.asExpression() );
    }
  }
 
  return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
}
QString QgsProcessingParameterPointCloudDestination::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QgsProcessingOutputDefinition *QgsProcessingParameterPointCloudDestination::toOutputDefinition() const
{
  return new QgsProcessingOutputPointCloudLayer( name(), description() );
}
QgsProcessingOutputDefinition *QgsProcessingParameterPointCloudDestination::toOutputDefinition() const {…}
 
QString QgsProcessingParameterPointCloudDestination::defaultFileExtension() const
{
  if ( auto *lOriginalProvider = originalProvider() )
  {
    return lOriginalProvider->defaultPointCloudFileExtension();
  }
  else if ( QgsProcessingProvider *p = provider() )
  {
    return p->defaultPointCloudFileExtension();
  }
  else
  {
    return QgsProcessingUtils::defaultPointCloudExtension();
  }
}
QString QgsProcessingParameterPointCloudDestination::defaultFileExtension() const {…}
 
QString QgsProcessingParameterPointCloudDestination::createFileFilter() const
{
  const QStringList exts = supportedOutputPointCloudLayerExtensions();
  QStringList filters;
  for ( const QString &ext : exts )
  {
    filters << QObject::tr( "%1 files (*.%2)" ).arg( ext.toUpper(), ext.toLower() );
  }
  return filters.join( QLatin1String( ";;" ) ) + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
}
QString QgsProcessingParameterPointCloudDestination::createFileFilter() const {…}
 
QStringList QgsProcessingParameterPointCloudDestination::supportedOutputPointCloudLayerExtensions() const
{
  if ( auto *lOriginalProvider = originalProvider() )
  {
    return lOriginalProvider->supportedOutputPointCloudLayerExtensions();
  }
  else if ( QgsProcessingProvider *p = provider() )
  {
    return p->supportedOutputPointCloudLayerExtensions();
  }
  else
  {
    QString ext = QgsProcessingUtils::defaultPointCloudExtension();
    return QStringList() << ext;
  }
}
QStringList QgsProcessingParameterPointCloudDestination::supportedOutputPointCloudLayerExtensions() const {…}
 
QgsProcessingParameterPointCloudDestination *QgsProcessingParameterPointCloudDestination::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterPointCloudDestination( name, description, definition.isEmpty() ? QVariant() : definition, isOptional );
}
QgsProcessingParameterPointCloudDestination *QgsProcessingParameterPointCloudDestination::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
//
// QgsProcessingParameterPointCloudAttribute
//
 
QgsProcessingParameterPointCloudAttribute::QgsProcessingParameterPointCloudAttribute( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentLayerParameterName, bool allowMultiple, bool optional, bool defaultToAllAttributes )
  : QgsProcessingParameterDefinition( name, description, defaultValue, optional )
  , mParentLayerParameterName( parentLayerParameterName )
  , mAllowMultiple( allowMultiple )
  , mDefaultToAllAttributes( defaultToAllAttributes )
{
}
QgsProcessingParameterPointCloudAttribute::QgsProcessingParameterPointCloudAttribute( const QString &name, const QString &description, const QVariant &defaultValue, const QString &parentLayerParameterName, bool allowMultiple, bool optional, bool defaultToAllAttributes ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterPointCloudAttribute::clone() const
{
  return new QgsProcessingParameterPointCloudAttribute( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterPointCloudAttribute::clone() const {…}
 
bool QgsProcessingParameterPointCloudAttribute::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const
{
  QVariant input = v;
  if ( !v.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    input = defaultValue();
  }
 
  if ( input.userType() == qMetaTypeId<QgsProperty>() )
  {
    return true;
  }
 
  if ( input.userType() == QMetaType::Type::QVariantList || input.userType() == QMetaType::Type::QStringList )
  {
    if ( !mAllowMultiple )
      return false;
 
    if ( input.toList().isEmpty() && !( mFlags & Qgis::ProcessingParameterFlag::Optional ) )
      return false;
  }
  else if ( input.userType() == QMetaType::Type::QString )
  {
    if ( input.toString().isEmpty() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    const QStringList parts = input.toString().split( ';' );
    if ( parts.count() > 1 && !mAllowMultiple )
      return false;
  }
  else
  {
    if ( input.toString().isEmpty() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
  }
  return true;
}
bool QgsProcessingParameterPointCloudAttribute::checkValueIsAcceptable( const QVariant &v, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterPointCloudAttribute::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.userType() == QMetaType::Type::QVariantList )
  {
    QStringList parts;
    const auto constToList = value.toList();
    for ( const QVariant &val : constToList )
    {
      parts << QgsProcessingUtils::stringToPythonLiteral( val.toString() );
    }
    return parts.join( ',' ).prepend( '[' ).append( ']' );
  }
  else if ( value.userType() == QMetaType::Type::QStringList )
  {
    QStringList parts;
    const auto constToStringList = value.toStringList();
    for ( const QString &s : constToStringList )
    {
      parts << QgsProcessingUtils::stringToPythonLiteral( s );
    }
    return parts.join( ',' ).prepend( '[' ).append( ']' );
  }
 
  return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
}
QString QgsProcessingParameterPointCloudAttribute::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QString QgsProcessingParameterPointCloudAttribute::asScriptCode() const
{
  QString code = QStringLiteral( "##%1=" ).arg( mName );
  if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
    code += QLatin1String( "optional " );
  code += QLatin1String( "attribute " );
 
  if ( mAllowMultiple )
    code += QLatin1String( "multiple " );
 
  if ( mDefaultToAllAttributes )
    code += QLatin1String( "default_to_all_attributes " );
 
  code += mParentLayerParameterName + ' ';
 
  code += mDefault.toString();
  return code.trimmed();
}
QString QgsProcessingParameterPointCloudAttribute::asScriptCode() const {…}
 
QString QgsProcessingParameterPointCloudAttribute::asPythonString( const QgsProcessing::PythonOutputType outputType ) const
{
  switch ( outputType )
  {
    case QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass:
    {
      QString code = QStringLiteral( "QgsProcessingParameterPointCloudAttribute('%1', %2" )
                     .arg( name(), QgsProcessingUtils::stringToPythonLiteral( description() ) );
      if ( mFlags & Qgis::ProcessingParameterFlag::Optional )
        code += QLatin1String( ", optional=True" );
 
      code += QStringLiteral( ", parentLayerParameterName='%1'" ).arg( mParentLayerParameterName );
      code += QStringLiteral( ", allowMultiple=%1" ).arg( mAllowMultiple ? QStringLiteral( "True" ) : QStringLiteral( "False" ) );
      QgsProcessingContext c;
      code += QStringLiteral( ", defaultValue=%1" ).arg( valueAsPythonString( mDefault, c ) );
 
      if ( mDefaultToAllAttributes )
        code += QLatin1String( ", defaultToAllAttributes=True" );
 
      code += ')';
 
      return code;
    }
  }
  return QString();
}
QString QgsProcessingParameterPointCloudAttribute::asPythonString( const QgsProcessing::PythonOutputType outputType ) const {…}
 
QStringList QgsProcessingParameterPointCloudAttribute::dependsOnOtherParameters() const
{
  QStringList depends;
  if ( !mParentLayerParameterName.isEmpty() )
    depends << mParentLayerParameterName;
  return depends;
}
QStringList QgsProcessingParameterPointCloudAttribute::dependsOnOtherParameters() const {…}
 
QString QgsProcessingParameterPointCloudAttribute::parentLayerParameterName() const
{
  return mParentLayerParameterName;
}
QString QgsProcessingParameterPointCloudAttribute::parentLayerParameterName() const {…}
 
void QgsProcessingParameterPointCloudAttribute::setParentLayerParameterName( const QString &parentLayerParameterName )
{
  mParentLayerParameterName = parentLayerParameterName;
}
void QgsProcessingParameterPointCloudAttribute::setParentLayerParameterName( const QString &parentLayerParameterName ) {…}
 
bool QgsProcessingParameterPointCloudAttribute::allowMultiple() const
{
  return mAllowMultiple;
}
bool QgsProcessingParameterPointCloudAttribute::allowMultiple() const {…}
 
void QgsProcessingParameterPointCloudAttribute::setAllowMultiple( bool allowMultiple )
{
  mAllowMultiple = allowMultiple;
}
void QgsProcessingParameterPointCloudAttribute::setAllowMultiple( bool allowMultiple ) {…}
 
bool QgsProcessingParameterPointCloudAttribute::defaultToAllAttributes() const
{
  return mDefaultToAllAttributes;
}
bool QgsProcessingParameterPointCloudAttribute::defaultToAllAttributes() const {…}
 
void QgsProcessingParameterPointCloudAttribute::setDefaultToAllAttributes( bool enabled )
{
  mDefaultToAllAttributes = enabled;
}
void QgsProcessingParameterPointCloudAttribute::setDefaultToAllAttributes( bool enabled ) {…}
 
QVariantMap QgsProcessingParameterPointCloudAttribute::toVariantMap() const
{
  QVariantMap map = QgsProcessingParameterDefinition::toVariantMap();
  map.insert( QStringLiteral( "parent_layer" ), mParentLayerParameterName );
  map.insert( QStringLiteral( "allow_multiple" ), mAllowMultiple );
  map.insert( QStringLiteral( "default_to_all_attributes" ), mDefaultToAllAttributes );
  return map;
}
QVariantMap QgsProcessingParameterPointCloudAttribute::toVariantMap() const {…}
 
bool QgsProcessingParameterPointCloudAttribute::fromVariantMap( const QVariantMap &map )
{
  QgsProcessingParameterDefinition::fromVariantMap( map );
  mParentLayerParameterName = map.value( QStringLiteral( "parent_layer" ) ).toString();
  mAllowMultiple = map.value( QStringLiteral( "allow_multiple" ) ).toBool();
  mDefaultToAllAttributes = map.value( QStringLiteral( "default_to_all_attributes" ) ).toBool();
  return true;
}
bool QgsProcessingParameterPointCloudAttribute::fromVariantMap( const QVariantMap &map ) {…}
 
QgsProcessingParameterPointCloudAttribute *QgsProcessingParameterPointCloudAttribute::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  QString parent;
  bool allowMultiple = false;
  bool defaultToAllAttributes = false;
  QString def = definition;
 
  if ( def.startsWith( QLatin1String( "multiple" ), Qt::CaseInsensitive ) )
  {
    allowMultiple = true;
    def = def.mid( 8 ).trimmed();
  }
 
  if ( def.startsWith( QLatin1String( "default_to_all_attributes" ), Qt::CaseInsensitive ) )
  {
    defaultToAllAttributes = true;
    def = def.mid( 25 ).trimmed();
  }
 
  const thread_local QRegularExpression re( QStringLiteral( "(.*?)\\s+(.*)$" ) );
  const QRegularExpressionMatch m = re.match( def );
  if ( m.hasMatch() )
  {
    parent = m.captured( 1 ).trimmed();
    def = m.captured( 2 );
  }
  else
  {
    parent = def;
    def.clear();
  }
 
  return new QgsProcessingParameterPointCloudAttribute( name, description, def.isEmpty() ? QVariant() : def, parent, allowMultiple, isOptional, defaultToAllAttributes );
}
QgsProcessingParameterPointCloudAttribute *QgsProcessingParameterPointCloudAttribute::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}
 
//
// QgsProcessingParameterVectorTileDestination
//
 
QgsProcessingParameterVectorTileDestination::QgsProcessingParameterVectorTileDestination( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, bool createByDefault )
  : QgsProcessingDestinationParameter( name, description, defaultValue, optional, createByDefault )
{
}
QgsProcessingParameterVectorTileDestination::QgsProcessingParameterVectorTileDestination( const QString &name, const QString &description, const QVariant &defaultValue, bool optional, bool createByDefault ) {…}
 
QgsProcessingParameterDefinition *QgsProcessingParameterVectorTileDestination::clone() const
{
  return new QgsProcessingParameterVectorTileDestination( *this );
}
QgsProcessingParameterDefinition *QgsProcessingParameterVectorTileDestination::clone() const {…}
 
bool QgsProcessingParameterVectorTileDestination::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const
{
  QVariant var = input;
  if ( !var.isValid() )
  {
    if ( !defaultValue().isValid() )
      return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
    var = defaultValue();
  }
 
  if ( var.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( var );
    var = fromVar.sink;
  }
 
  if ( var.userType() == qMetaTypeId<QgsProperty>() )
  {
    const QgsProperty p = var.value< QgsProperty >();
    if ( p.propertyType() == Qgis::PropertyType::Static )
    {
      var = p.staticValue();
    }
    else
    {
      return true;
    }
  }
 
  if ( var.userType() != QMetaType::Type::QString )
    return false;
 
  if ( var.toString().isEmpty() )
    return mFlags & Qgis::ProcessingParameterFlag::Optional;
 
  return true;
}
bool QgsProcessingParameterVectorTileDestination::checkValueIsAcceptable( const QVariant &input, QgsProcessingContext * ) const {…}
 
QString QgsProcessingParameterVectorTileDestination::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const
{
  if ( !value.isValid() )
    return QStringLiteral( "None" );
 
  if ( value.userType() == qMetaTypeId<QgsProperty>() )
    return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( value.value< QgsProperty >().asExpression() );
 
  if ( value.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
  {
    const QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( value );
    if ( fromVar.sink.propertyType() == Qgis::PropertyType::Static )
    {
      return QgsProcessingUtils::stringToPythonLiteral( fromVar.sink.staticValue().toString() );
    }
    else
    {
      return QStringLiteral( "QgsProperty.fromExpression('%1')" ).arg( fromVar.sink.asExpression() );
    }
  }
 
  return QgsProcessingUtils::stringToPythonLiteral( value.toString() );
}
QString QgsProcessingParameterVectorTileDestination::valueAsPythonString( const QVariant &value, QgsProcessingContext & ) const {…}
 
QgsProcessingOutputDefinition *QgsProcessingParameterVectorTileDestination::toOutputDefinition() const
{
  return new QgsProcessingOutputVectorTileLayer( name(), description() );
}
QgsProcessingOutputDefinition *QgsProcessingParameterVectorTileDestination::toOutputDefinition() const {…}
 
QString QgsProcessingParameterVectorTileDestination::defaultFileExtension() const
{
  return QgsProcessingUtils::defaultVectorTileExtension();
}
QString QgsProcessingParameterVectorTileDestination::defaultFileExtension() const {…}
 
QString QgsProcessingParameterVectorTileDestination::createFileFilter() const
{
  const QStringList exts = supportedOutputVectorTileLayerExtensions();
  QStringList filters;
  for ( const QString &ext : exts )
  {
    filters << QObject::tr( "%1 files (*.%2)" ).arg( ext.toUpper(), ext.toLower() );
  }
  return filters.join( QLatin1String( ";;" ) ) + QStringLiteral( ";;" ) + QObject::tr( "All files (*.*)" );
}
QString QgsProcessingParameterVectorTileDestination::createFileFilter() const {…}
 
QStringList QgsProcessingParameterVectorTileDestination::supportedOutputVectorTileLayerExtensions() const
{
  QString ext = QgsProcessingUtils::defaultVectorTileExtension();
  return QStringList() << ext;
}
QStringList QgsProcessingParameterVectorTileDestination::supportedOutputVectorTileLayerExtensions() const {…}
 
QgsProcessingParameterVectorTileDestination *QgsProcessingParameterVectorTileDestination::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition )
{
  return new QgsProcessingParameterVectorTileDestination( name, description, definition.isEmpty() ? QVariant() : definition, isOptional );
}
QgsProcessingParameterVectorTileDestination *QgsProcessingParameterVectorTileDestination::fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) {…}