mirror of
https://github.com/qgis/QGIS.git
synced 2025-11-03 00:14:12 -05:00
f23caeef50
These should probably be returned as None or NULL for consistency, but let's not break API right now...
1020 lines
28 KiB
Plaintext
1020 lines
28 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/qgsfeature.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl 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 );
|
|
%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<QVariant *>( 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<QVariant *>( 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/;
|
|
%Docstring
|
|
Copy constructor
|
|
%End
|
|
|
|
|
|
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<QString,QVariant>" );
|
|
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<QVariant *>( 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: <QgsGeometry: Point (210 41)>
|
|
|
|
# Sets a feature's geometry to a line string
|
|
feature.setGeometry( QgsLineString( [ QgsPoint( 210, 41 ), QgsPoint( 301, 55 ) ] ) )
|
|
print(feature.geometry())
|
|
# output: <QgsGeometry: LineString (210 41, 301 55)>
|
|
|
|
|
|
|
|
.. 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<QVariant *>( 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<qint64, QMap<int, QVariant> > QgsChangedAttributesMap;
|
|
|
|
|
|
typedef QMap<qint64, QgsGeometry> QgsGeometryMap;
|
|
|
|
typedef QList<QgsFeature> QgsFeatureList;
|
|
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/qgsfeature.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|