qgsvectorfilewriter.h

Go to the documentation of this file.

/***************************************************************************
                          qgsvectorfilewriter.h
                          generic vector file writer
                             -------------------
    begin                : Jun 6 2004
    copyright            : (C) 2004 by Tim Sutton
    email                : tim at linfiniti.com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSVECTORFILEWRITER_H
#define QGSVECTORFILEWRITER_H
 
#include <ogr_api.h>
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsabstractdatabaseproviderconnection.h"
#include "qgsfeaturesink.h"
#include "qgsfeedback.h"
#include "qgsfields.h"
#include "qgsgeometryengine.h"
#include "qgsogrutils.h"
#include "qgsrendercontext.h"
#include "qgsrenderer.h"
 
#include <QString>
 
using namespace Qt::StringLiterals;
 
class QgsSymbolLayer;
class QTextCodec;
class QgsFeatureIterator;
class QgsSettingsEntryString;

class CORE_EXPORT QgsVectorFileWriter : public QgsFeatureSink
{
  public:
    enum OptionType
    {
      Set,
      String,
      Int,
      Hidden
    };

    class Option
    {
      public:
        Option( const QString &docString, QgsVectorFileWriter::OptionType type )
          : docString( docString )
          , type( type )
        {}
        virtual ~Option() = default;
 
        QString docString;
        QgsVectorFileWriter::OptionType type;
    };

    class SetOption : public QgsVectorFileWriter::Option
    {
      public:
        SetOption( const QString &docString, const QStringList &values, const QString &defaultValue, bool allowNone = false )
          : Option( docString, Set )
          , values( values.begin(), values.end() )
          , defaultValue( defaultValue )
          , allowNone( allowNone )
        {}
 
        QSet<QString> values;
        QString defaultValue;
        bool allowNone;
    };

    class StringOption : public QgsVectorFileWriter::Option
    {
      public:
        StringOption( const QString &docString, const QString &defaultValue = QString() )
          : Option( docString, String )
          , defaultValue( defaultValue )
        {}
 
        QString defaultValue;
    };

    class IntOption : public QgsVectorFileWriter::Option
    {
      public:
        IntOption( const QString &docString, int defaultValue )
          : Option( docString, Int )
          , defaultValue( defaultValue )
        {}
 
        int defaultValue;
    };

    class BoolOption : public QgsVectorFileWriter::SetOption
    {
      public:
        BoolOption( const QString &docString, bool defaultValue )
          : SetOption( docString, QStringList() << u"YES"_s << u"NO"_s, defaultValue ? "YES" : "NO" )
        {}
    };

    class HiddenOption : public QgsVectorFileWriter::Option
    {
      public:
        explicit HiddenOption( const QString &value )
          : Option( QString(), Hidden )
          , mValue( value )
        {}
 
        QString mValue;
    };
 
    struct MetaData
    {
        MetaData() = default;
 
        MetaData(
          const QString &longName,
          const QString &trLongName,
          const QString &glob,
          const QString &ext,
          const QMap<QString, QgsVectorFileWriter::Option *> &driverOptions,
          const QMap<QString, QgsVectorFileWriter::Option *> &layerOptions,
          const QString &compulsoryEncoding = QString()
        )
          : longName( longName )
          , trLongName( trLongName )
          , glob( glob )
          , ext( ext )
          , driverOptions( driverOptions )
          , layerOptions( layerOptions )
          , compulsoryEncoding( compulsoryEncoding )
        {}
 
        QString longName;
        QString trLongName;
        QString glob;
        QString ext;
        QMap<QString, QgsVectorFileWriter::Option *> driverOptions;
        QMap<QString, QgsVectorFileWriter::Option *> layerOptions;
        QString compulsoryEncoding;
    };
 
    enum WriterError
    {
      NoError = 0,
      ErrDriverNotFound,
      ErrCreateDataSource,
      ErrCreateLayer,
      ErrAttributeTypeUnsupported,
      ErrAttributeCreationFailed,
      ErrProjection,
      ErrFeatureWriteFailed,
      ErrInvalidLayer,
      ErrSavingMetadata, 
      Canceled,          
    };

    enum FieldNameSource
    {
      Original = 0, 
      PreferAlias,  
    };

    enum VectorFormatOption SIP_ENUM_BASETYPE( IntFlag )
    {
      SortRecommended = 1 << 1,        
      SkipNonSpatialFormats = 1 << 2,  
      SupportsMultipleLayers = 1 << 3, 
    };
    Q_DECLARE_FLAGS( VectorFormatOptions, VectorFormatOption )
 
    
    class CORE_EXPORT FieldValueConverter
    {
      public:
        FieldValueConverter() = default;
 
        virtual ~FieldValueConverter() = default;

        virtual QgsField fieldDefinition( const QgsField &field );

        virtual QVariant convert( int fieldIdxInLayer, const QVariant &value );

        virtual QgsVectorFileWriter::FieldValueConverter *clone() const SIP_FACTORY;
    };

    enum EditionCapability SIP_ENUM_BASETYPE( IntFlag )
    {
      CanAddNewLayer = 1 << 0,

      CanAppendToExistingLayer = 1 << 1,

      CanAddNewFieldsToExistingLayer = 1 << 2,

      CanDeleteLayer = 1 << 3
    };

    Q_DECLARE_FLAGS( EditionCapabilities, EditionCapability )
 
    
    enum ActionOnExistingFile
    {
      CreateOrOverwriteFile,

      CreateOrOverwriteLayer,

      AppendToLayerNoNewFields,

      AppendToLayerAddFields
    };
 
#ifndef SIP_RUN
 
    static const QgsSettingsEntryString *settingsDefaultEncoding SIP_SKIP;

#else

#endif
    Q_DECL_DEPRECATED static QgsVectorFileWriter::WriterError writeAsVectorFormat(
      QgsVectorLayer *layer,
      const QString &fileName,
      const QString &fileEncoding,
      const QgsCoordinateReferenceSystem &destCRS = QgsCoordinateReferenceSystem(),
      const QString &driverName = "GPKG",
      bool onlySelected = false,
      QString *errorMessage SIP_OUT = nullptr,
      const QStringList &datasourceOptions = QStringList(),
      const QStringList &layerOptions = QStringList(),
      bool skipAttributeCreation = false,
      QString *newFilename = nullptr,
      Qgis::FeatureSymbologyExport symbologyExport = Qgis::FeatureSymbologyExport::NoSymbology,
      double symbologyScale = 1.0,
      const QgsRectangle *filterExtent = nullptr,
      Qgis::WkbType overrideGeometryType = Qgis::WkbType::Unknown,
      bool forceMulti = false,
      bool includeZ = false,
      const QgsAttributeList &attributes = QgsAttributeList(),
      QgsVectorFileWriter::FieldValueConverter *fieldValueConverter = nullptr
#ifndef SIP_RUN
      ,
      QString *newLayer = nullptr
    );
#else
    ) SIP_DEPRECATED;
#endif
 
#ifndef SIP_RUN

#else

#endif
    Q_DECL_DEPRECATED static QgsVectorFileWriter::WriterError writeAsVectorFormat(
      QgsVectorLayer *layer,
      const QString &fileName,
      const QString &fileEncoding,
      const QgsCoordinateTransform &ct,
      const QString &driverName = "GPKG",
      bool onlySelected = false,
      QString *errorMessage SIP_OUT = nullptr,
      const QStringList &datasourceOptions = QStringList(),
      const QStringList &layerOptions = QStringList(),
      bool skipAttributeCreation = false,
      QString *newFilename = nullptr,
      Qgis::FeatureSymbologyExport symbologyExport = Qgis::FeatureSymbologyExport::NoSymbology,
      double symbologyScale = 1.0,
      const QgsRectangle *filterExtent = nullptr,
      Qgis::WkbType overrideGeometryType = Qgis::WkbType::Unknown,
      bool forceMulti = false,
      bool includeZ = false,
      const QgsAttributeList &attributes = QgsAttributeList(),
      QgsVectorFileWriter::FieldValueConverter *fieldValueConverter = nullptr
#ifndef SIP_RUN
      ,
      QString *newLayer = nullptr
    );
#else
    ) SIP_DEPRECATED;
#endif

    class CORE_EXPORT SaveVectorOptions
    {
      public:
        SaveVectorOptions();
 
        virtual ~SaveVectorOptions() = default;

        QString driverName;

        QString layerName;

        QgsVectorFileWriter::ActionOnExistingFile actionOnExistingFile = CreateOrOverwriteFile;

        QString fileEncoding;

        QgsCoordinateTransform ct;

        bool onlySelectedFeatures = false;

        QStringList datasourceOptions;

        QStringList layerOptions;

        bool skipAttributeCreation = false;

        QgsAttributeList attributes;

        QStringList attributesExportNames;

        Qgis::FeatureSymbologyExport symbologyExport = Qgis::FeatureSymbologyExport::NoSymbology;

        double symbologyScale = 1.0;

        QgsRectangle filterExtent;

        Qgis::WkbType overrideGeometryType = Qgis::WkbType::Unknown;

        bool forceMulti = false;

        bool includeZ = false;

        QgsVectorFileWriter::FieldValueConverter *fieldValueConverter = nullptr;

        QgsFeedback *feedback = nullptr;

        QgsVectorFileWriter::FieldNameSource fieldNameSource = QgsVectorFileWriter::Original;

        bool saveMetadata = false;

        QgsLayerMetadata layerMetadata;

        bool includeConstraints = false;

        bool setFieldDomains = true;

        const QgsAbstractDatabaseProviderConnection *sourceDatabaseProviderConnection = nullptr;
    };
 
#ifndef SIP_RUN

#else

#endif
    Q_DECL_DEPRECATED static QgsVectorFileWriter::WriterError writeAsVectorFormat(
      QgsVectorLayer *layer,
      const QString &fileName,
      const QgsVectorFileWriter::SaveVectorOptions &options,
      QString *newFilename = nullptr,
      QString *errorMessage SIP_OUT = nullptr
#ifndef SIP_RUN
      ,
      QString *newLayer = nullptr
    );
#else
    ) SIP_DEPRECATED;
#endif

    Q_DECL_DEPRECATED QgsVectorFileWriter(
      const QString &vectorFileName,
      const QString &fileEncoding,
      const QgsFields &fields,
      Qgis::WkbType geometryType,
      const QgsCoordinateReferenceSystem &srs = QgsCoordinateReferenceSystem(),
      const QString &driverName = "GPKG",
      const QStringList &datasourceOptions = QStringList(),
      const QStringList &layerOptions = QStringList(),
      QString *newFilename = nullptr,
      Qgis::FeatureSymbologyExport symbologyExport = Qgis::FeatureSymbologyExport::NoSymbology,
      QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags()
#ifndef SIP_RUN
        ,
      QString *newLayer = nullptr,
      const QgsCoordinateTransformContext &transformContext = QgsCoordinateTransformContext(),
      FieldNameSource fieldNameSource = Original
#endif
    ) SIP_DEPRECATED;

    Q_DECL_DEPRECATED QgsVectorFileWriter(
      const QString &vectorFileName,
      const QString &fileEncoding,
      const QgsFields &fields,
      Qgis::WkbType geometryType,
      const QgsCoordinateReferenceSystem &srs,
      const QString &driverName,
      const QStringList &datasourceOptions,
      const QStringList &layerOptions,
      QString *newFilename,
      Qgis::FeatureSymbologyExport symbologyExport,
      QgsVectorFileWriter::FieldValueConverter *fieldValueConverter,
      const QString &layerName,
      QgsVectorFileWriter::ActionOnExistingFile action,
      QString *newLayer = nullptr,
      const QgsCoordinateTransformContext &transformContext = QgsCoordinateTransformContext(),
      QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(),
      FieldNameSource fieldNameSource = Original,
      bool includeConstraints = false,
      bool setFieldDomains = true,
      const QgsAbstractDatabaseProviderConnection *sourceDatabaseProviderConnection = nullptr
    ) SIP_SKIP;
 
    QgsVectorFileWriter( const QgsVectorFileWriter &rh ) = delete;
    QgsVectorFileWriter &operator=( const QgsVectorFileWriter &rh ) = delete;

    static QgsVectorFileWriter *create(
      const QString &fileName,
      const QgsFields &fields,
      Qgis::WkbType geometryType,
      const QgsCoordinateReferenceSystem &srs,
      const QgsCoordinateTransformContext &transformContext,
      const QgsVectorFileWriter::SaveVectorOptions &options,
      QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(),
      QString *newFilename = nullptr,
      QString *newLayer = nullptr
    ) SIP_FACTORY;

    Q_DECL_DEPRECATED static QgsVectorFileWriter::WriterError writeAsVectorFormatV2(
      QgsVectorLayer *layer,
      const QString &fileName,
      const QgsCoordinateTransformContext &transformContext,
      const QgsVectorFileWriter::SaveVectorOptions &options,
      QString *newFilename = nullptr,
      QString *newLayer = nullptr,
      QString *errorMessage SIP_OUT = nullptr
    ) SIP_DEPRECATED;

    static QgsVectorFileWriter::WriterError writeAsVectorFormatV3(
      QgsVectorLayer *layer,
      const QString &fileName,
      const QgsCoordinateTransformContext &transformContext,
      const QgsVectorFileWriter::SaveVectorOptions &options,
      QString *errorMessage SIP_OUT = nullptr,
      QString *newFilename SIP_OUT = nullptr,
      QString *newLayer SIP_OUT = nullptr
    );

    struct FilterFormatDetails
    {
        QString driverName;

        QString filterString;

        QStringList globs;
    };

    static QList< QgsVectorFileWriter::FilterFormatDetails > supportedFiltersAndFormats( VectorFormatOptions options = SortRecommended );

    static QStringList supportedFormatExtensions( VectorFormatOptions options = SortRecommended );

    static bool supportsFeatureStyles( const QString &driverName );

    struct DriverDetails
    {
        QString longName;

        QString driverName;
    };

    static QList< QgsVectorFileWriter::DriverDetails > ogrDriverList( VectorFormatOptions options = SortRecommended );

    static QString driverForExtension( const QString &extension );

    static QString fileFilterString( VectorFormatOptions options = SortRecommended );

    static QString filterForDriver( const QString &driverName );

    static QString convertCodecNameForEncodingOption( const QString &codecName );

    QgsVectorFileWriter::WriterError hasError() const;

    QString errorMessage() const;

    QString driver() const;

    QString driverLongName() const;

    Qgis::VectorFileWriterCapabilities capabilities() const;
 
    bool addFeature( QgsFeature &feature, QgsFeatureSink::Flags flags = QgsFeatureSink::Flags() ) override;
 
    using QgsFeatureSink::addFeatures;
    bool addFeatures( QgsFeatureList &features, QgsFeatureSink::Flags flags = QgsFeatureSink::Flags() ) override;
    QString lastError() const override;

    bool addFeatureWithStyle( QgsFeature &feature, QgsFeatureRenderer *renderer, Qgis::DistanceUnit outputUnit = Qgis::DistanceUnit::Meters );

    QMap<int, int> sourceFieldIndexToWriterFieldIndex() const { return mAttrIdxToProviderIdx; }

    ~QgsVectorFileWriter() override;

    static bool deleteShapeFile( const QString &fileName );

    Qgis::FeatureSymbologyExport symbologyExport() const { return mSymbologyExport; }

    void setSymbologyExport( Qgis::FeatureSymbologyExport symExport ) { mSymbologyExport = symExport; }

    double symbologyScale() const { return mSymbologyScale; }

    void setSymbologyScale( double scale );
 
    static bool driverMetadata( const QString &driverName, MetaData &driverMetadata );

    static QStringList defaultDatasetOptions( const QString &driverName );

    static QStringList defaultLayerOptions( const QString &driverName );

    static OGRwkbGeometryType ogrTypeFromWkbType( Qgis::WkbType type ) SIP_SKIP;

    static QgsVectorFileWriter::EditionCapabilities editionCapabilities( const QString &datasetName );

    static bool targetLayerExists( const QString &datasetName, const QString &layerName );

    static bool areThereNewFieldsToCreate( const QString &datasetName, const QString &layerName, QgsVectorLayer *layer, const QgsAttributeList &attributes );
 
  protected:
    OGRGeometryH createEmptyGeometry( Qgis::WkbType wkbType ) SIP_SKIP;
 
    gdal::ogr_datasource_unique_ptr mDS;
    OGRLayerH mLayer = nullptr;
    OGRSpatialReferenceH mOgrRef = nullptr;
 
    QgsFields mFields;

    WriterError mError;
    QString mErrorMessage;
 
    QTextCodec *mCodec = nullptr;

    Qgis::WkbType mWkbType;

    // In particular for a GeoPackage file, a field with the FID column is always put in first position.
    QMap<int, int> mAttrIdxToProviderIdx;

    QMap<int, int> mAttrIdxToOgrLayerIdx;
 
    Qgis::FeatureSymbologyExport mSymbologyExport = Qgis::FeatureSymbologyExport::NoSymbology;
 
    QMap< QgsSymbolLayer *, QString > mSymbolLayerTable;

    double mSymbologyScale;
 
    QString mOgrDriverName;
    QString mOgrDriverLongName;

    FieldValueConverter *mFieldValueConverter = nullptr;

    bool mIncludeConstraints = false;

    bool mSetFieldDomains = true;
 
  private:
#ifdef SIP_RUN
    QgsVectorFileWriter( const QgsVectorFileWriter &rh );
#endif
 
    struct PreparedWriterDetails
    {
        std::unique_ptr< QgsFeatureRenderer > renderer;
        QgsCoordinateReferenceSystem sourceCrs;
        Qgis::WkbType sourceWkbType = Qgis::WkbType::Unknown;
        QgsFields sourceFields;
        QString providerType;
        long long featureCount = 0;
        QgsFeatureIds selectedFeatureIds;
        QString dataSourceUri;
        QString storageType;
        QgsFeatureIterator geometryTypeScanIterator;
        QgsExpressionContext expressionContext;
        QSet< int > fieldsToConvertToInt;
        QgsRenderContext renderContext;
        bool shallTransform = false;
        QgsCoordinateReferenceSystem outputCrs;
        Qgis::WkbType destWkbType = Qgis::WkbType::Unknown;
        QgsAttributeList attributes;
        QgsFields outputFields;
        QgsFeatureIterator sourceFeatureIterator;
        QgsGeometry filterRectGeometry;
        std::unique_ptr< QgsGeometryEngine > filterRectEngine;
        QVariantMap providerUriParams;
        std::unique_ptr< QgsAbstractDatabaseProviderConnection > sourceDatabaseProviderConnection;
    };

    static QgsVectorFileWriter::WriterError prepareWriteAsVectorFormat( QgsVectorLayer *layer, const QgsVectorFileWriter::SaveVectorOptions &options, PreparedWriterDetails &details );

    static QgsVectorFileWriter::WriterError writeAsVectorFormatV2(
      PreparedWriterDetails &details,
      const QString &fileName,
      const QgsCoordinateTransformContext &transformContext,
      const QgsVectorFileWriter::SaveVectorOptions &options,
      QString *newFilename = nullptr,
      QString *newLayer = nullptr,
      QString *errorMessage SIP_OUT = nullptr,
      QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags()
    );

    Q_DECL_DEPRECATED static QgsVectorFileWriter::WriterError writeAsVectorFormat(
      PreparedWriterDetails &details,
      const QString &fileName,
      const QgsVectorFileWriter::SaveVectorOptions &options,
      QString *newFilename = nullptr,
      QString *errorMessage SIP_OUT = nullptr,
      QString *newLayer = nullptr
    ) SIP_DEPRECATED;
 
    void init(
      QString vectorFileName,
      QString fileEncoding,
      const QgsFields &fields,
      Qgis::WkbType geometryType,
      QgsCoordinateReferenceSystem srs,
      const QString &driverName,
      QStringList datasourceOptions,
      QStringList layerOptions,
      QString *newFilename,
      QgsVectorFileWriter::FieldValueConverter *fieldValueConverter,
      const QString &layerName,
      QgsVectorFileWriter::ActionOnExistingFile action,
      QString *newLayer,
      QgsFeatureSink::SinkFlags sinkFlags,
      const QgsCoordinateTransformContext &transformContext,
      FieldNameSource fieldNameSource,
      const QgsAbstractDatabaseProviderConnection *sourceDatabaseProviderConnection
    );
    void resetMap( const QgsAttributeList &attributes );
 
    std::unique_ptr< QgsFeatureRenderer > mRenderer;
    QgsRenderContext mRenderContext;
 
 
    std::unique_ptr< QgsCoordinateTransform > mCoordinateTransform;
 
    bool mUsingTransaction = false;
    QSet< QMetaType::Type > mSupportedListSubTypes;
 
    Qgis::VectorFileWriterCapabilities mCapabilities;
 
    void createSymbolLayerTable( QgsVectorLayer *vl, const QgsCoordinateTransform &ct, OGRDataSourceH ds );
    gdal::ogr_feature_unique_ptr createFeature( const QgsFeature &feature );
    bool writeFeature( OGRLayerH layer, OGRFeatureH feature );

    QgsVectorFileWriter::WriterError exportFeaturesSymbolLevels( const PreparedWriterDetails &details, QgsFeatureIterator &fit, const QgsCoordinateTransform &ct, QString *errorMessage = nullptr );
    double mmScaleFactor( double scale, Qgis::RenderUnit symbolUnits, Qgis::DistanceUnit mapUnits );
    double mapUnitScaleFactor( double scale, Qgis::RenderUnit symbolUnits, Qgis::DistanceUnit mapUnits );
 
    void startRender( QgsFeatureRenderer *sourceRenderer, const QgsFields &fields );
    void stopRender();
    std::unique_ptr< QgsFeatureRenderer > createSymbologyRenderer( QgsFeatureRenderer *sourceRenderer ) const;
    static void addRendererAttributes( QgsFeatureRenderer *renderer, QgsRenderContext &context, const QgsFields &fields, QgsAttributeList &attList );

    static QStringList concatenateOptions( const QMap<QString, Option *> &options );
 
    friend class QgsVectorFileWriterTask;
    friend class TestQgsVectorFileWriter;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsVectorFileWriter::EditionCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsVectorFileWriter::VectorFormatOptions )
 
// clazy:excludeall=qstring-allocations
 
#endif