/************************************************************************ * This file has been generated automatically from * * * * src/core/qgsfeature.h * * * * Do not edit manually ! Edit header and run scripts/sipify.py again * ************************************************************************/ class QgsFeature { %Docstring(signature="appended") The feature class encapsulates a single feature including its unique ID, geometry and a list of field/values attributes. .. note:: :py:class:`QgsFeature` objects are implicitly shared. %End %TypeHeaderCode #include "qgsfeature.h" #if (SIP_VERSION >= 0x040900 && SIP_VERSION < 0x040c01) #define sipType_QVariant ((sipWrapperType *) sipTypeAsPyTypeObject (sipType_QVariant)) #endif %End public: static const QMetaObject staticMetaObject; public: SIP_PYOBJECT __iter__() /HoldGIL/; %MethodCode QgsAttributes attributes = sipCpp->attributes(); PyObject *attrs = sipConvertFromType( &attributes, sipType_QgsAttributes, Py_None ); sipRes = PyObject_GetIter( attrs ); // PyObject_GetIter has added a ref to attrs - we need to decrement the ref from sipConvertFromType, // so that the garbage collector will delete attrs when the iterator is deleted Py_DECREF( attrs ); %End SIP_PYOBJECT __getitem__( int key ) /HoldGIL/; %MethodCode if ( a0 < 0 || a0 >= sipCpp->attributeCount() ) { PyErr_SetString( PyExc_KeyError, QByteArray::number( a0 ) ); sipIsErr = 1; } else { const QVariant v = sipCpp->attribute( a0 ); if ( !v.isValid() ) { Py_INCREF( Py_None ); sipRes = Py_None; } // QByteArray null handling is "special"! See null_from_qvariant_converter in conversions.sip else if ( QgsVariantUtils::isNull( v, true ) && v.userType() != QMetaType::Type::QByteArray ) { PyObject *vartype = sipConvertFromEnum( v.type(), sipType_QVariant_Type ); PyObject *args = PyTuple_Pack( 1, vartype ); PyTypeObject *typeObj = sipTypeAsPyTypeObject( sipType_QVariant ); sipRes = PyObject_Call( ( PyObject * )typeObj, args, nullptr ); Py_DECREF( args ); Py_DECREF( vartype ); } else { switch ( v.userType() ) { case QMetaType::Type::Int: sipRes = PyLong_FromLong( v.toInt() ); break; case QMetaType::Type::UInt: sipRes = PyLong_FromUnsignedLong( v.toUInt() ); break; case QMetaType::Type::Long: case QMetaType::Type::LongLong: sipRes = PyLong_FromLongLong( v.toLongLong() ); break; case QMetaType::Type::ULong: case QMetaType::Type::ULongLong: sipRes = PyLong_FromUnsignedLongLong( v.toULongLong() ); break; case QMetaType::Type::Bool: sipRes = PyBool_FromLong( v.toBool() ? 1 : 0 ); break; case QMetaType::Type::Float: case QMetaType::Type::Double: sipRes = PyFloat_FromDouble( v.toDouble() ); break; case QMetaType::Type::QString: sipRes = PyUnicode_FromString( v.toString().toUtf8().constData() ); break; default: { QVariant *newV = new QVariant( v ); sipRes = sipConvertFromNewType( newV, sipType_QVariant, Py_None ); break; } } } } %End SIP_PYOBJECT __getitem__( const QString &name ) /HoldGIL/; %MethodCode int fieldIdx = sipCpp->fieldNameIndex( *a0 ); if ( fieldIdx == -1 ) { PyErr_SetString( PyExc_KeyError, a0->toLatin1() ); sipIsErr = 1; } else { const QVariant v = sipCpp->attribute( fieldIdx ); if ( !v.isValid() ) { Py_INCREF( Py_None ); sipRes = Py_None; } // QByteArray null handling is "special"! See null_from_qvariant_converter in conversions.sip else if ( QgsVariantUtils::isNull( v, true ) && v.userType() != QMetaType::Type::QByteArray ) { PyObject *vartype = sipConvertFromEnum( v.type(), sipType_QVariant_Type ); PyObject *args = PyTuple_Pack( 1, vartype ); PyTypeObject *typeObj = sipTypeAsPyTypeObject( sipType_QVariant ); sipRes = PyObject_Call( ( PyObject * )typeObj, args, nullptr ); Py_DECREF( args ); Py_DECREF( vartype ); } else { switch ( v.userType() ) { case QMetaType::Type::Int: sipRes = PyLong_FromLong( v.toInt() ); break; case QMetaType::Type::UInt: sipRes = PyLong_FromUnsignedLong( v.toUInt() ); break; case QMetaType::Type::Long: case QMetaType::Type::LongLong: sipRes = PyLong_FromLongLong( v.toLongLong() ); break; case QMetaType::Type::ULong: case QMetaType::Type::ULongLong: sipRes = PyLong_FromUnsignedLongLong( v.toULongLong() ); break; case QMetaType::Type::Bool: sipRes = PyBool_FromLong( v.toBool() ? 1 : 0 ); break; case QMetaType::Type::Float: case QMetaType::Type::Double: sipRes = PyFloat_FromDouble( v.toDouble() ); break; case QMetaType::Type::QString: sipRes = PyUnicode_FromString( v.toString().toUtf8().constData() ); break; default: { QVariant *newV = new QVariant( v ); sipRes = sipConvertFromNewType( newV, sipType_QVariant, Py_None ); break; } } } } %End void __setitem__( int key, SIP_PYOBJECT value /TypeHint="Optional[Union[bool, int, float, str, QVariant]]"/ ) /HoldGIL/; %MethodCode bool rv; if ( a1 == Py_None ) { rv = sipCpp->setAttribute( a0, QVariant( QVariant::Int ) ); } else if ( PyBool_Check( a1 ) ) { rv = sipCpp->setAttribute( a0, QVariant( PyObject_IsTrue( a1 ) == 1 ) ); } else if ( PyLong_Check( a1 ) ) { rv = sipCpp->setAttribute( a0, QVariant( PyLong_AsLongLong( a1 ) ) ); } else if ( PyFloat_Check( a1 ) ) { rv = sipCpp->setAttribute( a0, QVariant( PyFloat_AsDouble( a1 ) ) ); } else if ( PyUnicode_Check( a1 ) ) { rv = sipCpp->setAttribute( a0, QVariant( QString::fromUtf8( PyUnicode_AsUTF8( a1 ) ) ) ); } else if ( sipCanConvertToType( a1, sipType_QVariant, SIP_NOT_NONE ) ) { int state; QVariant *qvariant = reinterpret_cast( sipConvertToType( a1, sipType_QVariant, 0, SIP_NOT_NONE, &state, &sipIsErr ) ); if ( sipIsErr ) { rv = false; } else { rv = sipCpp->setAttribute( a0, *qvariant ); } sipReleaseType( qvariant, sipType_QVariant, state ); } else { rv = false; } if ( !rv ) { PyErr_SetString( PyExc_KeyError, QByteArray::number( a0 ) ); sipIsErr = 1; } %End void __setitem__( const QString &key, SIP_PYOBJECT value /TypeHint="Optional[Union[bool, int, float, str, QVariant]]"/ ) /HoldGIL/; %MethodCode int fieldIdx = sipCpp->fieldNameIndex( *a0 ); if ( fieldIdx == -1 ) { PyErr_SetString( PyExc_KeyError, a0->toLatin1() ); sipIsErr = 1; } else { if ( a1 == Py_None ) { sipCpp->setAttribute( fieldIdx, QVariant( QVariant::Int ) ); } else if ( PyBool_Check( a1 ) ) { sipCpp->setAttribute( fieldIdx, QVariant( PyObject_IsTrue( a1 ) == 1 ) ); } else if ( PyLong_Check( a1 ) ) { sipCpp->setAttribute( fieldIdx, QVariant( PyLong_AsLongLong( a1 ) ) ); } else if ( PyFloat_Check( a1 ) ) { sipCpp->setAttribute( fieldIdx, QVariant( PyFloat_AsDouble( a1 ) ) ); } else if ( PyUnicode_Check( a1 ) ) { sipCpp->setAttribute( fieldIdx, QVariant( QString::fromUtf8( PyUnicode_AsUTF8( a1 ) ) ) ); } else if ( sipCanConvertToType( a1, sipType_QVariant, SIP_NOT_NONE ) ) { int state; QVariant *qvariant = reinterpret_cast( sipConvertToType( a1, sipType_QVariant, 0, SIP_NOT_NONE, &state, &sipIsErr ) ); if ( !sipIsErr ) { sipCpp->setAttribute( fieldIdx, *qvariant ); } sipReleaseType( qvariant, sipType_QVariant, state ); } else { sipIsErr = 1; } } %End void __delitem__( int key ) /HoldGIL/; %MethodCode if ( a0 >= 0 && a0 < sipCpp->attributeCount() ) sipCpp->deleteAttribute( a0 ); else { PyErr_SetString( PyExc_KeyError, QByteArray::number( a0 ) ); sipIsErr = 1; } %End void __delitem__( const QString &name ) /HoldGIL/; %MethodCode int fieldIdx = sipCpp->fieldNameIndex( *a0 ); if ( fieldIdx == -1 ) { PyErr_SetString( PyExc_KeyError, a0->toLatin1() ); sipIsErr = 1; } else sipCpp->deleteAttribute( fieldIdx ); %End long __hash__() const /HoldGIL/; %MethodCode sipRes = qHash( *sipCpp ); %End QgsFeature( qint64 id = FID_NULL ) /HoldGIL/; %Docstring Constructor for QgsFeature :param id: unique feature ID %End QgsFeature( const QgsFields &fields, qint64 id = FID_NULL ) /HoldGIL/; %Docstring Constructor for QgsFeature :param fields: feature's fields :param id: unique feature ID %End QgsFeature( const QgsFeature &rhs ) /HoldGIL/; bool operator==( const QgsFeature &other ) const /HoldGIL/; bool operator!=( const QgsFeature &other ) const /HoldGIL/; virtual ~QgsFeature(); QgsFeatureId id() const /HoldGIL/; %Docstring Returns the feature ID for this feature. .. seealso:: :py:func:`setId` %End void setId( QgsFeatureId id ) /HoldGIL/; %Docstring Sets the feature ``id`` for this feature. :param id: feature id .. seealso:: :py:func:`id` .. warning:: Feature IDs will be automatically changed whenever a feature is added to vector layer or data provider. This method is not designed to allow a specific feature ID to be assigned to a feature which will be added to a layer or data provider, and the results will be unpredictable %End QgsAttributes attributes() const /HoldGIL/; %Docstring Returns the feature's attributes. Alternatively, in Python it is possible to directly iterate over a feature in order to retrieve its attributes: .. code-block:: python feature = QgsFeature() feature.setAttributes([11, 'string value', 55.5]) for attr in feature: print(attr) .. seealso:: :py:func:`setAttributes` .. seealso:: :py:func:`attributeMap` %End SIP_PYOBJECT attributeMap() const /HoldGIL,TypeHint="Dict[str, Optional[object]]"/; %Docstring Returns the feature's attributes as a map of field name to value. .. note:: The fields definition must be associated with the feature using :py:func:`~QgsFeature.setFields` before this method can be used. :raises ValueError: if the field definition is unset or the size of the fields does not match the size of the feature's attributes() .. seealso:: :py:func:`attributes` .. seealso:: :py:func:`setAttributes` .. versionadded:: 3.22.2 %End %MethodCode const int fieldSize = sipCpp->fields().size(); const int attributeSize = sipCpp->attributeCount(); if ( fieldSize == 0 && attributeSize != 0 ) { PyErr_SetString( PyExc_ValueError, QStringLiteral( "Field definition has not been set for feature" ).toUtf8().constData() ); sipIsErr = 1; } else if ( fieldSize != attributeSize ) { PyErr_SetString( PyExc_ValueError, QStringLiteral( "Feature attribute size (%1) does not match number of fields (%2)" ).arg( attributeSize ).arg( fieldSize ).toUtf8().constData() ); sipIsErr = 1; } else { QVariantMap *v = new QVariantMap( sipCpp->attributeMap() ); const sipTypeDef *qvariantmap_type = sipFindType( "QMap" ); sipRes = sipConvertFromNewType( v, qvariantmap_type, Py_None ); } %End int attributeCount() const /HoldGIL/; %Docstring Returns the number of attributes attached to the feature. .. versionadded:: 3.18 %End void setAttributes( const QgsAttributes &attrs ) /HoldGIL/; %Docstring Sets the feature's attributes. Calling this method will automatically set the feature as valid (see :py:func:`~QgsFeature.isValid`). The number of provided attributes need to exactly match the number of the feature's fields. :param attrs: List of attribute values .. warning:: If the number of provided attributes does not exactly match the number of the feature's fields then it will not be possible to add this feature to the corresponding data provider. .. seealso:: :py:func:`setAttribute` .. seealso:: :py:func:`attributes` %End bool setAttribute( int field, SIP_PYOBJECT attr /TypeHint="Optional[Union[bool, int, float, str, QVariant]]"/ ) /HoldGIL/; %Docstring Sets an attribute's value by field index. If the attribute was successfully set then the feature will be automatically marked as valid (see :py:func:`~QgsFeature.isValid`). Alternatively, in Python it is possible to directly set a field's value via the field's index: .. code-block:: python fields = QgsFields() fields.append(QgsField('my_id', QVariant.Int)) fields.append(QgsField('name', QVariant.String)) feature = QgsFeature(fields) # set the "name" field value feature[1] = "my name" # set the "my_id" field value feature[0] = 55 :param field: the index of the field to set :param attr: the value of the attribute :raises KeyError: if the field index does not exist .. seealso:: :py:func:`setAttributes` %End %MethodCode bool rv; if ( a1 == Py_None ) { rv = sipCpp->setAttribute( a0, QVariant( QVariant::Int ) ); } else if ( PyBool_Check( a1 ) ) { rv = sipCpp->setAttribute( a0, QVariant( PyObject_IsTrue( a1 ) == 1 ) ); } else if ( PyLong_Check( a1 ) ) { rv = sipCpp->setAttribute( a0, QVariant( PyLong_AsLongLong( a1 ) ) ); } else if ( PyFloat_Check( a1 ) ) { rv = sipCpp->setAttribute( a0, QVariant( PyFloat_AsDouble( a1 ) ) ); } else if ( PyUnicode_Check( a1 ) ) { rv = sipCpp->setAttribute( a0, QVariant( QString::fromUtf8( PyUnicode_AsUTF8( a1 ) ) ) ); } else if ( sipCanConvertToType( a1, sipType_QVariant, SIP_NOT_NONE ) ) { int state; QVariant *qvariant = reinterpret_cast( sipConvertToType( a1, sipType_QVariant, 0, SIP_NOT_NONE, &state, &sipIsErr ) ); if ( sipIsErr ) { rv = false; } else { rv = sipCpp->setAttribute( a0, *qvariant ); } sipReleaseType( qvariant, sipType_QVariant, state ); } else { rv = false; } if ( !rv ) { PyErr_SetString( PyExc_KeyError, QByteArray::number( a0 ) ); sipIsErr = 1; } sipRes = rv; %End void initAttributes( int fieldCount ) /HoldGIL/; %Docstring Initialize this feature with the given number of fields. Discards any previously set attribute data. :param fieldCount: Number of fields to initialize .. seealso:: :py:func:`resizeAttributes` %End void resizeAttributes( int fieldCount ) /HoldGIL/; %Docstring Resizes the attributes attached to this feature to the given number of fields. If the new ``fieldCount`` is greater than the original number of fields then the additional attributes will be filled with NULL values. All existing attributes will remain unchanged. If the new ``fieldCount`` is less than the original number of fields then the unwanted values will be discarded from the end of the existing attributes. .. seealso:: :py:func:`initAttributes` .. seealso:: :py:func:`padAttributes` .. versionadded:: 3.18 %End void padAttributes( int count ) /HoldGIL/; %Docstring Resizes the attributes attached to this feature by appending the specified ``count`` of NULL values to the end of the existing attributes. .. seealso:: :py:func:`resizeAttributes` .. versionadded:: 3.18 %End void deleteAttribute( int field ) /HoldGIL/; %Docstring Clear's an attribute's value by its index. :param field: the index of the field Alternatively, in Python it is possible to directly `del` an attribute via its index: .. code-block:: python feature = QgsFeature() feature.setAttributes([11, 'my feature', 55.5]) # will print [11, 'my feature', 55.5] print(feature.attributes()) # clear the second attribute del feature[1] # will now print [11, NONE] print(feature.attributes()) :raises KeyError: if the field is not found .. seealso:: :py:func:`setAttribute` %End %MethodCode if ( a0 >= 0 && a0 < sipCpp->attributeCount() ) sipCpp->deleteAttribute( a0 ); else { PyErr_SetString( PyExc_KeyError, QByteArray::number( a0 ) ); sipIsErr = 1; } %End bool isValid() const /HoldGIL/; %Docstring Returns the validity of this feature. This is normally set by the provider to indicate some problem that makes the feature invalid or to indicate a null feature. .. seealso:: :py:func:`setValid` %End void setValid( bool validity ) /HoldGIL/; %Docstring Sets the validity of the feature. :param validity: set to ``True`` if feature is valid .. seealso:: :py:func:`isValid` %End bool hasGeometry() const /HoldGIL/; %Docstring Returns ``True`` if the feature has an associated geometry. .. seealso:: :py:func:`geometry` %End QgsGeometry geometry() const /HoldGIL/; %Docstring Returns the geometry associated with this feature. If the feature has no geometry, an empty :py:class:`QgsGeometry` object will be returned. .. seealso:: :py:func:`hasGeometry` .. seealso:: :py:func:`setGeometry` %End void setGeometry( const QgsGeometry &geometry ) /HoldGIL/; %Docstring Set the feature's geometry. Calling this method will automatically set the feature as valid (see :py:func:`~QgsFeature.isValid`). :param geometry: new feature geometry .. seealso:: :py:func:`geometry` .. seealso:: :py:func:`clearGeometry` %End void setGeometry( QgsAbstractGeometry *geometry /Transfer/ ) /HoldGIL/; %Docstring Set the feature's ``geometry``. Ownership of the geometry is transferred to the feature. Calling this method will automatically set the feature as valid (see :py:func:`~QgsFeature.isValid`). This method is a shortcut for calling: .. code-block:: python feature.setGeometry( QgsGeometry( geometry ) ) Example ------------------------------------- .. code-block:: python # Sets a feature's geometry to a point geometry feature.setGeometry( QgsPoint( 210, 41 ) ) print(feature.geometry()) # output: # Sets a feature's geometry to a line string feature.setGeometry( QgsLineString( [ QgsPoint( 210, 41 ), QgsPoint( 301, 55 ) ] ) ) print(feature.geometry()) # output: .. seealso:: :py:func:`geometry` .. seealso:: :py:func:`clearGeometry` .. versionadded:: 3.6 %End %MethodCode sipCpp->setGeometry( std::unique_ptr< QgsAbstractGeometry>( a0 ) ); %End void clearGeometry() /HoldGIL/; %Docstring Removes any geometry associated with the feature. .. seealso:: :py:func:`setGeometry` .. seealso:: :py:func:`hasGeometry` %End void setFields( const QgsFields &fields, bool initAttributes = true ) /HoldGIL/; %Docstring Assigns a field map with the feature to allow attribute access by attribute name. :param fields: The attribute fields which this feature holds :param initAttributes: If ``True``, attributes are initialized. Clears any data previously assigned. .. seealso:: :py:func:`fields` %End QgsFields fields() const /HoldGIL/; %Docstring Returns the field map associated with the feature. .. seealso:: :py:func:`setFields` %End void setAttribute( const QString &name, SIP_PYOBJECT value /TypeHint="Optional[Union[bool, int, float, str, QVariant]]"/ ) /HoldGIL/; %Docstring Insert a value into attribute, by field ``name``. Field map must be associated using :py:func:`~QgsFeature.setFields` before this method can be used. Calling this method will automatically set the feature as valid (see :py:func:`~QgsFeature.isValid`). Alternatively, in Python it is possible to directly set a field's value via the field's name: .. code-block:: python fields = QgsFields() fields.append(QgsField('my_id', QVariant.Int)) fields.append(QgsField('name', QVariant.String)) feature = QgsFeature(fields) # set the "name" field value feature['name'] = "my name" # set the "my_id" field value feature['my_id'] = 55 :param name: The name of the field to set :param value: The value to set :raises KeyError: if the attribute name could not could not be matched. .. seealso:: :py:func:`setFields` %End %MethodCode int fieldIdx = sipCpp->fieldNameIndex( *a0 ); if ( fieldIdx == -1 ) { PyErr_SetString( PyExc_KeyError, a0->toLatin1() ); sipIsErr = 1; } else { if ( a1 == Py_None ) { sipCpp->setAttribute( fieldIdx, QVariant( QVariant::Int ) ); } else if ( PyBool_Check( a1 ) ) { sipCpp->setAttribute( fieldIdx, QVariant( PyObject_IsTrue( a1 ) == 1 ) ); } else if ( PyLong_Check( a1 ) ) { sipCpp->setAttribute( fieldIdx, QVariant( PyLong_AsLongLong( a1 ) ) ); } else if ( PyFloat_Check( a1 ) ) { sipCpp->setAttribute( fieldIdx, QVariant( PyFloat_AsDouble( a1 ) ) ); } else if ( PyUnicode_Check( a1 ) ) { sipCpp->setAttribute( fieldIdx, QVariant( QString::fromUtf8( PyUnicode_AsUTF8( a1 ) ) ) ); } else if ( sipCanConvertToType( a1, sipType_QVariant, SIP_NOT_NONE ) ) { int state; QVariant *qvariant = reinterpret_cast( sipConvertToType( a1, sipType_QVariant, 0, SIP_NOT_NONE, &state, &sipIsErr ) ); if ( !sipIsErr ) { sipCpp->setAttribute( fieldIdx, *qvariant ); } sipReleaseType( qvariant, sipType_QVariant, state ); } else { sipIsErr = 1; } } %End bool deleteAttribute( const QString &name ) /HoldGIL/; %Docstring Clear's an attribute's value by its field ``name``. Field map must be associated using :py:func:`~QgsFeature.setFields` before this method can be used. Alternatively, in Python it is possible to directly `del` an attribute via its name: .. code-block:: python fields = QgsFields() fields.append(QgsField('my_id', QVariant.Int)) fields.append(QgsField('name', QVariant.String)) feature = QgsFeature(fields) feature.setAttributes([11, 'my feature']) # will print [11, 'my feature'] print(feature.attributes()) # clear the 'name' attribute del feature['name'] # will now print [11, NULL] print(feature.attributes()) :param name: The name of the field to clear :raises KeyError: if attribute name could not be matched. .. seealso:: :py:func:`setFields` %End %MethodCode int fieldIdx = sipCpp->fieldNameIndex( *a0 ); if ( fieldIdx == -1 ) { PyErr_SetString( PyExc_KeyError, a0->toLatin1() ); sipIsErr = 1; sipRes = false; } else { sipCpp->deleteAttribute( fieldIdx ); sipRes = true; } %End SIP_PYOBJECT attribute( const QString &name ) const /HoldGIL/; %Docstring Lookup attribute value by attribute ``name``. Field map must be associated using :py:func:`~QgsFeature.setFields` before this method can be used. Alternatively, in Python it is possible to directly retrieve a field's value via the field's name: .. code-block:: python fields = QgsFields() fields.append(QgsField('my_id', QVariant.Int)) fields.append(QgsField('name', QVariant.String)) feature = QgsFeature(fields) feature.setAttributes([11, 'my feature']) # print the "name" field value print(feature['name']) # print the "my_id" field value print(feature['my_id']) :param name: The name of the attribute to get :return: The value of the attribute :raises KeyError: if the field is not found .. seealso:: :py:func:`setFields` %End %MethodCode int fieldIdx = sipCpp->fieldNameIndex( *a0 ); if ( fieldIdx == -1 ) { PyErr_SetString( PyExc_KeyError, a0->toLatin1() ); sipIsErr = 1; } else { QVariant *v = new QVariant( sipCpp->attribute( fieldIdx ) ); sipRes = sipConvertFromNewType( v, sipType_QVariant, Py_None ); } %End SIP_PYOBJECT attribute( int fieldIdx ) const /HoldGIL/; %Docstring Lookup attribute value from its index. Alternatively, in Python it is possible to directly retrieve a field's value via its index: .. code-block:: python feature = QgsFeature() feature.setAttributes([11, 'my feature', 55.5]) # will print 11 print(feature[0]) # will print 'my feature' print(feature[1]) # will print 55.5 print(feature[2]) :param fieldIdx: The index of the attribute to get :return: The value of the attribute :raises KeyError: if the field is not found .. seealso:: :py:func:`setFields` %End %MethodCode { if ( a0 < 0 || a0 >= sipCpp->attributeCount() ) { PyErr_SetString( PyExc_KeyError, QByteArray::number( a0 ) ); sipIsErr = 1; } else { QVariant *v = new QVariant( sipCpp->attribute( a0 ) ); sipRes = sipConvertFromNewType( v, sipType_QVariant, Py_None ); } } %End bool isUnsetValue( int fieldIdx ) const /HoldGIL/; %Docstring Returns ``True`` if the attribute at the specified index is an unset value. :raises KeyError: if the field is not found .. seealso:: :py:class:`QgsUnsetAttributeValue` .. versionadded:: 3.28 %End %MethodCode { if ( a0 < 0 || a0 >= sipCpp->attributeCount() ) { PyErr_SetString( PyExc_KeyError, QByteArray::number( a0 ) ); sipIsErr = 1; } else { sipRes = sipCpp->isUnsetValue( a0 ); } } %End const QgsSymbol *embeddedSymbol() const /HoldGIL/; %Docstring Returns the feature's embedded symbology, or ``None`` if the feature has no embedded symbol. .. versionadded:: 3.20 %End void setEmbeddedSymbol( QgsSymbol *symbol /Transfer/ ) /HoldGIL/; %Docstring Sets the feature's embedded ``symbol``. Ownership of ``symbol`` is transferred to the feature. .. versionadded:: 3.20 %End int fieldNameIndex( const QString &fieldName ) const /HoldGIL/; %Docstring Utility method to get attribute index from name. Field map must be associated using :py:func:`~QgsFeature.setFields` before this method can be used. :param fieldName: name of field to get attribute index of :return: - 1 if field does not exist or field map is not associated. .. seealso:: :py:func:`setFields` %End int approximateMemoryUsage() const; %Docstring Returns the approximate RAM usage of the feature, in bytes. This method takes into account the size of variable elements (strings, geometry, ...), but the value returned should be considered as a lower bound estimation. .. versionadded:: 3.16 %End operator QVariant() const; }; // class QgsFeature typedef QMap > QgsChangedAttributesMap; typedef QMap QgsGeometryMap; typedef QList QgsFeatureList; /************************************************************************ * This file has been generated automatically from * * * * src/core/qgsfeature.h * * * * Do not edit manually ! Edit header and run scripts/sipify.py again * ************************************************************************/