Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgsexpressionfunction.h
3 : : -------------------
4 : : begin : May 2017
5 : : copyright : (C) 2017 Matthias Kuhn
6 : : email : matthias@opengis.ch
7 : : ***************************************************************************
8 : : * *
9 : : * This program is free software; you can redistribute it and/or modify *
10 : : * it under the terms of the GNU General Public License as published by *
11 : : * the Free Software Foundation; either version 2 of the License, or *
12 : : * (at your option) any later version. *
13 : : * *
14 : : ***************************************************************************/
15 : :
16 : : #ifndef QGSEXPRESSIONFUNCTION_H
17 : : #define QGSEXPRESSIONFUNCTION_H
18 : :
19 : : #include <functional>
20 : :
21 : : #include <QString>
22 : : #include <QVariant>
23 : : #include <QSet>
24 : : #include <QJsonDocument>
25 : : #include <QJsonObject>
26 : :
27 : : #include "qgis.h"
28 : : #include "qgis_core.h"
29 : : #include "qgsexpressionnode.h"
30 : :
31 : : class QgsExpressionNodeFunction;
32 : : class QgsExpression;
33 : : class QgsExpressionContext;
34 : : class QgsExpressionContextScope;
35 : :
36 : : /**
37 : : * \ingroup core
38 : : * \brief A abstract base class for defining QgsExpression functions.
39 : : */
40 : : class CORE_EXPORT QgsExpressionFunction
41 : : {
42 : : public:
43 : :
44 : : /**
45 : : * Function definition for evaluation against an expression context, using a list of values as parameters to the function.
46 : : */
47 : : typedef QVariant( *FcnEval )( const QVariantList &values, const QgsExpressionContext *context, QgsExpression *parent, const QgsExpressionNodeFunction *node ) SIP_SKIP;
48 : :
49 : : /**
50 : : * \ingroup core
51 : : * \brief Represents a single parameter passed to a function.
52 : : * \since QGIS 2.16
53 : : */
54 : 0 : class CORE_EXPORT Parameter
55 : : {
56 : : public:
57 : :
58 : : /**
59 : : * Constructor for Parameter.
60 : : * \param name parameter name, used when named parameter are specified in an expression
61 : : * \param optional set to TRUE if parameter should be optional
62 : : * \param defaultValue default value to use for optional parameters
63 : : * \param isSubExpression set to TRUE if this parameter is a sub-expression
64 : : */
65 : 0 : Parameter( const QString &name,
66 : : bool optional = false,
67 : : const QVariant &defaultValue = QVariant(),
68 : : bool isSubExpression = false )
69 : 0 : : mName( name )
70 : 0 : , mOptional( optional )
71 : 0 : , mDefaultValue( defaultValue )
72 : 0 : , mIsSubExpression( isSubExpression )
73 : 0 : {}
74 : :
75 : : //! Returns the name of the parameter.
76 : 0 : QString name() const { return mName; }
77 : :
78 : : //! Returns TRUE if the parameter is optional.
79 : 0 : bool optional() const { return mOptional; }
80 : :
81 : : //! Returns the default value for the parameter.
82 : 0 : QVariant defaultValue() const { return mDefaultValue; }
83 : :
84 : : /**
85 : : * Returns TRUE if parameter argument is a separate sub-expression, and
86 : : * should not be checked while determining referenced columns for the expression.
87 : : * \since QGIS 3.2
88 : : */
89 : 0 : bool isSubExpression() const { return mIsSubExpression; }
90 : :
91 : 0 : bool operator==( const QgsExpressionFunction::Parameter &other ) const
92 : : {
93 : 0 : return ( QString::compare( mName, other.mName, Qt::CaseInsensitive ) == 0 );
94 : : }
95 : :
96 : : private:
97 : : QString mName;
98 : : bool mOptional = false;
99 : : QVariant mDefaultValue;
100 : : bool mIsSubExpression = false;
101 : : };
102 : :
103 : : //! List of parameters, used for function definition
104 : : typedef QList< QgsExpressionFunction::Parameter > ParameterList;
105 : :
106 : : //! Constructor for function which uses unnamed parameters
107 : 2 : QgsExpressionFunction( const QString &fnname,
108 : : int params,
109 : : const QString &group,
110 : : const QString &helpText = QString(),
111 : : bool lazyEval = false,
112 : : bool handlesNull = false,
113 : : bool isContextual = false )
114 : 2 : : mName( fnname )
115 : 2 : , mParams( params )
116 : 2 : , mGroups( group.isEmpty() ? QStringList() : QStringList() << group )
117 : 2 : , mHelpText( helpText )
118 : 2 : , mLazyEval( lazyEval )
119 : 2 : , mHandlesNull( handlesNull )
120 : 2 : , mIsContextual( isContextual )
121 : 2 : {
122 : 2 : }
123 : :
124 : : /**
125 : : * Constructor for function which uses unnamed parameters and group list
126 : : * \since QGIS 3.0
127 : : */
128 : : QgsExpressionFunction( const QString &fnname,
129 : : int params,
130 : : const QStringList &groups,
131 : : const QString &helpText = QString(),
132 : : bool lazyEval = false,
133 : : bool handlesNull = false,
134 : : bool isContextual = false )
135 : : : mName( fnname )
136 : : , mParams( params )
137 : : , mGroups( groups )
138 : : , mHelpText( helpText )
139 : : , mLazyEval( lazyEval )
140 : : , mHandlesNull( handlesNull )
141 : : , mIsContextual( isContextual )
142 : : {
143 : : }
144 : :
145 : : /**
146 : : * Constructor for function which uses named parameter list.
147 : : * \since QGIS 2.16
148 : : */
149 : 0 : QgsExpressionFunction( const QString &fnname,
150 : : const QgsExpressionFunction::ParameterList ¶ms,
151 : : const QString &group,
152 : : const QString &helpText = QString(),
153 : : bool lazyEval = false,
154 : : bool handlesNull = false,
155 : : bool isContextual = false )
156 : 0 : : mName( fnname )
157 : 0 : , mParams( 0 )
158 : 0 : , mParameterList( params )
159 : 0 : , mGroups( group.isEmpty() ? QStringList() : QStringList() << group )
160 : 0 : , mHelpText( helpText )
161 : 0 : , mLazyEval( lazyEval )
162 : 0 : , mHandlesNull( handlesNull )
163 : 0 : , mIsContextual( isContextual )
164 : 0 : {}
165 : :
166 : : /**
167 : : * Constructor for function which uses named parameter list and group list.
168 : : * \since QGIS 3.0
169 : : */
170 : 0 : QgsExpressionFunction( const QString &fnname,
171 : : const QgsExpressionFunction::ParameterList ¶ms,
172 : : const QStringList &groups,
173 : : const QString &helpText = QString(),
174 : : bool lazyEval = false,
175 : : bool handlesNull = false,
176 : : bool isContextual = false )
177 : 0 : : mName( fnname )
178 : 0 : , mParams( 0 )
179 : 0 : , mParameterList( params )
180 : 0 : , mGroups( groups )
181 : 0 : , mHelpText( helpText )
182 : 0 : , mLazyEval( lazyEval )
183 : 0 : , mHandlesNull( handlesNull )
184 : 0 : , mIsContextual( isContextual )
185 : 0 : {}
186 : :
187 : 2 : virtual ~QgsExpressionFunction() = default;
188 : :
189 : : //! The name of the function.
190 : 0 : QString name() const { return mName; }
191 : :
192 : : //! The number of parameters this function takes.
193 : 0 : int params() const { return mParameterList.isEmpty() ? mParams : mParameterList.count(); }
194 : :
195 : : //! The minimum number of parameters this function takes.
196 : 0 : int minParams() const
197 : : {
198 : 0 : if ( mParameterList.isEmpty() )
199 : 0 : return mParams;
200 : :
201 : 0 : int min = 0;
202 : 0 : for ( const Parameter ¶m : mParameterList )
203 : : {
204 : 0 : if ( !param.optional() )
205 : 0 : min++;
206 : : }
207 : 0 : return min;
208 : 0 : }
209 : :
210 : : /**
211 : : * Returns the list of named parameters for the function, if set.
212 : : * \since QGIS 2.16
213 : : */
214 : 0 : const QgsExpressionFunction::ParameterList ¶meters() const { return mParameterList; }
215 : :
216 : : //! Does this function use a geometry object.
217 : : virtual bool usesGeometry( const QgsExpressionNodeFunction *node ) const;
218 : :
219 : : /**
220 : : * Returns a list of possible aliases for the function. These include
221 : : * other permissible names for the function, e.g., deprecated names.
222 : : * \returns list of known aliases
223 : : * \since QGIS 2.9
224 : : */
225 : : virtual QStringList aliases() const;
226 : :
227 : : /**
228 : : * TRUE if this function should use lazy evaluation. Lazy evaluation functions take QgsExpression::Node objects
229 : : * rather than the node results when called. You can use node->eval(parent, feature) to evaluate the node and return the result
230 : : * Functions are non lazy default and will be given the node return value when called.
231 : : */
232 : 0 : bool lazyEval() const { return mLazyEval; }
233 : :
234 : : /**
235 : : * Will be called during prepare to determine if the function is static.
236 : : * A function is static if it will return the same value for every feature with different
237 : : * attributes and/or geometry.
238 : : *
239 : : * By default this will return TRUE, if all arguments that have been passed to the function
240 : : * are also static.
241 : : *
242 : : * \since QGIS 3.0
243 : : */
244 : : virtual bool isStatic( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const;
245 : :
246 : : /**
247 : : * This will be called during the prepare step() of an expression if it is not static.
248 : : *
249 : : * This can be used by functions to do any preparation steps that might help to speedup the upcoming
250 : : * evaluation.
251 : : *
252 : : * \since QGIS 3.0
253 : : */
254 : : virtual bool prepare( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const;
255 : :
256 : : /**
257 : : * Returns a set of field names which are required for this function.
258 : : * May contain QgsFeatureRequest::AllAttributes to signal that all
259 : : * attributes are required.
260 : : * If in doubt this will return more fields than strictly required.
261 : : *
262 : : * \since QGIS 3.0
263 : : */
264 : : virtual QSet<QString> referencedColumns( const QgsExpressionNodeFunction *node ) const;
265 : :
266 : : /**
267 : : * Returns whether the function is only available if provided by a QgsExpressionContext object.
268 : : * \since QGIS 2.12
269 : : */
270 : : bool isContextual() const { return mIsContextual; }
271 : :
272 : : /**
273 : : * Returns TRUE if the function is deprecated and should not be presented as a valid option
274 : : * to users in expression builders.
275 : : * \since QGIS 3.0
276 : : */
277 : : virtual bool isDeprecated() const;
278 : :
279 : : /**
280 : : * Returns the first group which the function belongs to.
281 : : * \note consider using groups() instead, as some functions naturally belong in multiple groups
282 : : */
283 : : QString group() const { return mGroups.isEmpty() ? QString() : mGroups.at( 0 ); }
284 : :
285 : : /**
286 : : * Returns a list of the groups the function belongs to.
287 : : * \see group()
288 : : * \since QGIS 3.0
289 : : */
290 : : QStringList groups() const { return mGroups; }
291 : :
292 : : //! The help text for the function.
293 : : const QString helpText() const;
294 : :
295 : : /**
296 : : * Returns result of evaluating the function.
297 : : * \param values list of values passed to the function
298 : : * \param context context expression is being evaluated against
299 : : * \param parent parent expression
300 : : * \param node expression node
301 : : * \returns result of function
302 : : */
303 : : virtual QVariant func( const QVariantList &values, const QgsExpressionContext *context, QgsExpression *parent, const QgsExpressionNodeFunction *node ) = 0;
304 : :
305 : : /**
306 : : * Evaluates the function, first evaluating all required arguments before passing them to the
307 : : * function's func() method.
308 : : */
309 : : virtual QVariant run( QgsExpressionNode::NodeList *args, const QgsExpressionContext *context, QgsExpression *parent, const QgsExpressionNodeFunction *node );
310 : :
311 : : bool operator==( const QgsExpressionFunction &other ) const;
312 : :
313 : : /**
314 : : * Returns TRUE if the function handles NULL values in arguments by itself, and the default
315 : : * NULL value handling should be skipped.
316 : : */
317 : : virtual bool handlesNull() const;
318 : :
319 : : protected:
320 : :
321 : : /**
322 : : * This will return TRUE if all the params for the provided function \a node are static within the
323 : : * constraints imposed by the \a context within the given \a parent.
324 : : *
325 : : * This can be used as callback for custom implementations of subclasses. It is the default for implementation
326 : : * for StaticFunction::isStatic.
327 : : *
328 : : * \since QGIS 3.0
329 : : */
330 : : static bool allParamsStatic( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context );
331 : :
332 : : private:
333 : : QString mName;
334 : : int mParams;
335 : : QgsExpressionFunction::ParameterList mParameterList;
336 : : QStringList mGroups;
337 : : QString mHelpText;
338 : : bool mLazyEval;
339 : : bool mHandlesNull;
340 : : bool mIsContextual; //if true function is only available through an expression context
341 : : };
342 : :
343 : : /**
344 : : * \ingroup core
345 : : * \brief c++ helper class for defining QgsExpression functions.
346 : : * \note not available in Python bindings
347 : : */
348 : : #ifndef SIP_RUN
349 : 0 : class QgsStaticExpressionFunction : public QgsExpressionFunction
350 : : {
351 : : public:
352 : :
353 : : /**
354 : : * Static function for evaluation against a QgsExpressionContext, using an unnamed list of parameter values.
355 : : */
356 : 0 : QgsStaticExpressionFunction( const QString &fnname,
357 : : int params,
358 : : FcnEval fcn,
359 : : const QString &group,
360 : : const QString &helpText = QString(),
361 : : bool usesGeometry = false,
362 : : const QSet<QString> &referencedColumns = QSet<QString>(),
363 : : bool lazyEval = false,
364 : : const QStringList &aliases = QStringList(),
365 : : bool handlesNull = false )
366 : 0 : : QgsExpressionFunction( fnname, params, group, helpText, lazyEval, handlesNull )
367 : 0 : , mFnc( fcn )
368 : 0 : , mAliases( aliases )
369 : 0 : , mUsesGeometry( usesGeometry )
370 : 0 : , mReferencedColumns( referencedColumns )
371 : 0 : {
372 : 0 : }
373 : :
374 : : /**
375 : : * Static function for evaluation against a QgsExpressionContext, using an unnamed list of parameter values and list
376 : : * of groups.
377 : : */
378 : : QgsStaticExpressionFunction( const QString &fnname,
379 : : int params,
380 : : FcnEval fcn,
381 : : const QStringList &groups,
382 : : const QString &helpText = QString(),
383 : : bool usesGeometry = false,
384 : : const QSet<QString> &referencedColumns = QSet<QString>(),
385 : : bool lazyEval = false,
386 : : const QStringList &aliases = QStringList(),
387 : : bool handlesNull = false )
388 : : : QgsExpressionFunction( fnname, params, groups, helpText, lazyEval, handlesNull )
389 : : , mFnc( fcn )
390 : : , mAliases( aliases )
391 : : , mUsesGeometry( usesGeometry )
392 : : , mReferencedColumns( referencedColumns )
393 : : {
394 : : }
395 : :
396 : : /**
397 : : * Static function for evaluation against a QgsExpressionContext, using a named list of parameter values.
398 : : */
399 : 0 : QgsStaticExpressionFunction( const QString &fnname,
400 : : const QgsExpressionFunction::ParameterList ¶ms,
401 : : FcnEval fcn,
402 : : const QString &group,
403 : : const QString &helpText = QString(),
404 : : bool usesGeometry = false,
405 : : const QSet<QString> &referencedColumns = QSet<QString>(),
406 : : bool lazyEval = false,
407 : : const QStringList &aliases = QStringList(),
408 : : bool handlesNull = false )
409 : 0 : : QgsExpressionFunction( fnname, params, group, helpText, lazyEval, handlesNull )
410 : 0 : , mFnc( fcn )
411 : 0 : , mAliases( aliases )
412 : 0 : , mUsesGeometry( usesGeometry )
413 : 0 : , mReferencedColumns( referencedColumns )
414 : 0 : {}
415 : :
416 : : /**
417 : : * Static function for evaluation against a QgsExpressionContext, using a named list of parameter values.
418 : : *
419 : : * Lambda functions can be provided that will be called to determine if a geometry is used an which
420 : : * columns are referenced.
421 : : * This is only required if this cannot be determined by calling each parameter node's usesGeometry() or
422 : : * referencedColumns() method. For example, an aggregate expression requires the geometry and all columns
423 : : * if the parent variable is used.
424 : : * If NULLPTR is passed as a node to these functions, they should stay on the safe side and return if they
425 : : * could potentially require a geometry or columns.
426 : : */
427 : : QgsStaticExpressionFunction( const QString &fnname,
428 : : const QgsExpressionFunction::ParameterList ¶ms,
429 : : FcnEval fcn,
430 : : const QString &group,
431 : : const QString &helpText,
432 : : const std::function< bool( const QgsExpressionNodeFunction *node )> &usesGeometry,
433 : : const std::function< QSet<QString>( const QgsExpressionNodeFunction *node )> &referencedColumns,
434 : : bool lazyEval = false,
435 : : const QStringList &aliases = QStringList(),
436 : : bool handlesNull = false );
437 : :
438 : : /**
439 : : * Static function for evaluation against a QgsExpressionContext, using a named list of parameter values and list
440 : : * of groups.
441 : : */
442 : 0 : QgsStaticExpressionFunction( const QString &fnname,
443 : : const QgsExpressionFunction::ParameterList ¶ms,
444 : : FcnEval fcn,
445 : : const QStringList &groups,
446 : : const QString &helpText = QString(),
447 : : bool usesGeometry = false,
448 : : const QSet<QString> &referencedColumns = QSet<QString>(),
449 : : bool lazyEval = false,
450 : : const QStringList &aliases = QStringList(),
451 : : bool handlesNull = false )
452 : 0 : : QgsExpressionFunction( fnname, params, groups, helpText, lazyEval, handlesNull )
453 : 0 : , mFnc( fcn )
454 : 0 : , mAliases( aliases )
455 : 0 : , mUsesGeometry( usesGeometry )
456 : 0 : , mReferencedColumns( referencedColumns )
457 : 0 : {}
458 : :
459 : : /**
460 : : * Returns result of evaluating the function.
461 : : * \param values list of values passed to the function
462 : : * \param context context expression is being evaluated against
463 : : * \param parent parent expression
464 : : * \param node function node
465 : : * \returns result of function
466 : : */
467 : 0 : QVariant func( const QVariantList &values, const QgsExpressionContext *context, QgsExpression *parent, const QgsExpressionNodeFunction *node ) override
468 : : {
469 : 0 : return mFnc ? mFnc( values, context, parent, node ) : QVariant();
470 : : }
471 : :
472 : : QStringList aliases() const override;
473 : :
474 : : bool usesGeometry( const QgsExpressionNodeFunction *node ) const override;
475 : :
476 : : QSet<QString> referencedColumns( const QgsExpressionNodeFunction *node ) const override;
477 : :
478 : : bool isStatic( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const override;
479 : :
480 : : bool prepare( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const override;
481 : :
482 : : /**
483 : : * Set a function that will be called in the prepare step to determine if the function is
484 : : * static or not.
485 : : * By default this is set to a function that checks all arguments that have been passed to the variable
486 : : * and if all of them are static, it will be assumed that the function is static as well.
487 : : */
488 : : void setIsStaticFunction( const std::function< bool ( const QgsExpressionNodeFunction *, QgsExpression *, const QgsExpressionContext * ) > &isStatic );
489 : :
490 : : /**
491 : : * Tag this function as either static or not static.
492 : : * This will indicate that the function is always expected to return the same value for
493 : : * an iteration (or explicitly request that it's going to be called for every feature, if FALSE).
494 : : *
495 : : * \see setIsStaticFunction
496 : : */
497 : : void setIsStatic( bool isStatic );
498 : :
499 : : /**
500 : : * Set a function that will be called in the prepare step to determine if the function is
501 : : * static or not.
502 : : * By default this is set to a function that checks all arguments that have been passed to the variable
503 : : * and if all of them are static, it will be assumed that the function is static as well.
504 : : */
505 : : void setPrepareFunction( const std::function< bool( const QgsExpressionNodeFunction *, QgsExpression *, const QgsExpressionContext * )> &prepareFunc );
506 : :
507 : : /**
508 : : * Returns a list of all registered expression functions.
509 : : */
510 : : static const QList<QgsExpressionFunction *> &functions();
511 : :
512 : : private:
513 : : FcnEval mFnc;
514 : : QStringList mAliases;
515 : : bool mUsesGeometry;
516 : : std::function < bool( const QgsExpressionNodeFunction *node ) > mUsesGeometryFunc;
517 : : std::function < QSet<QString>( const QgsExpressionNodeFunction *node ) > mReferencedColumnsFunc;
518 : 0 : std::function < bool( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) > mIsStaticFunc = allParamsStatic;
519 : : std::function < bool( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) > mPrepareFunc;
520 : : QSet<QString> mReferencedColumns;
521 : 0 : bool mIsStatic = false;
522 : : };
523 : :
524 : : /**
525 : : * \brief Handles the array looping``array_Foreach(array, expression)`` expression function.
526 : : * It temporarily appends a new scope to the expression context.
527 : : *
528 : : * \ingroup core
529 : : * \note Not available in Python bindings
530 : : * \since QGIS 3.4
531 : : */
532 : 0 : class QgsArrayForeachExpressionFunction : public QgsExpressionFunction
533 : : {
534 : : public:
535 : : QgsArrayForeachExpressionFunction();
536 : :
537 : : bool isStatic( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const override;
538 : :
539 : : QVariant run( QgsExpressionNode::NodeList *args, const QgsExpressionContext *context, QgsExpression *parent, const QgsExpressionNodeFunction *node ) override;
540 : :
541 : : QVariant func( const QVariantList &values, const QgsExpressionContext *context, QgsExpression *parent, const QgsExpressionNodeFunction *node ) override;
542 : :
543 : : bool prepare( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const override;
544 : :
545 : : };
546 : :
547 : : /**
548 : : * \brief Handles the ``array_filter(array, expression)`` expression function.
549 : : * It temporarily appends a new scope to the expression context.
550 : : *
551 : : * \ingroup core
552 : : * \note Not available in Python bindings
553 : : * \since QGIS 3.4
554 : : */
555 : 0 : class QgsArrayFilterExpressionFunction : public QgsExpressionFunction
556 : : {
557 : : public:
558 : : QgsArrayFilterExpressionFunction();
559 : :
560 : : bool isStatic( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const override;
561 : :
562 : : QVariant run( QgsExpressionNode::NodeList *args, const QgsExpressionContext *context, QgsExpression *parent, const QgsExpressionNodeFunction *node ) override;
563 : :
564 : : QVariant func( const QVariantList &values, const QgsExpressionContext *context, QgsExpression *parent, const QgsExpressionNodeFunction *node ) override;
565 : :
566 : : bool prepare( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const override;
567 : :
568 : : };
569 : :
570 : : /**
571 : : * \brief Handles the ``with_variable(name, value, node)`` expression function.
572 : : * It temporarily appends a new scope to the expression context for all nested
573 : : * nodes.
574 : : *
575 : : * \ingroup core
576 : : * \note Not available in Python bindings
577 : : * \since QGIS 3.0
578 : : */
579 : 0 : class QgsWithVariableExpressionFunction : public QgsExpressionFunction
580 : : {
581 : : public:
582 : : QgsWithVariableExpressionFunction();
583 : :
584 : : bool isStatic( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const override;
585 : :
586 : : QVariant run( QgsExpressionNode::NodeList *args, const QgsExpressionContext *context, QgsExpression *parent, const QgsExpressionNodeFunction *node ) override;
587 : :
588 : : QVariant func( const QVariantList &values, const QgsExpressionContext *context, QgsExpression *parent, const QgsExpressionNodeFunction *node ) override;
589 : :
590 : : bool prepare( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const override;
591 : :
592 : : private:
593 : :
594 : : /**
595 : : * Append a scope with a single variable definition (``name``=``value``)
596 : : */
597 : : void appendTemporaryVariable( const QgsExpressionContext *context, const QString &name, const QVariant &value ) const;
598 : :
599 : : /**
600 : : * Pop the temporary scope again
601 : : */
602 : : void popTemporaryVariable( const QgsExpressionContext *context ) const;
603 : : };
604 : :
605 : : #endif
606 : :
607 : : #endif // QGSEXPRESSIONFUNCTION_H
|
