QGIS API Documentation  3.16.0-Hannover (43b64b13f3)
qgsprocessingparametervectortilewriterlayers.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsprocessingparametervectortilewriterlayers.cpp
3  ---------------------
4  Date : April 2020
5  Copyright : (C) 2020 by Martin Dobias
6  Email : wonder dot sk at gmail dot com
7  ***************************************************************************
8  * *
9  * This program is free software; you can redistribute it and/or modify *
10  * it under the terms of the GNU General Public License as published by *
11  * the Free Software Foundation; either version 2 of the License, or *
12  * (at your option) any later version. *
13  * *
14  ***************************************************************************/
15 
17 
18 #include "qgsvectorlayer.h"
19 
20 
22  : QgsProcessingParameterDefinition( name, description, QVariant(), false )
23 {
24 }
25 
27 {
29 }
30 
32 {
33  return typeName();
34 }
35 
37 {
38  if ( !input.isValid() )
39  return mFlags & FlagOptional;
40 
41  if ( input.type() != QVariant::List )
42  return false;
43 
44  const QVariantList inputList = input.toList();
45  for ( const QVariant &inputItem : inputList )
46  {
47  if ( inputItem.type() != QVariant::Map )
48  return false;
49  QVariantMap inputItemMap = inputItem.toMap();
50 
51  // "layer" is required - pointing to a vector layer
52  if ( !inputItemMap.contains( "layer" ) )
53  return false;
54 
55  QVariant inputItemLayer = inputItemMap["layer"];
56 
57  if ( qobject_cast< QgsVectorLayer * >( qvariant_cast<QObject *>( inputItemLayer ) ) )
58  continue;
59 
60  if ( !context )
61  continue; // when called without context, we will skip checking whether the layer can be resolved
62 
63  if ( !QgsProcessingUtils::mapLayerFromString( inputItemLayer.toString(), *context ) )
64  return false;
65  }
66 
67  return true;
68 }
69 
71 {
72  QStringList parts;
73  const QList<QgsVectorTileWriter::Layer> layers = parameterAsLayers( value, context );
74  for ( const QgsVectorTileWriter::Layer &layer : layers )
75  {
76  QStringList layerDefParts;
77  layerDefParts << QStringLiteral( "'layer': " ) + QgsProcessingUtils::stringToPythonLiteral( QgsProcessingUtils::normalizeLayerSource( layer.layer()->source() ) );
78  if ( !layer.filterExpression().isEmpty() )
79  layerDefParts << QStringLiteral( "'filterExpression': " ) + QgsProcessingUtils::variantToPythonLiteral( layer.filterExpression() );
80  if ( !layer.layerName().isEmpty() )
81  layerDefParts << QStringLiteral( "'layerName': " ) + QgsProcessingUtils::variantToPythonLiteral( layer.layerName() );
82  if ( layer.minZoom() >= 0 )
83  layerDefParts << QStringLiteral( "'minZoom': " ) + QgsProcessingUtils::variantToPythonLiteral( layer.minZoom() );
84  if ( layer.maxZoom() >= 0 )
85  layerDefParts << QStringLiteral( "'maxZoom': " ) + QgsProcessingUtils::variantToPythonLiteral( layer.maxZoom() );
86 
87  QString layerDef = QStringLiteral( "{ %1 }" ).arg( layerDefParts.join( ',' ) );
88  parts << layerDef;
89  }
90  return parts.join( ',' ).prepend( '[' ).append( ']' );
91 }
92 
94 {
95  switch ( outputType )
96  {
98  {
99  QString code = QStringLiteral( "QgsProcessingParameterVectorTileWriterLayers('%1', '%2')" ).arg( name(), description() );
100  return code;
101  }
102  }
103  return QString();
104 }
105 
106 QList<QgsVectorTileWriter::Layer> QgsProcessingParameterVectorTileWriterLayers::parameterAsLayers( const QVariant &layersVariant, QgsProcessingContext &context )
107 {
108  QList<QgsVectorTileWriter::Layer> layers;
109  const QVariantList layersVariantList = layersVariant.toList();
110  for ( const QVariant &layerItem : layersVariantList )
111  {
112  QVariantMap layerVariantMap = layerItem.toMap();
113  layers << variantMapAsLayer( layerVariantMap, context );
114  }
115  return layers;
116 }
117 
119 {
120  QVariant layerVariant = layerVariantMap["layer"];
121 
122  QgsVectorLayer *inputLayer = nullptr;
123  if ( ( inputLayer = qobject_cast< QgsVectorLayer * >( qvariant_cast<QObject *>( layerVariant ) ) ) )
124  {
125  // good
126  }
127  else if ( ( inputLayer = qobject_cast< QgsVectorLayer * >( QgsProcessingUtils::mapLayerFromString( layerVariant.toString(), context ) ) ) )
128  {
129  // good
130  }
131  else
132  {
133  // bad
134  }
135 
136  QgsVectorTileWriter::Layer writerLayer( inputLayer );
137  if ( layerVariantMap.contains( "filterExpression" ) )
138  writerLayer.setFilterExpression( layerVariantMap["filterExpression"].toString() );
139  if ( layerVariantMap.contains( "minZoom" ) )
140  writerLayer.setMinZoom( layerVariantMap["minZoom"].toInt() );
141  if ( layerVariantMap.contains( "maxZoom" ) )
142  writerLayer.setMaxZoom( layerVariantMap["maxZoom"].toInt() );
143  if ( layerVariantMap.contains( "layerName" ) )
144  writerLayer.setLayerName( layerVariantMap["layerName"].toString() );
145 
146  return writerLayer;
147 }
148 
150 {
151  QVariantMap vm;
152  if ( !layer.layer() )
153  return vm;
154 
155  vm["layer"] = layer.layer()->id();
156  vm["minZoom"] = layer.minZoom();
157  vm["maxZoom"] = layer.maxZoom();
158  vm["layerName"] = layer.layerName();
159  vm["filterExpression"] = layer.filterExpression();
160  return vm;
161 }
QgsVectorTileWriter::Layer::minZoom
int minZoom() const
Returns minimum zoom level at which this layer will be used. Negative value means no min....
Definition: qgsvectortilewriter.h:107
QgsProcessingParameterVectorTileWriterLayers::type
QString type() const override
Unique parameter type name.
Definition: qgsprocessingparametervectortilewriterlayers.cpp:31
QgsProcessingParameterDefinition::description
QString description() const
Returns the description for the parameter.
Definition: qgsprocessingparameters.h:474
QgsVectorTileWriter::Layer::setLayerName
void setLayerName(const QString &name)
Sets layer name in the output. If not set, layer()->name() will be used.
Definition: qgsvectortilewriter.h:104
QgsVectorTileWriter::Layer::setMinZoom
void setMinZoom(int minzoom)
Sets minimum zoom level at which this layer will be used. Negative value means no min....
Definition: qgsvectortilewriter.h:109
QgsProcessingUtils::normalizeLayerSource
static QString normalizeLayerSource(const QString &source)
Normalizes a layer source string for safe comparison across different operating system environments.
Definition: qgsprocessingutils.cpp:514
QgsProcessingParameterVectorTileWriterLayers::layerAsVariantMap
static QVariantMap layerAsVariantMap(const QgsVectorTileWriter::Layer &layer)
Converts a single input layer to QVariant representation (a QVariantMap)
Definition: qgsprocessingparametervectortilewriterlayers.cpp:149
QgsProcessingParameterDefinition
Base class for the definition of processing parameters.
Definition: qgsprocessingparameters.h:331
QgsVectorTileWriter::Layer::setMaxZoom
void setMaxZoom(int maxzoom)
Sets maximum zoom level at which this layer will be used. Negative value means no max....
Definition: qgsvectortilewriter.h:114
QgsVectorTileWriter::Layer::filterExpression
QString filterExpression() const
Returns filter expression. If not empty, only features matching the expression will be used.
Definition: qgsvectortilewriter.h:97
QgsProcessingUtils::stringToPythonLiteral
static QString stringToPythonLiteral(const QString &string)
Converts a string to a Python string literal.
Definition: qgsprocessingutils.cpp:611
QgsVectorTileWriter::Layer::setFilterExpression
void setFilterExpression(const QString &expr)
Sets filter expression. If not empty, only features matching the expression will be used.
Definition: qgsvectortilewriter.h:99
QgsVectorTileWriter::Layer::maxZoom
int maxZoom() const
Returns maximum zoom level at which this layer will be used. Negative value means no max....
Definition: qgsvectortilewriter.h:112
QgsProcessing::PythonQgsProcessingAlgorithmSubclass
@ PythonQgsProcessingAlgorithmSubclass
Full Python QgsProcessingAlgorithm subclass.
Definition: qgsprocessing.h:60
QgsProcessingParameterDefinition::mFlags
Flags mFlags
Parameter flags.
Definition: qgsprocessingparameters.h:733
QgsProcessingContext
Contains information about the context in which a processing algorithm is executed.
Definition: qgsprocessingcontext.h:44
qgsprocessingparametervectortilewriterlayers.h
QgsProcessingParameterDefinition::name
QString name() const
Returns the name of the parameter.
Definition: qgsprocessingparameters.h:460
QgsProcessingParameterVectorTileWriterLayers::asPythonString
QString asPythonString(QgsProcessing::PythonOutputType outputType=QgsProcessing::PythonQgsProcessingAlgorithmSubclass) const override
Returns the parameter definition as a Python command which can be used within a Python Processing scr...
Definition: qgsprocessingparametervectortilewriterlayers.cpp:93
QgsMapLayer::id
QString id() const
Returns the layer's unique ID, which is used to access this layer from QgsProject.
Definition: qgsmaplayer.cpp:148
QgsProcessingParameterVectorTileWriterLayers::parameterAsLayers
static QList< QgsVectorTileWriter::Layer > parameterAsLayers(const QVariant &layersVariant, QgsProcessingContext &context)
Converts a QVariant value (a QVariantList) to a list of input layers.
Definition: qgsprocessingparametervectortilewriterlayers.cpp:106
QgsProcessingParameterVectorTileWriterLayers::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition: qgsprocessingparametervectortilewriterlayers.h:58
qgsvectorlayer.h
QgsVectorTileWriter::Layer::layer
QgsVectorLayer * layer() const
Returns vector layer of this entry.
Definition: qgsvectortilewriter.h:94
QgsProcessingParameterVectorTileWriterLayers::QgsProcessingParameterVectorTileWriterLayers
QgsProcessingParameterVectorTileWriterLayers(const QString &name, const QString &description=QString())
Constructor for QgsProcessingParameterVectorTileWriterLayers.
Definition: qgsprocessingparametervectortilewriterlayers.cpp:21
QgsProcessingParameterVectorTileWriterLayers::checkValueIsAcceptable
bool checkValueIsAcceptable(const QVariant &input, QgsProcessingContext *context=nullptr) const override
Checks whether the specified input value is acceptable for the parameter.
Definition: qgsprocessingparametervectortilewriterlayers.cpp:36
QgsProcessingParameterVectorTileWriterLayers::variantMapAsLayer
static QgsVectorTileWriter::Layer variantMapAsLayer(const QVariantMap &layerVariantMap, QgsProcessingContext &context)
Converts a QVariant value (a QVariantMap) to a single input layer.
Definition: qgsprocessingparametervectortilewriterlayers.cpp:118
QgsVectorLayer
Represents a vector layer which manages a vector based data sets.
Definition: qgsvectorlayer.h:387
QgsProcessingUtils::variantToPythonLiteral
static QString variantToPythonLiteral(const QVariant &value)
Converts a variant to a Python literal.
Definition: qgsprocessingutils.cpp:521
QgsVectorTileWriter::Layer
Configuration of a single input vector layer to be included in the output.
Definition: qgsvectortilewriter.h:85
QgsProcessingParameterVectorTileWriterLayers::valueAsPythonString
QString valueAsPythonString(const QVariant &value, QgsProcessingContext &context) const override
Returns a string version of the parameter input value, which is suitable for use as an input paramete...
Definition: qgsprocessingparametervectortilewriterlayers.cpp:70
QgsProcessingUtils::mapLayerFromString
static QgsMapLayer * mapLayerFromString(const QString &string, QgsProcessingContext &context, bool allowLoadingNewLayers=true, QgsProcessingUtils::LayerHint typeHint=QgsProcessingUtils::LayerHint::UnknownType)
Interprets a string as a map layer within the supplied context.
Definition: qgsprocessingutils.cpp:316
QgsProcessingParameterDefinition::FlagOptional
@ FlagOptional
Parameter is optional.
Definition: qgsprocessingparameters.h:425
QgsProcessing::PythonOutputType
PythonOutputType
Available Python output types.
Definition: qgsprocessing.h:59
QgsVectorTileWriter::Layer::layerName
QString layerName() const
Returns layer name in the output. If not set, layer()->name() will be used.
Definition: qgsvectortilewriter.h:102
QgsProcessingParameterVectorTileWriterLayers::clone
QgsProcessingParameterDefinition * clone() const override
Creates a clone of the parameter definition.
Definition: qgsprocessingparametervectortilewriterlayers.cpp:26