mirror of
https://github.com/qgis/QGIS.git
synced 2025-10-15 00:02:52 -04:00
312 lines
8.9 KiB
Plaintext
312 lines
8.9 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/expression/qgsexpressionnode.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.py again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class QgsExpressionNode /Abstract/
|
|
{
|
|
%Docstring(signature="appended")
|
|
|
|
Abstract base class for all nodes that can appear in an expression.
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsexpressionnode.h"
|
|
%End
|
|
%ConvertToSubClassCode
|
|
switch ( sipCpp->nodeType() )
|
|
{
|
|
case QgsExpressionNode::ntUnaryOperator:
|
|
sipType = sipType_QgsExpressionNodeUnaryOperator;
|
|
break;
|
|
case QgsExpressionNode::ntBinaryOperator:
|
|
sipType = sipType_QgsExpressionNodeBinaryOperator;
|
|
break;
|
|
case QgsExpressionNode::ntInOperator:
|
|
sipType = sipType_QgsExpressionNodeInOperator;
|
|
break;
|
|
case QgsExpressionNode::ntFunction:
|
|
sipType = sipType_QgsExpressionNodeFunction;
|
|
break;
|
|
case QgsExpressionNode::ntLiteral:
|
|
sipType = sipType_QgsExpressionNodeLiteral;
|
|
break;
|
|
case QgsExpressionNode::ntColumnRef:
|
|
sipType = sipType_QgsExpressionNodeColumnRef;
|
|
break;
|
|
case QgsExpressionNode::ntCondition:
|
|
sipType = sipType_QgsExpressionNodeCondition;
|
|
break;
|
|
case QgsExpressionNode::ntBetweenOperator:
|
|
sipType = sipType_QgsExpressionNodeBetweenOperator;
|
|
break;
|
|
default:
|
|
sipType = 0;
|
|
break;
|
|
}
|
|
%End
|
|
public:
|
|
|
|
enum NodeType
|
|
{
|
|
ntUnaryOperator,
|
|
ntBinaryOperator,
|
|
ntInOperator,
|
|
ntFunction,
|
|
ntLiteral,
|
|
ntColumnRef,
|
|
ntCondition,
|
|
ntIndexOperator,
|
|
ntBetweenOperator,
|
|
};
|
|
|
|
|
|
struct NamedNode
|
|
{
|
|
public:
|
|
|
|
NamedNode( const QString &name, QgsExpressionNode *node );
|
|
%Docstring
|
|
Constructor for NamedNode
|
|
|
|
:param name: node name
|
|
:param node: node
|
|
%End
|
|
|
|
QString name;
|
|
|
|
QgsExpressionNode *node;
|
|
};
|
|
|
|
class NodeList
|
|
{
|
|
%Docstring(signature="appended")
|
|
A list of expression nodes.
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsexpressionnode.h"
|
|
%End
|
|
public:
|
|
virtual ~NodeList();
|
|
void append( QgsExpressionNode *node /Transfer/ );
|
|
%Docstring
|
|
Takes ownership of the provided node
|
|
%End
|
|
|
|
void append( QgsExpressionNode::NamedNode *node /Transfer/ );
|
|
%Docstring
|
|
Adds a named node. Takes ownership of the provided node.
|
|
%End
|
|
|
|
int count() const;
|
|
%Docstring
|
|
Returns the number of nodes in the list.
|
|
%End
|
|
|
|
void reserve( int size );
|
|
%Docstring
|
|
Reserves size for the node list.
|
|
|
|
.. versionadded:: 3.34
|
|
%End
|
|
|
|
bool hasNamedNodes() const;
|
|
%Docstring
|
|
Returns ``True`` if list contains any named nodes
|
|
%End
|
|
|
|
QList<QgsExpressionNode *> list();
|
|
%Docstring
|
|
Gets a list of all the nodes.
|
|
%End
|
|
|
|
QgsExpressionNode *at( int i );
|
|
%Docstring
|
|
Gets the node at position i in the list.
|
|
%End
|
|
|
|
QStringList names() const;
|
|
%Docstring
|
|
Returns a list of names for nodes. Unnamed nodes will be indicated by an empty string in the list.
|
|
%End
|
|
|
|
QgsExpressionNode::NodeList *clone() const /Factory/;
|
|
%Docstring
|
|
Creates a deep copy of this list. Ownership is transferred to the caller
|
|
%End
|
|
|
|
virtual QString dump() const;
|
|
%Docstring
|
|
Returns a string dump of the expression node.
|
|
%End
|
|
|
|
public:
|
|
};
|
|
|
|
virtual ~QgsExpressionNode();
|
|
|
|
virtual QgsExpressionNode::NodeType nodeType() const = 0;
|
|
%Docstring
|
|
Gets the type of this node.
|
|
|
|
:return: The type of this node
|
|
%End
|
|
|
|
virtual QString dump() const = 0;
|
|
%Docstring
|
|
Dump this node into a serialized (part) of an expression.
|
|
The returned expression does not necessarily literally match
|
|
the original expression, it's just guaranteed to behave the same way.
|
|
%End
|
|
|
|
QVariant eval( QgsExpression *parent, const QgsExpressionContext *context );
|
|
%Docstring
|
|
Evaluate this node with the given context and parent.
|
|
This will return a cached value if it has been determined to be static
|
|
during the :py:func:`~QgsExpressionNode.prepare` execution.
|
|
%End
|
|
|
|
virtual QgsExpressionNode *clone() const = 0;
|
|
%Docstring
|
|
Generate a clone of this node.
|
|
Ownership is transferred to the caller.
|
|
|
|
:return: a deep copy of this node.
|
|
%End
|
|
|
|
virtual QSet<QString> referencedColumns() const = 0;
|
|
%Docstring
|
|
Abstract virtual method which returns a list of columns required to
|
|
evaluate this node.
|
|
|
|
When reimplementing this, you need to return any column that is required to
|
|
evaluate this node and in addition recursively collect all the columns required
|
|
to evaluate child nodes.
|
|
|
|
.. warning::
|
|
|
|
If the expression has been prepared via a call to :py:func:`QgsExpression.prepare()`,
|
|
or a call to :py:func:`QgsExpressionNode.prepare()` for a node has been made, then some nodes in
|
|
the expression may have been determined to evaluate to a static pre-calculatable value.
|
|
In this case the results will omit attribute indices which are used by these
|
|
pre-calculated nodes, regardless of their actual referenced columns.
|
|
If you are seeking to use these functions to introspect an expression you must
|
|
take care to do this with an unprepared expression node.
|
|
|
|
:return: A list of columns required to evaluate this expression
|
|
%End
|
|
|
|
virtual QSet<QString> referencedVariables() const = 0;
|
|
%Docstring
|
|
Returns a set of all variables which are used in this expression.
|
|
|
|
.. note::
|
|
|
|
In contrast to the :py:func:`~QgsExpressionNode.referencedColumns` function this method
|
|
is not affected by any previous calls to :py:func:`QgsExpressionNode.prepare()`.
|
|
%End
|
|
|
|
virtual QSet<QString> referencedFunctions() const = 0;
|
|
%Docstring
|
|
Returns a set of all functions which are used in this expression.
|
|
|
|
.. note::
|
|
|
|
In contrast to the :py:func:`~QgsExpressionNode.referencedColumns` function this method
|
|
is not affected by any previous calls to :py:func:`QgsExpressionNode.prepare()`.
|
|
%End
|
|
|
|
virtual bool needsGeometry() const = 0;
|
|
%Docstring
|
|
Abstract virtual method which returns if the geometry is required to evaluate
|
|
this expression.
|
|
|
|
This needs to call `:py:func:`~QgsExpressionNode.needsGeometry`` recursively on any child nodes.
|
|
|
|
:return: ``True`` if a geometry is required to evaluate this expression
|
|
%End
|
|
|
|
virtual bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const = 0;
|
|
%Docstring
|
|
Returns ``True`` if this node can be evaluated for a static value. This is used during
|
|
the :py:func:`~QgsExpressionNode.prepare` step and in case it returns ``True``, the value of this node will already
|
|
be evaluated and the result cached (and therefore not re-evaluated in subsequent calls
|
|
to :py:func:`~QgsExpressionNode.eval`). In case this returns ``True``, :py:func:`~QgsExpressionNode.prepareNode` will never be called.
|
|
%End
|
|
|
|
bool prepare( QgsExpression *parent, const QgsExpressionContext *context );
|
|
%Docstring
|
|
Prepare this node for evaluation.
|
|
This will check if the node content is static and in this case cache the value.
|
|
If it's not static it will call :py:func:`~QgsExpressionNode.prepareNode` to allow the node to do initialization
|
|
work like for example resolving a column name to an attribute index.
|
|
%End
|
|
|
|
int parserFirstLine;
|
|
|
|
int parserFirstColumn;
|
|
|
|
int parserLastLine;
|
|
|
|
int parserLastColumn;
|
|
|
|
bool hasCachedStaticValue() const;
|
|
%Docstring
|
|
Returns ``True`` if the node can be replaced by a static cached value.
|
|
|
|
.. seealso:: :py:func:`cachedStaticValue`
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
QVariant cachedStaticValue() const;
|
|
%Docstring
|
|
Returns the node's static cached value. Only valid if :py:func:`~QgsExpressionNode.hasCachedStaticValue` is ``True``.
|
|
|
|
.. seealso:: :py:func:`hasCachedStaticValue`
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
|
|
const QgsExpressionNode *effectiveNode() const;
|
|
%Docstring
|
|
Returns a reference to the simplest node which represents this node,
|
|
after any compilation optimizations have been applied.
|
|
|
|
Eg. a node like "CASE WHEN true THEN "some_field" WHEN other condition THEN ... END" can effectively
|
|
be replaced entirely by a :py:class:`QgsExpressionNodeColumnRef` referencing the "some_field" field, as the
|
|
CASE WHEN ... will ALWAYS evaluate to "some_field".
|
|
|
|
Returns a reference to the current object if no optimizations were applied.
|
|
|
|
.. versionadded:: 3.20
|
|
%End
|
|
|
|
protected:
|
|
|
|
QgsExpressionNode();
|
|
QgsExpressionNode( const QgsExpressionNode &other );
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/expression/qgsexpressionnode.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.py again *
|
|
************************************************************************/
|