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_sip.h"
#include "qgsmaplayer.h"
#include "qgsfeature.h"
#include "qgsfeaturerequest.h"
#include "qgsfeaturesource.h"
#include "qgsfields.h"
#include "qgsvectordataprovider.h"
#include "qgsvectorsimplifymethod.h"
#include "qgseditformconfig.h"
#include "qgsattributetableconfig.h"
#include "qgsaggregatecalculator.h"
#include "qgsfeatureiterator.h"
#include "qgsexpressioncontextgenerator.h"
#include "qgsexpressioncontextscopegenerator.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 QgsRelationManager;
class QgsSingleSymbolRenderer;
class QgsSymbol;
class QgsVectorLayerJoinInfo;
class QgsVectorLayerEditBuffer;
class QgsVectorLayerJoinBuffer;
class QgsVectorLayerFeatureCounter;
class QgsAbstractVectorLayerLabeling;
class QgsPoint;
class QgsFeedback;
class QgsAuxiliaryStorage;
class QgsAuxiliaryLayer;
class QgsGeometryOptions;

typedef QList<int> QgsAttributeList;
typedef QSet<int> QgsAttributeIds;


class CORE_EXPORT QgsVectorLayer : public QgsMapLayer, public QgsExpressionContextGenerator, public QgsExpressionContextScopeGenerator, public QgsFeatureSink, public QgsFeatureSource
{
    Q_OBJECT

    Q_PROPERTY( QString subsetString READ subsetString WRITE setSubsetString NOTIFY subsetStringChanged )
    Q_PROPERTY( QString displayExpression READ displayExpression WRITE setDisplayExpression NOTIFY displayExpressionChanged )
    Q_PROPERTY( QString mapTipTemplate READ mapTipTemplate WRITE setMapTipTemplate NOTIFY mapTipTemplateChanged )
    Q_PROPERTY( QgsEditFormConfig editFormConfig READ editFormConfig WRITE setEditFormConfig NOTIFY editFormConfigChanged )
    Q_PROPERTY( bool readOnly READ isReadOnly WRITE setReadOnly NOTIFY readOnlyChanged )
    Q_PROPERTY( double opacity READ opacity WRITE setOpacity NOTIFY opacityChanged )

  public:

    enum EditResult
    {
      Success = 0, 
      EmptyGeometry = 1, 
      EditFailed = 2, 
      FetchFeatureFailed = 3, 
      InvalidLayer = 4, 
    };

    enum SelectBehavior
    {
      SetSelection, 
      AddToSelection, 
      IntersectSelection, 
      RemoveFromSelection, 
    };

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

      QgsWkbTypes::Type fallbackWkbType = QgsWkbTypes::Unknown;

      QgsCoordinateReferenceSystem fallbackCrs;

    };

    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;

    QgsVectorLayer *clone() const override SIP_FACTORY;

    QString storageType() const;

    QString capabilitiesString() const;

    QString dataComment() const;

    QString displayField() const;

    void setDisplayExpression( const QString &displayExpression );

    QString displayExpression() const;

    QgsVectorDataProvider *dataProvider() FINAL;
    const QgsVectorDataProvider *dataProvider() const FINAL SIP_SKIP;

    void setProviderEncoding( const QString &encoding );

    void setCoordinateSystem();

    bool addJoin( const QgsVectorLayerJoinInfo &joinInfo );

    bool removeJoin( const QString &joinLayerId );

    QgsVectorLayerJoinBuffer *joinBuffer() { return mJoinBuffer; }
    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;

    void selectByRect( QgsRectangle &rect, SelectBehavior behavior = SetSelection );

    void selectByExpression( const QString &expression, SelectBehavior behavior = SetSelection );

    void selectByIds( const QgsFeatureIds &ids, SelectBehavior behavior = SetSelection );

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

    void invertSelection();

    void selectAll();

    void invertSelectionInRectangle( QgsRectangle &rect );

    QgsFeatureList selectedFeatures() const;

    QgsFeatureIterator getSelectedFeatures( QgsFeatureRequest request = QgsFeatureRequest() ) const;

    const QgsFeatureIds &selectedFeatureIds() const;

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

    QgsWkbTypes::GeometryType geometryType() const;

    QgsWkbTypes::Type 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;

    virtual void saveStyleToDatabase( const QString &name, const QString &description,
                                      bool useAsDefault, const QString &uiFileContent,
                                      QString &msgError SIP_OUT );

    virtual int listStylesInDatabase( QStringList &ids SIP_OUT, QStringList &names SIP_OUT,
                                      QStringList &descriptions SIP_OUT, QString &msgError SIP_OUT );

    virtual QString getStyleFromDatabase( const QString &styleId, QString &msgError SIP_OUT );

    virtual bool deleteStyleFromDatabase( const QString &styleId, QString &msgError SIP_OUT );

    virtual QString loadNamedStyle( const QString &theURI, bool &resultFlag SIP_OUT, bool loadFromLocalDb,
                                    QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories );

    QString loadNamedStyle( const QString &theURI, bool &resultFlag SIP_OUT,
                            QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories ) 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;

    bool writeSld( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsStringMap &props = QgsStringMap() ) const;

    bool readSld( const QDomNode &node, QString &errorMessage ) FINAL;

    long featureCount( const QString &legendKey ) const;

    FeatureAvailability hasFeatures() const FINAL;

    Q_DECL_DEPRECATED void setDataSource( const QString &dataSource, const QString &baseName, const QString &provider, bool loadDefaultStyleFlag = false ) SIP_DEPRECATED;

    void setDataSource( const QString &dataSource, const QString &baseName, const QString &provider, const QgsDataProvider::ProviderOptions &options, bool loadDefaultStyleFlag = false ) override;

    QString loadDefaultStyle( bool &resultFlag SIP_OUT ) FINAL;

    QgsVectorLayerFeatureCounter *countSymbolFeatures();

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

    EditResult deleteVertex( QgsFeatureId featureId, int vertex );

    bool deleteSelectedFeatures( int *deletedCount = nullptr );

    QgsGeometry::OperationResult addRing( const QVector<QgsPointXY> &ring, QgsFeatureId *featureId = nullptr );

    QgsGeometry::OperationResult addRing( QgsCurve *ring SIP_TRANSFER, QgsFeatureId *featureId = nullptr ) SIP_PYNAME( addCurvedRing );

    QgsGeometry::OperationResult addPart( const QList<QgsPointXY> &ring );

    QgsGeometry::OperationResult addPart( const QgsPointSequence &ring ) SIP_PYNAME( addPartV2 );

    QgsGeometry::OperationResult addPart( QgsCurve *ring SIP_TRANSFER ) SIP_PYNAME( addCurvedPart );

    int translateFeature( QgsFeatureId featureId, double dx, double dy );

    QgsGeometry::OperationResult splitParts( const QVector<QgsPointXY> &splitLine, bool topologicalEditing = false );

    QgsGeometry::OperationResult splitFeatures( const QVector<QgsPointXY> &splitLine, bool topologicalEditing = false );

    int addTopologicalPoints( const QgsGeometry &geom );

    int addTopologicalPoints( const QgsPointXY &p );

    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;

    virtual bool isModified() const;

    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;

    QgsFields fields() const FINAL;

    inline QgsAttributeList attributeList() const { return mFields.allAttributesList(); }

    QgsAttributeList primaryKeyAttributes() const;

    long featureCount() const FINAL;

    bool setReadOnly( bool readonly = true );

    bool changeGeometry( QgsFeatureId fid, QgsGeometry &geometry, bool skipDefaultValue = false );

    bool changeAttributeValue( QgsFeatureId fid, int field, const QVariant &newValue, const QVariant &oldValue = QVariant(), bool skipDefaultValues = false );

    bool changeAttributeValues( QgsFeatureId fid, const QgsAttributeMap &newValues, const QgsAttributeMap &oldValues = QgsAttributeMap(), bool skipDefaultValues = false );

    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;

    QSet<QString> excludeAttributesWms() const { return mExcludeAttributesWMS; }

    void setExcludeAttributesWms( const QSet<QString> &att ) { mExcludeAttributesWMS = att; }

    QSet<QString> excludeAttributesWfs() const { return mExcludeAttributesWFS; }

    void setExcludeAttributesWfs( const QSet<QString> &att ) { mExcludeAttributesWFS = att; }

    virtual bool deleteAttribute( int attr );

    bool deleteAttributes( const QList<int> &attrs );

    bool addFeatures( QgsFeatureList &features, QgsFeatureSink::Flags flags = nullptr ) FINAL;

    bool deleteFeature( QgsFeatureId fid );

    bool deleteFeatures( const QgsFeatureIds &fids );

    bool commitChanges();

    QStringList commitErrors() const;

    bool rollBack( bool deleteBuffer = true );

    QList<QgsRelation> referencingRelations( int idx ) const;

    QgsVectorLayerEditBuffer *editBuffer() { return mEditBuffer; }

    const QgsVectorLayerEditBuffer *editBuffer() const SIP_SKIP { return mEditBuffer; }

    void beginEditCommand( const QString &text );

    void endEditCommand();

    void destroyEditCommand();

    enum VertexMarkerType
    {
      SemiTransparentCircle,
      Cross,
      NoMarker
    };

    Q_DECL_DEPRECATED static void drawVertexMarker( double x, double y, QPainter &p, QgsVectorLayer::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 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;

    QVariant aggregate( QgsAggregateCalculator::Aggregate aggregate,
                        const QString &fieldOrExpression,
                        const QgsAggregateCalculator::AggregateParameters &parameters = QgsAggregateCalculator::AggregateParameters(),
                        QgsExpressionContext *context = nullptr,
                        bool *ok = nullptr,
                        QgsFeatureIds *fids = nullptr ) const;

    void setFeatureBlendMode( QPainter::CompositionMode blendMode );
    QPainter::CompositionMode featureBlendMode() const;

    void setOpacity( double opacity );

    double opacity() const;

    QString htmlMetadata() const FINAL;

    void setSimplifyMethod( const QgsVectorSimplifyMethod &simplifyMethod ) { mSimplifyMethod = simplifyMethod; }

    inline const QgsVectorSimplifyMethod &simplifyMethod() const { return mSimplifyMethod; }

    bool simplifyDrawingCanbeApplied( const QgsRenderContext &renderContext, QgsVectorSimplifyMethod::SimplifyHint simplifyHint ) const;

    QgsConditionalLayerStyles *conditionalStyles() const;

    QgsAttributeTableConfig attributeTableConfig() const;

    void setAttributeTableConfig( const QgsAttributeTableConfig &attributeTableConfig );

    QString mapTipTemplate() const;

    void setMapTipTemplate( const QString &mapTipTemplate );

    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;


  public slots:

    void select( QgsFeatureId featureId );

    void select( const QgsFeatureIds &featureIds );

    void deselect( QgsFeatureId featureId );

    void deselect( const QgsFeatureIds &featureIds );

    void removeSelection();

    virtual void updateExtents( bool force = false );

    bool startEditing();

    virtual void setTransformContext( const QgsCoordinateTransformContext &transformContext ) override;

  signals:

    void selectionChanged( const QgsFeatureIds &selected, const QgsFeatureIds &deselected, bool clearAndSelect );

    void layerModified();

    void allowCommitChanged();

    void beforeModifiedCheck() const;

    void beforeEditingStarted();

    void editingStarted();

    void editingStopped();

    void beforeCommitChanges();

    void beforeRollBack();

    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 opacityChanged( double opacity );

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

    void displayExpressionChanged();

    void raiseError( const QString &msg );

    void editFormConfigChanged();

    void readOnlyChanged();

    void symbolFeatureCountMapChanged();

  protected:
    void setExtent( const QgsRectangle &rect ) FINAL;

  private slots:
    void invalidateSymbolCountedFlag();
    void onFeatureCounterCompleted();
    void onFeatureCounterTerminated();
    void onJoinedFieldsChanged();
    void onFeatureDeleted( QgsFeatureId fid );
    void onRelationsLoaded();
    void onSymbolsCounted();
    void onDirtyTransaction( const QString &sql, const QString &name );

  private:
    void updateDefaultValues( QgsFeatureId fid, QgsFeature feature = QgsFeature() );

    bool isReadOnly() const FINAL;

    bool setDataProvider( QString const &provider, const QgsDataProvider::ProviderOptions &options );

    void readSldLabeling( const QDomNode &node );

    QgsAbstractVectorLayerLabeling *readLabelingFromCustomProperties();

#ifdef SIP_RUN
    QgsVectorLayer( const QgsVectorLayer &rhs );
#endif

  private:                       // Private attributes
    QgsConditionalLayerStyles *mConditionalStyles = nullptr;

    QgsVectorDataProvider *mDataProvider = nullptr;

    QString mDisplayExpression;

    QString mMapTipTemplate;

    QgsActionManager *mActions = nullptr;

    bool mReadOnly = false;

    QgsFeatureIds mSelectedFeatureIds;

    QgsFields mFields;

    QgsStringMap mAttributeAliasMap;

    QMap<QString, QgsDefaultValue> mDefaultExpressionMap;

    QSet<int> mDefaultValueOnUpdateFields;

    QMap< QString, QgsFieldConstraints::Constraints > mFieldConstraints;

    QMap< QPair< QString, QgsFieldConstraints::Constraint >, QgsFieldConstraints::ConstraintStrength > mFieldConstraintStrength;

    QMap< QString, QPair< QString, QString > > mFieldConstraintExpressions;

    QMap< QString, QgsEditorWidgetSetup > mFieldWidgetSetups;

    QgsEditFormConfig mEditFormConfig;

    QSet<QString> mExcludeAttributesWMS;

    QSet<QString> mExcludeAttributesWFS;

    QgsWkbTypes::Type mWkbType = QgsWkbTypes::Unknown;

    QgsFeatureRenderer *mRenderer = nullptr;

    QgsVectorSimplifyMethod mSimplifyMethod;

    QgsAbstractVectorLayerLabeling *mLabeling = nullptr;

    bool mLabelsEnabled = false;

    bool mLabelFontNotFoundNotified = false;

    QPainter::CompositionMode mFeatureBlendMode = QPainter::CompositionMode_SourceOver;

    double mLayerOpacity = 1.0;

    bool mVertexMarkerOnlyForSelection = false;

    QStringList mCommitErrors;

    QgsVectorLayerEditBuffer *mEditBuffer = nullptr;
    friend class QgsVectorLayerEditBuffer;
    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 mValidExtent = false;
    mutable bool mLazyExtent = 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> mSymbolFeatureCountMap;

    bool mEditCommandActive = false;

    bool mReadExtentFromXml;
    QgsRectangle mXmlExtent;

    QgsFeatureIds mDeletedFids;

    QgsAttributeTableConfig mAttributeTableConfig;

    mutable QMutex mFeatureSourceConstructorMutex;

    QgsVectorLayerFeatureCounter *mFeatureCounter = nullptr;

    std::unique_ptr<QgsGeometryOptions> mGeometryOptions;

    bool mAllowCommit = true;

    friend class QgsVectorLayerFeatureSource;
};



// clazy:excludeall=qstring-allocations

#endif