QGIS API Documentation 3.39.0-Master (67e056379ed)
Loading...
Searching...
No Matches
qgsalgorithmpackage.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsalgorithmpackage.cpp
3 ---------------------
4 begin : November 2017
5 copyright : (C) 2017 by Nyall Dawson
6 email : nyall dot dawson at gmail dot com
7 ***************************************************************************/
8
9/***************************************************************************
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 ***************************************************************************/
17
18#include "qgsalgorithmpackage.h"
19#include "qgsogrutils.h"
20#include "qgsvectorfilewriter.h"
21#include "qgsvectorlayer.h"
22#include "qgssettings.h"
23
24#include <QLocale>
25
27
28QString QgsPackageAlgorithm::name() const
29{
30 return QStringLiteral( "package" );
31}
32
33QString QgsPackageAlgorithm::displayName() const
34{
35 return QObject::tr( "Package layers" );
36}
37
38QStringList QgsPackageAlgorithm::tags() const
39{
40 return QObject::tr( "geopackage,collect,merge,combine,styles" ).split( ',' );
41}
42
43QString QgsPackageAlgorithm::group() const
44{
45 return QObject::tr( "Database" );
46}
47
48QString QgsPackageAlgorithm::groupId() const
49{
50 return QStringLiteral( "database" );
51}
52
53void QgsPackageAlgorithm::initAlgorithm( const QVariantMap & )
54{
55 addParameter( new QgsProcessingParameterMultipleLayers( QStringLiteral( "LAYERS" ), QObject::tr( "Input layers" ), Qgis::ProcessingSourceType::Vector ) );
56 QgsProcessingParameterFileDestination *outputParameter = new QgsProcessingParameterFileDestination( QStringLiteral( "OUTPUT" ), QObject::tr( "Destination GeoPackage" ), QObject::tr( "GeoPackage files (*.gpkg)" ) );
57 outputParameter->setMetadata( QVariantMap( {{QStringLiteral( "widget_wrapper" ), QVariantMap( {{QStringLiteral( "dontconfirmoverwrite" ), true }} ) }} ) );
58 addParameter( outputParameter );
59 addParameter( new QgsProcessingParameterBoolean( QStringLiteral( "OVERWRITE" ), QObject::tr( "Overwrite existing GeoPackage" ), false ) );
60 addParameter( new QgsProcessingParameterBoolean( QStringLiteral( "SAVE_STYLES" ), QObject::tr( "Save layer styles into GeoPackage" ), true ) );
61 addParameter( new QgsProcessingParameterBoolean( QStringLiteral( "SAVE_METADATA" ), QObject::tr( "Save layer metadata into GeoPackage" ), true ) );
62 addParameter( new QgsProcessingParameterBoolean( QStringLiteral( "SELECTED_FEATURES_ONLY" ), QObject::tr( "Save only selected features" ), false ) );
63 addParameter( new QgsProcessingParameterBoolean( QStringLiteral( "EXPORT_RELATED_LAYERS" ), QObject::tr( "Export related layers following relations defined in the project" ), false ) );
64 addOutput( new QgsProcessingOutputMultipleLayers( QStringLiteral( "OUTPUT_LAYERS" ), QObject::tr( "Layers within new package" ) ) );
65}
66
67QString QgsPackageAlgorithm::shortHelpString() const
68{
69 return QObject::tr( "This algorithm collects a number of existing layers and packages them together into a single GeoPackage database." );
70}
71
72QgsPackageAlgorithm *QgsPackageAlgorithm::createInstance() const
73{
74 return new QgsPackageAlgorithm();
75}
76
77bool QgsPackageAlgorithm::prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
78{
79
80 const QList< QgsMapLayer * > layers = parameterAsLayerList( parameters, QStringLiteral( "LAYERS" ), context );
81
82 for ( const QgsMapLayer *layer : std::as_const( layers ) )
83 {
84 QgsMapLayer *clonedLayer { layer->clone() };
85 mClonedLayerIds.insert( clonedLayer->id(), layer->id( ) );
86 mLayers.emplace_back( clonedLayer );
87 }
88
89 if ( mLayers.empty() )
90 {
91 feedback->reportError( QObject::tr( "No layers selected, geopackage will be empty" ), false );
92 }
93
94 return true;
95}
96
97QVariantMap QgsPackageAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
98{
99 const bool overwrite = parameterAsBoolean( parameters, QStringLiteral( "OVERWRITE" ), context );
100 const bool saveStyles = parameterAsBoolean( parameters, QStringLiteral( "SAVE_STYLES" ), context );
101 const bool saveMetadata = parameterAsBoolean( parameters, QStringLiteral( "SAVE_METADATA" ), context );
102 const bool selectedFeaturesOnly = parameterAsBoolean( parameters, QStringLiteral( "SELECTED_FEATURES_ONLY" ), context );
103 const bool exportRelatedLayers = parameterAsBoolean( parameters, QStringLiteral( "EXPORT_RELATED_LAYERS" ), context );
104 const QString packagePath = parameterAsString( parameters, QStringLiteral( "OUTPUT" ), context );
105 const QList< QgsMapLayer * > layers = parameterAsLayerList( parameters, QStringLiteral( "LAYERS" ), context );
106
107 if ( packagePath.isEmpty() )
108 throw QgsProcessingException( QObject::tr( "No output file specified." ) );
109
110 // delete existing geopackage if it exists
111 if ( overwrite && QFile::exists( packagePath ) )
112 {
113 feedback->pushInfo( QObject::tr( "Removing existing file '%1'" ).arg( packagePath ) );
114 if ( !QFile( packagePath ).remove() )
115 {
116 throw QgsProcessingException( QObject::tr( "Could not remove existing file '%1'" ).arg( packagePath ) );
117 }
118 }
119
120 OGRSFDriverH hGpkgDriver = OGRGetDriverByName( "GPKG" );
121 if ( !hGpkgDriver )
122 {
123 throw QgsProcessingException( QObject::tr( "GeoPackage driver not found." ) );
124 }
125
126
127 // Collect related layers from project relations
128 if ( exportRelatedLayers )
129 {
130 const QgsProject *project { context.project() };
131 if ( project && ! project->relationManager()->relations().isEmpty() )
132 {
133
134 // Infinite recursion should not happen in the real world but better safe than sorry
135 const int maxRecursion { 10 };
136 int recursionGuard { 0 };
137
138 // This function recursively finds referenced layers
139 const auto findReferenced = [ =, &project, &feedback, &recursionGuard, &layers ]( const QgsVectorLayer * vLayer, bool onlySaveSelected, auto &&findReferenced ) -> void
140 {
141 const QgsVectorLayer *originalLayer { qobject_cast<QgsVectorLayer *>( project->mapLayer( mClonedLayerIds.value( vLayer->id(), vLayer->id() ) ) ) };
142 Q_ASSERT( originalLayer );
143 const QList<QgsRelation> relations { project->relationManager()->referencingRelations( originalLayer ) };
144 for ( const QgsRelation &relation : std::as_const( relations ) )
145 {
146
147 QgsVectorLayer *referencedLayer { relation.referencedLayer() };
148 QgsVectorLayer *relatedLayer { nullptr };
149
150 // Check if the layer was already in the export list
151 bool alreadyAdded { false };
152 for ( const auto &layerToExport : std::as_const( mLayers ) )
153 {
154 const QString originalId { mClonedLayerIds.value( layerToExport->id() ) };
155 if ( originalId == referencedLayer->id() )
156 {
157 relatedLayer = qobject_cast<QgsVectorLayer *>( layerToExport.get() );
158 alreadyAdded = true;
159 break;
160 }
161 }
162
163 if ( !alreadyAdded )
164 {
165 feedback->pushInfo( QObject::tr( "Adding referenced layer '%1'" ).arg( referencedLayer->name() ) );
166 relatedLayer = referencedLayer->clone();
167 mLayers.emplace_back( relatedLayer );
168 mClonedLayerIds.insert( relatedLayer->id(), referencedLayer->id() );
169 }
170
171 // Export only relevant features unless the layer was in the original export list and no selection was made on that layer
172 // in that case the user explicitly marked the layer for export and it is supposed to be exported fully.
173 if ( onlySaveSelected )
174 {
175 if ( ! layers.contains( qobject_cast<QgsMapLayer *>( referencedLayer ) ) || referencedLayer->selectedFeatureCount() > 0 )
176 {
177 Q_ASSERT( relatedLayer );
178 QgsFeatureIds selected;
179 QgsFeatureIterator it { vLayer->getSelectedFeatures() };
180 QgsFeature selectedFeature;
181 while ( it.nextFeature( selectedFeature ) )
182 {
183 QgsFeature referencedFeature { relation.getReferencedFeature( selectedFeature ) };
184 if ( referencedFeature.isValid() )
185 {
186 selected.insert( referencedFeature.id() );
187 }
188 }
189 relatedLayer->selectByIds( selected, Qgis::SelectBehavior::AddToSelection );
190 }
191 }
192
193 // Recursive finding
194 if ( recursionGuard > maxRecursion )
195 {
196 feedback->pushWarning( QObject::tr( "Max recursion (%1) adding referenced layer '%2', layer was not added" ).arg( QLocale().toString( recursionGuard ), referencedLayer->name() ) );
197 }
198 else
199 {
200 recursionGuard++;
201 findReferenced( relatedLayer, onlySaveSelected, findReferenced );
202 }
203 }
204
205 };
206
207 // This function recursively finds referencing layers
208 const auto findReferencing = [ =, &project, &feedback, &recursionGuard, &layers ]( const QgsVectorLayer * vLayer, bool onlySaveSelected, auto &&findReferencing ) -> void
209 {
210 const QgsVectorLayer *originalLayer { qobject_cast<QgsVectorLayer *>( project->mapLayer( mClonedLayerIds.value( vLayer->id(), vLayer->id() ) ) ) };
211 Q_ASSERT( originalLayer );
212 const QList<QgsRelation> relations { project->relationManager()->referencedRelations( originalLayer ) };
213 for ( const QgsRelation &relation : std::as_const( relations ) )
214 {
215
216 QgsVectorLayer *referencingLayer { relation.referencingLayer() };
217 QgsVectorLayer *relatedLayer { nullptr };
218 const bool layerWasExplicitlyAdded { layers.contains( qobject_cast<QgsMapLayer *>( referencingLayer ) ) };
219
220 // Check if the layer was already in the export list
221 bool alreadyAdded { false };
222 for ( const auto &layerToExport : std::as_const( mLayers ) )
223 {
224 const QString originalId { mClonedLayerIds.value( layerToExport->id() ) };
225 if ( originalId == referencingLayer->id() )
226 {
227 relatedLayer = qobject_cast<QgsVectorLayer *>( layerToExport.get() );
228 alreadyAdded = true;
229 break;
230 }
231 }
232
233 // Export only relevant features unless the layer was in the original export list and no selection was made on that layer
234 // in that case the user explicitly marked the layer for export and it is supposed to be exported fully.
235 QgsFeatureIds selected;
236
237 if ( onlySaveSelected && ( ! layerWasExplicitlyAdded || referencingLayer->selectedFeatureCount() > 0 ) )
238 {
239 if ( ! layers.contains( qobject_cast<QgsMapLayer *>( referencingLayer ) ) || referencingLayer->selectedFeatureCount() > 0 )
240 {
241 QgsFeatureIterator it { vLayer->getSelectedFeatures() };
242 QgsFeature selectedFeature;
243 while ( it.nextFeature( selectedFeature ) )
244 {
245 QgsFeatureIterator referencingFeaturesIterator { relation.getRelatedFeatures( selectedFeature ) };
246 QgsFeature referencingFeature;
247 while ( referencingFeaturesIterator.nextFeature( referencingFeature ) )
248 {
249 if ( referencingFeature.isValid() )
250 {
251 selected.insert( referencingFeature.id() );
252 }
253 }
254 }
255 }
256 }
257
258 if ( ! alreadyAdded && ( ! onlySaveSelected || ! selected.isEmpty() ) )
259 {
260 feedback->pushInfo( QObject::tr( "Adding referencing layer '%1'" ).arg( referencingLayer->name() ) );
261 relatedLayer = referencingLayer->clone();
262 mLayers.emplace_back( relatedLayer );
263 mClonedLayerIds.insert( relatedLayer->id(), referencingLayer->id() );
264 }
265
266 if ( relatedLayer && ! selected.isEmpty() )
267 {
268 relatedLayer->selectByIds( selected, Qgis::SelectBehavior::AddToSelection );
269 }
270
271 // Recursive finding
272 if ( recursionGuard > maxRecursion )
273 {
274 feedback->pushWarning( QObject::tr( "Max recursion (%1) adding referencing layer '%2', layer was not added" ).arg( QLocale().toString( recursionGuard ), referencingLayer->name() ) );
275 }
276 else if ( relatedLayer )
277 {
278 recursionGuard++;
279 findReferencing( relatedLayer, onlySaveSelected, findReferencing ) ;
280 }
281 }
282
283 };
284
285 for ( const QgsMapLayer *layer : std::as_const( layers ) )
286 {
287 const QgsVectorLayer *vLayer { qobject_cast<const QgsVectorLayer *>( layer ) };
288 if ( vLayer )
289 {
290 const bool onlySaveSelected = vLayer->selectedFeatureCount() > 0 && selectedFeaturesOnly;
291 recursionGuard = 0;
292 findReferenced( vLayer, onlySaveSelected, findReferenced );
293 recursionGuard = 0;
294 findReferencing( vLayer, onlySaveSelected, findReferencing );
295 }
296 }
297
298 }
299 }
300
302
303 if ( !QFile::exists( packagePath ) )
304 {
305 hDS = gdal::ogr_datasource_unique_ptr( OGR_Dr_CreateDataSource( hGpkgDriver, packagePath.toUtf8().constData(), nullptr ) );
306 if ( !hDS )
307 throw QgsProcessingException( QObject::tr( "Creation of database %1 failed (OGR error: %2)" ).arg( packagePath, QString::fromUtf8( CPLGetLastErrorMsg() ) ) );
308 }
309 else
310 {
311 hDS = gdal::ogr_datasource_unique_ptr( OGROpen( packagePath.toUtf8().constData(), true, nullptr ) );
312 if ( !hDS )
313 throw QgsProcessingException( QObject::tr( "Opening database %1 failed (OGR error: %2)" ).arg( packagePath, QString::fromUtf8( CPLGetLastErrorMsg() ) ) );
314 }
315
316
317 bool errored = false;
318
319 QgsProcessingMultiStepFeedback multiStepFeedback( mLayers.size(), feedback );
320
321 QStringList outputLayers;
322
323 int i = 0;
324 for ( const auto &layer : mLayers )
325 {
326 if ( feedback->isCanceled() )
327 break;
328
329 multiStepFeedback.setCurrentStep( i );
330 i++;
331
332 if ( !layer )
333 {
334 // don't throw immediately - instead do what we can and error out later
335 feedback->pushDebugInfo( QObject::tr( "Error retrieving map layer." ) );
336 errored = true;
337 continue;
338 }
339
340 feedback->pushInfo( QObject::tr( "Packaging layer %1/%2: %3" ).arg( i ).arg( mLayers.size() ).arg( layer ? layer->name() : QString() ) );
341
342 switch ( layer->type() )
343 {
345 {
346 QgsVectorLayer *vectorLayer = qobject_cast<QgsVectorLayer *>( layer.get() );
347 if ( !packageVectorLayer( vectorLayer, packagePath, context, &multiStepFeedback, saveStyles, saveMetadata, selectedFeaturesOnly ) )
348 errored = true;
349 else
350 outputLayers.append( QStringLiteral( "%1|layername=%2" ).arg( packagePath, layer->name() ) );
351 break;
352 }
353
355 {
356 //not supported
357 feedback->pushDebugInfo( QObject::tr( "Packaging raster layers is not supported." ) );
358 errored = true;
359 break;
360 }
361
363 //not supported
364 feedback->pushDebugInfo( QObject::tr( "Packaging plugin layers is not supported." ) );
365 errored = true;
366 break;
367
369 //not supported
370 feedback->pushDebugInfo( QObject::tr( "Packaging mesh layers is not supported." ) );
371 errored = true;
372 break;
373
375 //not supported
376 feedback->pushDebugInfo( QObject::tr( "Packaging point cloud layers is not supported." ) );
377 errored = true;
378 break;
379
381 //not supported
382 feedback->pushDebugInfo( QObject::tr( "Packaging vector tile layers is not supported." ) );
383 errored = true;
384 break;
385
387 //not supported
388 feedback->pushDebugInfo( QObject::tr( "Packaging annotation layers is not supported." ) );
389 errored = true;
390 break;
391
393 //not supported
394 feedback->pushDebugInfo( QObject::tr( "Packaging group layers is not supported." ) );
395 errored = true;
396 break;
397
399 //not supported
400 feedback->pushDebugInfo( QObject::tr( "Packaging tiled scene layers is not supported." ) );
401 errored = true;
402 break;
403 }
404 }
405
406 if ( errored )
407 throw QgsProcessingException( QObject::tr( "Error obtained while packaging one or more layers." ) );
408
409 QVariantMap outputs;
410 outputs.insert( QStringLiteral( "OUTPUT" ), packagePath );
411 outputs.insert( QStringLiteral( "OUTPUT_LAYERS" ), outputLayers );
412 return outputs;
413}
414
415bool QgsPackageAlgorithm::packageVectorLayer( QgsVectorLayer *layer, const QString &path, QgsProcessingContext &context,
416 QgsProcessingFeedback *feedback, bool saveStyles, bool saveMetadata, bool selectedFeaturesOnly )
417{
419 options.driverName = QStringLiteral( "GPKG" );
420 options.layerName = layer->name();
422 options.fileEncoding = context.defaultEncoding();
423 options.onlySelectedFeatures = selectedFeaturesOnly;
424 options.feedback = feedback;
425 if ( saveMetadata )
426 {
427 options.layerMetadata = layer->metadata();
428 options.saveMetadata = true;
429 }
430
431 // Check FID compatibility with GPKG and remove any existing FID field if not compatible,
432 // let this be completely recreated since many layer sources have fid fields which are
433 // not compatible with gpkg requirements
434 const QgsFields fields = layer->fields();
435 const int fidIndex = fields.lookupField( QStringLiteral( "fid" ) );
436
437 options.attributes = fields.allAttributesList();
438 if ( fidIndex >= 0 )
439 {
440 const QMetaType::Type fidType { layer->fields().field( fidIndex ).type() };
441 if ( ! layer->fieldConstraints( fidIndex ).testFlag( QgsFieldConstraints::Constraint::ConstraintUnique )
443 && fidType != QMetaType::Type::Int
444 && fidType != QMetaType::Type::UInt
445 && fidType != QMetaType::Type::LongLong
446 && fidType != QMetaType::Type::ULongLong )
447 {
448 options.attributes.removeAll( fidIndex );
449 }
450 }
451
452 if ( options.attributes.isEmpty() )
453 {
454 // fid was the only field
455 options.skipAttributeCreation = true;
456 }
457
458 QString error;
459 QString newFilename;
460 QString newLayer;
461 if ( QgsVectorFileWriter::writeAsVectorFormatV3( layer, path, context.transformContext(), options, &error, &newFilename, &newLayer ) != QgsVectorFileWriter::NoError )
462 {
463 feedback->reportError( QObject::tr( "Packaging layer failed: %1" ).arg( error ) );
464 return false;
465 }
466 else
467 {
468 if ( saveStyles )
469 {
470 std::unique_ptr< QgsVectorLayer > res = std::make_unique< QgsVectorLayer >( QStringLiteral( "%1|layername=%2" ).arg( newFilename, newLayer ) );
471 if ( res )
472 {
473 QString errorMsg;
474 QDomDocument doc( QStringLiteral( "qgis" ) );
475 const QgsReadWriteContext context;
476 layer->exportNamedStyle( doc, errorMsg, context );
477 if ( !errorMsg.isEmpty() )
478 {
479 feedback->reportError( QObject::tr( "Could not retrieve existing layer style: %1 " ).arg( errorMsg ) );
480 }
481 else
482 {
483 if ( !res->importNamedStyle( doc, errorMsg ) )
484 {
485 feedback->reportError( QObject::tr( "Could not set existing layer style: %1 " ).arg( errorMsg ) );
486 }
487 else
488 {
489 QgsSettings settings;
490 // this is not nice -- but needed to avoid an "overwrite" prompt messagebox from the provider! This api needs a rework to avoid this.
491 const QVariant prevOverwriteStyle = settings.value( QStringLiteral( "qgis/overwriteStyle" ) );
492 settings.setValue( QStringLiteral( "qgis/overwriteStyle" ), true );
493 res->saveStyleToDatabase( newLayer, QString(), true, QString(), errorMsg );
494 settings.setValue( QStringLiteral( "qgis/overwriteStyle" ), prevOverwriteStyle );
495 if ( !errorMsg.isEmpty() )
496 {
497 feedback->reportError( QObject::tr( "Could not save layer style: %1 " ).arg( errorMsg ) );
498 }
499 }
500 }
501 }
502 else
503 {
504 feedback->reportError( QObject::tr( "Could not save layer style -- error loading: %1 %2" ).arg( newFilename, newLayer ) );
505 }
506 }
507 return true;
508 }
509}
510
@ Vector
Tables (i.e. vector layers with or without geometry). When used for a sink this indicates the sink ha...
@ Group
Composite group layer. Added in QGIS 3.24.
@ Plugin
Plugin based layer.
@ TiledScene
Tiled scene layer. Added in QGIS 3.34.
@ Annotation
Contains freeform, georeferenced annotations. Added in QGIS 3.16.
@ Vector
Vector layer.
@ VectorTile
Vector tile layer. Added in QGIS 3.14.
@ Mesh
Mesh layer. Added in QGIS 3.2.
@ Raster
Raster layer.
@ PointCloud
Point cloud layer. Added in QGIS 3.18.
@ AddToSelection
Add selection to current selection.
Wrapper for iterator of features from vector data provider or vector layer.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:58
QgsFeatureId id
Definition qgsfeature.h:66
bool isValid() const
Returns the validity of this feature.
@ ConstraintNotNull
Field may not be null.
@ ConstraintUnique
Field must have a unique value.
QMetaType::Type type
Definition qgsfield.h:60
Container of fields for a vector layer.
Definition qgsfields.h:46
QgsAttributeList allAttributesList() const
Utility function to get list of attribute indexes.
QgsField field(int fieldIdx) const
Returns the field at particular index (must be in range 0..N-1).
Q_INVOKABLE int lookupField(const QString &fieldName) const
Looks up field's index from the field name.
Base class for all map layer types.
Definition qgsmaplayer.h:75
QString name
Definition qgsmaplayer.h:79
virtual void exportNamedStyle(QDomDocument &doc, QString &errorMsg, const QgsReadWriteContext &context=QgsReadWriteContext(), QgsMapLayer::StyleCategories categories=QgsMapLayer::AllStyleCategories) const
Export the properties of this layer as named style in a QDomDocument.
QgsLayerMetadata metadata
Definition qgsmaplayer.h:81
virtual QgsMapLayer * clone() const =0
Returns a new instance equivalent to this one except for the id which is still unique.
Contains information about the context in which a processing algorithm is executed.
QString defaultEncoding() const
Returns the default encoding to use for newly created files.
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context.
QgsProject * project() const
Returns the project in which the algorithm is being executed.
Custom exception class for processing related exceptions.
Base class for providing feedback from a processing algorithm.
virtual void pushInfo(const QString &info)
Pushes a general informational message from the algorithm.
virtual void reportError(const QString &error, bool fatalError=false)
Reports that the algorithm encountered an error while executing.
Processing feedback object for multi-step operations.
A multi-layer output for processing algorithms which create map layers, when the number and nature of...
A boolean parameter for processing algorithms.
void setMetadata(const QVariantMap &metadata)
Sets the parameter's freeform metadata.
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
A parameter for processing algorithms which accepts multiple map layers.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition qgsproject.h:107
The class is used as a container of context for various read/write operations on other objects.
This class is a composition of two QSettings instances:
Definition qgssettings.h:64
QVariant value(const QString &key, const QVariant &defaultValue=QVariant(), Section section=NoSection) const
Returns the value for setting key.
void setValue(const QString &key, const QVariant &value, QgsSettings::Section section=QgsSettings::NoSection)
Sets the value of setting key to value.
Options to pass to writeAsVectorFormat()
QgsLayerMetadata layerMetadata
Layer metadata to save for the exported vector file.
QString layerName
Layer name. If let empty, it will be derived from the filename.
bool saveMetadata
Set to true to save layer metadata for the exported vector file.
QgsVectorFileWriter::ActionOnExistingFile actionOnExistingFile
Action on existing file.
QgsAttributeList attributes
Attributes to export (empty means all unless skipAttributeCreation is set)
bool onlySelectedFeatures
Write only selected features of layer.
bool skipAttributeCreation
Only write geometries.
QgsFeedback * feedback
Optional feedback object allowing cancellation of layer save.
static QgsVectorFileWriter::WriterError writeAsVectorFormatV3(QgsVectorLayer *layer, const QString &fileName, const QgsCoordinateTransformContext &transformContext, const QgsVectorFileWriter::SaveVectorOptions &options, QString *errorMessage=nullptr, QString *newFilename=nullptr, QString *newLayer=nullptr)
Writes a layer out to a vector file.
@ CreateOrOverwriteLayer
Create or overwrite layer.
Represents a vector layer which manages a vector based data sets.
QgsFieldConstraints::Constraints fieldConstraints(int fieldIndex) const
Returns any constraints which are present for a specified field index.
int selectedFeatureCount() const
Returns the number of features that are selected in this layer.
std::unique_ptr< std::remove_pointer< OGRDataSourceH >::type, OGRDataSourceDeleter > ogr_datasource_unique_ptr
Scoped OGR data source.
QSet< QgsFeatureId > QgsFeatureIds