mirror of
https://github.com/qgis/QGIS.git
synced 2025-11-12 00:06:54 -05:00
14f2ab53b1
stage, be more intelligent about compiling AND or OR nodes We can take advantage of the fact that and AND node will ALWAYS be false if either input node is static and evaluates to FALSE, and that OR nodes will always be true if either input is static and evaluates to TRUE. In some cases this allows us the shortcut and cut out non-static nodes during preparation, resulting in faster evaluation and more easily compiled expressions...
297 lines
8.2 KiB
Plaintext
297 lines
8.2 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/expression/qgsexpressionnode.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class QgsExpressionNode /Abstract/
|
|
{
|
|
%Docstring
|
|
|
|
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;
|
|
default:
|
|
sipType = 0;
|
|
break;
|
|
}
|
|
%End
|
|
public:
|
|
|
|
enum NodeType
|
|
{
|
|
ntUnaryOperator,
|
|
ntBinaryOperator,
|
|
ntInOperator,
|
|
ntFunction,
|
|
ntLiteral,
|
|
ntColumnRef,
|
|
ntCondition,
|
|
ntIndexOperator,
|
|
};
|
|
|
|
|
|
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
|
|
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.
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
int count() const;
|
|
%Docstring
|
|
Returns the number of nodes in the list.
|
|
%End
|
|
|
|
bool hasNamedNodes() const;
|
|
%Docstring
|
|
Returns ``True`` if list contains any named nodes
|
|
|
|
.. versionadded:: 2.16
|
|
%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.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QStringList names() const;
|
|
%Docstring
|
|
Returns a list of names for nodes. Unnamed nodes will be indicated by an empty string in the list.
|
|
|
|
.. versionadded:: 2.16
|
|
%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.
|
|
|
|
.. versionadded:: 2.12
|
|
%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.
|
|
|
|
.. versionadded:: 3.0
|
|
%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.
|
|
|
|
.. versionadded:: 2.12
|
|
%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
|
|
|
|
protected:
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/expression/qgsexpressionnode.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|