qgsvectorlayer.h

Go to the documentation of this file.

 
/***************************************************************************
                             -------------------
    begin                : Oct 29, 2003
    copyright            : (C) 2003 by Gary E.Sherman
    email                : sherman at mrcc.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 QGSVECTORLAYER_H
#define QGSVECTORLAYER_H
 
#include "qgis_core.h"
#include <QMap>
#include <QSet>
#include <QList>
#include <QStringList>
#include <QFont>
#include <QMutex>
 
#include "qgis.h"
#include "qgsmaplayer.h"
#include "qgsfeature.h"
#include "qgsfeaturerequest.h"
#include "qgsfeaturesource.h"
#include "qgsfields.h"
#include "qgsvectordataprovider.h"
#include "qgsvectorlayertoolscontext.h"
#include "qgseditformconfig.h"
#include "qgsattributetableconfig.h"
#include "qgsaggregatecalculator.h"
#include "qgsfeatureiterator.h"
#include "qgsexpressioncontextgenerator.h"
#include "qgsexpressioncontextscopegenerator.h"
#include "qgsexpressioncontext.h"
#include "qgsabstractprofilesource.h"
#include "qgsvectorsimplifymethod.h"
 
class QPainter;
class QImage;
 
class QgsAbstractGeometrySimplifier;
class QgsActionManager;
class QgsConditionalLayerStyles;
class QgsCurve;
class QgsDiagramLayerSettings;
class QgsDiagramRenderer;
class QgsEditorWidgetWrapper;
class QgsExpressionFieldBuffer;
class QgsFeatureRenderer;
class QgsGeometry;
class QgsGeometryVertexIndex;
class QgsMapToPixel;
class QgsRectangle;
class QgsRectangle;
class QgsRelation;
class QgsWeakRelation;
class QgsRelationManager;
class QgsSingleSymbolRenderer;
class QgsStoredExpressionManager;
class QgsSymbol;
class QgsVectorLayerJoinInfo;
class QgsVectorLayerEditBuffer;
class QgsVectorLayerJoinBuffer;
class QgsVectorLayerFeatureCounter;
class QgsAbstractVectorLayerLabeling;
class QgsPalLayerSettings;
class QgsPoint;
class QgsFeedback;
class QgsAuxiliaryStorage;
class QgsAuxiliaryLayer;
class QgsGeometryOptions;
class QgsStyleEntityVisitorInterface;
class QgsVectorLayerSelectionProperties;
class QgsVectorLayerTemporalProperties;
class QgsFeatureRendererGenerator;
class QgsVectorLayerElevationProperties;
 
#ifndef SIP_RUN
template<class T>
class QgsSettingsEntryEnumFlag;
#endif
class QgsSettingsEntryDouble;
class QgsSettingsEntryBool;
 
 
typedef QList<int> QgsAttributeList;
typedef QSet<int> QgsAttributeIds;
 
// TODO QGIS4: Remove virtual from non-inherited methods (like isModified)
 
class CORE_EXPORT QgsVectorLayer : public QgsMapLayer, public QgsExpressionContextGenerator, public QgsExpressionContextScopeGenerator, public QgsFeatureSink, public QgsFeatureSource, public QgsAbstractProfileSource
{
    Q_OBJECT
 
    Q_PROPERTY( QString subsetString READ subsetString WRITE setSubsetString NOTIFY subsetStringChanged )
    Q_PROPERTY( QString displayExpression READ displayExpression WRITE setDisplayExpression NOTIFY displayExpressionChanged )
    Q_PROPERTY( QgsEditFormConfig editFormConfig READ editFormConfig WRITE setEditFormConfig NOTIFY editFormConfigChanged )
    Q_PROPERTY( bool readOnly READ isReadOnly WRITE setReadOnly NOTIFY readOnlyChanged )
    Q_PROPERTY( bool supportsEditing READ supportsEditing NOTIFY supportsEditingChanged )
    Q_PROPERTY( QgsFields fields READ fields NOTIFY updatedFields )
 
  public:
 
    static const QgsSettingsEntryBool *settingsSimplifyLocal SIP_SKIP;
 
    static const QgsSettingsEntryDouble *settingsSimplifyMaxScale SIP_SKIP;
    static const QgsSettingsEntryDouble *settingsSimplifyDrawingTol SIP_SKIP;
    static const QgsSettingsEntryEnumFlag<Qgis::VectorSimplificationAlgorithm> *settingsSimplifyAlgorithm SIP_SKIP;
    static const QgsSettingsEntryEnumFlag<Qgis::VectorRenderingSimplificationFlags> *settingsSimplifyDrawingHints SIP_SKIP;
 
    struct LayerOptions
    {
 
      explicit LayerOptions( bool loadDefaultStyle = true,
                             bool readExtentFromXml = false )
        : loadDefaultStyle( loadDefaultStyle )
        , readExtentFromXml( readExtentFromXml )
      {}
      explicit LayerOptions( bool loadDefaultStyle = true, {…}
 
      explicit LayerOptions( const QgsCoordinateTransformContext &transformContext,
                             bool loadDefaultStyle = true,
                             bool readExtentFromXml = false
                           )
        : loadDefaultStyle( loadDefaultStyle )
        , readExtentFromXml( readExtentFromXml )
        , transformContext( transformContext )
      {}
      explicit LayerOptions( const QgsCoordinateTransformContext &transformContext, {…}
 
      bool loadDefaultStyle = true;
 
      bool readExtentFromXml = false;
 
      QgsCoordinateTransformContext transformContext = QgsCoordinateTransformContext();
 
      Qgis::WkbType fallbackWkbType = Qgis::WkbType::Unknown;
 
      QgsCoordinateReferenceSystem fallbackCrs;
 
      bool skipCrsValidation = false;
 
      bool forceReadOnly = false;
 
      bool loadAllStoredStyles = false;
    };
    struct LayerOptions {…};
 
    struct CORE_EXPORT DeleteContext
    {
 
      explicit DeleteContext( bool cascade = false, QgsProject *project = nullptr ): cascade( cascade ), project( project ) {}
 
      QList<QgsVectorLayer *> handledLayers( bool includeAuxiliaryLayers = true ) const;
 
      QgsFeatureIds handledFeatures( QgsVectorLayer *layer ) const;
 
      QMap<QgsVectorLayer *, QgsFeatureIds> mHandledFeatures SIP_SKIP;
      bool cascade;
      QgsProject *project;
    };
    struct CORE_EXPORT DeleteContext {…};
 
    explicit QgsVectorLayer( const QString &path = QString(), const QString &baseName = QString(),
                             const QString &providerLib = "ogr", const QgsVectorLayer::LayerOptions &options = QgsVectorLayer::LayerOptions() );
 
    ~QgsVectorLayer() override;
 
    QgsVectorLayer( const QgsVectorLayer &rhs ) = delete;
    QgsVectorLayer &operator=( QgsVectorLayer const &rhs ) = delete;
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsVectorLayer: '%1' (%2)>" ).arg( sipCpp->name(), sipCpp->dataProvider() ? sipCpp->dataProvider()->name() : QStringLiteral( "Invalid" ) );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
    QgsVectorLayer *clone() const override SIP_FACTORY;
 
    QString storageType() const;
 
    QString capabilitiesString() const;
 
 
    bool isSqlQuery() const;
 
    Qgis::VectorLayerTypeFlags vectorLayerTypeFlags() const;
 
 
    QString dataComment() const;
 
    QString displayField() const;
 
    void setDisplayExpression( const QString &displayExpression );
 
    QString displayExpression() const;
 
    bool hasMapTips() const FINAL;
 
    QgsVectorDataProvider *dataProvider() FINAL;
    const QgsVectorDataProvider *dataProvider() const FINAL SIP_SKIP;
    QgsMapLayerSelectionProperties *selectionProperties() override;
    QgsMapLayerTemporalProperties *temporalProperties() override;
    QgsMapLayerElevationProperties *elevationProperties() override;
    QgsAbstractProfileSource *profileSource() override {return this;}
    QgsAbstractProfileGenerator *createProfileGenerator( const QgsProfileRequest &request ) override SIP_FACTORY;
 
    void setProviderEncoding( const QString &encoding );
 
    void setCoordinateSystem();
 
    bool addJoin( const QgsVectorLayerJoinInfo &joinInfo );
 
    bool removeJoin( const QString &joinLayerId );
 
    QgsVectorLayerJoinBuffer *joinBuffer() { return mJoinBuffer; }
 
    const QgsVectorLayerJoinBuffer *joinBuffer() const { return mJoinBuffer; } SIP_SKIP;
 
    const QList<QgsVectorLayerJoinInfo> vectorJoins() const;
 
    bool setDependencies( const QSet<QgsMapLayerDependency> &layers ) FINAL;
 
    QSet<QgsMapLayerDependency> dependencies() const FINAL;
 
    int addExpressionField( const QString &exp, const QgsField &fld );
 
    void removeExpressionField( int index );
 
    QString expressionField( int index ) const;
 
    void updateExpressionField( int index, const QString &exp );
 
    QgsActionManager *actions() { return mActions; }
 
    const QgsActionManager *actions() const SIP_SKIP { return mActions; }
 
    int selectedFeatureCount() const;
 
    Q_INVOKABLE void selectByRect( QgsRectangle &rect, Qgis::SelectBehavior behavior = Qgis::SelectBehavior::SetSelection );
 
    Q_INVOKABLE void selectByExpression( const QString &expression, Qgis::SelectBehavior behavior = Qgis::SelectBehavior::SetSelection, QgsExpressionContext *context = nullptr );
 
    Q_INVOKABLE void selectByIds( const QgsFeatureIds &ids, Qgis::SelectBehavior behavior = Qgis::SelectBehavior::SetSelection );
 
    Q_INVOKABLE void modifySelection( const QgsFeatureIds &selectIds, const QgsFeatureIds &deselectIds );
 
    Q_INVOKABLE void invertSelection();
 
    Q_INVOKABLE void selectAll();
 
    Q_INVOKABLE void invertSelectionInRectangle( QgsRectangle &rect );
 
    Q_INVOKABLE QgsFeatureList selectedFeatures() const;
 
    QgsFeatureIterator getSelectedFeatures( QgsFeatureRequest request = QgsFeatureRequest() ) const;
 
    Q_INVOKABLE const QgsFeatureIds &selectedFeatureIds() const;
 
    Q_INVOKABLE QgsRectangle boundingBoxOfSelected() const;
 
    bool labelsEnabled() const;
 
    void setLabelsEnabled( bool enabled );
 
    bool diagramsEnabled() const;
 
    void setDiagramRenderer( QgsDiagramRenderer *r SIP_TRANSFER );
    const QgsDiagramRenderer *diagramRenderer() const { return mDiagramRenderer; }
 
    void setDiagramLayerSettings( const QgsDiagramLayerSettings &s );
    const QgsDiagramLayerSettings *diagramLayerSettings() const { return mDiagramLayerSettings; }
 
    QgsFeatureRenderer *renderer() { return mRenderer; }
 
    const QgsFeatureRenderer *renderer() const SIP_SKIP { return mRenderer; }
 
    void setRenderer( QgsFeatureRenderer *r SIP_TRANSFER );
 
    void addFeatureRendererGenerator( QgsFeatureRendererGenerator *generator SIP_TRANSFER );
 
    void removeFeatureRendererGenerator( const QString &id );
 
    QList< const QgsFeatureRendererGenerator * > featureRendererGenerators() const;
 
    Q_INVOKABLE Qgis::GeometryType geometryType() const;
 
    Q_INVOKABLE Qgis::WkbType wkbType() const FINAL;
 
    QgsCoordinateReferenceSystem sourceCrs() const FINAL;
    QString sourceName() const FINAL;
 
    bool readXml( const QDomNode &layer_node, QgsReadWriteContext &context ) FINAL;
 
    bool writeXml( QDomNode &layer_node, QDomDocument &doc, const QgsReadWriteContext &context ) const FINAL;
 
    QString encodedSource( const QString &source, const QgsReadWriteContext &context ) const FINAL;
    QString decodedSource( const QString &source, const QString &provider, const QgsReadWriteContext &context ) const FINAL;
 
    void resolveReferences( QgsProject *project ) FINAL;
 
    bool loadAuxiliaryLayer( const QgsAuxiliaryStorage &storage, const QString &key = QString() );
 
    void setAuxiliaryLayer( QgsAuxiliaryLayer *layer SIP_TRANSFER = nullptr );
 
    QgsAuxiliaryLayer *auxiliaryLayer();
 
    const QgsAuxiliaryLayer *auxiliaryLayer() const SIP_SKIP;
 
    bool readSymbology( const QDomNode &layerNode, QString &errorMessage,
                        QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories ) FINAL;
    bool readStyle( const QDomNode &node, QString &errorMessage,
                    QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories ) FINAL;
    bool writeSymbology( QDomNode &node, QDomDocument &doc, QString &errorMessage,
                         const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories ) const FINAL;
    bool writeStyle( QDomNode &node, QDomDocument &doc, QString &errorMessage,
                     const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories ) const FINAL;
 
    Q_DECL_DEPRECATED bool writeSld( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QVariantMap &props = QVariantMap() ) const SIP_DEPRECATED;
 
    bool writeSld( QDomNode &node, QDomDocument &doc, QgsSldExportContext &context ) const;
 
    bool readSld( const QDomNode &node, QString &errorMessage ) FINAL;
 
    long long featureCount( const QString &legendKey ) const;
 
    QgsFeatureIds symbolFeatureIds( const QString &legendKey ) const;
 
    Qgis::FeatureAvailability hasFeatures() const FINAL;
 
    QString loadDefaultStyle( bool &resultFlag SIP_OUT ) FINAL;
 
    QgsVectorLayerFeatureCounter *countSymbolFeatures( bool storeSymbolFids = false );
 
    virtual bool setSubsetString( const QString &subset );
 
    virtual QString subsetString() const;
 
    QgsFeatureIterator getFeatures( const QgsFeatureRequest &request = QgsFeatureRequest() ) const FINAL;
 
    inline QgsFeatureIterator getFeatures( const QString &expression )
    {
      return getFeatures( QgsFeatureRequest( expression ) );
    }
    inline QgsFeatureIterator getFeatures( const QString &expression ) {…}
 
    Q_INVOKABLE inline QgsFeature getFeature( QgsFeatureId fid ) const
    {
      QgsFeature feature;
      getFeatures( QgsFeatureRequest( fid ) ).nextFeature( feature );
      return feature;
    }
    Q_INVOKABLE inline QgsFeature getFeature( QgsFeatureId fid ) const {…}
 
    QgsGeometry getGeometry( QgsFeatureId fid ) const;
 
    inline QgsFeatureIterator getFeatures( const QgsFeatureIds &fids )
    {
      return getFeatures( QgsFeatureRequest( fids ) );
    }
    inline QgsFeatureIterator getFeatures( const QgsFeatureIds &fids ) {…}
 
    inline QgsFeatureIterator getFeatures( const QgsRectangle &rectangle )
    {
      return getFeatures( QgsFeatureRequest( rectangle ) );
    }
    inline QgsFeatureIterator getFeatures( const QgsRectangle &rectangle ) {…}
 
    bool addFeature( QgsFeature &feature, QgsFeatureSink::Flags flags = QgsFeatureSink::Flags() ) FINAL;
 
    bool updateFeature( QgsFeature &feature, bool skipDefaultValues = false );
 
    bool insertVertex( double x, double y, QgsFeatureId atFeatureId, int beforeVertex );
 
    bool insertVertex( const QgsPoint &point, QgsFeatureId atFeatureId, int beforeVertex );
 
    bool moveVertex( double x, double y, QgsFeatureId atFeatureId, int atVertex );
 
    bool moveVertex( const QgsPoint &p, QgsFeatureId atFeatureId, int atVertex ) SIP_PYNAME( moveVertexV2 );
 
    Qgis::VectorEditResult deleteVertex( QgsFeatureId featureId, int vertex );
 
    Q_INVOKABLE bool deleteSelectedFeatures( int *deletedCount = nullptr, QgsVectorLayer::DeleteContext *context = nullptr );
 
    Q_DECL_DEPRECATED Qgis::GeometryOperationResult addRing( const QVector<QgsPointXY> &ring, QgsFeatureId *featureId = nullptr ) SIP_DEPRECATED;
 
 
    Q_INVOKABLE Qgis::GeometryOperationResult addRing( const QgsPointSequence &ring, QgsFeatureId *featureId = nullptr );
 
    Q_INVOKABLE Qgis::GeometryOperationResult addRing( QgsCurve *ring SIP_TRANSFER, QgsFeatureId *featureId = nullptr ) SIP_PYNAME( addCurvedRing );
 
    Q_DECL_DEPRECATED Qgis::GeometryOperationResult addPart( const QList<QgsPointXY> &ring ) SIP_DEPRECATED;
 
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 
    Q_DECL_DEPRECATED Qgis::GeometryOperationResult addPart( const QVector<QgsPointXY> &ring ) SIP_PYNAME( addPartV2 ) SIP_DEPRECATED;
#endif
 
    Q_INVOKABLE Qgis::GeometryOperationResult addPart( const QgsPointSequence &ring ) SIP_PYNAME( addPartV2 );
 
    Q_INVOKABLE Qgis::GeometryOperationResult addPart( QgsCurve *ring SIP_TRANSFER ) SIP_PYNAME( addCurvedPart );
 
    Q_INVOKABLE int translateFeature( QgsFeatureId featureId, double dx, double dy );
 
    Q_DECL_DEPRECATED Qgis::GeometryOperationResult splitParts( const QVector<QgsPointXY> &splitLine, bool topologicalEditing = false ) SIP_DEPRECATED;
 
    Q_INVOKABLE Qgis::GeometryOperationResult splitParts( const QgsPointSequence &splitLine, bool topologicalEditing = false );
 
    Q_DECL_DEPRECATED Qgis::GeometryOperationResult splitFeatures( const QVector<QgsPointXY> &splitLine, bool topologicalEditing = false ) SIP_DEPRECATED;
 
    Q_INVOKABLE Qgis::GeometryOperationResult splitFeatures( const QgsPointSequence &splitLine, bool topologicalEditing = false );
 
    Q_INVOKABLE Qgis::GeometryOperationResult splitFeatures( const QgsCurve *curve, QgsPointSequence &topologyTestPoints SIP_OUT, bool preserveCircular = false, bool topologicalEditing = false );
 
    int addTopologicalPoints( const QgsGeometry &geom );
 
    Q_DECL_DEPRECATED int addTopologicalPoints( const QgsPointXY &p )  SIP_DEPRECATED;
 
    int addTopologicalPoints( const QgsPoint &p );
 
    int addTopologicalPoints( const QgsPointSequence &ps );
 
    const QgsAbstractVectorLayerLabeling *labeling() const SIP_SKIP { return mLabeling; }
 
    QgsAbstractVectorLayerLabeling *labeling() { return mLabeling; }
 
    void setLabeling( QgsAbstractVectorLayerLabeling *labeling SIP_TRANSFER );
 
    bool isEditable() const FINAL;
 
    bool isSpatial() const FINAL;
 
    bool isModified() const override;
 
    bool isAuxiliaryField( int index, int &srcIndex ) const;
 
    void reload() FINAL;
 
    QgsMapLayerRenderer *createMapRenderer( QgsRenderContext &rendererContext ) FINAL SIP_FACTORY;
 
    QgsRectangle extent() const FINAL;
    QgsRectangle sourceExtent() const FINAL;
 
    QgsBox3D extent3D() const FINAL;
    QgsBox3D sourceExtent3D() const FINAL;
 
    QgsFields fields() const FINAL;
 
    Q_INVOKABLE inline QgsAttributeList attributeList() const { return mFields.allAttributesList(); }
 
    QgsAttributeList primaryKeyAttributes() const;
 
    long long featureCount() const FINAL;
 
    bool setReadOnly( bool readonly = true );
 
    bool supportsEditing() const override;
 
    bool changeGeometry( QgsFeatureId fid, QgsGeometry &geometry, bool skipDefaultValue = false );
 
    Q_INVOKABLE bool changeAttributeValue( QgsFeatureId fid, int field, const QVariant &newValue, const QVariant &oldValue = QVariant(), bool skipDefaultValues = false,  QgsVectorLayerToolsContext *context = nullptr );
 
    Q_INVOKABLE bool changeAttributeValues( QgsFeatureId fid, const QgsAttributeMap &newValues, const QgsAttributeMap &oldValues = QgsAttributeMap(), bool skipDefaultValues = false, QgsVectorLayerToolsContext *context = nullptr );
 
    bool addAttribute( const QgsField &field );
 
    void setFieldAlias( int index, const QString &aliasString );
 
    void removeFieldAlias( int index );
 
    bool renameAttribute( int index, const QString &newName );
 
    QString attributeAlias( int index ) const;
 
    QString attributeDisplayName( int index ) const;
 
    QgsStringMap attributeAliases() const;
 
#ifndef SIP_RUN
 
    void setFieldSplitPolicy( int index, Qgis::FieldDomainSplitPolicy policy );
 
    void setFieldDuplicatePolicy( int index, Qgis::FieldDuplicatePolicy policy );
 
    void setFieldMergePolicy( int index, Qgis::FieldDomainMergePolicy policy );
#else
 
    void setFieldSplitPolicy( int index, Qgis::FieldDomainSplitPolicy policy );
 
    % MethodCode
    if ( a0 < 0 || a0 >= sipCpp->fields().count() )
    {
      PyErr_SetString( PyExc_KeyError, QByteArray::number( a0 ) );
      sipIsErr = 1;
    }
    else
    {
      sipCpp->setFieldSplitPolicy( a0, a1 );
    }
    % End
 
    void setFieldDuplicatePolicy( int index, Qgis::FieldDuplicatePolicy policy );
 
    % MethodCode
    if ( a0 < 0 || a0 >= sipCpp->fields().count() )
    {
      PyErr_SetString( PyExc_KeyError, QByteArray::number( a0 ) );
      sipIsErr = 1;
    }
    else
    {
      sipCpp->setFieldDuplicatePolicy( a0, a1 );
    }
    % End
 
    void setFieldMergePolicy( int index, Qgis::FieldDomainMergePolicy policy );
 
    % MethodCode
    if ( a0 < 0 || a0 >= sipCpp->fields().count() )
    {
      PyErr_SetString( PyExc_KeyError, QByteArray::number( a0 ) );
      sipIsErr = 1;
    }
    else
    {
      sipCpp->setFieldMergePolicy( a0, a1 );
    }
    % End
#endif
 
    Q_DECL_DEPRECATED QSet<QString> excludeAttributesWms() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setExcludeAttributesWms( const QSet<QString> &att ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QSet<QString> excludeAttributesWfs() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setExcludeAttributesWfs( const QSet<QString> &att ) SIP_DEPRECATED;
 
    virtual bool deleteAttribute( int attr );
 
    bool deleteAttributes( const QList<int> &attrs );
 
    bool addFeatures( QgsFeatureList &features, QgsFeatureSink::Flags flags = QgsFeatureSink::Flags() ) FINAL;
 
    Q_INVOKABLE bool deleteFeature( QgsFeatureId fid, QgsVectorLayer::DeleteContext *context = nullptr );
 
    Q_INVOKABLE bool deleteFeatures( const QgsFeatureIds &fids, QgsVectorLayer::DeleteContext *context = nullptr );
 
    Q_INVOKABLE bool commitChanges( bool stopEditing = true );
 
    QStringList commitErrors() const;
 
    Q_INVOKABLE bool rollBack( bool deleteBuffer = true );
 
    QList<QgsRelation> referencingRelations( int idx ) const;
 
    QList<QgsWeakRelation> weakRelations() const SIP_SKIP;
 
    void setWeakRelations( const QList< QgsWeakRelation > &relations ) SIP_SKIP;
 
    Q_INVOKABLE QgsVectorLayerEditBuffer *editBuffer() { return mEditBuffer; }
 
    const QgsVectorLayerEditBuffer *editBuffer() const SIP_SKIP { return mEditBuffer; }
 
    void beginEditCommand( const QString &text );
 
    void endEditCommand();
 
    void destroyEditCommand();
 
    Q_DECL_DEPRECATED static void drawVertexMarker( double x, double y, QPainter &p, Qgis::VertexMarkerType type, int vertexSize );
 
    void updateFields();
 
    QVariant defaultValue( int index, const QgsFeature &feature = QgsFeature(),
                           QgsExpressionContext *context = nullptr ) const;
 
    void setDefaultValueDefinition( int index, const QgsDefaultValue &definition );
 
    QgsDefaultValue defaultValueDefinition( int index ) const;
 
    QgsFieldConstraints::Constraints fieldConstraints( int fieldIndex ) const;
 
    QMap< QgsFieldConstraints::Constraint, QgsFieldConstraints::ConstraintStrength> fieldConstraintsAndStrength( int fieldIndex ) const;
 
    void setFieldConstraint( int index, QgsFieldConstraints::Constraint constraint, QgsFieldConstraints::ConstraintStrength strength = QgsFieldConstraints::ConstraintStrengthHard );
 
    void removeFieldConstraint( int index, QgsFieldConstraints::Constraint constraint );
 
    QString constraintExpression( int index ) const;
 
    QString constraintDescription( int index ) const;
 
    void setConstraintExpression( int index, const QString &expression, const QString &description = QString() );
 
    void setFieldConfigurationFlags( int index, Qgis::FieldConfigurationFlags flags );
 
    void setFieldConfigurationFlag( int index, Qgis::FieldConfigurationFlag flag, bool active );
 
    Qgis::FieldConfigurationFlags fieldConfigurationFlags( int index ) const;
 
    void setEditorWidgetSetup( int index, const QgsEditorWidgetSetup &setup );
 
    QgsEditorWidgetSetup editorWidgetSetup( int index ) const;
 
    QSet<QVariant> uniqueValues( int fieldIndex, int limit = -1 ) const FINAL;
 
    QStringList uniqueStringsMatching( int index, const QString &substring, int limit = -1,
                                       QgsFeedback *feedback = nullptr ) const;
 
    QVariant minimumValue( int index ) const FINAL;
 
    QVariant maximumValue( int index ) const FINAL;
 
 
    void minimumAndMaximumValue( int index, QVariant &minimum SIP_OUT, QVariant &maximum SIP_OUT ) const;
 
    QVariant aggregate( Qgis::Aggregate aggregate,
                        const QString &fieldOrExpression,
                        const QgsAggregateCalculator::AggregateParameters &parameters = QgsAggregateCalculator::AggregateParameters(),
                        QgsExpressionContext *context = nullptr,
                        bool *ok = nullptr,
                        QgsFeatureIds *fids = nullptr,
                        QgsFeedback *feedback = nullptr,
                        QString *error SIP_PYARGREMOVE = nullptr ) const;
 
    void setFeatureBlendMode( QPainter::CompositionMode blendMode );
    QPainter::CompositionMode featureBlendMode() const;
 
    QString htmlMetadata() const FINAL;
 
    void setSimplifyMethod( const QgsVectorSimplifyMethod &simplifyMethod ) { mSimplifyMethod = simplifyMethod; }
 
    inline const QgsVectorSimplifyMethod &simplifyMethod() const { return mSimplifyMethod; }
 
    bool simplifyDrawingCanbeApplied( const QgsRenderContext &renderContext, Qgis::VectorRenderingSimplificationFlag simplifyHint ) const;
 
    QgsConditionalLayerStyles *conditionalStyles() const;
 
    QgsAttributeTableConfig attributeTableConfig() const;
 
    void setAttributeTableConfig( const QgsAttributeTableConfig &attributeTableConfig );
 
    QgsExpressionContext createExpressionContext() const FINAL;
 
    QgsExpressionContextScope *createExpressionContextScope() const FINAL SIP_FACTORY;
 
    QgsEditFormConfig editFormConfig() const;
 
    void setEditFormConfig( const QgsEditFormConfig &editFormConfig );
 
    void setReadExtentFromXml( bool readExtentFromXml );
 
    bool readExtentFromXml() const;
 
    bool isEditCommandActive() const { return mEditCommandActive; }
 
    QgsGeometryOptions *geometryOptions() const;
 
    bool allowCommit() const SIP_SKIP;
 
    void setAllowCommit( bool allowCommit ) SIP_SKIP;
 
    QgsStoredExpressionManager *storedExpressionManager() { return mStoredExpressionManager; }
 
  public slots:
 
    void select( QgsFeatureId featureId );
 
    Q_INVOKABLE void select( const QgsFeatureIds &featureIds );
 
    void deselect( QgsFeatureId featureId );
 
    Q_INVOKABLE void deselect( const QgsFeatureIds &featureIds );
 
    Q_INVOKABLE void removeSelection();
 
    void reselect();
 
    virtual void updateExtents( bool force = false );
 
    Q_INVOKABLE bool startEditing();
 
    virtual void setTransformContext( const QgsCoordinateTransformContext &transformContext ) override;
 
    Qgis::SpatialIndexPresence hasSpatialIndex() const override;
 
    bool accept( QgsStyleEntityVisitorInterface *visitor ) const override;
 
  signals:
 
    void selectionChanged( const QgsFeatureIds &selected, const QgsFeatureIds &deselected, bool clearAndSelect );
 
    void allowCommitChanged();
 
    void beforeModifiedCheck() const;
 
    void beforeEditingStarted();
 
    void beforeCommitChanges( bool stopEditing );
 
    void beforeRollBack();
 
    void afterCommitChanges();
 
    void afterRollBack();
 
    void attributeAdded( int idx );
 
    void beforeAddingExpressionField( const QString &fieldName );
 
    void attributeDeleted( int idx );
 
    void beforeRemovingExpressionField( int idx );
 
    void featureAdded( QgsFeatureId fid );
 
    void featureDeleted( QgsFeatureId fid );
 
    void featuresDeleted( const QgsFeatureIds &fids );
 
    void updatedFields();
 
    void subsetStringChanged();
 
    void attributeValueChanged( QgsFeatureId fid, int idx, const QVariant &value );
 
    void geometryChanged( QgsFeatureId fid, const QgsGeometry &geometry );
 
    void committedAttributesDeleted( const QString &layerId, const QgsAttributeList &deletedAttributes );
    void committedAttributesAdded( const QString &layerId, const QList<QgsField> &addedAttributes );
    void committedFeaturesAdded( const QString &layerId, const QgsFeatureList &addedFeatures );
    void committedFeaturesRemoved( const QString &layerId, const QgsFeatureIds &deletedFeatureIds );
    void committedAttributeValuesChanges( const QString &layerId, const QgsChangedAttributesMap &changedAttributesValues );
    void committedGeometriesChanges( const QString &layerId, const QgsGeometryMap &changedGeometries );
 
    void labelingFontNotFound( QgsVectorLayer *layer, const QString &fontfamily );
 
    void featureBlendModeChanged( QPainter::CompositionMode blendMode );
 
    void editCommandStarted( const QString &text );
 
    void editCommandEnded();
 
    void editCommandDestroyed();
 
    void readCustomSymbology( const QDomElement &element, QString &errorMessage );
 
    void writeCustomSymbology( QDomElement &element, QDomDocument &doc, QString &errorMessage ) const;
 
    void displayExpressionChanged();
 
    void raiseError( const QString &msg );
 
    void editFormConfigChanged();
 
    void readOnlyChanged();
 
    void supportsEditingChanged();
 
    void symbolFeatureCountMapChanged();
 
  protected:
    void setExtent( const QgsRectangle &rect ) FINAL;
    void setExtent3D( const QgsBox3D &rect ) FINAL;
 
  private slots:
    void invalidateSymbolCountedFlag();
    void onFeatureCounterCompleted();
    void onFeatureCounterTerminated();
    void onJoinedFieldsChanged();
    void onFeatureAdded( QgsFeatureId fid );
    void onFeatureDeleted( QgsFeatureId fid );
    void onRelationsLoaded();
    void onSymbolsCounted();
    void onDirtyTransaction( const QString &sql, const QString &name );
    void emitDataChanged();
 
  private:
    void updateDefaultValues( QgsFeatureId fid, QgsFeature feature = QgsFeature(), QgsExpressionContext *context = nullptr );
 
    bool isReadOnly() const FINAL;
 
    bool setDataProvider( QString const &provider, const QgsDataProvider::ProviderOptions &options, Qgis::DataProviderReadFlags flags = Qgis::DataProviderReadFlags() );
 
    void setDataSourcePrivate( const QString &dataSource, const QString &baseName, const QString &provider, const QgsDataProvider::ProviderOptions &options, Qgis::DataProviderReadFlags flags ) override;
 
    void readSldLabeling( const QDomNode &node );
 
    bool readSldTextSymbolizer( const QDomNode &node, QgsPalLayerSettings &settings ) const;
 
    QgsAbstractVectorLayerLabeling *readLabelingFromCustomProperties();
 
    bool deleteFeatureCascade( QgsFeatureId fid, DeleteContext *context = nullptr );
 
#ifdef SIP_RUN
    QgsVectorLayer( const QgsVectorLayer &rhs );
#endif
    void minimumOrMaximumValue( int index, QVariant *minimum, QVariant *maximum ) const;
 
    void createEditBuffer();
    void clearEditBuffer();
 
    QgsConditionalLayerStyles *mConditionalStyles = nullptr;
    QgsVectorDataProvider *mDataProvider = nullptr;
    QgsVectorLayerSelectionProperties *mSelectionProperties = nullptr;
    QgsVectorLayerTemporalProperties *mTemporalProperties = nullptr;
    QgsVectorLayerElevationProperties *mElevationProperties = nullptr;
 
    QString mDisplayExpression;
 
    QgsActionManager *mActions = nullptr;
 
    bool mDataSourceReadOnly = false;
 
    bool mReadOnly = false;
 
    QgsFeatureIds mSelectedFeatureIds;
 
    QgsFeatureIds mPreviousSelectedFeatureIds;
 
    QgsFields mFields;
 
    QgsStringMap mAttributeAliasMap;
 
    QMap<QString, QgsDefaultValue> mDefaultExpressionMap;
 
    QMap< QString, Qgis::FieldDomainSplitPolicy > mAttributeSplitPolicy;
 
    QMap< QString, Qgis::FieldDuplicatePolicy > mAttributeDuplicatePolicy;
 
    QMap< QString, Qgis::FieldDomainMergePolicy > mAttributeMergePolicy;
 
    QSet<int> mDefaultValueOnUpdateFields;
 
    QMap< QString, QgsFieldConstraints::Constraints > mFieldConstraints;
 
    QMap< QPair< QString, QgsFieldConstraints::Constraint >, QgsFieldConstraints::ConstraintStrength > mFieldConstraintStrength;
 
    QMap< QString, QPair< QString, QString > > mFieldConstraintExpressions;
 
    QMap< QString, Qgis::FieldConfigurationFlags > mFieldConfigurationFlags;
    QMap< QString, QgsEditorWidgetSetup > mFieldWidgetSetups;
 
    QgsEditFormConfig mEditFormConfig;
 
    Qgis::WkbType mWkbType = Qgis::WkbType::Unknown;
 
    QgsFeatureRenderer *mRenderer = nullptr;
 
    QgsVectorSimplifyMethod mSimplifyMethod;
 
    QgsAbstractVectorLayerLabeling *mLabeling = nullptr;
 
    bool mLabelsEnabled = false;
 
    bool mLabelFontNotFoundNotified = false;
 
    QPainter::CompositionMode mFeatureBlendMode = QPainter::CompositionMode_SourceOver;
 
    bool mVertexMarkerOnlyForSelection = false;
 
    QStringList mCommitErrors;
 
    QgsVectorLayerEditBuffer *mEditBuffer = nullptr;
    friend class QgsVectorLayerEditBuffer;
    friend class QgsVectorLayerEditBufferGroup;
    friend class QgsVectorLayerEditPassthrough;
 
    //stores information about joined layers
    QgsVectorLayerJoinBuffer *mJoinBuffer = nullptr;
 
    QgsExpressionFieldBuffer *mExpressionFieldBuffer = nullptr;
 
    //diagram rendering object. 0 if diagram drawing is disabled
    QgsDiagramRenderer *mDiagramRenderer = nullptr;
 
    //stores infos about diagram placement (placement type, priority, position distance)
    QgsDiagramLayerSettings *mDiagramLayerSettings = nullptr;
 
    mutable bool mValidExtent2D = false;
    mutable bool mLazyExtent2D = true;
    mutable bool mValidExtent3D = false;
    mutable bool mLazyExtent3D = true;
 
    std::unique_ptr<QgsAuxiliaryLayer> mAuxiliaryLayer;
 
    QString mAuxiliaryLayerKey;
 
    // Features in renderer classes counted
    bool mSymbolFeatureCounted = false;
 
    // Feature counts for each renderer legend key
    QHash<QString, long long> mSymbolFeatureCountMap;
    QHash<QString, QgsFeatureIds> mSymbolFeatureIdMap;
 
    bool mEditCommandActive = false;
 
    bool mCommitChangesActive = false;
 
    bool mReadExtentFromXml;
    QgsRectangle mXmlExtent2D;
    QgsBox3D mXmlExtent3D;
 
    QgsFeatureIds mDeletedFids;
 
    QgsAttributeTableConfig mAttributeTableConfig;
 
    mutable QMutex mFeatureSourceConstructorMutex;
 
    QgsVectorLayerFeatureCounter *mFeatureCounter = nullptr;
 
    std::unique_ptr<QgsGeometryOptions> mGeometryOptions;
 
    bool mAllowCommit = true;
 
    QgsStoredExpressionManager *mStoredExpressionManager = nullptr;
 
    friend class QgsVectorLayerFeatureSource;
 
    bool mDataChangedFired = false;
 
    QList<QgsWeakRelation> mWeakRelations;
 
    bool mSetLegendFromStyle = false;
 
    QList< QgsFeatureRendererGenerator * > mRendererGenerators;
 
    QTimer *mRefreshRendererTimer = nullptr;
 
    bool mLoadAllStoredStyle = false;
 
};
class CORE_EXPORT QgsVectorLayer : public QgsMapLayer, public QgsExpressionContextGenerator, public QgsExpressionContextScopeGenerator, public QgsFeatureSink, public QgsFeatureSource, public QgsAbstractProfileSource {…};
 
 
 
// clazy:excludeall=qstring-allocations
 
#endif