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.h"
#include "qgis_core.h"
#include "qgsabstractprofilesource.h"
#include "qgsaggregatecalculator.h"
#include "qgsattributetableconfig.h"
#include "qgseditformconfig.h"
#include "qgsexpressioncontext.h"
#include "qgsexpressioncontextgenerator.h"
#include "qgsexpressioncontextscopegenerator.h"
#include "qgsfeature.h"
#include "qgsfeatureiterator.h"
#include "qgsfeaturerequest.h"
#include "qgsfeaturesource.h"
#include "qgsfields.h"
#include "qgsmaplayer.h"
#include "qgsstyleentityvisitor.h"
#include "qgsvectordataprovider.h"
#include "qgsvectorlayertoolscontext.h"
#include "qgsvectorsimplifymethod.h"
 
#include <QFont>
#include <QList>
#include <QMap>
#include <QMutex>
#include <QSet>
#include <QString>
#include <QStringList>
 
using namespace Qt::StringLiterals;
 
class QPainter;
class QImage;
 
class QgsAbstractGeometrySimplifier;
class QgsActionManager;
class QgsConditionalLayerStyles;
class QgsCurve;
class QgsCurvePolygon;
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 QgsVectorLayerSelectionProperties;
class QgsVectorLayerTemporalProperties;
class QgsFeatureRendererGenerator;
class QgsVectorLayerElevationProperties;
class QgsObjectEntityVisitorInterface;
class QgsObjectVisitorContext;
 
#ifndef SIP_RUN
template<class T> class QgsSettingsEntryEnumFlag;
#endif
class QgsSettingsEntryDouble;
class QgsSettingsEntryBool;
 
 
typedef QList<int> QgsAttributeList;
typedef QSet<int> QgsAttributeIds;
 
// TODO QGIS 5: 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( const QgsCoordinateTransformContext &transformContext, bool loadDefaultStyle = true, bool readExtentFromXml = false )
          : loadDefaultStyle( loadDefaultStyle )
          , readExtentFromXml( readExtentFromXml )
          , transformContext( 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 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;
    };

    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
    // clang-format off
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = u"<QgsVectorLayer: '%1' (%2)>"_s.arg( sipCpp->name(), sipCpp->dataProvider() ? sipCpp->dataProvider()->name() : u"Invalid"_s );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
// clang-format on
#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; }
    QString profileSourceId() const override { return id(); }
    QString profileSourceName() const override { return name(); }
    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( const 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, bool validateIds = false );

    Q_INVOKABLE void modifySelection( const QgsFeatureIds &selectIds, const QgsFeatureIds &deselectIds );

    Q_INVOKABLE void invertSelection();

    Q_INVOKABLE void selectAll();

    Q_INVOKABLE void invertSelectionInRectangle( const 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.get(); }
 
    void setDiagramLayerSettings( const QgsDiagramLayerSettings &s );
    const QgsDiagramLayerSettings *diagramLayerSettings() const { return mDiagramLayerSettings.get(); }

    QgsFeatureRenderer *renderer() { return mRenderer.get(); }

    const QgsFeatureRenderer *renderer() const SIP_SKIP { return mRenderer.get(); }

    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 ) ); }

    Q_INVOKABLE inline QgsFeature getFeature( QgsFeatureId fid ) const
    {
      QgsFeature feature;
      getFeatures( QgsFeatureRequest( fid ) ).nextFeature( feature );
      return feature;
    }

    QgsGeometry getGeometry( QgsFeatureId fid ) const;

    inline QgsFeatureIterator getFeatures( const QgsFeatureIds &fids ) { return getFeatures( QgsFeatureRequest( fids ) ); }

    inline QgsFeatureIterator getFeatures( const QgsRectangle &rectangle ) { return getFeatures( QgsFeatureRequest( 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 );

    Qgis::VectorEditResult deleteVertices( QgsFeatureId featureId, const QSet<int> &vertices );

    Q_INVOKABLE bool deleteSelectedFeatures( int *deletedCount SIP_OUT = 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;

    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 Qgis::GeometryOperationResult addPart( QgsCurvePolygon *polygon SIP_TRANSFER ) SIP_PYNAME( addPolygonPart );

    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.get(); }

    QgsAbstractVectorLayerLabeling *labeling() { return mLabeling.get(); }

    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 );

    Q_INVOKABLE 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
    );

    Q_INVOKABLE bool addAttribute( const QgsField &field );

    Q_INVOKABLE void setFieldAlias( int index, const QString &aliasString );

    Q_INVOKABLE void removeFieldAlias( int index );

    Q_INVOKABLE void setFieldCustomComment( int index, const QString &customCommentString );

    Q_INVOKABLE void removeFieldCustomComment( int index );

    Q_INVOKABLE QString attributeCustomComment( int index ) const;

    QgsStringMap attributeCustomComments() const;

    Q_INVOKABLE bool renameAttribute( int index, const QString &newName );

    Q_INVOKABLE QString attributeAlias( int index ) const;

    Q_INVOKABLE 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
    // clang-format off

    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
// clang-format on
#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;

    Q_INVOKABLE virtual bool deleteAttribute( int attr );

    Q_INVOKABLE bool deleteAttributes( const QList<int> &attrs );
 
    using QgsFeatureSink::addFeatures;
    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;

    Q_INVOKABLE QSet<QVariant> uniqueValues( int fieldIndex, int limit = -1 ) const final;

    QStringList uniqueStringsMatching( int index, const QString &substring, int limit = -1, QgsFeedback *feedback = nullptr ) const;

    Q_INVOKABLE QVariant minimumValue( int index ) const final;

    Q_INVOKABLE 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();

    void setTransformContext( const QgsCoordinateTransformContext &transformContext ) override;
 
    Qgis::SpatialIndexPresence hasSpatialIndex() const override;
 
    bool accept( QgsStyleEntityVisitorInterface *visitor ) const override;
 
    bool accept( QgsObjectEntityVisitorInterface *visitor, const QgsObjectVisitorContext &context ) 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 onDependencyAfterCommitChanges();
    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();

    void applyRendererSettings();
 
    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;

    QgsStringMap mAttributeCustomCommentMap;

    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;

    std::unique_ptr<QgsFeatureRenderer> mRenderer;

    QgsVectorSimplifyMethod mSimplifyMethod;

    std::unique_ptr<QgsAbstractVectorLayerLabeling> mLabeling;

    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;

    std::unique_ptr<QgsExpressionFieldBuffer> mExpressionFieldBuffer;
 
    //diagram rendering object. 0 if diagram drawing is disabled
    std::unique_ptr<QgsDiagramRenderer> mDiagramRenderer;
 
    //stores infos about diagram placement (placement type, priority, position distance)
    std::unique_ptr<QgsDiagramLayerSettings> mDiagramLayerSettings;
 
    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;
};
 
 
// clazy:excludeall=qstring-allocations
 
#endif