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 "qgis_core.h"
#include "qgis_sip.h"
#include "qgsfields.h"
#include "qgsfeedback.h"
#include "qgssymbol.h"
#include "qgstaskmanager.h"
#include "qgsogrutils.h"
#include "qgsrenderer.h"
#include "qgsgeometryengine.h"
#include "qgsfeaturesink.h"
#include <ogr_api.h>
 
class QgsSymbolLayer;
class QTextCodec;
class QgsFeatureIterator;
 
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( qgis::listToSet( values ) )
          , 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() << QStringLiteral( "YES" ) << QStringLiteral( "NO" ), 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,
      Canceled, 
    };
 
    enum SymbologyExport
    {
      NoSymbology = 0, //export only data
      FeatureSymbology, //Keeps the number of features and export symbology per feature
      SymbolLayerSymbology //Exports one feature per symbol layer (considering symbol levels)
    };
 
 
    enum VectorFormatOption
    {
      SortRecommended = 1 << 1, 
      SkipNonSpatialFormats = 1 << 2, 
    };
    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
    {
      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
 
#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,
        QgsVectorFileWriter::SymbologyExport symbologyExport = QgsVectorFileWriter::NoSymbology,
        double symbologyScale = 1.0,
        const QgsRectangle *filterExtent = nullptr,
        QgsWkbTypes::Type overrideGeometryType = QgsWkbTypes::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,
        QgsVectorFileWriter::SymbologyExport symbologyExport = QgsVectorFileWriter::NoSymbology,
        double symbologyScale = 1.0,
        const QgsRectangle *filterExtent = nullptr,
        QgsWkbTypes::Type overrideGeometryType = QgsWkbTypes::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;
 
        QgsVectorFileWriter::SymbologyExport symbologyExport = NoSymbology;
 
        double symbologyScale = 1.0;
 
        QgsRectangle filterExtent;
 
        QgsWkbTypes::Type overrideGeometryType = QgsWkbTypes::Unknown;
 
        bool forceMulti = false;
 
        bool includeZ = false;
 
        QgsVectorFileWriter::FieldValueConverter *fieldValueConverter = nullptr;
 
        QgsFeedback *feedback = 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,
                                           QgsWkbTypes::Type geometryType,
                                           const QgsCoordinateReferenceSystem &srs = QgsCoordinateReferenceSystem(),
                                           const QString &driverName = "GPKG",
                                           const QStringList &datasourceOptions = QStringList(),
                                           const QStringList &layerOptions = QStringList(),
                                           QString *newFilename = nullptr,
                                           QgsVectorFileWriter::SymbologyExport symbologyExport = QgsVectorFileWriter::NoSymbology,
                                           QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags()
#ifndef SIP_RUN
                                               , QString *newLayer = nullptr,
                                           QgsCoordinateTransformContext transformContext = QgsCoordinateTransformContext()
#endif
                                         ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QgsVectorFileWriter( const QString &vectorFileName,
                                           const QString &fileEncoding,
                                           const QgsFields &fields,
                                           QgsWkbTypes::Type geometryType,
                                           const QgsCoordinateReferenceSystem &srs,
                                           const QString &driverName,
                                           const QStringList &datasourceOptions,
                                           const QStringList &layerOptions,
                                           QString *newFilename,
                                           QgsVectorFileWriter::SymbologyExport symbologyExport,
                                           QgsVectorFileWriter::FieldValueConverter *fieldValueConverter,
                                           const QString &layerName,
                                           QgsVectorFileWriter::ActionOnExistingFile action,
                                           QString *newLayer = nullptr,
                                           QgsCoordinateTransformContext transformContext = QgsCoordinateTransformContext(),
                                           QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags()
                                         ) SIP_SKIP;
 
    QgsVectorFileWriter( const QgsVectorFileWriter &rh ) = delete;
    QgsVectorFileWriter &operator=( const QgsVectorFileWriter &rh ) = delete;
 
    static QgsVectorFileWriter *create( const QString &fileName,
                                        const QgsFields &fields,
                                        QgsWkbTypes::Type geometryType,
                                        const QgsCoordinateReferenceSystem &srs,
                                        const QgsCoordinateTransformContext &transformContext,
                                        const QgsVectorFileWriter::SaveVectorOptions &options,
                                        QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(),
                                        QString *newFilename = nullptr,
                                        QString *newLayer = nullptr ) SIP_FACTORY;
 
    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 );
 
    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();
 
    QString errorMessage();
 
    bool addFeature( QgsFeature &feature, QgsFeatureSink::Flags flags = QgsFeatureSink::Flags() ) override;
    bool addFeatures( QgsFeatureList &features, QgsFeatureSink::Flags flags = QgsFeatureSink::Flags() ) override;
    QString lastError() const override;
 
    bool addFeatureWithStyle( QgsFeature &feature, QgsFeatureRenderer *renderer, QgsUnitTypes::DistanceUnit outputUnit = QgsUnitTypes::DistanceMeters );
 
    QMap<int, int> attrIdxToOgrIdx() { return mAttrIdxToOgrIdx; } SIP_SKIP
 
    ~QgsVectorFileWriter() override;
 
    static bool deleteShapeFile( const QString &fileName );
 
    QgsVectorFileWriter::SymbologyExport symbologyExport() const { return mSymbologyExport; }
    void setSymbologyExport( QgsVectorFileWriter::SymbologyExport 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( QgsWkbTypes::Type 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( QgsWkbTypes::Type wkbType ) SIP_SKIP;
 
    gdal::ogr_datasource_unique_ptr mDS;
    OGRLayerH mLayer = nullptr;
    OGRSpatialReferenceH mOgrRef = nullptr;
 
    QgsFields mFields;
 
    WriterError mError;
    QString mErrorMessage;
 
    QTextCodec *mCodec = nullptr;
 
    QgsWkbTypes::Type mWkbType;
 
    QMap<int, int> mAttrIdxToOgrIdx;
 
    SymbologyExport mSymbologyExport;
 
    QMap< QgsSymbolLayer *, QString > mSymbolLayerTable;
 
    double mSymbologyScale;
 
    QString mOgrDriverName;
 
    FieldValueConverter *mFieldValueConverter = nullptr;
 
  private:
#ifdef SIP_RUN
    QgsVectorFileWriter( const QgsVectorFileWriter &rh );
#endif
 
    struct PreparedWriterDetails
    {
      std::unique_ptr< QgsFeatureRenderer > renderer;
      QgsCoordinateReferenceSystem sourceCrs;
      QgsWkbTypes::Type sourceWkbType = QgsWkbTypes::Unknown;
      QgsFields sourceFields;
      QString providerType;
      long featureCount = 0;
      QgsFeatureIds selectedFeatureIds;
      QString dataSourceUri;
      QString storageType;
      QgsFeatureIterator geometryTypeScanIterator;
      QgsExpressionContext expressionContext;
      QSet< int > fieldsToConvertToInt;
      QgsRenderContext renderContext;
      bool shallTransform = false;
      QgsCoordinateReferenceSystem outputCrs;
      QgsWkbTypes::Type destWkbType = QgsWkbTypes::Unknown;
      QgsAttributeList attributes;
      QgsFields outputFields;
      QgsFeatureIterator sourceFeatureIterator;
      QgsGeometry filterRectGeometry;
      std::unique_ptr< QgsGeometryEngine  > filterRectEngine;
      QVariantMap providerUriParams;
    };
 
    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 );
 
    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,
               QgsWkbTypes::Type 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 );
    void resetMap( const QgsAttributeList &attributes );
 
    std::unique_ptr< QgsFeatureRenderer > mRenderer;
    QgsRenderContext mRenderContext;
 
 
    std::unique_ptr< QgsCoordinateTransform > mCoordinateTransform;
 
    bool mUsingTransaction = false;
    bool supportsStringList = false;
 
    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, QgsUnitTypes::RenderUnit symbolUnits, QgsUnitTypes::DistanceUnit mapUnits );
    double mapUnitScaleFactor( double scale, QgsUnitTypes::RenderUnit symbolUnits, QgsUnitTypes::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