qgsexpressioncontext.h

Go to the documentation of this file.

/***************************************************************************
     qgsexpressioncontext.h
     ----------------------
    Date                 : April 2015
    Copyright            : (C) 2015 by Nyall Dawson
    Email                : nyall dot dawson at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef QGSEXPRESSIONCONTEXT_H
#define QGSEXPRESSIONCONTEXT_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include <QVariant>
#include <QHash>
#include <QString>
#include <QStringList>
#include <QSet>
#include <QPointer>
 
#include "qgsexpressionfunction.h"
#include "qgsfeature.h"
 
class QgsReadWriteContext;
class QgsMapLayerStore;
class LoadLayerFunction;
 
class CORE_EXPORT QgsScopedExpressionFunction : public QgsExpressionFunction
{
  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 )
      : QgsExpressionFunction( fnname, params, group, helpText, lazyEval, handlesNull, isContextual )
      , mUsesGeometry( usesGeometry )
      , mReferencedColumns( referencedColumns )
    {}
    QgsScopedExpressionFunction( const QString &fnname, {…}
 
    QgsScopedExpressionFunction( const QString &fnname,
                                 const QgsExpressionFunction::ParameterList &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 )
      : QgsExpressionFunction( fnname, params, group, helpText, lazyEval, handlesNull, isContextual )
      , mUsesGeometry( usesGeometry )
      , mReferencedColumns( referencedColumns )
    {}
    QgsScopedExpressionFunction( const QString &fnname, {…}
 
    QVariant func( const QVariantList &values, const QgsExpressionContext *context, QgsExpression *parent, const QgsExpressionNodeFunction *node ) override = 0;
 
    virtual QgsScopedExpressionFunction *clone() const = 0 SIP_FACTORY;
 
    bool usesGeometry( const QgsExpressionNodeFunction *node ) const override;
 
    QSet<QString> referencedColumns( const QgsExpressionNodeFunction *node ) const override;
 
    bool isStatic( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const override;
 
  private:
    bool mUsesGeometry;
    QSet<QString> mReferencedColumns;
};
class CORE_EXPORT QgsScopedExpressionFunction : public QgsExpressionFunction {…};
 
 
class CORE_EXPORT QgsExpressionContextScope
{
  public:
 
    struct StaticVariable
    {
 
      StaticVariable( const QString &name = QString(), const QVariant &value = QVariant(), bool readOnly = false, bool isStatic = false, const QString &description = QString() )
        : name( name )
        , value( value )
        , readOnly( readOnly )
        , isStatic( isStatic )
        , description( description )
      {}
      StaticVariable( const QString &name = QString(), const QVariant &value = QVariant(), bool readOnly = false, bool isStatic = false, const QString &description = QString() ) {…}
 
      QString name;
 
      QVariant value;
 
      bool readOnly;
 
      bool isStatic;
 
      QString description;
    };
    struct StaticVariable {…};
 
    QgsExpressionContextScope( const QString &name = QString() );
 
    QgsExpressionContextScope( const QgsExpressionContextScope &other );
 
    QgsExpressionContextScope &operator=( const QgsExpressionContextScope &other );
 
    ~QgsExpressionContextScope();
 
    QString name() const { return mName; }
 
    void setVariable( const QString &name, const QVariant &value, bool isStatic = false );
 
    void addVariable( const QgsExpressionContextScope::StaticVariable &variable );
 
    bool removeVariable( const QString &name );
 
    bool hasVariable( const QString &name ) const;
 
    QVariant variable( const QString &name ) const;
 
    QStringList variableNames() const;
 
    QStringList filteredVariableNames() const;
 
    bool isReadOnly( const QString &name ) const;
 
    bool isStatic( const QString &name ) const;
 
    QString description( const QString &name ) const;
 
    int variableCount() const { return mVariables.count(); }
 
    bool hasFunction( const QString &name ) const;
 
    QgsExpressionFunction *function( const QString &name ) const;
 
    QStringList functionNames() const;
 
    void addFunction( const QString &name, QgsScopedExpressionFunction *function SIP_TRANSFER );
 
    bool hasFeature() const { return mHasFeature; }
 
    QgsFeature feature() const { return mFeature; }
 
    void setFeature( const QgsFeature &feature ) { mHasFeature = true; mFeature = feature; }
 
    void removeFeature() { mHasFeature = false; mFeature = QgsFeature(); }
 
    bool hasGeometry() const { return mHasGeometry; }
 
    QgsGeometry geometry() const { return mGeometry; }
 
    void setGeometry( const QgsGeometry &geometry ) { mHasGeometry = true; mGeometry = geometry; }
 
    void removeGeometry() { mHasGeometry = false; mGeometry = QgsGeometry(); }
 
    void setFields( const QgsFields &fields );
 
    void readXml( const QDomElement &element, const QgsReadWriteContext &context );
 
    bool writeXml( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const;
 
 
    QStringList hiddenVariables() const;
 
    void setHiddenVariables( const QStringList &hiddenVariables );
 
 
    void addHiddenVariable( const QString &hiddenVariable );
 
    void removeHiddenVariable( const QString &hiddenVariable );
 
    void addLayerStore( QgsMapLayerStore *store );
 
    QList< QgsMapLayerStore * > layerStores() const;
 
  private:
    QString mName;
    QHash<QString, StaticVariable> mVariables;
    QHash<QString, QgsScopedExpressionFunction * > mFunctions;
    bool mHasFeature = false;
    QgsFeature mFeature;
    bool mHasGeometry = false;
    QgsGeometry mGeometry;
    QStringList mHiddenVariables;
 
    QList< QPointer< QgsMapLayerStore > > mLayerStores;
};
class CORE_EXPORT QgsExpressionContextScope {…};
 
class CORE_EXPORT QgsExpressionContext
{
  public:
 
    QgsExpressionContext();
 
    explicit QgsExpressionContext( const QList<QgsExpressionContextScope *> &scopes SIP_TRANSFER );
 
    QgsExpressionContext( const QgsExpressionContext &other );
 
    QgsExpressionContext &operator=( const QgsExpressionContext &other ) SIP_SKIP;
 
    QgsExpressionContext &operator=( QgsExpressionContext &&other ) noexcept SIP_SKIP;
 
    ~QgsExpressionContext();
 
    bool hasVariable( const QString &name ) const;
 
    QVariant variable( const QString &name ) const;
 
    QVariantMap variablesToMap() const;
 
    bool isHighlightedVariable( const QString &name ) const;
 
    QStringList highlightedVariables() const;
 
    void setHighlightedVariables( const QStringList &variableNames );
 
    bool isHighlightedFunction( const QString &name ) const;
 
    void setHighlightedFunctions( const QStringList &names );
 
    QgsExpressionContextScope *activeScopeForVariable( const QString &name );
 
    const QgsExpressionContextScope *activeScopeForVariable( const QString &name ) const SIP_SKIP;
 
    QgsExpressionContextScope *scope( int index );
 
    QgsExpressionContextScope *lastScope();
 
    QList< QgsExpressionContextScope * > scopes() { return mStack; }
 
    int indexOfScope( QgsExpressionContextScope *scope ) const;
 
    int indexOfScope( const QString &scopeName ) const;
 
    QStringList variableNames() const;
 
    QStringList filteredVariableNames() const;
 
    bool isReadOnly( const QString &name ) const;
 
    QString description( const QString &name ) const;
 
    bool hasFunction( const QString &name ) const;
 
    QStringList functionNames() const;
 
    QgsExpressionFunction *function( const QString &name ) const;
 
    int scopeCount() const;
 
    void appendScope( QgsExpressionContextScope *scope SIP_TRANSFER );
 
    void appendScopes( const QList<QgsExpressionContextScope *> &scopes SIP_TRANSFER );
 
    QgsExpressionContextScope *popScope();
 
    QList<QgsExpressionContextScope *> takeScopes() SIP_SKIP;
 
    QgsExpressionContext &operator<< ( QgsExpressionContextScope *scope SIP_TRANSFER );
 
    void setFeature( const QgsFeature &feature );
 
    bool hasFeature() const;
 
    QgsFeature feature() const;
 
    void setGeometry( const QgsGeometry &geometry );
 
    bool hasGeometry() const;
 
    QgsGeometry geometry() const;
 
    void setFields( const QgsFields &fields );
 
    QgsFields fields() const;
 
    void setOriginalValueVariable( const QVariant &value );
 
    void setCachedValue( const QString &key, const QVariant &value ) const;
 
    bool hasCachedValue( const QString &key ) const;
 
    QVariant cachedValue( const QString &key ) const;
 
    void clearCachedValues() const;
 
    QList< QgsMapLayerStore * > layerStores() const;
 
    void setLoadedLayerStore( QgsMapLayerStore *store );
 
    QgsMapLayerStore *loadedLayerStore() const;
 
    void setFeedback( QgsFeedback *feedback );
 
    QgsFeedback *feedback() const;
 
    QString uniqueHash( bool &ok SIP_OUT, const QSet<QString> &variables = QSet<QString>() ) const;
 
    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_RING_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;
 
  private:
 
    QList< QgsExpressionContextScope * > mStack;
    QStringList mHighlightedVariables;
    QStringList mHighlightedFunctions;
 
    QgsFeedback *mFeedback = nullptr;
 
    std::unique_ptr< LoadLayerFunction > mLoadLayerFunction;
    QPointer< QgsMapLayerStore > mDestinationStore;
 
    // Cache is mutable because we want to be able to add cached values to const contexts
    mutable QMap< QString, QVariant > mCachedValues;
 
};
class CORE_EXPORT QgsExpressionContext {…};
 
#endif // QGSEXPRESSIONCONTEXT_H