qgsvectorlayer.h

Go to the documentation of this file.

/***************************************************************************
                          qgsvectorlayer.h  -  description
                             -------------------
    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 <QMap>
#include <QSet>
#include <QList>
#include <QStringList>
#include <QFont>

#include "qgis.h"
#include "qgsmaplayer.h"
#include "qgsfeature.h"
#include "qgsfeatureiterator.h"
#include "qgseditorwidgetconfig.h"
#include "qgsfield.h"
#include "qgssnapper.h"
#include "qgsvectorsimplifymethod.h"
#include "qgseditformconfig.h"

class QPainter;
class QImage;

class QgsAbstractGeometrySimplifier;
class QgsAttributeAction;
class QgsConditionalLayerStyles;
class QgsCoordinateTransform;
class QgsCurveV2;
class QgsDiagramLayerSettings;
class QgsDiagramRendererV2;
class QgsEditorWidgetWrapper;
class QgsExpressionFieldBuffer;
class QgsFeatureRendererV2;
class QgsFeatureRequest;
class QgsGeometry;
class QgsGeometryCache;
class QgsGeometryVertexIndex;
class QgsLabel;
class QgsMapToPixel;
class QgsRectangle;
class QgsRectangle;
class QgsRelation;
class QgsRelationManager;
class QgsSingleSymbolRendererV2;
class QgsSymbolV2;
class QgsVectorDataProvider;
class QgsVectorLayerEditBuffer;
class QgsVectorLayerJoinBuffer;
class QgsAbstractVectorLayerLabeling;
class QgsPointV2;

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


struct CORE_EXPORT QgsVectorJoinInfo
{
  QString targetFieldName;
  QString joinLayerId;
  QString joinFieldName;
  bool memoryCache;
  QHash< QString, QgsAttributes> cachedAttributes;

  int targetFieldIndex;
  int joinFieldIndex;

  QString prefix;

  bool operator==( const QgsVectorJoinInfo& other ) const
  {
    return targetFieldName == other.targetFieldName &&
           joinLayerId == other.joinLayerId &&
           joinFieldName == other.joinFieldName &&
           joinFieldsSubset == other.joinFieldsSubset &&
           memoryCache == other.memoryCache &&
           prefix == other.prefix;
  }

  void setJoinFieldNamesSubset( QStringList* fieldNamesSubset ) { joinFieldsSubset = QSharedPointer<QStringList>( fieldNamesSubset ); }
  QStringList* joinFieldNamesSubset() const { return joinFieldsSubset.data(); }

protected:
  QSharedPointer<QStringList> joinFieldsSubset;
};



class CORE_EXPORT QgsVectorLayer : public QgsMapLayer
{
    Q_OBJECT

  public:

    typedef QgsEditFormConfig::GroupData GroupData;
    typedef QgsEditFormConfig::TabData TabData;

    enum EditorLayout
    {
      GeneratedLayout = 0,
      TabLayout = 1,
      UiFileLayout = 2
    };

    struct RangeData
    {
      Q_DECL_DEPRECATED RangeData() { mMin = QVariant( 0 ); mMax = QVariant( 5 ); mStep = QVariant( 1 );}
      Q_DECL_DEPRECATED RangeData( const QVariant& theMin, const QVariant& theMax, const QVariant& theStep )
          : mMin( theMin ), mMax( theMax ), mStep( theStep ) {}

      QVariant mMin;
      QVariant mMax;
      QVariant mStep;
    };

    struct ValueRelationData
    {
      ValueRelationData() : mAllowNull( false ), mOrderByValue( false ), mAllowMulti( false ) {}
      ValueRelationData( const QString& layer, const QString& key, const QString& value, bool allowNull, bool orderByValue,
                         bool allowMulti = false,
                         const QString& filterExpression = QString::null )
          : mLayer( layer )
          , mKey( key )
          , mValue( value )
          , mFilterExpression( filterExpression )
          , mAllowNull( allowNull )
          , mOrderByValue( orderByValue )
          , mAllowMulti( allowMulti )
      {}

      QString mLayer;
      QString mKey;
      QString mValue;
      QString mFilterExpression;
      bool mAllowNull;
      bool mOrderByValue;
      bool mAllowMulti;  /* allow selection of multiple keys */
    };

    enum FeatureFormSuppress
    {
      SuppressDefault = 0, // use the application-wide setting
      SuppressOn = 1,
      SuppressOff = 2
    };

    enum EditType
    {
      LineEdit,
      UniqueValues,
      UniqueValuesEditable,
      ValueMap,
      Classification,
      EditRange,
      SliderRange,
      CheckBox,
      FileName,
      Enumeration,
      Immutable,      
      Hidden,         
      TextEdit,       
      Calendar,       
      DialRange,      
      ValueRelation,  
      UuidGenerator,  
      Photo,          
      WebView,        
      Color,          
      EditorWidgetV2, 
    };

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

    QgsVectorLayer( const QString& path = QString::null, const QString& baseName = QString::null,
                    const QString& providerLib = QString::null, bool loadDefaultStyleFlag = true );

    virtual ~QgsVectorLayer();

    QString storageType() const;

    QString capabilitiesString() const;

    QString dataComment() const;

    void setDisplayField( const QString& fldName = "" );

    const QString displayField() const;

    void setDisplayExpression( const QString &displayExpression );

    const QString displayExpression();

    QgsVectorDataProvider* dataProvider();

    const QgsVectorDataProvider* dataProvider() const;

    void setProviderEncoding( const QString& encoding );

    void setCoordinateSystem();

    bool addJoin( const QgsVectorJoinInfo& joinInfo );

    bool removeJoin( const QString& joinLayerId );

    QgsVectorLayerJoinBuffer* joinBuffer() { return mJoinBuffer; }
    const QList<QgsVectorJoinInfo> vectorJoins() const;

    virtual QSet<QString> layerDependencies() const;

    int addExpressionField( const QString& exp, const QgsField& fld );

    void removeExpressionField( int index );

    QString expressionField( int index );

    void updateExpressionField( int index, const QString& exp );

    QgsLabel *label();

    const QgsLabel *label() const;

    QgsAttributeAction *actions() { return mActions; }

    int selectedFeatureCount();

    void select( QgsRectangle & rect, bool addToSelection );

    void modifySelection( QgsFeatureIds selectIds, QgsFeatureIds deselectIds );

    void invertSelection();

    void selectAll();

    QgsFeatureIds allFeatureIds();

    void invertSelectionInRectangle( QgsRectangle & rect );

    QgsFeatureList selectedFeatures();

    QgsFeatureIterator selectedFeaturesIterator( QgsFeatureRequest request = QgsFeatureRequest() );

    const QgsFeatureIds &selectedFeaturesIds() const;

    void setSelectedFeatures( const QgsFeatureIds &ids );

    QgsRectangle boundingBoxOfSelected();

    bool labelsEnabled() const;

    bool diagramsEnabled() const;

    void setDiagramRenderer( QgsDiagramRendererV2* r );
    const QgsDiagramRendererV2* diagramRenderer() const { return mDiagramRenderer; }

    void setDiagramLayerSettings( const QgsDiagramLayerSettings& s );
    const QgsDiagramLayerSettings *diagramLayerSettings() const { return mDiagramLayerSettings; }

    QgsFeatureRendererV2* rendererV2() { return mRendererV2; }

    const QgsFeatureRendererV2* rendererV2() const { return mRendererV2; }

    void setRendererV2( QgsFeatureRendererV2* r );

    QGis::GeometryType geometryType() const;

    bool hasGeometryType() const;

    QGis::WkbType wkbType() const;

    QString providerType() const;

    virtual bool readXml( const QDomNode& layer_node ) override;

    virtual bool writeXml( QDomNode & layer_node, QDomDocument & doc ) override;

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

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

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

    virtual QString loadNamedStyle( const QString &theURI, bool &theResultFlag, bool loadFromLocalDb );

    virtual QString loadNamedStyle( const QString &theURI, bool &theResultFlag ) override;

    Q_DECL_DEPRECATED virtual bool applyNamedStyle( const QString& namedStyle, QString &errorMsg );

    QgsAttributeEditorElement* attributeEditorElementFromDomElement( QDomElement &elem, QObject* parent ) { return mEditFormConfig->attributeEditorElementFromDomElement( elem, parent ); }

    bool readSymbology( const QDomNode& node, QString& errorMessage ) override;

    bool writeSymbology( QDomNode& node, QDomDocument& doc, QString& errorMessage ) const override;


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

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

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

    long featureCount( QgsSymbolV2* symbol );

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

    bool countSymbolFeatures( bool showProgress = true );

    virtual bool setSubsetString( const QString& subset );

    virtual QString subsetString();

    QgsFeatureIterator getFeatures( const QgsFeatureRequest& request = QgsFeatureRequest() );

    bool addFeature( QgsFeature& f, bool alsoUpdateExtent = true );

    bool updateFeature( QgsFeature &f );

    bool insertVertex( double x, double y, QgsFeatureId atFeatureId, int beforeVertex );

    bool moveVertex( double x, double y, QgsFeatureId atFeatureId, int atVertex );

    bool moveVertex( const QgsPointV2& p, QgsFeatureId atFeatureId, int atVertex );

    Q_DECL_DEPRECATED bool deleteVertex( QgsFeatureId atFeatureId, int atVertex );

    //TODO QGIS 3.0 - rename back to deleteVertex
    EditResult deleteVertexV2( QgsFeatureId featureId, int vertex );

    bool deleteSelectedFeatures( int *deletedCount = nullptr );

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int addRing( const QList<QgsPoint>& ring, QgsFeatureId* featureId = nullptr );

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int addRing( QgsCurveV2* ring, QgsFeatureId* featureId = nullptr );

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int addPart( const QList<QgsPoint>& ring );

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int addPart( const QgsPointSequenceV2 &ring );

    int addPart( QgsCurveV2* ring );

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

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int splitParts( const QList<QgsPoint>& splitLine, bool topologicalEditing = false );

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int splitFeatures( const QList<QgsPoint>& splitLine, bool topologicalEditing = false );

    Q_DECL_DEPRECATED int removePolygonIntersections( QgsGeometry* geom, const QgsFeatureIds& ignoreFeatures = QgsFeatureIds() );

    int addTopologicalPoints( const QgsGeometry* geom );

    int addTopologicalPoints( const QgsPoint& p );

    int insertSegmentVerticesForSnap( const QList<QgsSnappingResult>& snapResults );

    Q_DECL_DEPRECATED void enableLabels( bool on );

    Q_DECL_DEPRECATED bool hasLabelsEnabled() const;

    const QgsAbstractVectorLayerLabeling* labeling() const { return mLabeling; }

    void setLabeling( QgsAbstractVectorLayerLabeling* labeling );

    virtual bool isEditable() const override;

    virtual bool isReadOnly() const;

    virtual bool isModified() const;

    bool snapPoint( QgsPoint& point, double tolerance );

    int snapWithContext( const QgsPoint& startPoint,
                         double snappingTolerance,
                         QMultiMap < double, QgsSnappingResult > &snappingResults,
                         QgsSnapper::SnappingType snap_to );

    virtual void reload() override;

    virtual QgsMapLayerRenderer* createMapRenderer( QgsRenderContext& rendererContext ) override;

    bool draw( QgsRenderContext& rendererContext ) override;

    Q_DECL_DEPRECATED void drawLabels( QgsRenderContext& rendererContext ) override;

    QgsRectangle extent() override;

    inline QgsFields fields() const { return mUpdatedFields; }

    inline QgsFields pendingFields() const { return mUpdatedFields; }

    inline QgsAttributeList pendingAllAttributesList() const { return mUpdatedFields.allAttributesList(); }

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

    inline QgsAttributeList pendingPkAttributesList() const { return pkAttributeList(); }

    QgsAttributeList pkAttributeList() const;

    inline long pendingFeatureCount() const { return featureCount(); }

    long featureCount() const;

    bool setReadOnly( bool readonly = true );

    bool changeGeometry( QgsFeatureId fid, QgsGeometry* geom );

    Q_DECL_DEPRECATED bool changeAttributeValue( QgsFeatureId fid, int field, const QVariant& value, bool emitSignal );

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

    bool addAttribute( const QgsField &field );

    void addAttributeAlias( int attIndex, const QString& aliasString );

    void remAttributeAlias( int attIndex );

    Q_DECL_DEPRECATED void addAttributeEditorWidget( QgsAttributeEditorElement* data ) {mEditFormConfig->addTab( data );}

    Q_DECL_DEPRECATED const QString editorWidgetV2( int fieldIdx ) const { return mEditFormConfig->widgetType( fieldIdx ); }

    Q_DECL_DEPRECATED const QString editorWidgetV2( const QString& fieldName ) const { return mEditFormConfig->widgetType( fieldName ); }

    Q_DECL_DEPRECATED const QgsEditorWidgetConfig editorWidgetV2Config( int fieldIdx ) const { return mEditFormConfig->widgetConfig( fieldIdx ); }

    Q_DECL_DEPRECATED const QgsEditorWidgetConfig editorWidgetV2Config( const QString& fieldName ) const { return mEditFormConfig->widgetConfig( fieldName ); }

    Q_DECL_DEPRECATED QList< QgsAttributeEditorElement* > attributeEditorElements() { return mEditFormConfig->tabs(); }

    QgsEditFormConfig* editFormConfig() const { return mEditFormConfig; }

    void clearAttributeEditorWidgets() { mEditFormConfig->clearTabs(); }

    QString attributeAlias( int attributeIndex ) const;

    QString attributeDisplayName( int attributeIndex ) const;

    const QMap< QString, QString >& attributeAliases() const { return mAttributeAliasMap; }

    const QSet<QString>& excludeAttributesWMS() const { return mExcludeAttributesWMS; }
    void setExcludeAttributesWMS( const QSet<QString>& att ) { mExcludeAttributesWMS = att; }

    const QSet<QString>& excludeAttributesWFS() const { return mExcludeAttributesWFS; }
    void setExcludeAttributesWFS( const QSet<QString>& att ) { mExcludeAttributesWFS = att; }

    bool deleteAttribute( int attr );

    bool deleteAttributes( QList<int> attrs );

    bool addFeatures( QgsFeatureList features, bool makeSelected = true );

    bool deleteFeature( QgsFeatureId fid );

    bool deleteFeatures( const QgsFeatureIds& fids );

    bool commitChanges();
    const QStringList &commitErrors();

    bool rollBack( bool deleteBuffer = true );

    Q_DECL_DEPRECATED EditType editType( int idx );

    Q_DECL_DEPRECATED void setEditType( int idx, EditType edit );

    Q_DECL_DEPRECATED EditorLayout editorLayout() { return static_cast< EditorLayout >( mEditFormConfig->layout() ); }

    Q_DECL_DEPRECATED void setEditorLayout( EditorLayout editorLayout ) { mEditFormConfig->setLayout( static_cast< QgsEditFormConfig::EditorLayout >( editorLayout ) ); }

    Q_DECL_DEPRECATED void setEditorWidgetV2( int attrIdx, const QString& widgetType ) { mEditFormConfig->setWidgetType( attrIdx, widgetType ); }

    Q_DECL_DEPRECATED void setEditorWidgetV2Config( int attrIdx, const QgsEditorWidgetConfig& config ) { mEditFormConfig->setWidgetConfig( attrIdx, config ); }

    Q_DECL_DEPRECATED void setCheckedState( int idx, const QString& checked, const QString& notChecked );

    Q_DECL_DEPRECATED QString editForm() const { return mEditFormConfig->uiForm(); }

    Q_DECL_DEPRECATED void setEditForm( const QString& ui ) { mEditFormConfig->setUiForm( ui ); }

    Q_DECL_DEPRECATED QgsVectorLayer::FeatureFormSuppress featureFormSuppress() const { return static_cast< FeatureFormSuppress >( mEditFormConfig->suppress() ); }

    Q_DECL_DEPRECATED void setFeatureFormSuppress( QgsVectorLayer::FeatureFormSuppress s ) { mEditFormConfig->setSuppress( static_cast< QgsEditFormConfig::FeatureFormSuppress >( s ) ); }

    QString annotationForm() const { return mAnnotationForm; }

    void setAnnotationForm( const QString& ui );

    Q_DECL_DEPRECATED QString editFormInit() const { return mEditFormConfig->initFunction(); }

    Q_DECL_DEPRECATED void setEditFormInit( const QString& function ) { mEditFormConfig->setInitFunction( function ); }

    Q_DECL_DEPRECATED QMap<QString, QVariant> valueMap( int idx );

    Q_DECL_DEPRECATED RangeData range( int idx );

    ValueRelationData valueRelation( int idx );

    QList<QgsRelation> referencingRelations( int idx );

    Q_DECL_DEPRECATED QString dateFormat( int idx );

    Q_DECL_DEPRECATED QSize widgetSize( int idx );

    Q_DECL_DEPRECATED bool fieldEditable( int idx ) { return !mEditFormConfig->readOnly( idx ); }

    Q_DECL_DEPRECATED bool labelOnTop( int idx ) { return mEditFormConfig->labelOnTop( idx ); }

    Q_DECL_DEPRECATED void setFieldEditable( int idx, bool editable ) { mEditFormConfig->setReadOnly( idx, !editable ); }

    Q_DECL_DEPRECATED void setLabelOnTop( int idx, bool onTop ) { mEditFormConfig->setLabelOnTop( idx, onTop ); }

    QgsVectorLayerEditBuffer* editBuffer() { return mEditBuffer; }

    void beginEditCommand( const QString& text );

    void endEditCommand();

    void destroyEditCommand();

    int fieldNameIndex( const QString& fieldName ) const;

    enum VertexMarkerType
    {
      SemiTransparentCircle,
      Cross,
      NoMarker
    };

    static void drawVertexMarker( double x, double y, QPainter& p, QgsVectorLayer::VertexMarkerType type, int vertexSize );

    void updateFields();

    void createJoinCaches();

    void uniqueValues( int index, QList<QVariant> &uniqueValues, int limit = -1 );

    QVariant minimumValue( int index );

    QVariant maximumValue( int index );

    QList< QVariant > getValues( const QString &fieldOrExpression, bool &ok, bool selectedOnly = false );

    QList< double > getDoubleValues( const QString &fieldOrExpression, bool &ok, bool selectedOnly = false, int* nullCount = nullptr );

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

    void setLayerTransparency( int layerTransparency );
    int layerTransparency() const;

    QString metadata() override;

    inline QgsGeometryCache* cache() { return mCache; }

    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;

  public slots:
    void select( QgsFeatureId featureId );

    void select( const QgsFeatureIds& featureIds );

    void deselect( const QgsFeatureId featureId );

    void deselect( const QgsFeatureIds& featureIds );

    void removeSelection();

    virtual void updateExtents();

    void checkJoinLayerRemove( const QString& theLayerId );

    bool startEditing();


  protected slots:
    void invalidateSymbolCountedFlag();

  signals:

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

    void selectionChanged();

    void layerModified();

    void beforeModifiedCheck() const;

    void beforeEditingStarted();

    void editingStarted();

    void editingStopped();

    void beforeCommitChanges();

    void beforeRollBack();

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

    void attributeValueChanged( QgsFeatureId fid, int idx, const QVariant & );
    void geometryChanged( QgsFeatureId fid, QgsGeometry &geom );

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

    void labelingFontNotFound( QgsVectorLayer* layer, const QString& fontfamily );

    void featureBlendModeChanged( QPainter::CompositionMode blendMode );

    void layerTransparencyChanged( int layerTransparency );

    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 raiseError( const QString& msg );

  private slots:
    void onJoinedFieldsChanged();
    void onFeatureDeleted( QgsFeatureId fid );

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

  private:                       // Private methods

    QgsVectorLayer( const QgsVectorLayer & rhs );

    QgsVectorLayer & operator=( QgsVectorLayer const & rhs );


    bool setDataProvider( QString const & provider );

    QgsFeatureId findFreeId();

    void snapToGeometry( const QgsPoint& startPoint,
                         QgsFeatureId featureId,
                         const QgsGeometry *geom,
                         double sqrSnappingTolerance,
                         QMultiMap<double, QgsSnappingResult>& snappingResults,
                         QgsSnapper::SnappingType snap_to ) const;

    //void addJoinedAttributes( QgsFeature& f, bool all = false );

    void readSldLabeling( const QDomNode& node );

  private:                       // Private attributes

    QgsConditionalLayerStyles * mConditionalStyles;

    QgsVectorDataProvider *mDataProvider;

    QString mDisplayField;

    QString mDisplayExpression;

    QString mProviderKey;

    QgsAttributeAction* mActions;

    bool mReadOnly;

    QgsFeatureIds mSelectedFeatureIds;

    QgsFields mUpdatedFields;

    QMap< QString, QString > mAttributeAliasMap;

    QgsEditFormConfig* mEditFormConfig;

    QSet<QString> mExcludeAttributesWMS;

    QSet<QString> mExcludeAttributesWFS;

    QGis::WkbType mWkbType;

    QgsFeatureRendererV2 *mRendererV2;

    QgsVectorSimplifyMethod mSimplifyMethod;

    QgsLabel *mLabel;

    bool mLabelOn;

    QgsAbstractVectorLayerLabeling* mLabeling;

    bool mLabelFontNotFoundNotified;

    QPainter::CompositionMode mFeatureBlendMode;

    int mLayerTransparency;

    bool mVertexMarkerOnlyForSelection;

    QStringList mCommitErrors;

    QString mAnnotationForm;

    QgsGeometryCache* mCache;

    QgsVectorLayerEditBuffer* mEditBuffer;
    friend class QgsVectorLayerEditBuffer;

    //stores information about joined layers
    QgsVectorLayerJoinBuffer* mJoinBuffer;

    QgsExpressionFieldBuffer* mExpressionFieldBuffer;

    //diagram rendering object. 0 if diagram drawing is disabled
    QgsDiagramRendererV2* mDiagramRenderer;

    //stores infos about diagram placement (placement type, priority, position distance)
    QgsDiagramLayerSettings *mDiagramLayerSettings;

    bool mValidExtent;
    bool mLazyExtent;

    // Features in renderer classes counted
    bool mSymbolFeatureCounted;

    // Feature counts for each renderer symbol
    QMap<QgsSymbolV2*, long> mSymbolFeatureCountMap;

    bool mEditCommandActive;

    QgsFeatureIds mDeletedFids;

    friend class QgsVectorLayerFeatureSource;
};

#endif