QGIS API Documentation  3.18.1-Zürich (202f1bf7e5)
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 }
QString id() const
Returns the layer's unique ID, which is used to access this layer from QgsProject.
Contains information about the context in which a processing algorithm is executed.
Base class for the definition of processing parameters.
QString description() const
Returns the description for the parameter.
QString name() const
Returns the name of the parameter.
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...
static QList< QgsVectorTileWriter::Layer > parameterAsLayers(const QVariant &layersVariant, QgsProcessingContext &context)
Converts a QVariant value (a QVariantList) to a list of input layers.
QgsProcessingParameterDefinition * clone() const override
Creates a clone of the parameter definition.
static QgsVectorTileWriter::Layer variantMapAsLayer(const QVariantMap &layerVariantMap, QgsProcessingContext &context)
Converts a QVariant value (a QVariantMap) to a single input layer.
static QVariantMap layerAsVariantMap(const QgsVectorTileWriter::Layer &layer)
Converts a single input layer to QVariant representation (a QVariantMap)
bool checkValueIsAcceptable(const QVariant &input, QgsProcessingContext *context=nullptr) const override
Checks whether the specified input value is acceptable for the parameter.
QgsProcessingParameterVectorTileWriterLayers(const QString &name, const QString &description=QString())
Constructor for QgsProcessingParameterVectorTileWriterLayers.
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...
QString type() const override
Unique parameter type name.
static QString typeName()
Returns the type name for the parameter class.
static QString stringToPythonLiteral(const QString &string)
Converts a string to a Python string literal.
static QString normalizeLayerSource(const QString &source)
Normalizes a layer source string for safe comparison across different operating system environments.
static QString variantToPythonLiteral(const QVariant &value)
Converts a variant to a Python literal.
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.
PythonOutputType
Available Python output types.
Definition: qgsprocessing.h:59
@ PythonQgsProcessingAlgorithmSubclass
Full Python QgsProcessingAlgorithm subclass.
Definition: qgsprocessing.h:60
Represents a vector layer which manages a vector based data sets.
Configuration of a single input vector layer to be included in the output.
QString layerName() const
Returns layer name in the output. If not set, layer()->name() will be used.
QgsVectorLayer * layer() const
Returns vector layer of this entry.
void setLayerName(const QString &name)
Sets layer name in the output. If not set, layer()->name() will be used.
void setMaxZoom(int maxzoom)
Sets maximum zoom level at which this layer will be used. Negative value means no max....
void setFilterExpression(const QString &expr)
Sets filter expression. If not empty, only features matching the expression will be used.
void setMinZoom(int minzoom)
Sets minimum zoom level at which this layer will be used. Negative value means no min....
QString filterExpression() const
Returns filter expression. If not empty, only features matching the expression will be used.
int maxZoom() const
Returns maximum zoom level at which this layer will be used. Negative value means no max....
int minZoom() const
Returns minimum zoom level at which this layer will be used. Negative value means no min....