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 <QVariant>
#include <QHash>
#include <QString>
#include <QStringList>
#include <QSet>
#include "qgsexpression.h"

class QgsExpression;
class QgsMapLayer;
class QgsComposition;
class QgsComposerItem;
class QgsAtlasComposition;
class QgsMapSettings;
class QgsSymbolV2;

class CORE_EXPORT QgsScopedExpressionFunction : public QgsExpression::Function
{
  public:
    QgsScopedExpressionFunction( const QString& fnname,
                                 int params,
                                 const QString& group,
                                 const QString& helpText = QString(),
                                 bool usesGeometry = false,
                                 const QStringList& referencedColumns = QStringList(),
                                 bool lazyEval = false,
                                 bool handlesNull = false,
                                 bool isContextual = true )
        : QgsExpression::Function( fnname, params, group, helpText, usesGeometry, referencedColumns, lazyEval, handlesNull, isContextual )
    {}

    virtual ~QgsScopedExpressionFunction() {}

    virtual QVariant func( const QVariantList& values, const QgsExpressionContext* context, QgsExpression* parent ) override = 0;

    virtual QgsScopedExpressionFunction* clone() const = 0;

};


class CORE_EXPORT QgsExpressionContextScope
{
  public:

    struct StaticVariable
    {
      StaticVariable( const QString& name = QString(), const QVariant& value = QVariant(), bool readOnly = false )
          : name( name )
          , value( value )
          , readOnly( readOnly )
      {}

      QString name;

      QVariant value;

      bool readOnly;
    };

    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 );

    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;

    int variableCount() const { return mVariables.count(); }

    bool hasFunction( const QString &name ) const;

    QgsExpression::Function* function( const QString &name ) const;

    QStringList functionNames() const;

    void addFunction( const QString& name, QgsScopedExpressionFunction* function );

    void setFeature( const QgsFeature& feature );

    void setFields( const QgsFields& fields );

  private:
    QString mName;
    QHash<QString, StaticVariable> mVariables;
    QHash<QString, QgsScopedExpressionFunction* > mFunctions;

    bool variableNameSort( const QString &a, const QString &b );
};

class CORE_EXPORT QgsExpressionContext
{
  public:

    QgsExpressionContext() {}

    QgsExpressionContext( const QgsExpressionContext& other );

    QgsExpressionContext& operator=( const QgsExpressionContext& other );

    ~QgsExpressionContext();

    bool hasVariable( const QString& name ) const;

    QVariant variable( const QString& name ) const;

    bool isHighlightedVariable( const QString& name ) const;

    void setHighlightedVariables( const QStringList& variableNames );

    QgsExpressionContextScope* activeScopeForVariable( const QString& name );

    const QgsExpressionContextScope* activeScopeForVariable( const QString& name ) const;

    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;

    bool hasFunction( const QString& name ) const;

    QStringList functionNames() const;

    QgsExpression::Function* function( const QString& name ) const;

    int scopeCount() const;

    void appendScope( QgsExpressionContextScope* scope );

    QgsExpressionContextScope* popScope();

    QgsExpressionContext& operator<< ( QgsExpressionContextScope* scope );

    void setFeature( const QgsFeature& feature );

    QgsFeature feature() 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;

    static const QString EXPR_FIELDS;
    static const QString EXPR_FEATURE;
    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;

  private:

    QList< QgsExpressionContextScope* > mStack;
    QStringList mHighlightedVariables;

    // Cache is mutable because we want to be able to add cached values to const contexts
    mutable QMap< QString, QVariant > mCachedValues;

};

class CORE_EXPORT QgsExpressionContextUtils
{
  public:

    static QgsExpressionContextScope* globalScope();

    static void setGlobalVariable( const QString& name, const QVariant& value );

    static void setGlobalVariables( const QgsStringMap& variables );

    static QgsExpressionContextScope* projectScope();

    static void setProjectVariable( const QString& name, const QVariant& value );

    static void setProjectVariables( const QgsStringMap& variables );

    static QgsExpressionContextScope* layerScope( const QgsMapLayer *layer );

    static void setLayerVariable( QgsMapLayer* layer, const QString& name, const QVariant& value );

    static void setLayerVariables( QgsMapLayer* layer, const QgsStringMap& variables );

    static QgsExpressionContextScope* mapSettingsScope( const QgsMapSettings &mapSettings );

    static QgsExpressionContextScope* updateSymbolScope( const QgsSymbolV2* symbol, QgsExpressionContextScope* symbolScope = nullptr );

    static QgsExpressionContextScope* compositionScope( const QgsComposition *composition );

    static void setCompositionVariable( QgsComposition* composition, const QString& name, const QVariant& value );

    static void setCompositionVariables( QgsComposition* composition, const QgsStringMap& variables );

    static QgsExpressionContextScope* atlasScope( const QgsAtlasComposition* atlas );

    static QgsExpressionContextScope* composerItemScope( const QgsComposerItem *composerItem );

    static void setComposerItemVariable( QgsComposerItem* composerItem, const QString& name, const QVariant& value );

    static void setComposerItemVariables( QgsComposerItem* composerItem, const QgsStringMap& variables );

    static QgsExpressionContext createFeatureBasedContext( const QgsFeature& feature, const QgsFields& fields );

    static void registerContextFunctions();

};

#endif // QGSEXPRESSIONCONTEXT_H