/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/core/vector/qgsvectorlayer.h                                     *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.py again   *
 ************************************************************************/










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


class QgsVectorLayer : QgsMapLayer, QgsExpressionContextGenerator, QgsExpressionContextScopeGenerator, QgsFeatureSink, QgsFeatureSource, QgsAbstractProfileSource
{
%Docstring(signature="appended")
Represents a vector layer which manages a vector based data sets.

The :py:class:`QgsVectorLayer` is instantiated by specifying the name of
a data provider, such as postgres or wfs, and url defining the specific
data set to connect to. The vector layer constructor in turn
instantiates a :py:class:`QgsVectorDataProvider` subclass corresponding
to the provider type, and passes it the url. The data provider connects
to the data source.

The :py:class:`QgsVectorLayer` provides a common interface to the
different data types. It also manages editing transactions by buffering
layer edits until they are written to the underlying
:py:class:`QgsVectorDataProvider`. Before edits can be made a call to
:py:func:`~startEditing` is required. Any edits made to a
:py:class:`QgsVectorLayer` are then held in memory only, and are not
written to the underlying :py:class:`QgsVectorDataProvider` until a call
to :py:func:`~commitChanges` is made. Buffered edits can be rolled back
and discarded without altering the underlying provider by calling
:py:func:`~rollBack`.

Sample usage of the :py:class:`QgsVectorLayer` class:

.. code-block:: python

         uri = "point?crs=epsg:4326&field=id:integer"
         scratchLayer = QgsVectorLayer(uri, "Scratch point layer",  "memory")

The main data providers supported by QGIS are listed below.

Vector data providers
---------------------

Memory data providerType (memory)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

The memory data provider is used to construct in memory data, for
example scratch data or data generated from spatial operations such as
contouring. There is no inherent persistent storage of the data. The
data source uri is constructed. The url specifies the geometry type
("point", "linestring", "polygon",
"multipoint","multilinestring","multipolygon"), optionally followed by
url parameters as follows:

- crs=definition Defines the coordinate reference system to use for the
  layer. definition is any string accepted by
  :py:func:`QgsCoordinateReferenceSystem.createFromString()`
- index=yes Specifies that the layer will be constructed with a spatial
  index
- field=name:type(length,precision) Defines an attribute of the layer.
  Multiple field parameters can be added to the data provider
  definition. type is one of "integer", "double", "string".

An example url is
"Point?crs=epsg:4326&field=id:integer&field=name:string(20)&index=yes"

Since QGIS 3.4 when closing a project, the application shows a warning
about potential data loss if there are any non-empty memory layers
present. If your memory layer should not trigger such warning, it is
possible to suppress that by setting the following custom variable:

.. code-block:: python

         layer.setCustomProperty("skipMemoryLayersCheck", 1)

OGR data provider (ogr)
^^^^^^^^^^^^^^^^^^^^^^^

Accesses data using the OGR drivers
(https://gdal.org/drivers/vector/index.html). The url is the OGR
connection string. A wide variety of data formats can be accessed using
this driver, including file based formats used by many GIS systems,
database formats, and web services. Some of these formats are also
supported by custom data providers listed below.

SpatiaLite data provider (spatialite)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Access data in a SpatiaLite database. The url defines the connection
parameters, table, geometry column, and other attributes. The url can be
constructed using the :py:class:`QgsDataSourceUri` class.

PostgreSQL data provider (postgres)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Connects to a PostgreSQL database. The url defines the connection
parameters, table, geometry column, and other attributes. The url can be
constructed using the :py:class:`QgsDataSourceUri` class.

Microsoft SQL server data provider (mssql)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Connects to a Microsoft SQL server database. The url defines the
connection parameters, table, geometry column, and other attributes. The
url can be constructed using the :py:class:`QgsDataSourceUri` class.

WFS (web feature service) data provider (wfs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Used to access data provided by a web feature service.

The url can be a HTTP url to a WFS server (legacy, e.g.
http://foobar/wfs?TYPENAME=xxx&SRSNAME=yyy[&FILTER=zzz]), or a URI
constructed using the :py:class:`QgsDataSourceUri` class with the
following parameters (note that parameter keys are case sensitive):

- url=string (mandatory): HTTP url to a WFS server endpoint. e.g
  http://foobar/wfs
- typename=string (mandatory): WFS typename
- srsname=string (recommended): SRS like 'EPSG:XXXX'
- username=string
- password=string
- authcfg=string
- version=auto/1.0.0/1.1.0/2.0.0
- sql=string: full SELECT SQL statement with optional WHERE, ORDER BY
  and possibly with JOIN if supported on server
- filter=string: QGIS expression or OGC/FES filter
- restrictToRequestBBOX=1: to download only features in the view extent
  (or more generally in the bounding box of the feature iterator)
- pageSize=number: number of features to retrieve in a single request
  (WFS 2)
- maxNumFeatures=number: maximum number of features to retrieve
  (possibly across several multiple paging requests)
- IgnoreAxisOrientation=1: to ignore EPSG axis order for WFS 1.1 or 2.0
- InvertAxisOrientation=1: to invert axis order
- hideDownloadProgressDialog=1: to hide the download progress dialog
- featureMode=default/simpleFeatures/complexFeatures (QGIS >= 3.44)

The ‘filter’ key value can either be a QGIS expression or an OGC XML
filter. If the value is set to a QGIS expression the driver will turn it
into OGC XML filter before passing it to the WFS server. Beware the QGIS
expression filter only supports” =, !=, <, >, <=, >=, AND, OR, NOT,
LIKE, IS NULL” attribute operators, “BBOX, Disjoint, Intersects,
Touches, Crosses, Contains, Overlaps, Within” spatial binary operators
and the QGIS local “geomFromWKT, geomFromGML” geometry constructor
functions.

Also note:

- You can use various functions available in the QGIS Expression list,
  however the function must exist server side and have the same name and
  arguments to work.
- Use the special ``@geometry`` parameter to provide the layer geometry
  column as input into the spatial binary operators e.g
  ``intersects(@geometry, geomFromWKT('POINT (5 6)'))``

OGC API Features data provider (oapif)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Used to access data provided by a OGC API - Features server.

The URI should be constructed using the :py:class:`QgsDataSourceUri`
class with the following parameters:

- url=string (mandatory): HTTP url to a OGC API - Features landing page.
- typename=string (mandatory): Collection id
- username=string
- password=string
- authcfg=string
- filter=string: QGIS expression (only datetime filtering is forwarded
  to the server)
- restrictToRequestBBOX=1: to download only features in the view extent
  (or more generally in the bounding box of the feature iterator)
- pageSize=number: number of features to retrieve in a single request
- maxNumFeatures=number: maximum number of features to retrieve
  (possibly across several multiple paging requests)
- hideDownloadProgressDialog=1: to hide the download progress dialog.

Delimited text file data provider (delimitedtext)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Accesses data in a delimited text file, for example CSV files generated
by spreadsheets. The contents of the file are split into columns based
on specified delimiter characters. Each record may be represented
spatially either by an X and Y coordinate column, or by a WKT (well
known text) formatted columns.

The url defines the filename, the formatting options (how the text in
the file is divided into data fields, and which fields contain the X,Y
coordinates or WKT text definition. The options are specified as url
query items.

At its simplest the url can just be the filename, in which case it will
be loaded as a CSV formatted file.

The url may include the following items:

- encoding=UTF-8

Defines the character encoding in the file. The default is UTF-8. To use
the default encoding for the operating system use "System".

- type=(csv|regexp|whitespace|plain)

Defines the algorithm used to split records into columns. Records are
defined by new lines, except for csv format files for which quoted
fields may span multiple records. The default type is csv.

- "csv" splits the file based on three sets of characters: delimiter
  characters, quote characters, and escape characters. Delimiter
  characters mark the end of a field. Quote characters enclose a field
  which can contain delimiter characters, and newlines. Escape
  characters cause the following character to be treated literally
  (including delimiter, quote, and newline characters). Escape and quote
  characters must be different from delimiter characters. Escape
  characters that are also quote characters are treated specially - they
  can only escape themselves within quotes. Elsewhere they are treated
  as quote characters. The defaults for delimiter, quote, and escape are
  ',', '"', '"'.
- "regexp" splits each record using a regular expression (see
  QRegularExpression documentation for details).
- "whitespace" splits each record based on whitespace (on or more
  whitespace characters. Leading whitespace in the record is ignored.
- "plain" is provided for backwards compatibility. It is equivalent to
  CSV except that the default quote characters are single and double
  quotes, and there is no escape characters.
- delimiter=characters

Defines the delimiter characters used for csv and plain type files, or
the regular expression for regexp type files. It is a literal string of
characters except that "\t" may be used to represent a tab character.

- quote=characters

Defines the characters that are used as quote characters for csv and
plain type files.

- escape=characters

Defines the characters used to escape delimiter, quote, and newline
characters.

- skipLines=n

Defines the number of lines to ignore at the beginning of the file
(default 0)

- useHeader=(yes|no)

Defines whether the first record in the file (after skipped lines)
contains column names (default yes)

- trimFields=(yes|no)

If yes then leading and trailing whitespace will be removed from fields

- skipEmptyFields=(yes|no)

If yes then empty fields will be discarded (equivalent to concatenating
consecutive delimiters)

- maxFields=#

Specifies the maximum number of fields to load for each record.
Additional fields will be discarded. Default is 0 - load all fields.

- decimalPoint=c

Defines a character that is used as a decimal point in the numeric
columns The default is '.'.

- xField=column yField=column

Defines the name of the columns holding the x and y coordinates for XY
point geometries. If the useHeader is no (ie there are no column names),
then this is the column number (with the first column as 1).

- xyDms=(yes|no)

If yes then the X and Y coordinates are interpreted as
degrees/minutes/seconds format (fairly permissively), or degree/minutes
format.

- wktField=column

Defines the name of the columns holding the WKT geometry definition for
WKT geometries. If the useHeader is no (ie there are no column names),
then this is the column number (with the first column as 1).

- geomType=(point|line|polygon|none)

Defines the geometry type for WKT type geometries. QGIS will only
display one type of geometry for the layer - any others will be ignored
when the file is loaded. By default the provider uses the type of the
first geometry in the file. Use geomType to override this type.

geomType can also be set to none, in which case the layer is loaded
without geometries.

- subset=expression

Defines an expression that will identify a subset of records to display

- crs=crsstring

Defines the coordinate reference system used for the layer. This can be
any string accepted by
:py:func:`QgsCoordinateReferenceSystem.createFromString()`

- subsetIndex=(yes|no)

Determines whether the provider generates an index to improve the
efficiency of subsets. The default is yes

- spatialIndex=(yes|no)

Determines whether the provider generates a spatial index. The default
is no.

- watchFile=(yes|no)

Defines whether the file will be monitored for changes. The default is
to monitor for changes.

- quiet

Errors encountered loading the file will not be reported in a user
dialog if quiet is included (They will still be shown in the output
log).

GPX data provider (gpx)
^^^^^^^^^^^^^^^^^^^^^^^

Provider reads tracks, routes, and waypoints from a GPX file. The url
defines the name of the file, and the type of data to retrieve from it
("track", "route", or "waypoint").

An example url is "/home/user/data/holiday.gpx?type=route"

Grass data provider (grass)
^^^^^^^^^^^^^^^^^^^^^^^^^^^

Provider to display vector data in a GRASS GIS layer.

.. seealso:: :py:class:`QgsVectorLayerUtils`
%End

%TypeHeaderCode
#include "qgsvectorlayer.h"
%End
  public:



    struct LayerOptions
    {

      explicit LayerOptions( bool loadDefaultStyle = true,
                             bool readExtentFromXml = false );
%Docstring
Constructor for LayerOptions.
%End

      explicit LayerOptions( const QgsCoordinateTransformContext &transformContext,
                             bool loadDefaultStyle = true,
                             bool readExtentFromXml = false
                           );
%Docstring
Constructor for LayerOptions.

.. versionadded:: 3.8
%End

      bool loadDefaultStyle;

      bool readExtentFromXml;

      QgsCoordinateTransformContext transformContext;

      Qgis::WkbType fallbackWkbType;

      QgsCoordinateReferenceSystem fallbackCrs;

      bool skipCrsValidation;

      bool forceReadOnly;

      bool loadAllStoredStyles;
    };

    struct DeleteContext
    {

      explicit DeleteContext( bool cascade = false, QgsProject *project = 0 );
%Docstring
Constructor for DeleteContext.
%End

      QList<QgsVectorLayer *> handledLayers( bool includeAuxiliaryLayers = true ) const;
%Docstring
Returns a list of all layers affected by the delete operation.

If ``includeAuxiliaryLayers`` is ``False`` then auxiliary layers will
not be included in the returned list.
%End

      QgsFeatureIds handledFeatures( QgsVectorLayer *layer ) const;
%Docstring
Returns a list of feature IDs from the specified ``layer`` affected by
the delete operation.
%End

      bool cascade;
      QgsProject *project;
    };

    explicit QgsVectorLayer( const QString &path = QString(), const QString &baseName = QString(),
                             const QString &providerLib = "ogr", const QgsVectorLayer::LayerOptions &options = QgsVectorLayer::LayerOptions() );
%Docstring
Constructor - creates a vector layer

The QgsVectorLayer is constructed by instantiating a data provider. The
provider interprets the supplied path (url) of the data source to
connect to and access the data.

:param path: The path or url of the parameter. Typically this encodes
             parameters used by the data provider as url query items.
:param baseName: The name used to represent the layer in the legend
:param providerLib: The name of the data provider, e.g., "memory",
                    "postgres"
:param options: layer load options
%End

    ~QgsVectorLayer();


    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

    virtual QgsVectorLayer *clone() const /Factory/;

%Docstring
Returns a new instance equivalent to this one. A new provider is created
for the same data source and renderers for features and diagrams are
cloned too. Moreover, each attributes (transparency, extent, selected
features and so on) are identical.

:return: a new layer instance
%End

    QString storageType() const;
%Docstring
Returns the permanent storage type for this layer as a friendly name.
This is obtained from the data provider and does not follow any
standard.
%End

    QString capabilitiesString() const;
%Docstring
Capabilities for this layer, comma separated and translated.
%End


    bool isSqlQuery() const;
%Docstring
Returns ``True`` if the layer is a query (SQL) layer.

.. note::

   this is simply a shortcut to check if the SqlQuery flag
   is set.

.. seealso:: :py:func:`vectorLayerTypeFlags`

.. versionadded:: 3.24
%End

    Qgis::VectorLayerTypeFlags vectorLayerTypeFlags() const;
%Docstring
Returns the vector layer type flags.

.. seealso:: :py:func:`isSqlQuery`

.. versionadded:: 3.24
%End


    QString dataComment() const;
%Docstring
Returns a description for this layer as defined in the data provider.
%End

    QString displayField() const;
%Docstring
This is a shorthand for accessing the displayExpression if it is a
simple field. If the displayExpression is more complex than a simple
field, a null string will be returned.

.. seealso:: :py:func:`displayExpression`
%End

    void setDisplayExpression( const QString &displayExpression );
%Docstring
Set the preview expression, used to create a human readable preview
string. Used e.g. in the attribute table feature list. Uses
:py:class:`QgsExpression`.

:param displayExpression: The expression which will be used to preview
                          features for this layer
%End

    QString displayExpression() const;
%Docstring
Returns the preview expression, used to create a human readable preview
string. Uses :py:class:`QgsExpression`

:return: The expression which will be used to preview features for this
         layer
%End

    virtual bool hasMapTips() const ${SIP_FINAL};


    virtual QgsVectorDataProvider *dataProvider() ${SIP_FINAL};

    virtual QgsMapLayerSelectionProperties *selectionProperties();

    virtual QgsMapLayerTemporalProperties *temporalProperties();

    virtual QgsMapLayerElevationProperties *elevationProperties();

    virtual QgsAbstractProfileGenerator *createProfileGenerator( const QgsProfileRequest &request ) /Factory/;


    void setProviderEncoding( const QString &encoding );
%Docstring
Sets the text ``encoding`` of the data provider.

An empty ``encoding`` string indicates that the provider should
automatically select the most appropriate encoding.

.. warning::

   Support for setting the provider encoding depends on the underlying data
   provider. Check :py:func:`~QgsVectorLayer.dataProvider`.capabilities() for the :py:class:`QgsVectorDataProvider`.SelectEncoding
   capability in order to determine if the provider supports this ability.
%End

    void setCoordinateSystem();
%Docstring
Setup the coordinate system transformation for the layer
%End

    bool addJoin( const QgsVectorLayerJoinInfo &joinInfo );
%Docstring
Joins another vector layer to this layer

:param joinInfo: join object containing join layer id, target and source
                 field

.. note::

   since 2.6 returns bool indicating whether the join can be added
%End

    bool removeJoin( const QString &joinLayerId );
%Docstring
Removes a vector layer join

:return: ``True`` if join was found and successfully removed
%End

    QgsVectorLayerJoinBuffer *joinBuffer();
%Docstring
Returns the join buffer object.
%End

    const QList<QgsVectorLayerJoinInfo> vectorJoins() const;

    virtual bool setDependencies( const QSet<QgsMapLayerDependency> &layers ) ${SIP_FINAL};

%Docstring
Sets the list of dependencies.

.. seealso:: :py:func:`dependencies`

:param layers: set of :py:class:`QgsMapLayerDependency`. Only
               user-defined dependencies will be added

:return: ``False`` if a dependency cycle has been detected
%End

    virtual QSet<QgsMapLayerDependency> dependencies() const ${SIP_FINAL};

%Docstring
Gets the list of dependencies. This includes data dependencies set by
the user (:py:func:`setDataDependencies`) as well as dependencies given
by the provider

:return: a set of :py:class:`QgsMapLayerDependency`
%End

    int addExpressionField( const QString &exp, const QgsField &fld );
%Docstring
Add a new field which is calculated by the expression specified

:param exp: The expression which calculates the field
:param fld: The field to calculate

:return: The index of the new field
%End

    void removeExpressionField( int index );
%Docstring
Removes an expression field

:param index: The index of the field
%End

    QString expressionField( int index ) const;
%Docstring
Returns the expression used for a given expression field

:param index: An index of an epxression based (virtual) field

:return: The expression for the field at index
%End

    void updateExpressionField( int index, const QString &exp );
%Docstring
Changes the expression used to define an expression based (virtual)
field

:param index: The index of the expression to change

:param exp: The new expression to set
%End

    QgsActionManager *actions();
%Docstring
Returns all layer actions defined on this layer.

The pointer which is returned directly points to the actions object
which is used by the layer, so any changes are immediately applied.
%End


    int selectedFeatureCount() const;
%Docstring
Returns the number of features that are selected in this layer.

.. seealso:: :py:func:`selectedFeatureIds`
%End

    void selectByRect( QgsRectangle &rect, Qgis::SelectBehavior behavior = Qgis::SelectBehavior::SetSelection );
%Docstring
Selects features found within the search rectangle (in layer's
coordinates)

:param rect: search rectangle
:param behavior: selection type, allows adding to current selection,
                 removing from selection, etc.

.. seealso:: :py:func:`invertSelectionInRectangle`

.. seealso:: :py:func:`selectByExpression`

.. seealso:: :py:func:`selectByIds`
%End

    void selectByExpression( const QString &expression, Qgis::SelectBehavior behavior = Qgis::SelectBehavior::SetSelection, QgsExpressionContext *context = 0 );
%Docstring
Selects matching features using an expression.

:param expression: expression to evaluate to select features
:param behavior: selection type, allows adding to current selection,
                 removing from selection, etc.
:param context: since QGIS 3.26, specifies an optional expression
                context to use when selecting features. If not specified
                a default one will be built.

.. seealso:: :py:func:`selectByRect`

.. seealso:: :py:func:`selectByIds`
%End

    void selectByIds( const QgsFeatureIds &ids, Qgis::SelectBehavior behavior = Qgis::SelectBehavior::SetSelection );
%Docstring
Selects matching features using a list of feature IDs. Will emit the
:py:func:`~QgsVectorLayer.selectionChanged` signal with the
clearAndSelect flag set.

:param ids: feature IDs to select
:param behavior: selection type, allows adding to current selection,
                 removing from selection, etc.

.. seealso:: :py:func:`selectByRect`

.. seealso:: :py:func:`selectByExpression`
%End

    void modifySelection( const QgsFeatureIds &selectIds, const QgsFeatureIds &deselectIds );
%Docstring
Modifies the current selection on this layer

:param selectIds: Select these ids
:param deselectIds: Deselect these ids

.. seealso:: :py:func:`selectByIds`

.. seealso:: :py:func:`deselect`

.. seealso:: :py:func:`deselect`

.. seealso:: :py:func:`selectByExpression`
%End

    void invertSelection();
%Docstring
Selects not selected features and deselects selected ones
%End

    void selectAll();
%Docstring
Select all the features
%End

    void invertSelectionInRectangle( QgsRectangle &rect );
%Docstring
Inverts selection of features found within the search rectangle (in
layer's coordinates)

:param rect: The rectangle in which the selection of features will be
             inverted

.. seealso:: :py:func:`invertSelection`
%End

    QgsFeatureList selectedFeatures() const;
%Docstring
Returns a copy of the user-selected features.

.. warning::

   Calling this method triggers a request for all attributes and geometry for the selected features.
   Consider using the much more efficient :py:func:`~QgsVectorLayer.selectedFeatureIds` or :py:func:`~QgsVectorLayer.selectedFeatureCount` if you do not
   require access to the feature attributes or geometry.

:return: A list of :py:class:`QgsFeature`

.. seealso:: :py:func:`selectedFeatureIds`

.. seealso:: :py:func:`getSelectedFeatures` which is more memory friendly when handling large selections
%End

    QgsFeatureIterator getSelectedFeatures( QgsFeatureRequest request = QgsFeatureRequest() ) const;
%Docstring
Returns an iterator of the selected features.

:param request: You may specify a request, e.g. to limit the set of
                requested attributes. Any filter on the request will be
                discarded.

:return: Iterator over the selected features

.. warning::

   Calling this method returns an iterator for all attributes and geometry for the selected features.
   Consider using the much more efficient :py:func:`~QgsVectorLayer.selectedFeatureIds` or :py:func:`~QgsVectorLayer.selectedFeatureCount` if you do not
   require access to the feature attributes or geometry.

.. seealso:: :py:func:`selectedFeatureIds`

.. seealso:: :py:func:`selectedFeatures`
%End

    const QgsFeatureIds &selectedFeatureIds() const;
%Docstring
Returns a list of the selected features IDs in this layer.

.. seealso:: :py:func:`selectedFeatures`

.. seealso:: :py:func:`selectedFeatureCount`

.. seealso:: :py:func:`selectByIds`
%End

    QgsRectangle boundingBoxOfSelected() const;
%Docstring
Returns the bounding box of the selected features. If there is no
selection, QgsRectangle(0,0,0,0) is returned
%End

    bool labelsEnabled() const;
%Docstring
Returns whether the layer contains labels which are enabled and should
be drawn.

:return: ``True`` if layer contains enabled labels

.. seealso:: :py:func:`setLabelsEnabled`
%End

    void setLabelsEnabled( bool enabled );
%Docstring
Sets whether labels should be ``enabled`` for the layer.

.. note::

   Labels will only be rendered if :py:func:`~QgsVectorLayer.labelsEnabled` is ``True`` and a labeling
   object is returned by :py:func:`~QgsVectorLayer.labeling`.

.. seealso:: :py:func:`labelsEnabled`

.. seealso:: :py:func:`labeling`
%End

    bool diagramsEnabled() const;
%Docstring
Returns whether the layer contains diagrams which are enabled and should
be drawn.

:return: ``True`` if layer contains enabled diagrams
%End

    void setDiagramRenderer( QgsDiagramRenderer *r /Transfer/ );
%Docstring
Sets diagram rendering object (takes ownership)
%End
    const QgsDiagramRenderer *diagramRenderer() const;

    void setDiagramLayerSettings( const QgsDiagramLayerSettings &s );
    const QgsDiagramLayerSettings *diagramLayerSettings() const;

    QgsFeatureRenderer *renderer();
%Docstring
Returns the feature renderer used for rendering the features in the
layer in 2D map views.

.. seealso:: :py:func:`setRenderer`
%End


    void setRenderer( QgsFeatureRenderer *r /Transfer/ );
%Docstring
Sets the feature renderer which will be invoked to represent this layer
in 2D map views. Ownership is transferred.

.. seealso:: :py:func:`renderer`
%End

    void addFeatureRendererGenerator( QgsFeatureRendererGenerator *generator /Transfer/ );
%Docstring
Adds a new feature renderer ``generator`` to the layer.

Ownership of ``generator`` is transferred to the layer.

.. seealso:: :py:func:`removeFeatureRendererGenerator`

.. seealso:: :py:func:`featureRendererGenerators`

.. versionadded:: 3.18
%End

    void removeFeatureRendererGenerator( const QString &id );
%Docstring
Removes the feature renderer with matching ``id`` from the layer.

The corresponding generator will be deleted.

.. seealso:: :py:func:`addFeatureRendererGenerator`

.. seealso:: :py:func:`featureRendererGenerators`

.. versionadded:: 3.18
%End

    QList< const QgsFeatureRendererGenerator * > featureRendererGenerators() const;
%Docstring
Returns a list of the feature renderer generators owned by the layer.

.. seealso:: :py:func:`addFeatureRendererGenerator`

.. seealso:: :py:func:`removeFeatureRendererGenerator`

.. versionadded:: 3.18
%End

    Qgis::GeometryType geometryType() const;
%Docstring
Returns point, line or polygon
%End

    virtual Qgis::WkbType wkbType() const ${SIP_FINAL};

%Docstring
Returns the WKBType or WKBUnknown in case of error
%End

    virtual QgsCoordinateReferenceSystem sourceCrs() const ${SIP_FINAL};

    virtual QString sourceName() const ${SIP_FINAL};


    virtual bool readXml( const QDomNode &layer_node, QgsReadWriteContext &context ) ${SIP_FINAL};

%Docstring
Reads vector layer specific state from project file Dom node.

.. note::

   Called by :py:func:`QgsMapLayer.readXml()`.
%End

    virtual bool writeXml( QDomNode &layer_node, QDomDocument &doc, const QgsReadWriteContext &context ) const ${SIP_FINAL};

%Docstring
Writes vector layer specific state to project file Dom node.

.. note::

   Called by :py:func:`QgsMapLayer.writeXml()`.
%End

    virtual QString encodedSource( const QString &source, const QgsReadWriteContext &context ) const ${SIP_FINAL};

    virtual QString decodedSource( const QString &source, const QString &provider, const QgsReadWriteContext &context ) const ${SIP_FINAL};


    virtual void resolveReferences( QgsProject *project ) ${SIP_FINAL};

%Docstring
Resolves references to other layers (kept as layer IDs after reading
XML) into layer objects.
%End

    bool loadAuxiliaryLayer( const QgsAuxiliaryStorage &storage, const QString &key = QString() );
%Docstring
Loads the auxiliary layer for this vector layer. If there's no
corresponding table in the database, then nothing happens and ``False``
is returned. The key is optional because if this layer has been read
from a XML document, then the key read in this document is used by
default.

:param storage: The auxiliary storage where to look for the table
:param key: The key to use for joining.

:return: ``True`` if the auxiliary layer is well loaded, ``False``
         otherwise
%End

    void setAuxiliaryLayer( QgsAuxiliaryLayer *layer /Transfer/ = 0 );
%Docstring
Sets the current auxiliary layer. The auxiliary layer is automatically
put in editable mode and fields are updated. Moreover, a join is created
between the current layer and the auxiliary layer. Ownership is
transferred.
%End

    QgsAuxiliaryLayer *auxiliaryLayer();
%Docstring
Returns the current auxiliary layer.
%End


     virtual bool readSymbology( const QDomNode &layerNode, QString &errorMessage,
                        QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories ) ${SIP_FINAL};
     virtual bool readStyle( const QDomNode &node, QString &errorMessage,
                    QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories ) ${SIP_FINAL};
     virtual bool writeSymbology( QDomNode &node, QDomDocument &doc, QString &errorMessage,
                         const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories ) const ${SIP_FINAL};
     virtual bool writeStyle( QDomNode &node, QDomDocument &doc, QString &errorMessage,
                     const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories ) const ${SIP_FINAL};

    bool writeSld( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QVariantMap &props = QVariantMap() ) const;
%Docstring
Writes the symbology of the layer into the document provided in SLD 1.1
format

:param node: the node that will have the style element added to it.
:param doc: the document that will have the QDomNode added.
:param errorMessage: reference to string that will be updated with any
                     error messages
:param props: a open ended set of properties that can drive/inform the
              SLD encoding

:return: ``True`` in case of success
%End

    virtual bool readSld( const QDomNode &node, QString &errorMessage ) ${SIP_FINAL};


    long long featureCount( const QString &legendKey ) const;
%Docstring
Number of features rendered with specified legend key. Features must be
first calculated by :py:func:`~QgsVectorLayer.countSymbolFeatures`

:return: number of features rendered by symbol or -1 if failed or counts
         are not available
%End

    QgsFeatureIds symbolFeatureIds( const QString &legendKey ) const;
%Docstring
Ids of features rendered with specified legend key. Features must be
first calculated by :py:func:`~QgsVectorLayer.countSymbolFeatures`

:return: Ids of features rendered by symbol or -1 if failed or Ids are
         not available

.. versionadded:: 3.10
%End

    virtual Qgis::FeatureAvailability hasFeatures() const ${SIP_FINAL};

%Docstring
Determines if this vector layer has features.

.. warning::

   when a layer is editable and some features
   have been deleted, this will return
   :py:class:`QgsFeatureSource`.FeatureAvailability.FeaturesMayBeAvailable
   to avoid a potentially expensive call to the dataprovider.

.. versionadded:: 3.4
%End

    virtual QString loadDefaultStyle( bool &resultFlag /Out/ ) ${SIP_FINAL};


    QgsVectorLayerFeatureCounter *countSymbolFeatures( bool storeSymbolFids = false );
%Docstring
Count features for symbols. The method will return the feature counter
task. You will need to connect to the
:py:func:`~QgsVectorLayer.symbolFeatureCountMapChanged` signal to be
notified when the freshly updated feature counts are ready.

:param storeSymbolFids: If ``True`` will gather the feature ids (fids)
                        per symbol, otherwise only the count. Default
                        ``False``.

.. note::

   If the count features for symbols has been already done a
   ``None`` is returned. If you need to wait for the results,
   you can call :py:func:`~QgsVectorLayer.waitForFinished` on the feature counter.
%End

    virtual bool setSubsetString( const QString &subset );
%Docstring
Sets the string (typically sql) used to define a subset of the layer

:param subset: The subset string. This may be the where clause of a sql
               statement or other definition string specific to the
               underlying dataprovider and data store.

:return: ``True``, when setting the subset string was successful,
         ``False`` otherwise
%End

    virtual QString subsetString() const;
%Docstring
Returns the string (typically sql) used to define a subset of the layer.

:return: The subset string or null QString if not implemented by the
         provider
%End

    virtual QgsFeatureIterator getFeatures( const QgsFeatureRequest &request = QgsFeatureRequest() ) const ${SIP_FINAL};

%Docstring
Queries the layer for features specified in request.

:param request: feature request describing parameters of features to
                return

:return: iterator for matching features from provider
%End

    QgsFeatureIterator getFeatures( const QString &expression );
%Docstring
Queries the layer for features matching a given expression.
%End

    QgsFeature getFeature( QgsFeatureId fid ) const;
%Docstring
Queries the layer for the feature with the given id. If there is no such
feature, the returned feature will be invalid.
%End

    QgsGeometry getGeometry( QgsFeatureId fid ) const;
%Docstring
Queries the layer for the geometry at the given id. If there is no such
feature, the returned geometry will be invalid.
%End

    QgsFeatureIterator getFeatures( const QgsFeatureIds &fids );
%Docstring
Queries the layer for the features with the given ids.
%End

    QgsFeatureIterator getFeatures( const QgsRectangle &rectangle );
%Docstring
Queries the layer for the features which intersect the specified
rectangle.
%End

    virtual bool addFeature( QgsFeature &feature, QgsFeatureSink::Flags flags = QgsFeatureSink::Flags() ) ${SIP_FINAL};


    bool updateFeature( QgsFeature &feature, bool skipDefaultValues = false );
%Docstring
Updates an existing ``feature`` in the layer, replacing the attributes
and geometry for the feature with matching :py:func:`QgsFeature.id()`
with the attributes and geometry from ``feature``. Changes are not
immediately committed to the layer.

If ``skipDefaultValue`` is set to ``True``, default field values will
not be updated. This can be used to override default field value
expressions.

Returns ``True`` if the feature's attribute was successfully changed.

.. note::

   Calls to :py:func:`~QgsVectorLayer.updateFeature` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.

.. warning::

   This method needs to query the underlying data provider to fetch the feature
   with matching :py:func:`QgsFeature.id()` on every call. Depending on the underlying data source this
   can be slow to execute. Consider using the more efficient :py:func:`~QgsVectorLayer.changeAttributeValue` or
   :py:func:`~QgsVectorLayer.changeGeometry` methods instead.

.. seealso:: :py:func:`startEditing`

.. seealso:: :py:func:`commitChanges`

.. seealso:: :py:func:`changeGeometry`

.. seealso:: :py:func:`changeAttributeValue`
%End

    bool insertVertex( double x, double y, QgsFeatureId atFeatureId, int beforeVertex );
%Docstring
Inserts a new vertex before the given vertex number, in the given ring,
item (first number is index 0), and feature.

Not meaningful for Point geometries

.. note::

   Calls to :py:func:`~QgsVectorLayer.insertVertex` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    bool insertVertex( const QgsPoint &point, QgsFeatureId atFeatureId, int beforeVertex );
%Docstring
Inserts a new vertex before the given vertex number, in the given ring,
item (first number is index 0), and feature.

Not meaningful for Point geometries

.. note::

   Calls to :py:func:`~QgsVectorLayer.insertVertex` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    bool moveVertex( double x, double y, QgsFeatureId atFeatureId, int atVertex );
%Docstring
Moves the vertex at the given position number, ring and item (first
number is index 0), and feature to the given coordinates.

.. note::

   Calls to :py:func:`~QgsVectorLayer.moveVertex` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    bool moveVertex( const QgsPoint &p, QgsFeatureId atFeatureId, int atVertex ) /PyName=moveVertexV2/;
%Docstring
Moves the vertex at the given position number, ring and item (first
number is index 0), and feature to the given coordinates.



.. note::

   Calls to :py:func:`~QgsVectorLayer.moveVertex` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    Qgis::VectorEditResult deleteVertex( QgsFeatureId featureId, int vertex );
%Docstring
Deletes a vertex from a feature.

:param featureId: ID of feature to remove vertex from
:param vertex: index of vertex to delete

.. note::

   Calls to :py:func:`~QgsVectorLayer.deleteVertex` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    bool deleteSelectedFeatures( int *deletedCount = 0, QgsVectorLayer::DeleteContext *context = 0 );
%Docstring
Deletes the selected features

:param deletedCount: The number of successfully deleted features
:param context: The chain of features who will be deleted for feedback
                and to avoid endless recursions

:return: ``True`` in case of success and ``False`` otherwise
%End

 Qgis::GeometryOperationResult addRing( const QVector<QgsPointXY> &ring, QgsFeatureId *featureId = 0 ) /Deprecated/;
%Docstring
Adds a ring to polygon/multipolygon features

:param ring: ring to add
:param featureId: if specified, feature ID for feature ring was added to
                  will be stored in this parameter

:return: :py:class:`Qgis`.GeometryOperationResult

         - Success
         - LayerNotEditable
         - AddRingNotInExistingFeature
         - InvalidInputGeometryType
         - AddRingNotClosed
         - AddRingNotValid
         - AddRingCrossesExistingRings

.. note::

   Calls to :py:func:`~QgsVectorLayer.addRing` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.

.. deprecated:: 3.12

   Will be removed in QGIS 4.0. Use the variant which accepts :py:class:`QgsPoint` objects instead of :py:class:`QgsPointXY`.
%End


    Qgis::GeometryOperationResult addRing( const QgsPointSequence &ring, QgsFeatureId *featureId = 0 );
%Docstring
Adds a ring to polygon/multipolygon features

:param ring: ring to add
:param featureId: if specified, feature ID for feature ring was added to
                  will be stored in this parameter

:return: :py:class:`Qgis`.GeometryOperationResult

         - Success
         - LayerNotEditable
         - AddRingNotInExistingFeature
         - InvalidInputGeometryType
         - AddRingNotClosed
         - AddRingNotValid
         - AddRingCrossesExistingRings

.. note::

   Calls to :py:func:`~QgsVectorLayer.addRing` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    Qgis::GeometryOperationResult addRing( QgsCurve *ring /Transfer/, QgsFeatureId *featureId = 0 ) /PyName=addCurvedRing/;
%Docstring
Adds a ring to polygon/multipolygon features (takes ownership)

:param ring: ring to add
:param featureId: if specified, feature ID for feature ring was added to
                  will be stored in this parameter

:return: :py:class:`Qgis`.GeometryOperationResult

         - Success
         - LayerNotEditable
         - AddRingNotInExistingFeature
         - InvalidInputGeometryType
         - AddRingNotClosed
         - AddRingNotValid
         - AddRingCrossesExistingRings



.. note::

   Calls to :py:func:`~QgsVectorLayer.addRing` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

 Qgis::GeometryOperationResult addPart( const QList<QgsPointXY> &ring ) /Deprecated/;
%Docstring
Adds a new part polygon to a multipart feature

:return: :py:class:`Qgis`.GeometryOperationResult

         - Success
         - LayerNotEditable
         - SelectionIsEmpty
         - SelectionIsGreaterThanOne
         - AddPartSelectedGeometryNotFound
         - AddPartNotMultiGeometry
         - InvalidBaseGeometry
         - InvalidInputGeometryType

.. note::

   Calls to :py:func:`~QgsVectorLayer.addPart` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.

.. deprecated:: 3.12

   Will be removed in QGIS 4.0. Use the variant which accepts :py:class:`QgsPoint` objects instead of :py:class:`QgsPointXY`.
%End


 Qgis::GeometryOperationResult addPart( const QVector<QgsPointXY> &ring ) /PyName=addPartV2,Deprecated/;
%Docstring
Adds a new part polygon to a multipart feature

:return: :py:class:`Qgis`.GeometryOperationResult

         - Success
         - LayerNotEditable
         - SelectionIsEmpty
         - SelectionIsGreaterThanOne
         - AddPartSelectedGeometryNotFound
         - AddPartNotMultiGeometry
         - InvalidBaseGeometry
         - InvalidInputGeometryType

.. note::

   available in Python bindings as addPartV2

.. note::

   Calls to :py:func:`~QgsVectorLayer.addPart` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.

.. deprecated:: 3.12

   Will be removed in QGIS 4.0. Use the variant which accepts :py:class:`QgsPoint` objects instead of :py:class:`QgsPointXY`.
%End

    Qgis::GeometryOperationResult addPart( const QgsPointSequence &ring ) /PyName=addPartV2/;
%Docstring
Adds a new part polygon to a multipart feature

:return: :py:class:`Qgis`.GeometryOperationResult

         - Success
         - LayerNotEditable
         - SelectionIsEmpty
         - SelectionIsGreaterThanOne
         - AddPartSelectedGeometryNotFound
         - AddPartNotMultiGeometry
         - InvalidBaseGeometry
         - InvalidInputGeometryType



.. note::

   Calls to :py:func:`~QgsVectorLayer.addPart` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    Qgis::GeometryOperationResult addPart( QgsCurve *ring /Transfer/ ) /PyName=addCurvedPart/;
%Docstring
.. note::

   Calls to :py:func:`~QgsVectorLayer.addPart` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    int translateFeature( QgsFeatureId featureId, double dx, double dy );
%Docstring
Translates feature by dx, dy

:param featureId: id of the feature to translate
:param dx: translation of x-coordinate
:param dy: translation of y-coordinate

:return: 0 in case of success

.. note::

   Calls to :py:func:`~QgsVectorLayer.translateFeature` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

 Qgis::GeometryOperationResult splitParts( const QVector<QgsPointXY> &splitLine, bool topologicalEditing = false ) /Deprecated/;
%Docstring
Splits parts cut by the given line

:param splitLine: line that splits the layer features
:param topologicalEditing: ``True`` if topological editing is enabled

:return: :py:class:`Qgis`.GeometryOperationResult

         - Success
         - NothingHappened
         - LayerNotEditable
         - InvalidInputGeometryType
         - InvalidBaseGeometry
         - GeometryEngineError
         - SplitCannotSplitPoint

.. note::

   Calls to :py:func:`~QgsVectorLayer.splitParts` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.

.. deprecated:: 3.12

   Will be removed in QGIS 4.0. Use the variant which accepts :py:class:`QgsPoint` objects instead of :py:class:`QgsPointXY`.
%End

    Qgis::GeometryOperationResult splitParts( const QgsPointSequence &splitLine, bool topologicalEditing = false );
%Docstring
Splits parts cut by the given line

:param splitLine: line that splits the layer features
:param topologicalEditing: ``True`` if topological editing is enabled

:return: :py:class:`Qgis`.GeometryOperationResult

         - Success
         - NothingHappened
         - LayerNotEditable
         - InvalidInputGeometryType
         - InvalidBaseGeometry
         - GeometryEngineError
         - SplitCannotSplitPoint

.. note::

   Calls to :py:func:`~QgsVectorLayer.splitParts` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

 Qgis::GeometryOperationResult splitFeatures( const QVector<QgsPointXY> &splitLine, bool topologicalEditing = false ) /Deprecated/;
%Docstring
Splits features cut by the given line

:param splitLine: line that splits the layer features
:param topologicalEditing: ``True`` if topological editing is enabled

:return: :py:class:`Qgis`.GeometryOperationResult

         - Success
         - NothingHappened
         - LayerNotEditable
         - InvalidInputGeometryType
         - InvalidBaseGeometry
         - GeometryEngineError
         - SplitCannotSplitPoint

.. note::

   Calls to :py:func:`~QgsVectorLayer.splitFeatures` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.

.. deprecated:: 3.12

   Will be removed in QGIS 4.0. Use the variant which accepts :py:class:`QgsPoint` objects instead of :py:class:`QgsPointXY`.
%End

    Qgis::GeometryOperationResult splitFeatures( const QgsPointSequence &splitLine, bool topologicalEditing = false );
%Docstring
Splits features cut by the given line

:param splitLine: line that splits the layer features
:param topologicalEditing: ``True`` if topological editing is enabled

:return: :py:class:`Qgis`.GeometryOperationResult

         - Success
         - NothingHappened
         - LayerNotEditable
         - InvalidInputGeometryType
         - InvalidBaseGeometry
         - GeometryEngineError
         - SplitCannotSplitPoint

.. note::

   Calls to :py:func:`~QgsVectorLayer.splitFeatures` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    Qgis::GeometryOperationResult splitFeatures( const QgsCurve *curve, QgsPointSequence &topologyTestPoints /Out/, bool preserveCircular = false, bool topologicalEditing = false );
%Docstring
Splits features cut by the given curve

:param curve: curve that splits the layer features
:param preserveCircular: whether circular strings are preserved after
                         splitting
:param topologicalEditing: ``True`` if topological editing is enabled

:return: - :py:class:`Qgis`.GeometryOperationResult

           - Success
           - NothingHappened
           - LayerNotEditable
           - InvalidInputGeometryType
           - InvalidBaseGeometry
           - GeometryEngineError
           - SplitCannotSplitPoint

         - topologyTestPoints: topological points to be tested against other layers

.. note::

   Calls to :py:func:`~QgsVectorLayer.splitFeatures` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.

.. versionadded:: 3.16
%End

    int addTopologicalPoints( const QgsGeometry &geom );
%Docstring
Adds topological points for every vertex of the geometry.

:param geom: the geometry where each vertex is added to segments of
             other features

:return: - 1 in case of layer error (invalid or non editable)

:return: 0 in case of success

:return: 1 in case of geometry error (non spatial or null geometry)

:return: 2 in case no vertices needed to be added

.. note::

   geom is not going to be modified by the function

.. note::

   Calls to :py:func:`~QgsVectorLayer.addTopologicalPoints` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

 int addTopologicalPoints( const QgsPointXY &p )  /Deprecated/;
%Docstring
Adds a vertex to segments which intersect point ``p`` but don't already
have a vertex there. If a feature already has a vertex at position
``p``, no additional vertex is inserted. This method is useful for
topological editing.

:param p: position of the vertex

:return: - 1 in case of layer error (invalid or non editable)

:return: 0 in case of success

:return: 1 in case of geometry error (non spatial or null geometry)

:return: 2 in case no vertices needed to be added

.. note::

   Calls to :py:func:`~QgsVectorLayer.addTopologicalPoints` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.

.. deprecated:: 3.12

   Will be removed in QGIS 4.0. Use the variant which accepts :py:class:`QgsPoint` objects instead of :py:class:`QgsPointXY`.
%End

    int addTopologicalPoints( const QgsPoint &p );
%Docstring
Adds a vertex to segments which intersect point ``p`` but don't already
have a vertex there. If a feature already has a vertex at position
``p``, no additional vertex is inserted. This method is useful for
topological editing.

:param p: position of the vertex

:return: - 1 in case of layer error (invalid or non editable)

:return: 0 in case of success

:return: 1 in case of geometry error (non spatial or null geometry)

:return: 2 in case no vertices needed to be added

.. note::

   Calls to :py:func:`~QgsVectorLayer.addTopologicalPoints` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.

.. versionadded:: 3.10
%End

    int addTopologicalPoints( const QgsPointSequence &ps );
%Docstring
Adds a vertex to segments which intersect any of the points ``p`` but
don't already have a vertex there. If a feature already has a vertex at
position ``p``, no additional vertex is inserted. This method is useful
for topological editing.

:param ps: point sequence of the vertices

:return: - 1 in case of layer error (invalid or non editable)

:return: 0 in case of success

:return: 1 in case of geometry error (non spatial or null geometry)

:return: 2 in case no vertices needed to be added

.. note::

   Calls to :py:func:`~QgsVectorLayer.addTopologicalPoints` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.

.. versionadded:: 3.16
%End


    QgsAbstractVectorLayerLabeling *labeling();
%Docstring
Access to labeling configuration. May be ``None`` if labeling is not
used.

.. note::

   Labels will only be rendered if :py:func:`~QgsVectorLayer.labelsEnabled` returns ``True``.

.. seealso:: :py:func:`labelsEnabled`
%End

    void setLabeling( QgsAbstractVectorLayerLabeling *labeling /Transfer/ );
%Docstring
Sets labeling configuration. Takes ownership of the object.
%End

    virtual bool isEditable() const ${SIP_FINAL};

%Docstring
Returns ``True`` if the provider is in editing mode
%End

    virtual bool isSpatial() const ${SIP_FINAL};

%Docstring
Returns ``True`` if this is a geometry layer and ``False`` in case of
NoGeometry (table only) or UnknownGeometry
%End

    virtual bool isModified() const;

%Docstring
Returns ``True`` if the provider has been modified since the last commit
%End

    bool isAuxiliaryField( int index, int &srcIndex ) const;
%Docstring
Returns ``True`` if the field comes from the auxiliary layer, ``False``
otherwise.
%End

    virtual void reload() ${SIP_FINAL};

%Docstring
Synchronises with changes in the datasource
%End

    virtual QgsMapLayerRenderer *createMapRenderer( QgsRenderContext &rendererContext ) ${SIP_FINAL} /Factory/;

%Docstring
Returns new instance of :py:class:`QgsMapLayerRenderer` that will be
used for rendering of given context
%End

    virtual QgsRectangle extent() const ${SIP_FINAL};

    virtual QgsRectangle sourceExtent() const ${SIP_FINAL};


    virtual QgsBox3D extent3D() const ${SIP_FINAL};

    virtual QgsBox3D sourceExtent3D() const ${SIP_FINAL};


    virtual QgsFields fields() const ${SIP_FINAL};

%Docstring
Returns the list of fields of this layer. This also includes fields
which have not yet been saved to the provider.

:return: A list of fields
%End

    QgsAttributeList attributeList() const;
%Docstring
Returns list of attribute indexes. i.e. a list from 0 ...
:py:func:`~QgsVectorLayer.fieldCount`
%End

    QgsAttributeList primaryKeyAttributes() const;
%Docstring
Returns the list of attributes which make up the layer's primary keys.
%End

    virtual long long featureCount() const ${SIP_FINAL};

%Docstring
Returns feature count including changes which have not yet been
committed If you need only the count of committed features call this
method on this layer's provider.

:return: the number of features on this layer or -1 if unknown.
%End

    bool setReadOnly( bool readonly = true );
%Docstring
Makes layer read-only (editing disabled) or not

:return: ``False`` if the layer is in editing yet or if the data source
         is in read-only mode

.. seealso:: :py:func:`readOnlyChanged`
%End

    virtual bool supportsEditing() const;

%Docstring
Returns whether the layer supports editing or not

:return: ``False`` if the layer is read only or the data provider has no
         editing capabilities

.. versionadded:: 3.18
%End

    bool changeGeometry( QgsFeatureId fid, QgsGeometry &geometry, bool skipDefaultValue = false );
%Docstring
Changes a feature's ``geometry`` within the layer's edit buffer (but
does not immediately commit the changes). The ``fid`` argument specifies
the ID of the feature to be changed.

If ``skipDefaultValue`` is set to ``True``, default field values will
not be updated. This can be used to override default field value
expressions.

:return: ``True`` if the feature's geometry was successfully changed.

.. note::

   Calls to :py:func:`~QgsVectorLayer.changeGeometry` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.

.. seealso:: :py:func:`startEditing`

.. seealso:: :py:func:`commitChanges`

.. seealso:: :py:func:`changeAttributeValue`

.. seealso:: :py:func:`updateFeature`
%End

    bool changeAttributeValue( QgsFeatureId fid, int field, const QVariant &newValue, const QVariant &oldValue = QVariant(), bool skipDefaultValues = false,  QgsVectorLayerToolsContext *context = 0 );
%Docstring
Changes an attribute value for a feature (but does not immediately
commit the changes). The ``fid`` argument specifies the ID of the
feature to be changed.

The ``field`` argument must specify a valid field index for the layer
(where an index of 0 corresponds to the first field).

The new value to be assigned to the field is given by ``newValue``.

If a valid QVariant is specified for ``oldValue``, it will be used as
the field value in the case of an undo operation corresponding to this
attribute value change. If an invalid QVariant is used (the default
behavior), then the feature's current value will be automatically
retrieved and used. Note that this involves a feature request to the
underlying data provider, so it is more efficient to explicitly pass an
``oldValue`` if it is already available.

If ``skipDefaultValues`` is set to ``True``, default field values will
not be updated. This can be used to override default field value
expressions.

If ``context`` is provided, it will be used when updating default values
(since QGIS 3.38).

:return: ``True`` if the feature's attribute was successfully changed.

.. note::

   Calls to :py:func:`~QgsVectorLayer.changeAttributeValue` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.

.. seealso:: :py:func:`startEditing`

.. seealso:: :py:func:`commitChanges`

.. seealso:: :py:func:`changeGeometry`

.. seealso:: :py:func:`updateFeature`
%End

    bool changeAttributeValues( QgsFeatureId fid, const QgsAttributeMap &newValues, const QgsAttributeMap &oldValues = QgsAttributeMap(), bool skipDefaultValues = false, QgsVectorLayerToolsContext *context = 0 );
%Docstring
Changes attributes' values for a feature (but does not immediately
commit the changes). The ``fid`` argument specifies the ID of the
feature to be changed.

The new values to be assigned to the fields are given by ``newValues``.

If a valid QVariant is specified for a field in ``oldValues``, it will
be used as the field value in the case of an undo operation
corresponding to this attribute value change. If an invalid QVariant is
used (the default behavior), then the feature's current value will be
automatically retrieved and used. Note that this involves a feature
request to the underlying data provider, so it is more efficient to
explicitly pass an oldValue if it is already available.

If ``skipDefaultValues`` is set to ``True``, default field values will
not be updated. This can be used to override default field value
expressions.

If ``context`` is provided, it will be used when updating default values
(since QGIS 3.38).

:return: ``True`` if feature's attributes was successfully changed.

.. note::

   Calls to :py:func:`~QgsVectorLayer.changeAttributeValues` are only valid for layers in
   which edits have been enabled by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made
   to features using this method are not committed to the underlying data
   provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted changes
   can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.

.. seealso:: :py:func:`startEditing`

.. seealso:: :py:func:`commitChanges`

.. seealso:: :py:func:`changeGeometry`

.. seealso:: :py:func:`updateFeature`

.. seealso:: :py:func:`changeAttributeValue`
%End

    bool addAttribute( const QgsField &field );
%Docstring
Add an attribute field (but does not commit it) returns ``True`` if the
field was added

.. note::

   Calls to :py:func:`~QgsVectorLayer.addAttribute` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    void setFieldAlias( int index, const QString &aliasString );
%Docstring
Sets an alias (a display name) for attributes to display in dialogs
%End

    void removeFieldAlias( int index );
%Docstring
Removes an alias (a display name) for attributes to display in dialogs
%End

    bool renameAttribute( int index, const QString &newName );
%Docstring
Renames an attribute field (but does not commit it).

:param index: attribute index
:param newName: new name of field

.. note::

   Calls to :py:func:`~QgsVectorLayer.renameAttribute` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    QString attributeAlias( int index ) const;
%Docstring
Returns the alias of an attribute name or a null string if there is no
alias.

\see {attributeDisplayName( int attributeIndex )} which returns the
field name if no alias is defined.
%End

    QString attributeDisplayName( int index ) const;
%Docstring
Convenience function that returns the attribute alias if defined or the
field name else
%End

    QgsStringMap attributeAliases() const;
%Docstring
Returns a map of field name to attribute alias
%End


    void setFieldSplitPolicy( int index, Qgis::FieldDomainSplitPolicy policy );
%Docstring
Sets a split ``policy`` for the field with the specified index.

:raises KeyError: if no field with the specified index exists

.. versionadded:: 3.30
%End

%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 );
%Docstring
Sets a duplicate ``policy`` for the field with the specified index.

:raises KeyError: if no field with the specified index exists

.. versionadded:: 3.38
%End

%MethodCode
    if ( a0 < 0 || a0 >= sipCpp->fields().count() )
    {
      PyErr_SetString( PyExc_KeyError, QByteArray::number( a0 ) );
      sipIsErr = 1;
    }
    else
    {
      sipCpp->setFieldDuplicatePolicy( a0, a1 );
    }
%End

 QSet<QString> excludeAttributesWms() const /Deprecated/;
%Docstring
A set of attributes that are not advertised in WMS requests with QGIS
server.

.. deprecated:: 3.16

   Use :py:func:`~QgsVectorLayer.fields`.configurationFlags() instead.
%End

 void setExcludeAttributesWms( const QSet<QString> &att ) /Deprecated/;
%Docstring
A set of attributes that are not advertised in WMS requests with QGIS
server.

.. deprecated:: 3.16

   Use setFieldConfigurationFlag instead.
%End

 QSet<QString> excludeAttributesWfs() const /Deprecated/;
%Docstring
A set of attributes that are not advertised in WFS requests with QGIS
server.

.. deprecated:: 3.16

   Use :py:func:`~QgsVectorLayer.fields`.configurationFlags() instead.
%End

 void setExcludeAttributesWfs( const QSet<QString> &att ) /Deprecated/;
%Docstring
A set of attributes that are not advertised in WFS requests with QGIS
server.

.. deprecated:: 3.16

   Use setFieldConfigurationFlag instead.
%End

    virtual bool deleteAttribute( int attr );
%Docstring
Deletes an attribute field (but does not commit it).

.. note::

   Calls to :py:func:`~QgsVectorLayer.deleteAttribute` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    bool deleteAttributes( const QList<int> &attrs );
%Docstring
Deletes a list of attribute fields (but does not commit it)

:param attrs: the indices of the attributes to delete

:return: ``True`` if at least one attribute has been deleted
%End

    virtual bool addFeatures( QgsFeatureList &features, QgsFeatureSink::Flags flags = QgsFeatureSink::Flags() ) ${SIP_FINAL};


    bool deleteFeature( QgsFeatureId fid, QgsVectorLayer::DeleteContext *context = 0 );
%Docstring
Deletes a feature from the layer (but does not commit it).

:param fid: The feature id to delete
:param context: The chain of features who will be deleted for feedback
                and to avoid endless recursions

.. note::

   Calls to :py:func:`~QgsVectorLayer.deleteFeature` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    bool deleteFeatures( const QgsFeatureIds &fids, QgsVectorLayer::DeleteContext *context = 0 );
%Docstring
Deletes a set of features from the layer (but does not commit it)

:param fids: The feature ids to delete
:param context: The chain of features who will be deleted for feedback
                and to avoid endless recursions

:return: ``False`` if the layer is not in edit mode or does not support
         deleting in case of an active transaction depends on the
         provider implementation

.. note::

   Calls to :py:func:`~QgsVectorLayer.deleteFeatures` are only valid for layers in which edits have been enabled
   by a call to :py:func:`~QgsVectorLayer.startEditing`. Changes made to features using this method are not committed
   to the underlying data provider until a :py:func:`~QgsVectorLayer.commitChanges` call is made. Any uncommitted
   changes can be discarded by calling :py:func:`~QgsVectorLayer.rollBack`.
%End

    bool commitChanges( bool stopEditing = true );
%Docstring
Attempts to commit to the underlying data provider any buffered changes
made since the last to call to :py:func:`~QgsVectorLayer.startEditing`.

Returns the result of the attempt. If a commit fails (i.e. ``False`` is
returned), the in-memory changes are left untouched and are not
discarded. This allows editing to continue if the commit failed on e.g.
a disallowed value in a Postgres database - the user can re-edit and try
again.

The commits occur in distinct stages, (add attributes, add features,
change attribute values, change geometries, delete features, delete
attributes) so if a stage fails, it can be difficult to roll back
cleanly. Therefore any error message returned by
:py:func:`~QgsVectorLayer.commitErrors` also includes which stage failed
so that the user has some chance of repairing the damage cleanly.

By setting ``stopEditing`` to ``False``, the layer will stay in editing
mode. Otherwise the layer editing mode will be disabled if the commit is
successful.

.. seealso:: :py:func:`startEditing`

.. seealso:: :py:func:`commitErrors`

.. seealso:: :py:func:`rollBack`
%End

    QStringList commitErrors() const;
%Docstring
Returns a list containing any error messages generated when attempting
to commit changes to the layer.

.. seealso:: :py:func:`commitChanges`
%End

    bool rollBack( bool deleteBuffer = true );
%Docstring
Stops a current editing operation and discards any uncommitted edits.

If ``deleteBuffer`` is ``True`` the editing buffer will be completely
deleted (the default behavior).

.. seealso:: :py:func:`startEditing`

.. seealso:: :py:func:`commitChanges`
%End

    QList<QgsRelation> referencingRelations( int idx ) const;
%Docstring
Returns the layer's relations, where the foreign key is on this layer.

:param idx: Only get relations, where idx forms part of the foreign key

:return: A list of relations
%End



    QgsVectorLayerEditBuffer *editBuffer();
%Docstring
Buffer with uncommitted editing operations. Only valid after editing has
been turned on.
%End


    void beginEditCommand( const QString &text );
%Docstring
Create edit command for undo/redo operations

:param text: text which is to be displayed in undo window
%End

    void endEditCommand();
%Docstring
Finish edit command and add it to undo/redo stack
%End

    void destroyEditCommand();
%Docstring
Destroy active command and reverts all changes in it
%End

 static void drawVertexMarker( double x, double y, QPainter &p, Qgis::VertexMarkerType type, int vertexSize );
%Docstring
Draws a vertex symbol at (screen) coordinates x, y. (Useful to assist
vertex editing.)

.. deprecated:: 3.40

   Use the equivalent :py:class:`QgsSymbolLayerUtils`.drawVertexMarker function instead.
%End

    void updateFields();
%Docstring
Will regenerate the `fields` property of this layer by obtaining all
fields from the dataProvider, joined fields and virtual fields. It will
also take any changes made to default values into consideration.

.. note::

   Unless the fields on the provider have directly been modified, there is
   no reason to call this method.
%End

    QVariant defaultValue( int index, const QgsFeature &feature = QgsFeature(),
                           QgsExpressionContext *context = 0 ) const;
%Docstring
Returns the calculated default value for the specified field index. The
default value may be taken from a client side default value expression
(see :py:func:`~QgsVectorLayer.setDefaultValueDefinition`) or taken from
the underlying data provider.

:param index: field index
:param feature: optional feature to use for default value evaluation. If
                passed, then properties from the feature (such as
                geometry) can be used when calculating the default
                value.
:param context: optional expression context to evaluate expressions
                again. If not specified, a default context will be
                created

:return: calculated default value

.. seealso:: :py:func:`setDefaultValueDefinition`
%End

    void setDefaultValueDefinition( int index, const QgsDefaultValue &definition );
%Docstring
Sets the definition of the expression to use when calculating the
default value for a field.

:param index: field index
:param definition: default value definition to use and evaluate when
                   calculating default values for field. Pass an empty
                   expression to clear the default.

.. seealso:: :py:func:`defaultValue`

.. seealso:: :py:func:`defaultValueDefinition`
%End

    QgsDefaultValue defaultValueDefinition( int index ) const;
%Docstring
Returns the definition of the expression used when calculating the
default value for a field.

:param index: field index

:return: definition of the default value with the expression evaluated
         when calculating default values for field, or definition with
         an empty string if no default is set

.. seealso:: :py:func:`defaultValue`

.. seealso:: :py:func:`setDefaultValueDefinition`
%End

    QgsFieldConstraints::Constraints fieldConstraints( int fieldIndex ) const;
%Docstring
Returns any constraints which are present for a specified field index.
These constraints may be inherited from the layer's data provider or may
be set manually on the vector layer from within QGIS.

.. seealso:: :py:func:`setFieldConstraint`
%End

    QMap< QgsFieldConstraints::Constraint, QgsFieldConstraints::ConstraintStrength> fieldConstraintsAndStrength( int fieldIndex ) const;
%Docstring
Returns a map of constraint with their strength for a specific field of
the layer.

:param fieldIndex: field index
%End

    void setFieldConstraint( int index, QgsFieldConstraints::Constraint constraint, QgsFieldConstraints::ConstraintStrength strength = QgsFieldConstraints::ConstraintStrengthHard );
%Docstring
Sets a constraint for a specified field index. Any constraints inherited
from the layer's data provider will be kept intact and cannot be
modified. Ie, calling this method only allows for new constraints to be
added on top of the existing provider constraints.

.. seealso:: :py:func:`fieldConstraints`

.. seealso:: :py:func:`removeFieldConstraint`
%End

    void removeFieldConstraint( int index, QgsFieldConstraints::Constraint constraint );
%Docstring
Removes a constraint for a specified field index. Any constraints
inherited from the layer's data provider will be kept intact and cannot
be removed.

.. seealso:: :py:func:`fieldConstraints`

.. seealso:: :py:func:`setFieldConstraint`
%End

    QString constraintExpression( int index ) const;
%Docstring
Returns the constraint expression for for a specified field index, if
set.

.. seealso:: :py:func:`fieldConstraints`

.. seealso:: :py:func:`constraintDescription`

.. seealso:: :py:func:`setConstraintExpression`
%End

    QString constraintDescription( int index ) const;
%Docstring
Returns the descriptive name for the constraint expression for a
specified field index.

.. seealso:: :py:func:`fieldConstraints`

.. seealso:: :py:func:`constraintExpression`

.. seealso:: :py:func:`setConstraintExpression`
%End

    void setConstraintExpression( int index, const QString &expression, const QString &description = QString() );
%Docstring
Sets the constraint expression for the specified field index. An
optional descriptive name for the constraint can also be set. Setting an
empty expression will clear any existing expression constraint.

.. seealso:: :py:func:`constraintExpression`

.. seealso:: :py:func:`constraintDescription`

.. seealso:: :py:func:`fieldConstraints`
%End

    void setFieldConfigurationFlags( int index, Qgis::FieldConfigurationFlags flags );
%Docstring
Sets the configuration flags of the field at given index

.. seealso:: :py:func:`QgsField.configurationFlags`

.. versionadded:: 3.34
%End

    void setFieldConfigurationFlag( int index, Qgis::FieldConfigurationFlag flag, bool active );
%Docstring
Sets the given configuration ``flag`` for the field at given ``index``
to be ``active`` or not.

.. versionadded:: 3.34
%End

    Qgis::FieldConfigurationFlags fieldConfigurationFlags( int index ) const;
%Docstring
Returns the configuration flags of the field at given index

.. seealso:: :py:func:`QgsField.setConfigurationFlags`

.. versionadded:: 3.34
%End

    void setEditorWidgetSetup( int index, const QgsEditorWidgetSetup &setup );
%Docstring
Sets the editor widget ``setup`` for the field at the specified
``index``.

The editor widget setup defines which :py:class:`QgsFieldFormatter` and
editor widget will be used for the field.

.. seealso:: :py:func:`editorWidgetSetup`
%End

    QgsEditorWidgetSetup editorWidgetSetup( int index ) const;
%Docstring
Returns the editor widget setup for the field at the specified
``index``.

The editor widget setup defines which :py:class:`QgsFieldFormatter` and
editor widget will be used for the field.

.. seealso:: :py:func:`setEditorWidgetSetup`
%End

    virtual QSet<QVariant> uniqueValues( int fieldIndex, int limit = -1 ) const ${SIP_FINAL};

%Docstring
Calculates a list of unique values contained within an attribute in the
layer. Note that in some circumstances when unsaved changes are present
for the layer then the returned list may contain outdated values (for
instance when the attribute value in a saved feature has been changed
inside the edit buffer then the previous saved value will be included in
the returned list).

:param fieldIndex: column index for attribute
:param limit: maximum number of values to return (or -1 if unlimited)

.. seealso:: :py:func:`minimumValue`

.. seealso:: :py:func:`maximumValue`
%End

    QStringList uniqueStringsMatching( int index, const QString &substring, int limit = -1,
                                       QgsFeedback *feedback = 0 ) const;
%Docstring
Returns unique string values of an attribute which contain a specified
subset string. Subset matching is done in a case-insensitive manner.
Note that in some circumstances when unsaved changes are present for the
layer then the returned list may contain outdated values (for instance
when the attribute value in a saved feature has been changed inside the
edit buffer then the previous saved value will be included in the
returned list).

:param index: column index for attribute
:param substring: substring to match (case insensitive)
:param limit: maxmum number of the values to return, or -1 to return all
              unique values
:param feedback: optional feedback object for canceling request

:return: list of unique strings containing substring
%End

    virtual QVariant minimumValue( int index ) const ${SIP_FINAL};

%Docstring
Returns the minimum value for an attribute column or an invalid variant
in case of error.

.. note::

   In some circumstances when unsaved changes are present for the layer then the
   returned value may be outdated (for instance when the attribute value in a saved feature has
   been changed inside the edit buffer then the previous saved value may be returned as the minimum).

.. note::

   If both the minimum and maximum value are required it is more efficient to call :py:func:`~QgsVectorLayer.minimumAndMaximumValue`
   instead of separate calls to :py:func:`~QgsVectorLayer.minimumValue` and :py:func:`~QgsVectorLayer.maximumValue`.

.. seealso:: :py:func:`maximumValue`

.. seealso:: :py:func:`minimumAndMaximumValue`

.. seealso:: :py:func:`uniqueValues`
%End

    virtual QVariant maximumValue( int index ) const ${SIP_FINAL};

%Docstring
Returns the maximum value for an attribute column or an invalid variant
in case of error.

.. note::

   In some circumstances when unsaved changes are present for the layer then the
   returned value may be outdated (for instance when the attribute value in a saved feature has
   been changed inside the edit buffer then the previous saved value may be returned as the maximum).

.. note::

   If both the minimum and maximum value are required it is more efficient to call :py:func:`~QgsVectorLayer.minimumAndMaximumValue`
   instead of separate calls to :py:func:`~QgsVectorLayer.minimumValue` and :py:func:`~QgsVectorLayer.maximumValue`.

.. seealso:: :py:func:`minimumValue`

.. seealso:: :py:func:`minimumAndMaximumValue`

.. seealso:: :py:func:`uniqueValues`
%End


    void minimumAndMaximumValue( int index, QVariant &minimum /Out/, QVariant &maximum /Out/ ) const;
%Docstring
Calculates both the minimum and maximum value for an attribute column.

This is more efficient then calling both
:py:func:`~QgsVectorLayer.minimumValue` and
:py:func:`~QgsVectorLayer.maximumValue` when both the minimum and
maximum values are required.

:param index: index of field to calculate minimum and maximum value for.

.. note::

   In some circumstances when unsaved changes are present for the layer then the
   calculated values may be outdated (for instance when the attribute value in a saved feature has
   been changed inside the edit buffer then the previous saved value may be returned as the maximum).

.. seealso:: :py:func:`minimumValue`

.. seealso:: :py:func:`maximumValue`

:return: - minimum: minimum attribute value or an invalid variant in
           case of error.
         - maximum: maximum attribute value or an invalid variant in
           case of error.

.. versionadded:: 3.20
%End

    QVariant aggregate( Qgis::Aggregate aggregate,
                        const QString &fieldOrExpression,
                        const QgsAggregateCalculator::AggregateParameters &parameters = QgsAggregateCalculator::AggregateParameters(),
                        QgsExpressionContext *context = 0,
                        bool *ok = 0,
                        QgsFeatureIds *fids = 0,
                        QgsFeedback *feedback = 0 ) const;
%Docstring
Calculates an aggregated value from the layer's features. Currently any
filtering expression provided will override filters in the
FeatureRequest.

:param aggregate: aggregate to calculate
:param fieldOrExpression: source field or expression to use as basis for
                          aggregated values.
:param parameters: parameters controlling aggregate calculation
:param context: expression context for expressions and filters
:param ok: if specified, will be set to ``True`` if aggregate
           calculation was successful
:param fids: list of fids to filter, otherwise will use all fids
:param feedback: optional feedback argument for early cancellation
                 (since QGIS 3.22)

:return: calculated aggregate value
%End

    void setFeatureBlendMode( QPainter::CompositionMode blendMode );
%Docstring
Sets the blending mode used for rendering each feature
%End
    QPainter::CompositionMode featureBlendMode() const;
%Docstring
Returns the current blending mode for features
%End

    virtual QString htmlMetadata() const ${SIP_FINAL};


    void setSimplifyMethod( const QgsVectorSimplifyMethod &simplifyMethod );
%Docstring
Sets the simplification settings for fast rendering of features
%End

    const QgsVectorSimplifyMethod &simplifyMethod() const;
%Docstring
Returns the simplification settings for fast rendering of features
%End

    bool simplifyDrawingCanbeApplied( const QgsRenderContext &renderContext, Qgis::VectorRenderingSimplificationFlag simplifyHint ) const;
%Docstring
Returns whether the VectorLayer can apply the specified simplification
hint

.. note::

   Do not use in 3rd party code - may be removed in future version!
%End

    QgsConditionalLayerStyles *conditionalStyles() const;
%Docstring
Returns the conditional styles that are set for this layer. Style
information is used to render conditional formatting in the attribute
table.

:return: Return a :py:class:`QgsConditionalLayerStyles` object holding
         the conditional attribute style information. Style information
         is generic and can be used for anything.
%End

    QgsAttributeTableConfig attributeTableConfig() const;
%Docstring
Returns the attribute table configuration object. This defines the
appearance of the attribute table.
%End

    void setAttributeTableConfig( const QgsAttributeTableConfig &attributeTableConfig );
%Docstring
Sets the attribute table configuration object. This defines the
appearance of the attribute table.
%End

    virtual QgsExpressionContext createExpressionContext() const ${SIP_FINAL};


    virtual QgsExpressionContextScope *createExpressionContextScope() const ${SIP_FINAL} /Factory/;


    QgsEditFormConfig editFormConfig() const;
%Docstring
Returns the configuration of the form used to represent this vector
layer.

:return: The configuration of this layers' form
%End

    void setEditFormConfig( const QgsEditFormConfig &editFormConfig );
%Docstring
Sets the ``editFormConfig`` (configuration) of the form used to
represent this vector layer.

.. seealso:: :py:func:`editFormConfig`
%End

    void setReadExtentFromXml( bool readExtentFromXml );
%Docstring
Flag allowing to indicate if the extent has to be read from the XML
document when data source has no metadata or if the data provider has to
determine it.
%End

    bool readExtentFromXml() const;
%Docstring
Returns ``True`` if the extent is read from the XML document when data
source has no metadata, ``False`` if it's the data provider which
determines it.
%End

    bool isEditCommandActive() const;
%Docstring
Tests if an edit command is active
%End

    QgsGeometryOptions *geometryOptions() const;
%Docstring
Configuration and logic to apply automatically on any edit happening on
this layer.

.. versionadded:: 3.4
%End



    QgsStoredExpressionManager *storedExpressionManager();
%Docstring
Returns the manager of the stored expressions for this layer.

.. versionadded:: 3.10
%End

  public slots:

    void select( QgsFeatureId featureId );
%Docstring
Selects feature by its ID

:param featureId: The id of the feature to select

.. seealso:: :py:func:`select`
%End

    void select( const QgsFeatureIds &featureIds );
%Docstring
Selects features by their ID

:param featureIds: The ids of the features to select

.. seealso:: :py:func:`select`
%End

    void deselect( QgsFeatureId featureId );
%Docstring
Deselects feature by its ID

:param featureId: The id of the feature to deselect

.. seealso:: :py:func:`deselect`
%End

    void deselect( const QgsFeatureIds &featureIds );
%Docstring
Deselects features by their ID

:param featureIds: The ids of the features to deselect

.. seealso:: :py:func:`deselect`
%End

    void removeSelection();
%Docstring
Clear selection

.. seealso:: :py:func:`selectByIds`

.. seealso:: :py:func:`reselect`
%End

    void reselect();
%Docstring
Reselects the previous set of selected features. This is only applicable
after a prior call to :py:func:`~QgsVectorLayer.removeSelection`.

Any other modifications to the selection following a call to
:py:func:`~QgsVectorLayer.removeSelection` clears memory of the previous
selection and consequently calling :py:func:`~QgsVectorLayer.reselect`
has no impact.

.. seealso:: :py:func:`removeSelection`

.. versionadded:: 3.10
%End

    virtual void updateExtents( bool force = false );
%Docstring
Update the extents for the layer. This is necessary if features are
added/deleted or the layer has been subsetted.

:param force: ``True`` to update layer extent even if it's read from xml
              by default, ``False`` otherwise
%End

    bool startEditing();
%Docstring
Makes the layer editable.

This starts an edit session on this layer. Changes made in this edit
session will not be made persistent until
:py:func:`~QgsVectorLayer.commitChanges` is called, and can be reverted
by calling :py:func:`~QgsVectorLayer.rollBack`.

:return: ``True`` if the layer was successfully made editable, or
         ``False`` if the operation failed (e.g. due to an underlying
         read-only data source, or lack of edit support by the backend
         data provider).

.. seealso:: :py:func:`commitChanges`

.. seealso:: :py:func:`rollBack`
%End

    virtual void setTransformContext( const QgsCoordinateTransformContext &transformContext );
%Docstring
Sets the coordinate transform context to ``transformContext``

.. versionadded:: 3.8
%End

    virtual Qgis::SpatialIndexPresence hasSpatialIndex() const;


    virtual bool accept( QgsStyleEntityVisitorInterface *visitor ) const;


  signals:

    void selectionChanged( const QgsFeatureIds &selected, const QgsFeatureIds &deselected, bool clearAndSelect );
%Docstring
Emitted when selection was changed

:param selected: Newly selected feature ids
:param deselected: Ids of all features which have previously been
                   selected but are not any more
:param clearAndSelect: In case this is set to ``True``, the old
                       selection was dismissed and the new selection
                       corresponds to selected
%End

    void allowCommitChanged();
%Docstring
Emitted whenever the :py:func:`~QgsVectorLayer.allowCommit` property of
this layer changes.

.. versionadded:: 3.4
%End

    void beforeModifiedCheck() const;
%Docstring
Emitted when the layer is checked for modifications. Use for last-minute
additions.
%End

    void beforeEditingStarted();
%Docstring
Emitted before editing on this layer is started.
%End

    void beforeCommitChanges( bool stopEditing );
%Docstring
Emitted before changes are committed to the data provider.

The ``stopEditing`` flag specifies if the editing mode shall be left
after this commit.
%End

    void beforeRollBack();
%Docstring
Emitted before changes are rolled back.
%End

    void afterCommitChanges();
%Docstring
Emitted after changes are committed to the data provider.

.. versionadded:: 3.16
%End

    void afterRollBack();
%Docstring
Emitted after changes are rolled back.

.. versionadded:: 3.4
%End

    void attributeAdded( int idx );
%Docstring
Will be emitted, when a new attribute has been added to this vector
layer. Applies only to types :py:class:`QgsFields`.OriginEdit,
:py:class:`QgsFields`.OriginProvider and
:py:class:`QgsFields`.OriginExpression

:param idx: The index of the new attribute

.. seealso:: :py:func:`updatedFields`
%End

    void beforeAddingExpressionField( const QString &fieldName );
%Docstring
Will be emitted, when an expression field is going to be added to this
vector layer. Applies only to types
:py:class:`QgsFields`.OriginExpression

:param fieldName: The name of the attribute to be added
%End

    void attributeDeleted( int idx );
%Docstring
Will be emitted, when an attribute has been deleted from this vector
layer. Applies only to types :py:class:`QgsFields`.OriginEdit,
:py:class:`QgsFields`.OriginProvider and
:py:class:`QgsFields`.OriginExpression

:param idx: The index of the deleted attribute

.. seealso:: :py:func:`updatedFields`
%End

    void beforeRemovingExpressionField( int idx );
%Docstring
Will be emitted, when an expression field is going to be deleted from
this vector layer. Applies only to types
:py:class:`QgsFields`.OriginExpression

:param idx: The index of the attribute to be deleted
%End

    void featureAdded( QgsFeatureId fid );
%Docstring
Emitted when a new feature has been added to the layer

:param fid: The id of the new feature
%End

    void featureDeleted( QgsFeatureId fid );
%Docstring
Emitted when a feature has been deleted.

If you do expensive operations in a slot connected to this, you should
prefer to use :py:func:`~QgsVectorLayer.featuresDeleted`.

:param fid: The id of the feature which has been deleted
%End

    void featuresDeleted( const QgsFeatureIds &fids );
%Docstring
Emitted when features have been deleted.

If features are deleted within an edit command, this will only be
emitted once at the end to allow connected slots to minimize the
overhead. If features are deleted outside of an edit command, this
signal will be emitted once per feature.

:param fids: The feature ids that have been deleted.
%End

    void updatedFields();
%Docstring
Emitted whenever the fields available from this layer have been changed.
This can be due to manually adding attributes or due to a join.
%End

    void subsetStringChanged();
%Docstring
Emitted when the layer's subset string has changed.

.. versionadded:: 3.2
%End

    void attributeValueChanged( QgsFeatureId fid, int idx, const QVariant &value );
%Docstring
Emitted whenever an attribute value change is done in the edit buffer.
Note that at this point the attribute change is not yet saved to the
provider.

:param fid: The id of the changed feature
:param idx: The attribute index of the changed attribute
:param value: The new value of the attribute
%End

    void geometryChanged( QgsFeatureId fid, const QgsGeometry &geometry );
%Docstring
Emitted whenever a geometry change is done in the edit buffer. Note that
at this point the geometry change is not yet saved to the provider.

:param fid: The id of the changed feature
:param geometry: The new geometry
%End

    void committedAttributesDeleted( const QString &layerId, const QgsAttributeList &deletedAttributes );
%Docstring
Emitted when attributes are deleted from the provider if not in
transaction mode.
%End
    void committedAttributesAdded( const QString &layerId, const QList<QgsField> &addedAttributes );
%Docstring
Emitted when attributes are added to the provider if not in transaction
mode.
%End
    void committedFeaturesAdded( const QString &layerId, const QgsFeatureList &addedFeatures );
%Docstring
Emitted when features are added to the provider if not in transaction
mode.
%End
    void committedFeaturesRemoved( const QString &layerId, const QgsFeatureIds &deletedFeatureIds );
%Docstring
Emitted when features are deleted from the provider if not in
transaction mode.
%End
    void committedAttributeValuesChanges( const QString &layerId, const QgsChangedAttributesMap &changedAttributesValues );
%Docstring
Emitted when attribute value changes are saved to the provider if not in
transaction mode.
%End
    void committedGeometriesChanges( const QString &layerId, const QgsGeometryMap &changedGeometries );
%Docstring
Emitted when geometry changes are saved to the provider if not in
transaction mode.
%End

    void labelingFontNotFound( QgsVectorLayer *layer, const QString &fontfamily );
%Docstring
Emitted when the font family defined for labeling layer is not found on
system
%End

    void featureBlendModeChanged( QPainter::CompositionMode blendMode );
%Docstring
Signal emitted when :py:func:`~QgsVectorLayer.setFeatureBlendMode` is
called
%End

    void editCommandStarted( const QString &text );
%Docstring
Signal emitted when a new edit command has been started

:param text: Description for this edit command
%End

    void editCommandEnded();
%Docstring
Signal emitted, when an edit command successfully ended

.. note::

   This does not mean it is also committed, only that it is written
   to the edit buffer. See :py:func:`~QgsVectorLayer.beforeCommitChanges`
%End

    void editCommandDestroyed();
%Docstring
Signal emitted, when an edit command is destroyed

.. note::

   This is not a rollback, it is only related to the current edit command.
   See :py:func:`~QgsVectorLayer.beforeRollBack`
%End

    void readCustomSymbology( const QDomElement &element, QString &errorMessage );
%Docstring
Signal emitted whenever the symbology (QML-file) for this layer is being
read. If there is custom style information saved in the file, you can
connect to this signal and update the layer style accordingly.

:param element: The XML layer style element.

:param errorMessage: Write error messages into this string.
%End

    void writeCustomSymbology( QDomElement &element, QDomDocument &doc, QString &errorMessage ) const;
%Docstring
Signal emitted whenever the symbology (QML-file) for this layer is being
written. If there is custom style information you want to save to the
file, you can connect to this signal and update the element accordingly.

:param element: The XML element where you can add additional style
                information to.
:param doc: The XML document that you can use to create new XML nodes.
:param errorMessage: Write error messages into this string.
%End

    void displayExpressionChanged();
%Docstring
Emitted when the display expression changes
%End

    void raiseError( const QString &msg );
%Docstring
Signals an error related to this vector layer.
%End

    void editFormConfigChanged();
%Docstring
Will be emitted whenever the edit form configuration of this layer
changes.
%End

    void readOnlyChanged();
%Docstring
Emitted when the read only state of this layer is changed. Only applies
to manually set readonly state, not to the edit mode.

.. seealso:: :py:func:`setReadOnly`
%End

    void supportsEditingChanged();
%Docstring
Emitted when the read only state or the data provider of this layer is
changed.

.. versionadded:: 3.18
%End

    void symbolFeatureCountMapChanged();
%Docstring
Emitted when the feature count for symbols on this layer has been
recalculated.
%End

  protected:
    virtual void setExtent( const QgsRectangle &rect ) ${SIP_FINAL};

%Docstring
Sets the extent
%End
    virtual void setExtent3D( const QgsBox3D &rect ) ${SIP_FINAL};

%Docstring
Sets the extent
%End

  private:
    QgsVectorLayer( const QgsVectorLayer &rhs );
};




/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/core/vector/qgsvectorlayer.h                                     *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.py again   *
 ************************************************************************/