mirror of
https://github.com/qgis/QGIS.git
synced 2025-11-04 00:04:25 -05:00
808 lines
22 KiB
Plaintext
808 lines
22 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/qgsexpressioncontext.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
class QgsScopedExpressionFunction : QgsExpressionFunction
|
|
{
|
|
%Docstring
|
|
Expression function for use within a QgsExpressionContextScope. This differs from a
|
|
standard QgsExpression.Function in that it requires an implemented
|
|
:py:func:`~clone` method.
|
|
|
|
.. versionadded:: 2.12
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsexpressioncontext.h"
|
|
%End
|
|
public:
|
|
|
|
QgsScopedExpressionFunction( const QString &fnname,
|
|
int params,
|
|
const QString &group,
|
|
const QString &helpText = QString(),
|
|
bool usesGeometry = false,
|
|
const QSet<QString> &referencedColumns = QSet<QString>(),
|
|
bool lazyEval = false,
|
|
bool handlesNull = false,
|
|
bool isContextual = true );
|
|
%Docstring
|
|
Create a new QgsScopedExpressionFunction
|
|
|
|
.. versionadded:: 2.12
|
|
%End
|
|
|
|
QgsScopedExpressionFunction( const QString &fnname,
|
|
const QgsExpressionFunction::ParameterList ¶ms,
|
|
const QString &group,
|
|
const QString &helpText = QString(),
|
|
bool usesGeometry = false,
|
|
const QSet<QString> &referencedColumns = QSet<QString>(),
|
|
bool lazyEval = false,
|
|
bool handlesNull = false,
|
|
bool isContextual = true );
|
|
%Docstring
|
|
Create a new QgsScopedExpressionFunction using named parameters.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
virtual QVariant func( const QVariantList &values, const QgsExpressionContext *context, QgsExpression *parent, const QgsExpressionNodeFunction *node ) = 0;
|
|
|
|
|
|
virtual QgsScopedExpressionFunction *clone() const = 0 /Factory/;
|
|
%Docstring
|
|
Returns a clone of the function.
|
|
%End
|
|
|
|
virtual bool usesGeometry( const QgsExpressionNodeFunction *node ) const;
|
|
|
|
|
|
virtual QSet<QString> referencedColumns( const QgsExpressionNodeFunction *node ) const;
|
|
|
|
|
|
virtual bool isStatic( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const;
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
class QgsExpressionContextScope
|
|
{
|
|
%Docstring
|
|
Single scope for storing variables and functions for use within a :py:class:`QgsExpressionContext`.
|
|
Examples include a project's scope, which could contain information about the current project such as
|
|
the project file's location. QgsExpressionContextScope can encapsulate both variables (static values)
|
|
and functions(which are calculated only when an expression is evaluated).
|
|
|
|
See QgsExpressionContextUtils for helper methods for working with QgsExpressionContextScope objects.
|
|
|
|
.. versionadded:: 2.12
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsexpressioncontext.h"
|
|
%End
|
|
public:
|
|
|
|
struct StaticVariable
|
|
{
|
|
|
|
StaticVariable( const QString &name = QString(), const QVariant &value = QVariant(), bool readOnly = false, bool isStatic = false, const QString &description = QString() );
|
|
%Docstring
|
|
Constructor for StaticVariable.
|
|
|
|
:param name: variable name (should be unique within the QgsExpressionContextScope)
|
|
:param value: initial variable value
|
|
:param readOnly: ``True`` if variable should not be editable by users
|
|
:param isStatic: ``True`` if the variable will not change during the lifteime of an iterator.
|
|
:param description: optional translated description of variable, for use in expression builder widgets
|
|
%End
|
|
|
|
QString name;
|
|
|
|
QVariant value;
|
|
|
|
bool readOnly;
|
|
|
|
bool isStatic;
|
|
|
|
QString description;
|
|
};
|
|
|
|
QgsExpressionContextScope( const QString &name = QString() );
|
|
%Docstring
|
|
Constructor for QgsExpressionContextScope
|
|
|
|
:param name: friendly display name for the context scope
|
|
%End
|
|
|
|
QgsExpressionContextScope( const QgsExpressionContextScope &other );
|
|
%Docstring
|
|
Copy constructor
|
|
%End
|
|
|
|
|
|
~QgsExpressionContextScope();
|
|
|
|
QString name() const;
|
|
%Docstring
|
|
Returns the friendly display name of the context scope.
|
|
%End
|
|
|
|
void setVariable( const QString &name, const QVariant &value, bool isStatic = false );
|
|
%Docstring
|
|
Convenience method for setting a variable in the context scope by ``name`` name and ``value``. If a variable
|
|
with the same name is already set then its value is overwritten, otherwise a new variable is added to the scope.
|
|
If the ``isStatic`` parameter is set to ``True``, this variable can be cached during the execution
|
|
of :py:func:`QgsExpression.prepare()`.
|
|
|
|
.. seealso:: :py:func:`addVariable`
|
|
%End
|
|
|
|
void addVariable( const QgsExpressionContextScope::StaticVariable &variable );
|
|
%Docstring
|
|
Adds a variable into the context scope. If a variable with the same name is already set then its
|
|
value is overwritten, otherwise a new variable is added to the scope.
|
|
|
|
:param variable: definition of variable to insert
|
|
|
|
.. seealso:: :py:func:`setVariable`
|
|
|
|
.. seealso:: :py:func:`addFunction`
|
|
%End
|
|
|
|
bool removeVariable( const QString &name );
|
|
%Docstring
|
|
Removes a variable from the context scope, if found.
|
|
|
|
:param name: name of variable to remove
|
|
|
|
:return: ``True`` if variable was removed from the scope, ``False`` if matching variable was not
|
|
found within the scope
|
|
%End
|
|
|
|
bool hasVariable( const QString &name ) const;
|
|
%Docstring
|
|
Tests whether a variable with the specified name exists in the scope.
|
|
|
|
:param name: variable name
|
|
|
|
:return: ``True`` if matching variable was found in the scope
|
|
|
|
.. seealso:: :py:func:`variable`
|
|
|
|
.. seealso:: :py:func:`hasFunction`
|
|
%End
|
|
|
|
QVariant variable( const QString &name ) const;
|
|
%Docstring
|
|
Retrieves a variable's value from the scope.
|
|
|
|
:param name: variable name
|
|
|
|
:return: variable value, or invalid QVariant if matching variable could not be found
|
|
|
|
.. seealso:: :py:func:`hasVariable`
|
|
|
|
.. seealso:: :py:func:`function`
|
|
%End
|
|
|
|
QStringList variableNames() const;
|
|
%Docstring
|
|
Returns a list of variable names contained within the scope.
|
|
|
|
.. seealso:: :py:func:`functionNames`
|
|
|
|
.. seealso:: :py:func:`filteredVariableNames`
|
|
%End
|
|
|
|
QStringList filteredVariableNames() const;
|
|
%Docstring
|
|
Returns a filtered and sorted list of variable names contained within the scope.
|
|
Hidden variable names will be excluded, and the list will be sorted so that
|
|
read only variables are listed first.
|
|
|
|
.. seealso:: :py:func:`variableNames`
|
|
%End
|
|
|
|
bool isReadOnly( const QString &name ) const;
|
|
%Docstring
|
|
Tests whether the specified variable is read only and should not be editable
|
|
by users.
|
|
|
|
:param name: variable name
|
|
|
|
:return: ``True`` if variable is read only
|
|
%End
|
|
|
|
bool isStatic( const QString &name ) const;
|
|
%Docstring
|
|
Tests whether the variable with the specified ``name`` is static and can
|
|
be cached.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QString description( const QString &name ) const;
|
|
%Docstring
|
|
Returns the translated description for the variable with the specified ``name``
|
|
(if set).
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
int variableCount() const;
|
|
%Docstring
|
|
Returns the count of variables contained within the scope.
|
|
%End
|
|
|
|
bool hasFunction( const QString &name ) const;
|
|
%Docstring
|
|
Tests whether a function with the specified name exists in the scope.
|
|
|
|
:param name: function name
|
|
|
|
:return: ``True`` if matching function was found in the scope
|
|
|
|
.. seealso:: :py:func:`function`
|
|
|
|
.. seealso:: :py:func:`hasFunction`
|
|
%End
|
|
|
|
QgsExpressionFunction *function( const QString &name ) const;
|
|
%Docstring
|
|
Retrieves a function from the scope.
|
|
|
|
:param name: function name
|
|
|
|
:return: function, or ``None`` if matching function could not be found
|
|
|
|
.. seealso:: :py:func:`hasFunction`
|
|
|
|
.. seealso:: :py:func:`functionNames`
|
|
|
|
.. seealso:: :py:func:`variable`
|
|
%End
|
|
|
|
QStringList functionNames() const;
|
|
%Docstring
|
|
Retrieves a list of names of functions contained in the scope.
|
|
|
|
.. seealso:: :py:func:`function`
|
|
|
|
.. seealso:: :py:func:`variableNames`
|
|
%End
|
|
|
|
void addFunction( const QString &name, QgsScopedExpressionFunction *function /Transfer/ );
|
|
%Docstring
|
|
Adds a function to the scope.
|
|
|
|
:param name: function name
|
|
:param function: function to insert. Ownership is transferred to the scope.
|
|
|
|
.. seealso:: :py:func:`addVariable`
|
|
%End
|
|
|
|
bool hasFeature() const;
|
|
%Docstring
|
|
Returns ``True`` if the scope has a feature associated with it.
|
|
|
|
.. seealso:: :py:func:`feature`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QgsFeature feature() const;
|
|
%Docstring
|
|
Sets the feature associated with the scope.
|
|
|
|
.. seealso:: :py:func:`setFeature`
|
|
|
|
.. seealso:: :py:func:`hasFeature`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
void setFeature( const QgsFeature &feature );
|
|
%Docstring
|
|
Convenience function for setting a feature for the scope. Any existing
|
|
feature set by the scope will be overwritten.
|
|
|
|
:param feature: feature for scope
|
|
|
|
.. seealso:: :py:func:`removeFeature`
|
|
|
|
.. seealso:: :py:func:`feature`
|
|
%End
|
|
|
|
void removeFeature();
|
|
%Docstring
|
|
Removes any feature associated with the scope.
|
|
|
|
.. seealso:: :py:func:`setFeature`
|
|
|
|
.. seealso:: :py:func:`hasFeature`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
void setFields( const QgsFields &fields );
|
|
%Docstring
|
|
Convenience function for setting a fields for the scope. Any existing
|
|
fields set by the scope will be overwritten.
|
|
|
|
:param fields: fields for scope
|
|
%End
|
|
|
|
void readXml( const QDomElement &element, const QgsReadWriteContext &context );
|
|
%Docstring
|
|
Reads scope variables from an XML element.
|
|
|
|
.. seealso:: :py:func:`writeXml`
|
|
|
|
.. versionadded:: 3.6
|
|
%End
|
|
|
|
bool writeXml( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const;
|
|
%Docstring
|
|
Writes scope variables to an XML ``element``.
|
|
|
|
.. seealso:: :py:func:`readXml`
|
|
|
|
.. versionadded:: 3.6
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsExpressionContext
|
|
{
|
|
%Docstring
|
|
Expression contexts are used to encapsulate the parameters around which a QgsExpression should
|
|
be evaluated. QgsExpressions can then utilize the information stored within a context to contextualise
|
|
their evaluated result. A QgsExpressionContext consists of a stack of QgsExpressionContextScope objects,
|
|
where scopes added later to the stack will override conflicting variables and functions from scopes
|
|
lower in the stack.
|
|
|
|
See QgsExpressionContextUtils for helper methods for working with QgsExpressionContext objects.
|
|
|
|
.. versionadded:: 2.12
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsexpressioncontext.h"
|
|
%End
|
|
public:
|
|
|
|
QgsExpressionContext();
|
|
%Docstring
|
|
Constructor for QgsExpressionContext
|
|
%End
|
|
|
|
explicit QgsExpressionContext( const QList<QgsExpressionContextScope *> &scopes /Transfer/ );
|
|
%Docstring
|
|
Initializes the context with given list of scopes.
|
|
Ownership of the scopes is transferred to the stack.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QgsExpressionContext( const QgsExpressionContext &other );
|
|
%Docstring
|
|
Copy constructor
|
|
%End
|
|
|
|
|
|
|
|
~QgsExpressionContext();
|
|
|
|
bool hasVariable( const QString &name ) const;
|
|
%Docstring
|
|
Check whether a variable is specified by any scope within the context.
|
|
|
|
:param name: variable name
|
|
|
|
:return: ``True`` if variable is set
|
|
|
|
.. seealso:: :py:func:`variable`
|
|
|
|
.. seealso:: :py:func:`variableNames`
|
|
%End
|
|
|
|
QVariant variable( const QString &name ) const;
|
|
%Docstring
|
|
Fetches a matching variable from the context. The variable will be fetched
|
|
from the last scope contained within the context which has a matching
|
|
variable set.
|
|
|
|
:param name: variable name
|
|
|
|
:return: variable value if matching variable exists in the context, otherwise an invalid QVariant
|
|
|
|
.. seealso:: :py:func:`hasVariable`
|
|
|
|
.. seealso:: :py:func:`variableNames`
|
|
%End
|
|
|
|
QVariantMap variablesToMap() const;
|
|
%Docstring
|
|
Returns a map of variable name to value representing all the expression variables
|
|
contained by the context.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
bool isHighlightedVariable( const QString &name ) const;
|
|
%Docstring
|
|
Returns ``True`` if the specified variable ``name`` is intended to be highlighted to the
|
|
user. This is used by the expression builder to more prominently display the
|
|
variable.
|
|
|
|
.. seealso:: :py:func:`setHighlightedVariables`
|
|
|
|
.. seealso:: :py:func:`isHighlightedFunction`
|
|
%End
|
|
|
|
QStringList highlightedVariables() const;
|
|
%Docstring
|
|
Returns the current list of variables highlighted within the context.
|
|
|
|
.. seealso:: :py:func:`setHighlightedVariables`
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
void setHighlightedVariables( const QStringList &variableNames );
|
|
%Docstring
|
|
Sets the list of variable names within the context intended to be highlighted to the user. This
|
|
is used by the expression builder to more prominently display these variables.
|
|
|
|
:param variableNames: variable names to highlight
|
|
|
|
.. seealso:: :py:func:`isHighlightedVariable`
|
|
|
|
.. seealso:: :py:func:`setHighlightedFunctions`
|
|
%End
|
|
|
|
bool isHighlightedFunction( const QString &name ) const;
|
|
%Docstring
|
|
Returns ``True`` if the specified function ``name`` is intended to be highlighted to the
|
|
user. This is used by the expression builder to more prominently display the
|
|
function.
|
|
|
|
.. seealso:: :py:func:`setHighlightedFunctions`
|
|
|
|
.. seealso:: :py:func:`isHighlightedVariable`
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
void setHighlightedFunctions( const QStringList &names );
|
|
%Docstring
|
|
Sets the list of function ``names`` intended to be highlighted to the user. This
|
|
is used by the expression builder to more prominently display these functions.
|
|
|
|
Note that these function names may include standard functions which are not functions
|
|
specific to this context, and these standard functions will also be highlighted to users.
|
|
|
|
.. seealso:: :py:func:`isHighlightedFunction`
|
|
|
|
.. seealso:: :py:func:`setHighlightedVariables`
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
QgsExpressionContextScope *activeScopeForVariable( const QString &name );
|
|
%Docstring
|
|
Returns the currently active scope from the context for a specified variable name.
|
|
As scopes later in the stack override earlier contexts, this will be the last matching
|
|
scope which contains a matching variable.
|
|
|
|
:param name: variable name
|
|
|
|
:return: matching scope containing variable, or ``None`` if none found
|
|
%End
|
|
|
|
|
|
QgsExpressionContextScope *scope( int index );
|
|
%Docstring
|
|
Returns the scope at the specified index within the context.
|
|
|
|
:param index: index of scope
|
|
|
|
:return: matching scope, or ``None`` if none found
|
|
|
|
.. seealso:: :py:func:`lastScope`
|
|
%End
|
|
|
|
QgsExpressionContextScope *lastScope();
|
|
%Docstring
|
|
Returns the last scope added to the context.
|
|
|
|
.. seealso:: :py:func:`scope`
|
|
%End
|
|
|
|
QList< QgsExpressionContextScope * > scopes();
|
|
%Docstring
|
|
Returns a list of scopes contained within the stack.
|
|
|
|
:return: list of pointers to scopes
|
|
%End
|
|
|
|
int indexOfScope( QgsExpressionContextScope *scope ) const;
|
|
%Docstring
|
|
Returns the index of the specified scope if it exists within the context.
|
|
|
|
:param scope: scope to find
|
|
|
|
:return: index of scope, or -1 if scope was not found within the context.
|
|
%End
|
|
|
|
int indexOfScope( const QString &scopeName ) const;
|
|
%Docstring
|
|
Returns the index of the first scope with a matching name within the context.
|
|
|
|
:param scopeName: name of scope to find
|
|
|
|
:return: index of scope, or -1 if scope was not found within the context.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QStringList variableNames() const;
|
|
%Docstring
|
|
Returns a list of variables names set by all scopes in the context.
|
|
|
|
:return: list of unique variable names
|
|
|
|
.. seealso:: :py:func:`filteredVariableNames`
|
|
|
|
.. seealso:: :py:func:`functionNames`
|
|
|
|
.. seealso:: :py:func:`hasVariable`
|
|
|
|
.. seealso:: :py:func:`variable`
|
|
%End
|
|
|
|
QStringList filteredVariableNames() const;
|
|
%Docstring
|
|
Returns a filtered list of variables names set by all scopes in the context. The included
|
|
variables are those which should be seen by users.
|
|
|
|
:return: filtered list of unique variable names
|
|
|
|
.. seealso:: :py:func:`variableNames`
|
|
%End
|
|
|
|
bool isReadOnly( const QString &name ) const;
|
|
%Docstring
|
|
Returns whether a variable is read only, and should not be modifiable by users.
|
|
|
|
:param name: variable name
|
|
|
|
:return: ``True`` if variable is read only. Read only status will be taken from last
|
|
matching scope which contains a matching variable.
|
|
%End
|
|
|
|
QString description( const QString &name ) const;
|
|
%Docstring
|
|
Returns a translated description string for the variable with specified ``name``.
|
|
|
|
If no specific description has been provided for the variable, the value from
|
|
:py:func:`QgsExpression.variableHelpText()` will be returned.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
bool hasFunction( const QString &name ) const;
|
|
%Docstring
|
|
Checks whether a specified function is contained in the context.
|
|
|
|
:param name: function name
|
|
|
|
:return: ``True`` if context provides a matching function
|
|
|
|
.. seealso:: :py:func:`function`
|
|
%End
|
|
|
|
QStringList functionNames() const;
|
|
%Docstring
|
|
Retrieves a list of function names contained in the context.
|
|
|
|
.. seealso:: :py:func:`function`
|
|
|
|
.. seealso:: :py:func:`variableNames`
|
|
%End
|
|
|
|
QgsExpressionFunction *function( const QString &name ) const;
|
|
%Docstring
|
|
Fetches a matching function from the context. The function will be fetched
|
|
from the last scope contained within the context which has a matching
|
|
function set.
|
|
|
|
:param name: function name
|
|
|
|
:return: function if contained by the context, otherwise ``None``.
|
|
|
|
.. seealso:: :py:func:`hasFunction`
|
|
%End
|
|
|
|
int scopeCount() const;
|
|
%Docstring
|
|
Returns the number of scopes contained in the context.
|
|
%End
|
|
|
|
void appendScope( QgsExpressionContextScope *scope /Transfer/ );
|
|
%Docstring
|
|
Appends a scope to the end of the context. This scope will override
|
|
any matching variables or functions provided by existing scopes within the
|
|
context. Ownership of the scope is transferred to the stack.
|
|
|
|
:param scope: expression context to append to context
|
|
%End
|
|
|
|
void appendScopes( const QList<QgsExpressionContextScope *> &scopes /Transfer/ );
|
|
%Docstring
|
|
Appends a list of scopes to the end of the context. This scopes will override
|
|
any matching variables or functions provided by existing scopes within the
|
|
context. Ownership of the scopes is transferred to the stack.
|
|
|
|
:param scopes: scopes to append to context
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QgsExpressionContextScope *popScope();
|
|
%Docstring
|
|
Removes the last scope from the expression context and return it.
|
|
%End
|
|
|
|
|
|
|
|
void setFeature( const QgsFeature &feature );
|
|
%Docstring
|
|
Convenience function for setting a feature for the context. The feature
|
|
will be set within the last scope of the context, so will override any
|
|
existing features within the context.
|
|
|
|
:param feature: feature for context
|
|
|
|
.. seealso:: :py:func:`feature`
|
|
%End
|
|
|
|
bool hasFeature() const;
|
|
%Docstring
|
|
Returns ``True`` if the context has a feature associated with it.
|
|
|
|
.. seealso:: :py:func:`feature`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QgsFeature feature() const;
|
|
%Docstring
|
|
Convenience function for retrieving the feature for the context, if set.
|
|
|
|
.. seealso:: :py:func:`setFeature`
|
|
%End
|
|
|
|
void setFields( const QgsFields &fields );
|
|
%Docstring
|
|
Convenience function for setting a fields for the context. The fields
|
|
will be set within the last scope of the context, so will override any
|
|
existing fields within the context.
|
|
|
|
:param fields: fields for context
|
|
|
|
.. seealso:: :py:func:`fields`
|
|
%End
|
|
|
|
QgsFields fields() const;
|
|
%Docstring
|
|
Convenience function for retrieving the fields for the context, if set.
|
|
|
|
.. seealso:: :py:func:`setFields`
|
|
%End
|
|
|
|
void setOriginalValueVariable( const QVariant &value );
|
|
%Docstring
|
|
Sets the original value variable value for the context.
|
|
|
|
:param value: value for original value variable. This usually represents an original widget
|
|
value before any data defined overrides have been applied.
|
|
|
|
.. versionadded:: 2.12
|
|
%End
|
|
|
|
void setCachedValue( const QString &key, const QVariant &value ) const;
|
|
%Docstring
|
|
Sets a value to cache within the expression context. This can be used to cache the results
|
|
of expensive expression sub-calculations, to speed up future evaluations using the same
|
|
expression context.
|
|
|
|
:param key: unique key for retrieving cached value
|
|
:param value: value to cache
|
|
|
|
.. seealso:: :py:func:`hasCachedValue`
|
|
|
|
.. seealso:: :py:func:`cachedValue`
|
|
|
|
.. seealso:: :py:func:`clearCachedValues`
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
bool hasCachedValue( const QString &key ) const;
|
|
%Docstring
|
|
Returns ``True`` if the expression context contains a cached value with a matching key.
|
|
|
|
:param key: unique key used to store cached value
|
|
|
|
.. seealso:: :py:func:`setCachedValue`
|
|
|
|
.. seealso:: :py:func:`cachedValue`
|
|
|
|
.. seealso:: :py:func:`clearCachedValues`
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
QVariant cachedValue( const QString &key ) const;
|
|
%Docstring
|
|
Returns the matching cached value, if set. This can be used to retrieve the previously stored results
|
|
of an expensive expression sub-calculation.
|
|
|
|
:param key: unique key used to store cached value
|
|
|
|
:return: matching cached value, or invalid QVariant if not set
|
|
|
|
.. seealso:: :py:func:`setCachedValue`
|
|
|
|
.. seealso:: :py:func:`hasCachedValue`
|
|
|
|
.. seealso:: :py:func:`clearCachedValues`
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
void clearCachedValues() const;
|
|
%Docstring
|
|
Clears all cached values from the context.
|
|
|
|
.. seealso:: :py:func:`setCachedValue`
|
|
|
|
.. seealso:: :py:func:`hasCachedValue`
|
|
|
|
.. seealso:: :py:func:`cachedValue`
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
static const QString EXPR_FIELDS;
|
|
static const QString EXPR_ORIGINAL_VALUE;
|
|
static const QString EXPR_SYMBOL_COLOR;
|
|
static const QString EXPR_SYMBOL_ANGLE;
|
|
static const QString EXPR_GEOMETRY_PART_COUNT;
|
|
static const QString EXPR_GEOMETRY_PART_NUM;
|
|
static const QString EXPR_GEOMETRY_POINT_COUNT;
|
|
static const QString EXPR_GEOMETRY_POINT_NUM;
|
|
static const QString EXPR_CLUSTER_SIZE;
|
|
static const QString EXPR_CLUSTER_COLOR;
|
|
|
|
};
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/qgsexpressioncontext.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|