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 "qgsexpressionfunction.h"
#include "qgsfeature.h"
 
#include <QHash>
#include <QPointer>
#include <QSet>
#include <QString>
#include <QStringList>
#include <QVariant>
 
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,
      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 )
    {}
 
    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 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 )
        {}

        QString name;

        QVariant value;

        bool readOnly;

        bool isStatic;

        QString description;
    };

    QgsExpressionContextScope( const QString &name = QString() );
 
    QgsExpressionContextScope( const QgsExpressionContextScope &other );
    SIP_SKIP QgsExpressionContextScope( QgsExpressionContextScope &&other );
 
    QgsExpressionContextScope &operator=( const QgsExpressionContextScope &other );
    QgsExpressionContextScope &operator=( 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 QgsExpressionContext
{
  public:
    QgsExpressionContext();

    explicit QgsExpressionContext( const QList<QgsExpressionContextScope *> &scopes SIP_TRANSFER );
 
    QgsExpressionContext( const QgsExpressionContext &other );
    SIP_SKIP QgsExpressionContext( 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;
};
 
#endif // QGSEXPRESSIONCONTEXT_H