api/3.2/qgsexpressioncontext_8cpp_source.html

 /***************************************************************************
      qgsexpressioncontext.cpp
      ------------------------
     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.                                   *
  *                                                                         *
  ***************************************************************************/

 #include "qgsexpressioncontext.h"

 #include "qgslogger.h"
 #include "qgsexpression.h"
 #include "qgsexpressionfunction.h"
 #include "qgsfields.h"
 #include "qgsvectorlayer.h"
 #include "qgsproject.h"
 #include "qgssymbollayerutils.h"
 #include "qgsgeometry.h"
 #include "qgsapplication.h"
 #include "qgsmapsettings.h"
 #include "qgsmaplayerlistutils.h"
 #include "qgsprocessingcontext.h"
 #include "qgsprocessingalgorithm.h"
 #include "qgslayoutatlas.h"
 #include "qgslayout.h"
 #include "qgslayoutpagecollection.h"
 #include "qgslayoutreportcontext.h"

 #include <QSettings>
 #include <QDir>


 const QString QgsExpressionContext::EXPR_FIELDS( QStringLiteral( "_fields_" ) );
 const QString QgsExpressionContext::EXPR_ORIGINAL_VALUE( QStringLiteral( "value" ) );
 const QString QgsExpressionContext::EXPR_SYMBOL_COLOR( QStringLiteral( "symbol_color" ) );
 const QString QgsExpressionContext::EXPR_SYMBOL_ANGLE( QStringLiteral( "symbol_angle" ) );
 const QString QgsExpressionContext::EXPR_GEOMETRY_PART_COUNT( QStringLiteral( "geometry_part_count" ) );
 const QString QgsExpressionContext::EXPR_GEOMETRY_PART_NUM( QStringLiteral( "geometry_part_num" ) );
 const QString QgsExpressionContext::EXPR_GEOMETRY_POINT_COUNT( QStringLiteral( "geometry_point_count" ) );
 const QString QgsExpressionContext::EXPR_GEOMETRY_POINT_NUM( QStringLiteral( "geometry_point_num" ) );
 const QString QgsExpressionContext::EXPR_CLUSTER_SIZE( QStringLiteral( "cluster_size" ) );
 const QString QgsExpressionContext::EXPR_CLUSTER_COLOR( QStringLiteral( "cluster_color" ) );

 //
 // QgsExpressionContextScope
 //

 QgsExpressionContextScope::QgsExpressionContextScope( const QString &name )
   : mName( name )
 {

 }

 QgsExpressionContextScope::QgsExpressionContextScope( const QgsExpressionContextScope &other )
   : mName( other.mName )
   , mVariables( other.mVariables )
   , mHasFeature( other.mHasFeature )
   , mFeature( other.mFeature )
 {
   QHash<QString, QgsScopedExpressionFunction * >::const_iterator it = other.mFunctions.constBegin();
   for ( ; it != other.mFunctions.constEnd(); ++it )
   {
     mFunctions.insert( it.key(), it.value()->clone() );
   }
 }

 QgsExpressionContextScope &QgsExpressionContextScope::operator=( const QgsExpressionContextScope &other )
 {
   mName = other.mName;
   mVariables = other.mVariables;
   mHasFeature = other.mHasFeature;
   mFeature = other.mFeature;

   qDeleteAll( mFunctions );
   mFunctions.clear();
   QHash<QString, QgsScopedExpressionFunction * >::const_iterator it = other.mFunctions.constBegin();
   for ( ; it != other.mFunctions.constEnd(); ++it )
   {
     mFunctions.insert( it.key(), it.value()->clone() );
   }

   return *this;
 }

 QgsExpressionContextScope::~QgsExpressionContextScope()
 {
   qDeleteAll( mFunctions );
 }

 void QgsExpressionContextScope::setVariable( const QString &name, const QVariant &value, bool isStatic )
 {
   if ( mVariables.contains( name ) )
   {
     StaticVariable existing = mVariables.value( name );
     existing.value = value;
     existing.isStatic = isStatic;
     addVariable( existing );
   }
   else
   {
     addVariable( QgsExpressionContextScope::StaticVariable( name, value, false, isStatic ) );
   }
 }

 void QgsExpressionContextScope::addVariable( const QgsExpressionContextScope::StaticVariable &variable )
 {
   mVariables.insert( variable.name, variable );
 }

 bool QgsExpressionContextScope::removeVariable( const QString &name )
 {
   return mVariables.remove( name ) > 0;
 }

 bool QgsExpressionContextScope::hasVariable( const QString &name ) const
 {
   return mVariables.contains( name );
 }

 QVariant QgsExpressionContextScope::variable( const QString &name ) const
 {
   return hasVariable( name ) ? mVariables.value( name ).value : QVariant();
 }

 QStringList QgsExpressionContextScope::variableNames() const
 {
   QStringList names = mVariables.keys();
   return names;
 }

 bool QgsExpressionContextScope::variableNameSort( const QString &a, const QString &b )
 {
   return QString::localeAwareCompare( a, b ) < 0;
 }

 class QgsExpressionContextVariableCompare
 {
   public:
     explicit QgsExpressionContextVariableCompare( const QgsExpressionContextScope &scope )
       : mScope( scope )
     {  }

     bool operator()( const QString &a, const QString &b ) const
     {
       bool aReadOnly = mScope.isReadOnly( a );
       bool bReadOnly = mScope.isReadOnly( b );
       if ( aReadOnly != bReadOnly )
         return aReadOnly;
       return QString::localeAwareCompare( a, b ) < 0;
     }

   private:
     const QgsExpressionContextScope &mScope;
 };

 QStringList QgsExpressionContextScope::filteredVariableNames() const
 {
   QStringList allVariables = mVariables.keys();
   QStringList filtered;
   Q_FOREACH ( const QString &variable, allVariables )
   {
     if ( variable.startsWith( '_' ) )
       continue;

     filtered << variable;
   }
   QgsExpressionContextVariableCompare cmp( *this );
   std::sort( filtered.begin(), filtered.end(), cmp );

   return filtered;
 }

 bool QgsExpressionContextScope::isReadOnly( const QString &name ) const
 {
   return hasVariable( name ) ? mVariables.value( name ).readOnly : false;
 }

 bool QgsExpressionContextScope::isStatic( const QString &name ) const
 {
   return hasVariable( name ) ? mVariables.value( name ).isStatic : false;
 }

 QString QgsExpressionContextScope::description( const QString &name ) const
 {
   return hasVariable( name ) ? mVariables.value( name ).description : QString();
 }

 bool QgsExpressionContextScope::hasFunction( const QString &name ) const
 {
   return mFunctions.contains( name );
 }

 QgsExpressionFunction *QgsExpressionContextScope::function( const QString &name ) const
 {
   return mFunctions.contains( name ) ? mFunctions.value( name ) : nullptr;
 }

 QStringList QgsExpressionContextScope::functionNames() const
 {
   return mFunctions.keys();
 }

 void QgsExpressionContextScope::addFunction( const QString &name, QgsScopedExpressionFunction *function )
 {
   mFunctions.insert( name, function );
 }


 void QgsExpressionContextScope::setFields( const QgsFields &fields )
 {
   addVariable( StaticVariable( QgsExpressionContext::EXPR_FIELDS, QVariant::fromValue( fields ), true ) );
 }


 //
 // QgsExpressionContext
 //

 QgsExpressionContext::QgsExpressionContext( const QList<QgsExpressionContextScope *> &scopes )
   : mStack( scopes )
 {
 }

 QgsExpressionContext::QgsExpressionContext( const QgsExpressionContext &other )
 {
   Q_FOREACH ( const QgsExpressionContextScope *scope, other.mStack )
   {
     mStack << new QgsExpressionContextScope( *scope );
   }
   mHighlightedVariables = other.mHighlightedVariables;
   mCachedValues = other.mCachedValues;
 }

 QgsExpressionContext &QgsExpressionContext::operator=( QgsExpressionContext &&other ) noexcept
 {
   if ( this != &other )
   {
     qDeleteAll( mStack );
     // move the stack over
     mStack = other.mStack;
     other.mStack.clear();

     mHighlightedVariables = other.mHighlightedVariables;
     mCachedValues = other.mCachedValues;
   }
   return *this;
 }

 QgsExpressionContext &QgsExpressionContext::operator=( const QgsExpressionContext &other )
 {
   qDeleteAll( mStack );
   mStack.clear();
   Q_FOREACH ( const QgsExpressionContextScope *scope, other.mStack )
   {
     mStack << new QgsExpressionContextScope( *scope );
   }
   mHighlightedVariables = other.mHighlightedVariables;
   mCachedValues = other.mCachedValues;
   return *this;
 }

 QgsExpressionContext::~QgsExpressionContext()
 {
   qDeleteAll( mStack );
   mStack.clear();
 }

 bool QgsExpressionContext::hasVariable( const QString &name ) const
 {
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     if ( scope->hasVariable( name ) )
       return true;
   }
   return false;
 }

 QVariant QgsExpressionContext::variable( const QString &name ) const
 {
   const QgsExpressionContextScope *scope = activeScopeForVariable( name );
   return scope ? scope->variable( name ) : QVariant();
 }

 QVariantMap QgsExpressionContext::variablesToMap() const
 {
   QStringList names = variableNames();
   QVariantMap m;
   Q_FOREACH ( const QString &name, names )
   {
     m.insert( name, variable( name ) );
   }
   return m;
 }

 bool QgsExpressionContext::isHighlightedVariable( const QString &name ) const
 {
   return mHighlightedVariables.contains( name );
 }

 void QgsExpressionContext::setHighlightedVariables( const QStringList &variableNames )
 {
   mHighlightedVariables = variableNames;
 }

 const QgsExpressionContextScope *QgsExpressionContext::activeScopeForVariable( const QString &name ) const
 {
   //iterate through stack backwards, so that higher priority variables take precedence
   QList< QgsExpressionContextScope * >::const_iterator it = mStack.constEnd();
   while ( it != mStack.constBegin() )
   {
     --it;
     if ( ( *it )->hasVariable( name ) )
       return ( *it );
   }
   return nullptr;
 }

 QgsExpressionContextScope *QgsExpressionContext::activeScopeForVariable( const QString &name )
 {
   //iterate through stack backwards, so that higher priority variables take precedence
   QList< QgsExpressionContextScope * >::const_iterator it = mStack.constEnd();
   while ( it != mStack.constBegin() )
   {
     --it;
     if ( ( *it )->hasVariable( name ) )
       return ( *it );
   }
   return nullptr;
 }

 QgsExpressionContextScope *QgsExpressionContext::scope( int index )
 {
   if ( index < 0 || index >= mStack.count() )
     return nullptr;

   return mStack.at( index );
 }

 QgsExpressionContextScope *QgsExpressionContext::lastScope()
 {
   if ( mStack.count() < 1 )
     return nullptr;

   return mStack.last();
 }

 int QgsExpressionContext::indexOfScope( QgsExpressionContextScope *scope ) const
 {
   if ( !scope )
     return -1;

   return mStack.indexOf( scope );
 }

 int QgsExpressionContext::indexOfScope( const QString &scopeName ) const
 {
   int index = 0;
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     if ( scope->name() == scopeName )
       return index;

     index++;
   }
   return -1;
 }

 QStringList QgsExpressionContext::variableNames() const
 {
   QStringList names;
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     names << scope->variableNames();
   }
   return names.toSet().toList();
 }

 QStringList QgsExpressionContext::filteredVariableNames() const
 {
   QStringList allVariables = variableNames();
   QStringList filtered;
   Q_FOREACH ( const QString &variable, allVariables )
   {
     if ( variable.startsWith( '_' ) )
       continue;

     filtered << variable;
   }

   filtered.sort();
   return filtered;
 }

 bool QgsExpressionContext::isReadOnly( const QString &name ) const
 {
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     if ( scope->isReadOnly( name ) )
       return true;
   }
   return false;
 }

 QString QgsExpressionContext::description( const QString &name ) const
 {
   const QgsExpressionContextScope *scope = activeScopeForVariable( name );
   return ( scope && !scope->description( name ).isEmpty() ) ? scope->description( name ) : QgsExpression::variableHelpText( name );
 }

 bool QgsExpressionContext::hasFunction( const QString &name ) const
 {
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     if ( scope->hasFunction( name ) )
       return true;
   }
   return false;
 }

 QStringList QgsExpressionContext::functionNames() const
 {
   QStringList result;
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     result << scope->functionNames();
   }
   result = result.toSet().toList();
   result.sort();
   return result;
 }

 QgsExpressionFunction *QgsExpressionContext::function( const QString &name ) const
 {
   //iterate through stack backwards, so that higher priority variables take precedence
   QList< QgsExpressionContextScope * >::const_iterator it = mStack.constEnd();
   while ( it != mStack.constBegin() )
   {
     --it;
     if ( ( *it )->hasFunction( name ) )
       return ( *it )->function( name );
   }
   return nullptr;
 }

 int QgsExpressionContext::scopeCount() const
 {
   return mStack.count();
 }

 void QgsExpressionContext::appendScope( QgsExpressionContextScope *scope )
 {
   mStack.append( scope );
 }

 void QgsExpressionContext::appendScopes( const QList<QgsExpressionContextScope *> &scopes )
 {
   mStack.append( scopes );
 }

 QgsExpressionContextScope *QgsExpressionContext::popScope()
 {
   if ( !mStack.isEmpty() )
     return mStack.takeLast();

   return nullptr;
 }

 QList<QgsExpressionContextScope *> QgsExpressionContext::takeScopes()
 {
   QList<QgsExpressionContextScope *> stack = mStack;
   mStack.clear();
   return stack;
 }

 QgsExpressionContext &QgsExpressionContext::operator<<( QgsExpressionContextScope *scope )
 {
   mStack.append( scope );
   return *this;
 }

 void QgsExpressionContext::setFeature( const QgsFeature &feature )
 {
   if ( mStack.isEmpty() )
     mStack.append( new QgsExpressionContextScope() );

   mStack.last()->setFeature( feature );
 }

 bool QgsExpressionContext::hasFeature() const
 {
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     if ( scope->hasFeature() )
       return true;
   }
   return false;
 }

 QgsFeature QgsExpressionContext::feature() const
 {
   //iterate through stack backwards, so that higher priority variables take precedence
   QList< QgsExpressionContextScope * >::const_iterator it = mStack.constEnd();
   while ( it != mStack.constBegin() )
   {
     --it;
     if ( ( *it )->hasFeature() )
       return ( *it )->feature();
   }
   return QgsFeature();
 }

 void QgsExpressionContext::setFields( const QgsFields &fields )
 {
   if ( mStack.isEmpty() )
     mStack.append( new QgsExpressionContextScope() );

   mStack.last()->setFields( fields );
 }

 QgsFields QgsExpressionContext::fields() const
 {
   return qvariant_cast<QgsFields>( variable( QgsExpressionContext::EXPR_FIELDS ) );
 }

 void QgsExpressionContext::setOriginalValueVariable( const QVariant &value )
 {
   if ( mStack.isEmpty() )
     mStack.append( new QgsExpressionContextScope() );

   mStack.last()->addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_ORIGINAL_VALUE,
                               value, true ) );
 }

 void QgsExpressionContext::setCachedValue( const QString &key, const QVariant &value ) const
 {
   mCachedValues.insert( key, value );
 }

 bool QgsExpressionContext::hasCachedValue( const QString &key ) const
 {
   return mCachedValues.contains( key );
 }

 QVariant QgsExpressionContext::cachedValue( const QString &key ) const
 {
   return mCachedValues.value( key, QVariant() );
 }

 void QgsExpressionContext::clearCachedValues() const
 {
   mCachedValues.clear();
 }


 //
 // QgsExpressionContextUtils
 //

 QgsExpressionContextScope *QgsExpressionContextUtils::globalScope()
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Global" ) );

   QVariantMap customVariables = QgsApplication::customVariables();

   for ( QVariantMap::const_iterator it = customVariables.constBegin(); it != customVariables.constEnd(); ++it )
   {
     scope->setVariable( it.key(), it.value(), true );
   }

   //add some extra global variables
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_version" ), Qgis::QGIS_VERSION, true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_version_no" ), Qgis::QGIS_VERSION_INT, true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_short_version" ), QStringLiteral( "%1.%2" ).arg( Qgis::QGIS_VERSION_INT / 10000 ).arg( Qgis::QGIS_VERSION_INT / 100 % 100 ), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_release_name" ), Qgis::QGIS_RELEASE_NAME, true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_platform" ), QgsApplication::platform(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_os_name" ), QgsApplication::osName(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_locale" ), QgsApplication::locale(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "user_account_name" ), QgsApplication::userLoginName(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "user_full_name" ), QgsApplication::userFullName(), true, true ) );

   return scope;
 }

 void QgsExpressionContextUtils::setGlobalVariable( const QString &name, const QVariant &value )
 {
   QgsApplication::setCustomVariable( name, value );
 }

 void QgsExpressionContextUtils::setGlobalVariables( const QVariantMap &variables )
 {
   QgsApplication::setCustomVariables( variables );
 }

 void QgsExpressionContextUtils::removeGlobalVariable( const QString &name )
 {
   QVariantMap vars = QgsApplication::customVariables();
   if ( vars.remove( name ) )
     QgsApplication::setCustomVariables( vars );
 }


 class GetNamedProjectColor : public QgsScopedExpressionFunction
 {
   public:
     GetNamedProjectColor( const QgsProject *project )
       : QgsScopedExpressionFunction( QStringLiteral( "project_color" ), 1, QStringLiteral( "Color" ) )
       , mProject( project )
     {
       if ( !project )
         return;

       //build up color list from project. Do this in advance for speed
       QStringList colorStrings = project->readListEntry( QStringLiteral( "Palette" ), QStringLiteral( "/Colors" ) );
       QStringList colorLabels = project->readListEntry( QStringLiteral( "Palette" ), QStringLiteral( "/Labels" ) );

       //generate list from custom colors
       int colorIndex = 0;
       for ( QStringList::iterator it = colorStrings.begin();
             it != colorStrings.end(); ++it )
       {
         QColor color = QgsSymbolLayerUtils::decodeColor( *it );
         QString label;
         if ( colorLabels.length() > colorIndex )
         {
           label = colorLabels.at( colorIndex );
         }

         mColors.insert( label.toLower(), color );
         colorIndex++;
       }
     }

     QVariant func( const QVariantList &values, const QgsExpressionContext *, QgsExpression *, const QgsExpressionNodeFunction * ) override
     {
       QString colorName = values.at( 0 ).toString().toLower();
       if ( mColors.contains( colorName ) )
       {
         return QStringLiteral( "%1,%2,%3" ).arg( mColors.value( colorName ).red() ).arg( mColors.value( colorName ).green() ).arg( mColors.value( colorName ).blue() );
       }
       else
         return QVariant();
     }

     QgsScopedExpressionFunction *clone() const override
     {
       return new GetNamedProjectColor( mProject );
     }

   private:

     const QgsProject *mProject = nullptr;
     QHash< QString, QColor > mColors;

 };

 class GetLayoutItemVariables : public QgsScopedExpressionFunction
 {
   public:
     GetLayoutItemVariables( const QgsLayout *c )
       : QgsScopedExpressionFunction( QStringLiteral( "item_variables" ), QgsExpressionFunction::ParameterList() << QgsExpressionFunction::Parameter( QStringLiteral( "id" ) ), QStringLiteral( "Layout" ) )
       , mLayout( c )
     {}

     QVariant func( const QVariantList &values, const QgsExpressionContext *, QgsExpression *, const QgsExpressionNodeFunction * ) override
     {
       if ( !mLayout )
         return QVariant();

       QString id = values.at( 0 ).toString();

       const QgsLayoutItem *item = mLayout->itemById( id );
       if ( !item )
         return QVariant();

       QgsExpressionContext c = item->createExpressionContext();

       return c.variablesToMap();
     }

     QgsScopedExpressionFunction *clone() const override
     {
       return new GetLayoutItemVariables( mLayout );
     }

   private:

     const QgsLayout *mLayout = nullptr;

 };

 class GetLayerVisibility : public QgsScopedExpressionFunction
 {
   public:
     GetLayerVisibility( const QList<QgsMapLayer *> &layers )
       : QgsScopedExpressionFunction( QStringLiteral( "is_layer_visible" ), QgsExpressionFunction::ParameterList() << QgsExpressionFunction::Parameter( QStringLiteral( "id" ) ), QStringLiteral( "General" ) )
       , mLayers( layers )
     {}

     QVariant func( const QVariantList &values, const QgsExpressionContext *, QgsExpression *, const QgsExpressionNodeFunction * ) override
     {
       if ( mLayers.isEmpty() )
       {
         return QVariant( false );
       }

       QgsMapLayer *layer = _qgis_findLayer( mLayers, values.at( 0 ).toString() );
       if ( layer )
       {
         return QVariant( true );
       }
       else
       {
         return QVariant( false );
       }
     }

     QgsScopedExpressionFunction *clone() const override
     {
       return new GetLayerVisibility( mLayers );
     }

   private:

     const QList<QgsMapLayer *> mLayers;

 };


 class GetCurrentFormFieldValue : public QgsScopedExpressionFunction
 {
   public:
     GetCurrentFormFieldValue( )
       : QgsScopedExpressionFunction( QStringLiteral( "current_value" ), QgsExpressionFunction::ParameterList() << QStringLiteral( "field_name" ), QStringLiteral( "Form" ) )
     {}

     QVariant func( const QVariantList &values, const QgsExpressionContext *context, QgsExpression *, const QgsExpressionNodeFunction * ) override
     {
       QString fieldName( values.at( 0 ).toString() );
       const QgsFeature feat( context->variable( QStringLiteral( "current_feature" ) ).value<QgsFeature>() );
       if ( fieldName.isEmpty() || ! feat.isValid( ) )
       {
         return QVariant();
       }
       return feat.attribute( fieldName ) ;
     }

     QgsScopedExpressionFunction *clone() const override
     {
       return new GetCurrentFormFieldValue( );
     }

 };


 class GetProcessingParameterValue : public QgsScopedExpressionFunction
 {
   public:
     GetProcessingParameterValue( const QVariantMap &params )
       : QgsScopedExpressionFunction( QStringLiteral( "parameter" ), QgsExpressionFunction::ParameterList() << QgsExpressionFunction::Parameter( QStringLiteral( "name" ) ), QStringLiteral( "Processing" ) )
       , mParams( params )
     {}

     QVariant func( const QVariantList &values, const QgsExpressionContext *, QgsExpression *, const QgsExpressionNodeFunction * ) override
     {
       return mParams.value( values.at( 0 ).toString() );
     }

     QgsScopedExpressionFunction *clone() const override
     {
       return new GetProcessingParameterValue( mParams );
     }

   private:

     const QVariantMap mParams;

 };


 QgsExpressionContextScope *QgsExpressionContextUtils::formScope( const QgsFeature &formFeature )
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Form" ) );
   scope->addFunction( QStringLiteral( "current_value" ), new GetCurrentFormFieldValue( ) );
   scope->setVariable( QStringLiteral( "current_geometry" ), formFeature.geometry( ), true );
   scope->setVariable( QStringLiteral( "current_feature" ), formFeature, true );
   return scope;
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::projectScope( const QgsProject *project )
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Project" ) );

   if ( !project )
     return scope;

   const QVariantMap vars = project->customVariables();

   QVariantMap::const_iterator it = vars.constBegin();

   for ( ; it != vars.constEnd(); ++it )
   {
     scope->setVariable( it.key(), it.value(), true );
   }

   QString projectPath = project->projectStorage() ? project->fileName() : project->absoluteFilePath();
   QString projectFolder = QFileInfo( projectPath ).path();
   QString projectFilename = QFileInfo( projectPath ).fileName();
   QString projectBasename = project->baseName();

   //add other known project variables
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_title" ), project->title(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_path" ), QDir::toNativeSeparators( projectPath ), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_folder" ), QDir::toNativeSeparators( projectFolder ), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_filename" ), projectFilename, true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_basename" ), projectBasename, true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_home" ), QDir::toNativeSeparators( project->homePath() ), true, true ) );
   QgsCoordinateReferenceSystem projectCrs = project->crs();
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_crs" ), projectCrs.authid(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_crs_definition" ), projectCrs.toProj4(), true, true ) );

   // metadata
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_author" ), project->metadata().author(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_abstract" ), project->metadata().abstract(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_creation_date" ), project->metadata().creationDateTime(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_identifier" ), project->metadata().identifier(), true, true ) );

   // keywords
   QVariantMap keywords;
   QgsAbstractMetadataBase::KeywordMap metadataKeywords = project->metadata().keywords();
   for ( auto it = metadataKeywords.constBegin(); it != metadataKeywords.constEnd(); ++it )
   {
     keywords.insert( it.key(), it.value() );
   }
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_keywords" ), keywords, true, true ) );

   scope->addFunction( QStringLiteral( "project_color" ), new GetNamedProjectColor( project ) );
   return scope;
 }

 void QgsExpressionContextUtils::setProjectVariable( QgsProject *project, const QString &name, const QVariant &value )
 {
   if ( !project )
     return;

   QVariantMap vars = project->customVariables();

   vars.insert( name, value );

   project->setCustomVariables( vars );
 }

 void QgsExpressionContextUtils::setProjectVariables( QgsProject *project, const QVariantMap &variables )
 {
   if ( !project )
     return;

   project->setCustomVariables( variables );
 }

 void QgsExpressionContextUtils::removeProjectVariable( QgsProject *project, const QString &name )
 {
   if ( !project )
   {
     return;
   }

   QVariantMap vars = project->customVariables();
   if ( vars.remove( name ) )
     project->setCustomVariables( vars );
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::layerScope( const QgsMapLayer *layer )
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Layer" ) );

   if ( !layer )
     return scope;

   //add variables defined in layer properties
   QStringList variableNames = layer->customProperty( QStringLiteral( "variableNames" ) ).toStringList();
   QStringList variableValues = layer->customProperty( QStringLiteral( "variableValues" ) ).toStringList();

   int varIndex = 0;
   Q_FOREACH ( const QString &variableName, variableNames )
   {
     if ( varIndex >= variableValues.length() )
     {
       break;
     }

     QVariant varValue = variableValues.at( varIndex );
     varIndex++;
     scope->setVariable( variableName, varValue, true );
   }

   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layer_name" ), layer->name(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layer_id" ), layer->id(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layer" ), QVariant::fromValue<QgsWeakMapLayerPointer >( QgsWeakMapLayerPointer( const_cast<QgsMapLayer *>( layer ) ) ), true, true ) );

   const QgsVectorLayer *vLayer = qobject_cast< const QgsVectorLayer * >( layer );
   if ( vLayer )
   {
     scope->setFields( vLayer->fields() );
   }

   //TODO - add functions. Possibilities include:
   //is_selected
   //field summary stats

   return scope;
 }

 QList<QgsExpressionContextScope *> QgsExpressionContextUtils::globalProjectLayerScopes( const QgsMapLayer *layer )
 {
   QList<QgsExpressionContextScope *> scopes;
   scopes << globalScope();

   QgsProject *project = QgsProject::instance();  // TODO: use project associated with layer
   if ( project )
     scopes << projectScope( project );

   if ( layer )
     scopes << layerScope( layer );
   return scopes;
 }


 void QgsExpressionContextUtils::setLayerVariable( QgsMapLayer *layer, const QString &name, const QVariant &value )
 {
   if ( !layer )
     return;

   //write variable to layer
   QStringList variableNames = layer->customProperty( QStringLiteral( "variableNames" ) ).toStringList();
   QStringList variableValues = layer->customProperty( QStringLiteral( "variableValues" ) ).toStringList();

   variableNames << name;
   variableValues << value.toString();

   layer->setCustomProperty( QStringLiteral( "variableNames" ), variableNames );
   layer->setCustomProperty( QStringLiteral( "variableValues" ), variableValues );
 }

 void QgsExpressionContextUtils::setLayerVariables( QgsMapLayer *layer, const QVariantMap &variables )
 {
   if ( !layer )
     return;

   QStringList variableNames;
   QStringList variableValues;

   QVariantMap::const_iterator it = variables.constBegin();
   for ( ; it != variables.constEnd(); ++it )
   {
     variableNames << it.key();
     variableValues << it.value().toString();
   }

   layer->setCustomProperty( QStringLiteral( "variableNames" ), variableNames );
   layer->setCustomProperty( QStringLiteral( "variableValues" ), variableValues );
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::mapSettingsScope( const QgsMapSettings &mapSettings )
 {
   // IMPORTANT: ANY CHANGES HERE ALSO NEED TO BE MADE TO QgsLayoutItemMap::createExpressionContext()
   // (rationale is described in QgsLayoutItemMap::createExpressionContext() )

   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Map Settings" ) );

   //add known map settings context variables
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_id" ), "canvas", true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_rotation" ), mapSettings.rotation(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_scale" ), mapSettings.scale(), true ) );
   QgsGeometry extent = QgsGeometry::fromRect( mapSettings.visibleExtent() );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_extent" ), QVariant::fromValue( extent ), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_extent_width" ), mapSettings.visibleExtent().width(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_extent_height" ), mapSettings.visibleExtent().height(), true ) );
   QgsGeometry centerPoint = QgsGeometry::fromPointXY( mapSettings.visibleExtent().center() );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_extent_center" ), QVariant::fromValue( centerPoint ), true ) );

   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_crs" ), mapSettings.destinationCrs().authid(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_crs_definition" ), mapSettings.destinationCrs().toProj4(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_units" ), QgsUnitTypes::toString( mapSettings.mapUnits() ), true ) );

   scope->addFunction( QStringLiteral( "is_layer_visible" ), new GetLayerVisibility( mapSettings.layers() ) );

   return scope;
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::mapToolCaptureScope( const QList<QgsPointLocator::Match> &matches )
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Map Tool Capture" ) );

   QVariantList matchList;

   for ( const QgsPointLocator::Match &match : matches )
   {
     QVariantMap matchMap;

     matchMap.insert( QStringLiteral( "valid" ), match.isValid() );
     matchMap.insert( QStringLiteral( "layer" ), QVariant::fromValue<QgsWeakMapLayerPointer>( QgsWeakMapLayerPointer( match.layer() ) ) );
     matchMap.insert( QStringLiteral( "feature_id" ), match.featureId() );
     matchMap.insert( QStringLiteral( "vertex_index" ), match.vertexIndex() );
     matchMap.insert( QStringLiteral( "distance" ), match.distance() );

     matchList.append( matchMap );
   }

   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "snapping_results" ), matchList ) );

   return scope;
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::updateSymbolScope( const QgsSymbol *symbol, QgsExpressionContextScope *symbolScope )
 {
   if ( !symbolScope )
     return nullptr;

   symbolScope->addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_SYMBOL_COLOR, symbol ? symbol->color() : QColor(), true ) );

   double angle = 0.0;
   const QgsMarkerSymbol *markerSymbol = dynamic_cast< const QgsMarkerSymbol * >( symbol );
   if ( markerSymbol )
   {
     angle = markerSymbol->angle();
   }
   symbolScope->addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_SYMBOL_ANGLE, angle, true ) );

   return symbolScope;
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::layoutScope( const QgsLayout *layout )
 {
   std::unique_ptr< QgsExpressionContextScope > scope( new QgsExpressionContextScope( QObject::tr( "Layout" ) ) );
   if ( !layout )
     return scope.release();

   //add variables defined in layout properties
   QStringList variableNames = layout->customProperty( QStringLiteral( "variableNames" ) ).toStringList();
   QStringList variableValues = layout->customProperty( QStringLiteral( "variableValues" ) ).toStringList();

   int varIndex = 0;
   Q_FOREACH ( const QString &variableName, variableNames )
   {
     if ( varIndex >= variableValues.length() )
     {
       break;
     }

     QVariant varValue = variableValues.at( varIndex );
     varIndex++;
     scope->setVariable( variableName, varValue );
   }

   //add known layout context variables
   if ( const QgsMasterLayoutInterface *l = dynamic_cast< const QgsMasterLayoutInterface * >( layout ) )
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_name" ), l->name(), true ) );

   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_numpages" ), layout->pageCollection()->pageCount(), true ) );
   if ( layout->pageCollection()->pageCount() > 0 )
   {
     // just take first page size
     QSizeF s = layout->pageCollection()->page( 0 )->sizeWithUnits().toQSizeF();
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_pageheight" ), s.height(), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_pagewidth" ), s.width(), true ) );
   }
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_dpi" ), layout->renderContext().dpi(), true ) );

   scope->addFunction( QStringLiteral( "item_variables" ), new GetLayoutItemVariables( layout ) );

   if ( layout->reportContext().layer() )
   {
     scope->setFields( layout->reportContext().layer()->fields() );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_layerid" ), layout->reportContext().layer()->id(), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_layername" ), layout->reportContext().layer()->name(), true ) );
   }

   if ( layout->reportContext().feature().isValid() )
   {
     QgsFeature atlasFeature = layout->reportContext().feature();
     scope->setFeature( atlasFeature );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_feature" ), QVariant::fromValue( atlasFeature ), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_featureid" ), atlasFeature.id(), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_geometry" ), QVariant::fromValue( atlasFeature.geometry() ), true ) );
   }

   return scope.release();
 }

 void QgsExpressionContextUtils::setLayoutVariable( QgsLayout *layout, const QString &name, const QVariant &value )
 {
   if ( !layout )
     return;

   //write variable to layout
   QStringList variableNames = layout->customProperty( QStringLiteral( "variableNames" ) ).toStringList();
   QStringList variableValues = layout->customProperty( QStringLiteral( "variableValues" ) ).toStringList();

   variableNames << name;
   variableValues << value.toString();

   layout->setCustomProperty( QStringLiteral( "variableNames" ), variableNames );
   layout->setCustomProperty( QStringLiteral( "variableValues" ), variableValues );
 }

 void QgsExpressionContextUtils::setLayoutVariables( QgsLayout *layout, const QVariantMap &variables )
 {
   if ( !layout )
     return;

   QStringList variableNames;
   QStringList variableValues;

   QVariantMap::const_iterator it = variables.constBegin();
   for ( ; it != variables.constEnd(); ++it )
   {
     variableNames << it.key();
     variableValues << it.value().toString();
   }

   layout->setCustomProperty( QStringLiteral( "variableNames" ), variableNames );
   layout->setCustomProperty( QStringLiteral( "variableValues" ), variableValues );
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::atlasScope( QgsLayoutAtlas *atlas )
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Atlas" ) );
   if ( !atlas )
   {
     //add some dummy atlas variables. This is done so that as in certain contexts we want to show
     //users that these variables are available even if they have no current value
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_pagename" ), QString(), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_feature" ), QVariant::fromValue( QgsFeature() ), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_featureid" ), 0, true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_geometry" ), QVariant::fromValue( QgsGeometry() ), true ) );
     return scope;
   }

   //add known atlas variables
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_totalfeatures" ), atlas->count(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_featurenumber" ), atlas->currentFeatureNumber() + 1, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_filename" ), atlas->currentFilename(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_pagename" ), atlas->nameForPage( atlas->currentFeatureNumber() ), true ) );

   if ( atlas->enabled() && atlas->coverageLayer() )
   {
     scope->setFields( atlas->coverageLayer()->fields() );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_layerid" ), atlas->coverageLayer()->id(), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_layername" ), atlas->coverageLayer()->name(), true ) );
   }

   if ( atlas->enabled() )
   {
     QgsFeature atlasFeature = atlas->layout()->reportContext().feature();
     scope->setFeature( atlasFeature );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_feature" ), QVariant::fromValue( atlasFeature ), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_featureid" ), atlasFeature.id(), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_geometry" ), QVariant::fromValue( atlasFeature.geometry() ), true ) );
   }

   return scope;
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::layoutItemScope( const QgsLayoutItem *item )
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Layout Item" ) );
   if ( !item )
     return scope;

   //add variables defined in layout item properties
   const QStringList variableNames = item->customProperty( QStringLiteral( "variableNames" ) ).toStringList();
   const QStringList variableValues = item->customProperty( QStringLiteral( "variableValues" ) ).toStringList();

   int varIndex = 0;
   for ( const QString &variableName : variableNames )
   {
     if ( varIndex >= variableValues.length() )
     {
       break;
     }

     QVariant varValue = variableValues.at( varIndex );
     varIndex++;
     scope->setVariable( variableName, varValue );
   }

   //add known layout item context variables
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "item_id" ), item->id(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "item_uuid" ), item->uuid(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_page" ), item->page() + 1, true ) );

   if ( item->layout() )
   {
     const QgsLayoutItemPage *page = item->layout()->pageCollection()->page( item->page() );
     if ( page )
     {
       const QSizeF s = page->sizeWithUnits().toQSizeF();
       scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_pageheight" ), s.height(), true ) );
       scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_pagewidth" ), s.width(), true ) );
     }
     else
     {
       scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_pageheight" ), QVariant(), true ) );
       scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_pagewidth" ), QVariant(), true ) );
     }
   }

   return scope;
 }

 void QgsExpressionContextUtils::setLayoutItemVariable( QgsLayoutItem *item, const QString &name, const QVariant &value )
 {
   if ( !item )
     return;

   //write variable to layout item
   QStringList variableNames = item->customProperty( QStringLiteral( "variableNames" ) ).toStringList();
   QStringList variableValues = item->customProperty( QStringLiteral( "variableValues" ) ).toStringList();

   variableNames << name;
   variableValues << value.toString();

   item->setCustomProperty( QStringLiteral( "variableNames" ), variableNames );
   item->setCustomProperty( QStringLiteral( "variableValues" ), variableValues );
 }

 void QgsExpressionContextUtils::setLayoutItemVariables( QgsLayoutItem *item, const QVariantMap &variables )
 {
   if ( !item )
     return;

   QStringList variableNames;
   QStringList variableValues;

   QVariantMap::const_iterator it = variables.constBegin();
   for ( ; it != variables.constEnd(); ++it )
   {
     variableNames << it.key();
     variableValues << it.value().toString();
   }

   item->setCustomProperty( QStringLiteral( "variableNames" ), variableNames );
   item->setCustomProperty( QStringLiteral( "variableValues" ), variableValues );
 }

 QgsExpressionContext QgsExpressionContextUtils::createFeatureBasedContext( const QgsFeature &feature, const QgsFields &fields )
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope();
   scope->setFeature( feature );
   scope->setFields( fields );
   return QgsExpressionContext() << scope;
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::processingAlgorithmScope( const QgsProcessingAlgorithm *algorithm, const QVariantMap &parameters, QgsProcessingContext &context )
 {
   // set aside for future use
   Q_UNUSED( context );

   std::unique_ptr< QgsExpressionContextScope > scope( new QgsExpressionContextScope( QObject::tr( "Algorithm" ) ) );
   if ( !algorithm )
     return scope.release();

   //add standard algorithm variables
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "algorithm_id" ), algorithm->id(), true ) );

   scope->addFunction( QStringLiteral( "parameter" ), new GetProcessingParameterValue( parameters ) );

   return scope.release();
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::notificationScope( const QString &message )
 {
   std::unique_ptr< QgsExpressionContextScope > scope( new QgsExpressionContextScope() );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "notification_message" ), message, true ) );
   return scope.release();
 }

 void QgsExpressionContextUtils::registerContextFunctions()
 {
   QgsExpression::registerFunction( new GetNamedProjectColor( nullptr ) );
   QgsExpression::registerFunction( new GetLayoutItemVariables( nullptr ) );
   QgsExpression::registerFunction( new GetLayerVisibility( QList<QgsMapLayer *>() ) );
   QgsExpression::registerFunction( new GetProcessingParameterValue( QVariantMap() ) );
   QgsExpression::registerFunction( new GetCurrentFormFieldValue( ) );
 }

 bool QgsScopedExpressionFunction::usesGeometry( const QgsExpressionNodeFunction *node ) const
 {
   Q_UNUSED( node )
   return mUsesGeometry;
 }

 QSet<QString> QgsScopedExpressionFunction::referencedColumns( const QgsExpressionNodeFunction *node ) const
 {
   Q_UNUSED( node )
   return mReferencedColumns;
 }

 bool QgsScopedExpressionFunction::isStatic( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const
 {
   return allParamsStatic( node, parent, context );
 }
QgsPointLocator::Match
Definition: qgspointlocator.h:128

QgsFeature::isValid
bool isValid() const
Returns the validity of this feature.
Definition: qgsfeature.cpp:176

QgsExpressionContextScope::hasVariable
bool hasVariable(const QString &name) const
Tests whether a variable with the specified name exists in the scope.
Definition: qgsexpressioncontext.cpp:122

QgsExpressionContext::EXPR_ORIGINAL_VALUE
static const QString EXPR_ORIGINAL_VALUE
Inbuilt variable name for value original value variable.
Definition: qgsexpressioncontext.h:695

QgsExpression
Class for parsing and evaluation of expressions (formerly called "search strings").
Definition: qgsexpression.h:113

QgsApplication::locale
static QString locale()
Returns the QGIS locale.
Definition: qgsapplication.cpp:966

QgsFeature::id
QgsFeatureId id
Definition: qgsfeature.h:71

QgsExpressionContextUtils::updateSymbolScope
static QgsExpressionContextScope * updateSymbolScope(const QgsSymbol *symbol, QgsExpressionContextScope *symbolScope=nullptr)
Updates a symbol scope related to a QgsSymbol to an expression context.
Definition: qgsexpressioncontext.cpp:1027

QgsExpressionContext::cachedValue
QVariant cachedValue(const QString &key) const
Returns the matching cached value, if set.
Definition: qgsexpressioncontext.cpp:553

QgsExpressionContextScope::description
QString description(const QString &name) const
Returns the translated description for the variable with the specified name (if set).
Definition: qgsexpressioncontext.cpp:192

QgsExpressionContextUtils::processingAlgorithmScope
static QgsExpressionContextScope * processingAlgorithmScope(const QgsProcessingAlgorithm *algorithm, const QVariantMap &parameters, QgsProcessingContext &context)
Creates a new scope which contains variables and functions relating to a processing algorithm...
Definition: qgsexpressioncontext.cpp:1267

QgsExpressionContext::EXPR_CLUSTER_COLOR
static const QString EXPR_CLUSTER_COLOR
Inbuilt variable name for cluster color variable.
Definition: qgsexpressioncontext.h:711

QgsExpressionContextUtils::setLayoutItemVariable
static void setLayoutItemVariable(QgsLayoutItem *item, const QString &name, const QVariant &value)
Sets a layout item context variable, with the given name and value.
Definition: qgsexpressioncontext.cpp:1224

QgsLayoutItem::createExpressionContext
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
Definition: qgslayoutitem.cpp:1103

QgsExpressionContextScope::StaticVariable
Single variable definition for use within a QgsExpressionContextScope.
Definition: qgsexpressioncontext.h:136

QgsExpressionContextUtils::setGlobalVariable
static void setGlobalVariable(const QString &name, const QVariant &value)
Sets a global context variable.
Definition: qgsexpressioncontext.cpp:593

QgsMapLayer
Base class for all map layer types.
Definition: qgsmaplayer.h:61

QgsExpressionContext::setCachedValue
void setCachedValue(const QString &key, const QVariant &value) const
Sets a value to cache within the expression context.
Definition: qgsexpressioncontext.cpp:543

QgsExpressionContextUtils::setLayoutItemVariables
static void setLayoutItemVariables(QgsLayoutItem *item, const QVariantMap &variables)
Sets all layout item context variables for an item.
Definition: qgsexpressioncontext.cpp:1240

Qgis::QGIS_VERSION
static const QString QGIS_VERSION
Version string.
Definition: qgis.h:63

qgsproject.h

QgsExpressionContext::scope
QgsExpressionContextScope * scope(int index)
Returns the scope at the specified index within the context.
Definition: qgsexpressioncontext.cpp:340

QgsExpressionContextUtils::setLayerVariables
static void setLayerVariables(QgsMapLayer *layer, const QVariantMap &variables)
Sets all layer context variables.
Definition: qgsexpressioncontext.cpp:957

QgsProcessingAlgorithm::id
QString id() const
Returns the unique ID for the algorithm, which is a combination of the algorithm provider&#39;s ID and th...
Definition: qgsprocessingalgorithm.cpp:44

QgsAbstractMetadataBase::keywords
QgsAbstractMetadataBase::KeywordMap keywords() const
Returns the keywords map, which is a set of descriptive keywords associated with the resource...
Definition: qgsabstractmetadatabase.cpp:86

QgsExpressionContext::isReadOnly
bool isReadOnly(const QString &name) const
Returns whether a variable is read only, and should not be modifiable by users.
Definition: qgsexpressioncontext.cpp:403

QgsLayoutItem
Base class for graphical items within a QgsLayout.
Definition: qgslayoutitem.h:112

QgsExpressionContext::EXPR_GEOMETRY_POINT_COUNT
static const QString EXPR_GEOMETRY_POINT_COUNT
Inbuilt variable name for point count variable.
Definition: qgsexpressioncontext.h:705

QgsUnitTypes::toString
static Q_INVOKABLE QString toString(QgsUnitTypes::DistanceUnit unit)
Returns a translated string representing a distance unit.
Definition: qgsunittypes.cpp:152

QgsExpressionContextUtils::setLayoutVariable
static void setLayoutVariable(QgsLayout *layout, const QString &name, const QVariant &value)
Sets a layout context variable.
Definition: qgsexpressioncontext.cpp:1103

QgsExpressionContext::filteredVariableNames
QStringList filteredVariableNames() const
Returns a filtered list of variables names set by all scopes in the context.
Definition: qgsexpressioncontext.cpp:387

QgsApplication::setCustomVariables
static void setCustomVariables(const QVariantMap &customVariables)
Custom expression variables for this application.
Definition: qgsapplication.cpp:1439

QgsSymbol
Definition: qgssymbol.h:61

QgsExpressionContext::operator=
QgsExpressionContext & operator=(const QgsExpressionContext &other)
Definition: qgsexpressioncontext.cpp:258

QgsMapSettings::rotation
double rotation() const
Returns the rotation of the resulting map image, in degrees clockwise.
Definition: qgsmapsettings.cpp:90

qgslayout.h

QgsExpressionContext::hasFunction
bool hasFunction(const QString &name) const
Checks whether a specified function is contained in the context.
Definition: qgsexpressioncontext.cpp:419

QgsLayout::customProperty
QVariant customProperty(const QString &key, const QVariant &defaultValue=QVariant()) const
Read a custom property from the layout.
Definition: qgslayout.cpp:411

QgsExpressionContextScope::addFunction
void addFunction(const QString &name, QgsScopedExpressionFunction *function)
Adds a function to the scope.
Definition: qgsexpressioncontext.cpp:212

QgsExpressionContextScope::QgsExpressionContextScope
QgsExpressionContextScope(const QString &name=QString())
Constructor for QgsExpressionContextScope.
Definition: qgsexpressioncontext.cpp:55

QgsExpressionContext::setFeature
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
Definition: qgsexpressioncontext.cpp:490

QgsExpressionContextUtils::removeProjectVariable
static void removeProjectVariable(QgsProject *project, const QString &name)
Remove project context variable.
Definition: qgsexpressioncontext.cpp:873

qgslayoutatlas.h

QgsExpressionContext::activeScopeForVariable
QgsExpressionContextScope * activeScopeForVariable(const QString &name)
Returns the currently active scope from the context for a specified variable name.
Definition: qgsexpressioncontext.cpp:327

QgsExpressionContextUtils::createFeatureBasedContext
static QgsExpressionContext createFeatureBasedContext(const QgsFeature &feature, const QgsFields &fields)
Helper function for creating an expression context which contains just a feature and fields collectio...
Definition: qgsexpressioncontext.cpp:1259

QgsExpressionContextScope::variableNames
QStringList variableNames() const
Returns a list of variable names contained within the scope.
Definition: qgsexpressioncontext.cpp:132

QgsExpressionContext::hasCachedValue
bool hasCachedValue(const QString &key) const
Returns true if the expression context contains a cached value with a matching key.
Definition: qgsexpressioncontext.cpp:548

QgsLayoutItem::sizeWithUnits
QgsLayoutSize sizeWithUnits() const
Returns the item&#39;s current size, including units.
Definition: qgslayoutitem.h:549

QgsMapLayer::setCustomProperty
void setCustomProperty(const QString &key, const QVariant &value)
Set a custom property for layer.
Definition: qgsmaplayer.cpp:1591

QgsLayoutObject::setCustomProperty
void setCustomProperty(const QString &key, const QVariant &value)
Set a custom property for the object.
Definition: qgslayoutobject.cpp:112

QgsLayoutObject::customProperty
QVariant customProperty(const QString &key, const QVariant &defaultValue=QVariant()) const
Read a custom property from the object.
Definition: qgslayoutobject.cpp:117

QgsCoordinateReferenceSystem::toProj4
QString toProj4() const
Returns a Proj4 string representation of this CRS.
Definition: qgscoordinatereferencesystem.cpp:1018

QgsExpressionContextScope::isReadOnly
bool isReadOnly(const QString &name) const
Tests whether the specified variable is read only and should not be editable by users.
Definition: qgsexpressioncontext.cpp:182

qgsmaplayerlistutils.h

QgsProjectMetadata::author
QString author() const
Returns the project author string.
Definition: qgsprojectmetadata.cpp:70

QgsFields
Container of fields for a vector layer.
Definition: qgsfields.h:42

QgsExpressionContext::hasVariable
bool hasVariable(const QString &name) const
Check whether a variable is specified by any scope within the context.
Definition: qgsexpressioncontext.cpp:277

QgsGeometry
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:104

qgsexpressioncontext.h

QgsApplication::customVariables
static QVariantMap customVariables()
Custom expression variables for this application.
Definition: qgsapplication.cpp:1420

QgsExpressionContextScope::setFields
void setFields(const QgsFields &fields)
Convenience function for setting a fields for the scope.
Definition: qgsexpressioncontext.cpp:218

QgsExpressionContext::fields
QgsFields fields() const
Convenience function for retrieving the fields for the context, if set.
Definition: qgsexpressioncontext.cpp:529

QgsExpressionContextUtils::mapToolCaptureScope
static QgsExpressionContextScope * mapToolCaptureScope(const QList< QgsPointLocator::Match > &matches)
Sets the expression context variables which are available for expressions triggered by a map tool cap...
Definition: qgsexpressioncontext.cpp:1003

QgsExpression::variableHelpText
static QString variableHelpText(const QString &variableName)
Returns the help text for a specified variable.
Definition: qgsexpression.cpp:788

QgsExpressionContextUtils::projectScope
static QgsExpressionContextScope * projectScope(const QgsProject *project)
Creates a new scope which contains variables and functions relating to a QGIS project.
Definition: qgsexpressioncontext.cpp:802

QgsMapSettings::layers
QList< QgsMapLayer * > layers() const
Gets list of layers for map rendering The layers are stored in the reverse order of how they are rend...
Definition: qgsmapsettings.cpp:252

QgsFeature
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:62

QgsExpressionContextScope::operator=
QgsExpressionContextScope & operator=(const QgsExpressionContextScope &other)
Definition: qgsexpressioncontext.cpp:74

qgsexpression.h

QgsExpressionContext::takeScopes
QList< QgsExpressionContextScope * > takeScopes()
Returns all scopes from this context and remove them, leaving this context without any context...
Definition: qgsexpressioncontext.cpp:477

QgsScopedExpressionFunction::usesGeometry
bool usesGeometry(const QgsExpressionNodeFunction *node) const override
Does this function use a geometry object.
Definition: qgsexpressioncontext.cpp:1300

QgsExpressionContextUtils::setLayoutVariables
static void setLayoutVariables(QgsLayout *layout, const QVariantMap &variables)
Sets all layout context variables.
Definition: qgsexpressioncontext.cpp:1119

qgsmapsettings.h

QgsWeakMapLayerPointer
QPointer< QgsMapLayer > QgsWeakMapLayerPointer
Weak pointer for QgsMapLayer.
Definition: qgsmaplayer.h:1385

Qgis::QGIS_VERSION_INT
static const int QGIS_VERSION_INT
Version number used for comparing versions using the "Check QGIS Version" function.
Definition: qgis.h:65

QgsProcessingAlgorithm
Abstract base class for processing algorithms.
Definition: qgsprocessingalgorithm.h:51

QgsExpressionFunction::ParameterList
QList< QgsExpressionFunction::Parameter > ParameterList
List of parameters, used for function definition.
Definition: qgsexpressionfunction.h:102

QgsLayout::renderContext
QgsLayoutRenderContext & renderContext()
Returns a reference to the layout&#39;s render context, which stores information relating to the current ...
Definition: qgslayout.cpp:355

QgsMapSettings::visibleExtent
QgsRectangle visibleExtent() const
Returns the actual extent derived from requested extent that takes takes output image size into accou...
Definition: qgsmapsettings.cpp:341

QgsExpressionContext::variable
QVariant variable(const QString &name) const
Fetches a matching variable from the context.
Definition: qgsexpressioncontext.cpp:287

MathUtils::angle
double ANALYSIS_EXPORT angle(QgsPoint *p1, QgsPoint *p2, QgsPoint *p3, QgsPoint *p4)
Calculates the angle between two segments (in 2 dimension, z-values are ignored)
Definition: MathUtils.cpp:786

QgsExpressionContextScope::addVariable
void addVariable(const QgsExpressionContextScope::StaticVariable &variable)
Adds a variable into the context scope.
Definition: qgsexpressioncontext.cpp:112

QgsExpressionContext::operator<<
QgsExpressionContext & operator<<(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
Definition: qgsexpressioncontext.cpp:484

QgsMarkerSymbol
Definition: qgssymbol.h:611

QgsApplication::userFullName
static QString userFullName()
Returns the user&#39;s operating system login account full display name.
Definition: qgsapplication.cpp:912

QgsMapSettings::destinationCrs
QgsCoordinateReferenceSystem destinationCrs() const
returns CRS of destination coordinate reference system
Definition: qgsmapsettings.cpp:288

QgsExpressionContext::description
QString description(const QString &name) const
Returns a translated description string for the variable with specified name.
Definition: qgsexpressioncontext.cpp:413

QgsExpressionContext::~QgsExpressionContext
~QgsExpressionContext()
Definition: qgsexpressioncontext.cpp:271

qgsprocessingcontext.h

QgsExpressionContext::hasFeature
bool hasFeature() const
Returns true if the context has a feature associated with it.
Definition: qgsexpressioncontext.cpp:498

QgsMapSettings::mapUnits
QgsUnitTypes::DistanceUnit mapUnits() const
Gets units of map&#39;s geographical coordinates - used for scale calculation.
Definition: qgsmapsettings.cpp:330

QgsLayoutAtlas::layout
QgsLayout * layout() override
Returns the layout associated with the iterator.
Definition: qgslayoutatlas.cpp:40

QgsMapSettings
The QgsMapSettings class contains configuration for rendering of the map.
Definition: qgsmapsettings.h:58

QgsExpressionContextScope::setVariable
void setVariable(const QString &name, const QVariant &value, bool isStatic=false)
Convenience method for setting a variable in the context scope by name name and value.
Definition: qgsexpressioncontext.cpp:97

QgsProject::homePath
QString homePath
Definition: qgsproject.h:90

c
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
Definition: porting_processing.dox:1

QgsExpressionContextScope::~QgsExpressionContextScope
~QgsExpressionContextScope()
Definition: qgsexpressioncontext.cpp:92

QgsLayoutSize::toQSizeF
QSizeF toQSizeF() const
Converts the layout size to a QSizeF.
Definition: qgslayoutsize.cpp:47

QgsExpressionContextUtils::layoutItemScope
static QgsExpressionContextScope * layoutItemScope(const QgsLayoutItem *item)
Creates a new scope which contains variables and functions relating to a QgsLayoutItem.
Definition: qgsexpressioncontext.cpp:1177

QgsScopedExpressionFunction::isStatic
bool isStatic(const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context) const override
Will be called during prepare to determine if the function is static.
Definition: qgsexpressioncontext.cpp:1312

QgsGeometry::fromRect
static QgsGeometry fromRect(const QgsRectangle &rect)
Creates a new geometry from a QgsRectangle.
Definition: qgsgeometry.cpp:224

QgsExpressionContextScope::removeVariable
bool removeVariable(const QString &name)
Removes a variable from the context scope, if found.
Definition: qgsexpressioncontext.cpp:117

QgsExpressionContext::lastScope
QgsExpressionContextScope * lastScope()
Returns the last scope added to the context.
Definition: qgsexpressioncontext.cpp:348

QgsLayoutReportContext::layer
QgsVectorLayer * layer() const
Returns the vector layer associated with the layout&#39;s context.
Definition: qgslayoutreportcontext.cpp:65

QgsExpressionContextScope::hasFunction
bool hasFunction(const QString &name) const
Tests whether a function with the specified name exists in the scope.
Definition: qgsexpressioncontext.cpp:197

QgsExpressionContext::EXPR_SYMBOL_ANGLE
static const QString EXPR_SYMBOL_ANGLE
Inbuilt variable name for symbol angle variable.
Definition: qgsexpressioncontext.h:699

QgsExpressionContextUtils::globalScope
static QgsExpressionContextScope * globalScope()
Creates a new scope which contains variables and functions relating to the global QGIS context...
Definition: qgsexpressioncontext.cpp:568

QgsMapLayer::id
QString id() const
Returns the layer&#39;s unique ID, which is used to access this layer from QgsProject.
Definition: qgsmaplayer.cpp:147

QgsLayoutObject::layout
const QgsLayout * layout() const
Returns the layout the object is attached to.
Definition: qgslayoutobject.cpp:102

QgsLayoutPageCollection::page
QgsLayoutItemPage * page(int pageNumber)
Returns a specific page (by pageNumber) from the collection.
Definition: qgslayoutpagecollection.cpp:445

QgsVectorLayer::fields
QgsFields fields() const override
Returns the list of fields of this layer.
Definition: qgsvectorlayer.h:1348

QgsExpressionContext::scopeCount
int scopeCount() const
Returns the number of scopes contained in the context.
Definition: qgsexpressioncontext.cpp:454

qgsprocessingalgorithm.h

QgsExpressionContext::isHighlightedVariable
bool isHighlightedVariable(const QString &name) const
Returns true if the specified variable name is intended to be highlighted to the user.
Definition: qgsexpressioncontext.cpp:304

QgsLayout::pageCollection
QgsLayoutPageCollection * pageCollection()
Returns a pointer to the layout&#39;s page collection, which stores and manages page items in the layout...
Definition: qgslayout.cpp:455

QgsExpressionContextUtils::setProjectVariables
static void setProjectVariables(QgsProject *project, const QVariantMap &variables)
Sets all project context variables.
Definition: qgsexpressioncontext.cpp:865

QgsProject::metadata
QgsProjectMetadata metadata
Definition: qgsproject.h:97

QgsMapSettings::scale
double scale() const
Returns the calculated map scale.
Definition: qgsmapsettings.cpp:366

QgsLayoutRenderContext::dpi
double dpi() const
Returns the dpi for outputting the layout.
Definition: qgslayoutrendercontext.cpp:83

QgsRectangle::width
double width() const
Returns the width of the rectangle.
Definition: qgsrectangle.h:201

QgsExpressionContextUtils::notificationScope
static QgsExpressionContextScope * notificationScope(const QString &message=QString())
Creates a new scope which contains variables and functions relating to provider notifications.
Definition: qgsexpressioncontext.cpp:1284

QgsExpressionContext
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
Definition: qgsexpressioncontext.h:375

QgsExpressionContextUtils::removeGlobalVariable
static void removeGlobalVariable(const QString &name)
Remove a global context variable.
Definition: qgsexpressioncontext.cpp:603

QgsProject::crs
QgsCoordinateReferenceSystem crs
Definition: qgsproject.h:91

QgsExpressionContext::variablesToMap
QVariantMap variablesToMap() const
Returns a map of variable name to value representing all the expression variables contained by the co...
Definition: qgsexpressioncontext.cpp:293

QgsLayoutAtlas
Class used to render QgsLayout as an atlas, by iterating over the features from an associated vector ...
Definition: qgslayoutatlas.h:40

qgsapplication.h

QgsExpressionContextScope::variable
QVariant variable(const QString &name) const
Retrieves a variable&#39;s value from the scope.
Definition: qgsexpressioncontext.cpp:127

QgsExpressionContext::EXPR_SYMBOL_COLOR
static const QString EXPR_SYMBOL_COLOR
Inbuilt variable name for symbol color variable.
Definition: qgsexpressioncontext.h:697

QgsProjectMetadata::creationDateTime
QDateTime creationDateTime() const
Returns the project&#39;s creation date/timestamp.
Definition: qgsprojectmetadata.cpp:80

QgsExpression::registerFunction
static bool registerFunction(QgsExpressionFunction *function, bool transferOwnership=false)
Registers a function to the expression engine.
Definition: qgsexpression.cpp:42

QgsProject::readListEntry
QStringList readListEntry(const QString &scope, const QString &key, const QStringList &def=QStringList(), bool *ok=nullptr) const
Key value accessors.
Definition: qgsproject.cpp:1784

QgsProject
Reads and writes project states.
Definition: qgsproject.h:85

QgsApplication::setCustomVariable
static void setCustomVariable(const QString &name, const QVariant &value)
Set a single custom expression variable.
Definition: qgsapplication.cpp:1454

QgsSymbol::color
QColor color() const
Definition: qgssymbol.cpp:449

QgsLayoutAtlas::currentFilename
QString currentFilename() const
Returns the current feature filename.
Definition: qgslayoutatlas.cpp:433

QgsLayoutItem::page
int page() const
Returns the page the item is currently on, with the first page returning 0.
Definition: qgslayoutitem.cpp:492

QgsLayoutItem::id
QString id() const
Returns the item&#39;s ID name.
Definition: qgslayoutitem.h:325

QgsExpressionContextUtils::globalProjectLayerScopes
static QList< QgsExpressionContextScope * > globalProjectLayerScopes(const QgsMapLayer *layer)
Creates a list of three scopes: global, layer&#39;s project and layer.
Definition: qgsexpressioncontext.cpp:926

qgslayoutreportcontext.h

QgsExpressionContextScope::function
QgsExpressionFunction * function(const QString &name) const
Retrieves a function from the scope.
Definition: qgsexpressioncontext.cpp:202

QgsExpressionContext::EXPR_FIELDS
static const QString EXPR_FIELDS
Inbuilt variable name for fields storage.
Definition: qgsexpressioncontext.h:693

QgsExpressionContext::variableNames
QStringList variableNames() const
Returns a list of variables names set by all scopes in the context.
Definition: qgsexpressioncontext.cpp:377

QgsLayoutAtlas::count
int count() override
Returns the number of features to iterate over.
Definition: qgslayoutatlas.cpp:339

QgsExpressionContextScope
Single scope for storing variables and functions for use within a QgsExpressionContext.
Definition: qgsexpressioncontext.h:129

QgsExpressionNodeFunction
An expression node for expression functions.
Definition: qgsexpressionnodeimpl.h:265

QgsFeature::geometry
QgsGeometry geometry() const
Returns the geometry associated with this feature.
Definition: qgsfeature.cpp:101

QgsExpressionContextScope::setFeature
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the scope.
Definition: qgsexpressioncontext.h:335

QgsExpressionContextScope::functionNames
QStringList functionNames() const
Retrieves a list of names of functions contained in the scope.
Definition: qgsexpressioncontext.cpp:207

QgsProject::setCustomVariables
void setCustomVariables(const QVariantMap &customVariables)
A map of custom project variables.
Definition: qgsproject.cpp:1272

QgsLayout
Base class for layouts, which can contain items such as maps, labels, scalebars, etc.
Definition: qgslayout.h:49

algorithm
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into allowing algorithms to be written in pure substantial changes are required in order to port existing x Processing algorithms for QGIS x The most significant changes are outlined not GeoAlgorithm For algorithms which operate on features one by consider subclassing the QgsProcessingFeatureBasedAlgorithm class This class allows much of the boilerplate code for looping over features from a vector layer to be bypassed and instead requires implementation of a processFeature method Ensure that your algorithm(or algorithm 's parent class) implements the new pure virtual createInstance(self) call

QgsExpressionContext::setFields
void setFields(const QgsFields &fields)
Convenience function for setting a fields for the context.
Definition: qgsexpressioncontext.cpp:521

QgsProject::projectStorage
QgsProjectStorage * projectStorage() const
Returns pointer to project storage implementation that handles read/write of the project file...
Definition: qgsproject.cpp:471

QgsAbstractMetadataBase::abstract
QString abstract() const
Returns a free-form description of the resource.
Definition: qgsabstractmetadatabase.cpp:61

QgsExpressionContextUtils::setLayerVariable
static void setLayerVariable(QgsMapLayer *layer, const QString &name, const QVariant &value)
Sets a layer context variable.
Definition: qgsexpressioncontext.cpp:941

QgsApplication::userLoginName
static QString userLoginName()
Returns the user&#39;s operating system login account name.
Definition: qgsapplication.cpp:877

QgsApplication::osName
static QString osName()
Returns a string name of the operating system QGIS is running on.
Definition: qgsapplication.cpp:946

QgsLayoutPageCollection::pageCount
int pageCount() const
Returns the number of pages in the collection.
Definition: qgslayoutpagecollection.cpp:440

qgsgeometry.h

QgsLayoutAtlas::currentFeatureNumber
int currentFeatureNumber() const
Returns the current feature number, where a value of 0 corresponds to the first feature.
Definition: qgslayoutatlas.h:253

QgsLayout::reportContext
QgsLayoutReportContext & reportContext()
Returns a reference to the layout&#39;s report context, which stores information relating to the current ...
Definition: qgslayout.cpp:365

QgsExpressionContextUtils::setProjectVariable
static void setProjectVariable(QgsProject *project, const QString &name, const QVariant &value)
Sets a project context variable.
Definition: qgsexpressioncontext.cpp:853

QgsExpressionFunction
A abstract base class for defining QgsExpression functions.
Definition: qgsexpressionfunction.h:38

qgsfields.h

QgsExpressionContextUtils::registerContextFunctions
static void registerContextFunctions()
Registers all known core functions provided by QgsExpressionContextScope objects. ...
Definition: qgsexpressioncontext.cpp:1291

QgsExpressionContextUtils::atlasScope
static QgsExpressionContextScope * atlasScope(QgsLayoutAtlas *atlas)
Creates a new scope which contains variables and functions relating to a QgsLayoutAtlas.
Definition: qgsexpressioncontext.cpp:1138

QgsExpressionContextUtils::mapSettingsScope
static QgsExpressionContextScope * mapSettingsScope(const QgsMapSettings &mapSettings)
Creates a new scope which contains variables and functions relating to a QgsMapSettings object...
Definition: qgsexpressioncontext.cpp:976

QgsExpressionContext::functionNames
QStringList functionNames() const
Retrieves a list of function names contained in the context.
Definition: qgsexpressioncontext.cpp:429

Qgis::QGIS_RELEASE_NAME
static const QString QGIS_RELEASE_NAME
Release name.
Definition: qgis.h:67

QgsExpressionContext::QgsExpressionContext
QgsExpressionContext()=default
Constructor for QgsExpressionContext.

QgsExpressionContextUtils::layoutScope
static QgsExpressionContextScope * layoutScope(const QgsLayout *layout)
Creates a new scope which contains variables and functions relating to a QgsLayout layout...
Definition: qgsexpressioncontext.cpp:1045

QgsExpressionContextUtils::formScope
static QgsExpressionContextScope * formScope(const QgsFeature &formFeature=QgsFeature())
Creates a new scope which contains functions and variables from the current attribute form/table feat...
Definition: qgsexpressioncontext.cpp:793

QgsExpressionContext::clearCachedValues
void clearCachedValues() const
Clears all cached values from the context.
Definition: qgsexpressioncontext.cpp:558

QgsExpressionContext::appendScope
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
Definition: qgsexpressioncontext.cpp:459

QgsAbstractMetadataBase::KeywordMap
QMap< QString, QStringList > KeywordMap
Map of vocabulary string to keyword list.
Definition: qgsabstractmetadatabase.h:75

QgsProject::instance
static QgsProject * instance()
Returns the QgsProject singleton instance.
Definition: qgsproject.cpp:391

QgsLayoutItem::uuid
virtual QString uuid() const
Returns the item identification string.
Definition: qgslayoutitem.h:317

QgsCoordinateReferenceSystem
This class represents a coordinate reference system (CRS).
Definition: qgscoordinatereferencesystem.h:189

QgsExpressionContextScope::isStatic
bool isStatic(const QString &name) const
Tests whether the variable with the specified name is static and can be cached.
Definition: qgsexpressioncontext.cpp:187

QgsLayoutAtlas::nameForPage
QString nameForPage(int page) const
Returns the calculated name for a specified atlas page number.
Definition: qgslayoutatlas.cpp:161

QgsApplication::platform
static QString platform()
Returns the QGIS platform name, e.g., "desktop" or "server".
Definition: qgsapplication.cpp:961

qgssymbollayerutils.h

qgsvectorlayer.h

QgsExpressionContext::EXPR_CLUSTER_SIZE
static const QString EXPR_CLUSTER_SIZE
Inbuilt variable name for cluster size variable.
Definition: qgsexpressioncontext.h:709

QgsLayout::setCustomProperty
void setCustomProperty(const QString &key, const QVariant &value)
Set a custom property for the layout.
Definition: qgslayout.cpp:403

QgsLayoutAtlas::enabled
bool enabled() const
Returns whether the atlas generation is enabled.
Definition: qgslayoutatlas.h:66

QgsExpressionContextScope::hasFeature
bool hasFeature() const
Returns true if the scope has a feature associated with it.
Definition: qgsexpressioncontext.h:318

QgsExpressionContext::feature
QgsFeature feature() const
Convenience function for retrieving the feature for the context, if set.
Definition: qgsexpressioncontext.cpp:508

QgsExpressionContext::EXPR_GEOMETRY_POINT_NUM
static const QString EXPR_GEOMETRY_POINT_NUM
Inbuilt variable name for point number variable.
Definition: qgsexpressioncontext.h:707

QgsLayoutAtlas::coverageLayer
QgsVectorLayer * coverageLayer() const
Returns the coverage layer used for the atlas features.
Definition: qgslayoutatlas.h:115

QgsLayoutReportContext::feature
QgsFeature feature() const
Returns the current feature for evaluating the layout.
Definition: qgslayoutreportcontext.h:60

QgsExpressionContext::setHighlightedVariables
void setHighlightedVariables(const QStringList &variableNames)
Sets the list of variable names within the context intended to be highlighted to the user...
Definition: qgsexpressioncontext.cpp:309

QgsMapLayer::name
QString name
Definition: qgsmaplayer.h:65

QgsExpressionFunction::Parameter
Represents a single parameter passed to a function.
Definition: qgsexpressionfunction.h:52

QgsExpressionContext::appendScopes
void appendScopes(const QList< QgsExpressionContextScope *> &scopes)
Appends a list of scopes to the end of the context.
Definition: qgsexpressioncontext.cpp:464

QgsMapLayer::customProperty
QVariant customProperty(const QString &value, const QVariant &defaultValue=QVariant()) const
Read a custom property from layer.
Definition: qgsmaplayer.cpp:1601

qgslayoutpagecollection.h

QgsProject::title
QString title() const
Returns the project&#39;s title.
Definition: qgsproject.cpp:411

QgsRectangle::center
QgsPointXY center() const
Returns the center point of the rectangle.
Definition: qgsrectangle.h:229

QgsProject::customVariables
QVariantMap customVariables() const
A map of custom project variables.
Definition: qgsproject.cpp:1267

QgsExpressionContextScope::name
QString name() const
Returns the friendly display name of the context scope.
Definition: qgsexpressioncontext.h:189

QgsExpressionContext::popScope
QgsExpressionContextScope * popScope()
Removes the last scope from the expression context and return it.
Definition: qgsexpressioncontext.cpp:469

QgsExpressionContextUtils::layerScope
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
Definition: qgsexpressioncontext.cpp:885

QgsProject::baseName
QString baseName() const
Returns the base name of the project file without the path and without extension - derived from fileN...
Definition: qgsproject.cpp:501

QgsMasterLayoutInterface
Interface for master layout type objects, such as print layouts and reports.
Definition: qgsmasterlayoutinterface.h:41

QgsExpressionContext::EXPR_GEOMETRY_PART_NUM
static const QString EXPR_GEOMETRY_PART_NUM
Inbuilt variable name for geometry part number variable.
Definition: qgsexpressioncontext.h:703

QgsProject::absoluteFilePath
QString absoluteFilePath() const
Returns full absolute path to the project file if the project is stored in a file system - derived fr...
Definition: qgsproject.cpp:490

QgsExpressionContextScope::StaticVariable::isStatic
bool isStatic
A static variable can be cached for the lifetime of a context.
Definition: qgsexpressioncontext.h:165

QgsVectorLayer
Represents a vector layer which manages a vector based data sets.
Definition: qgsvectorlayer.h:353

QgsExpressionContext::indexOfScope
int indexOfScope(QgsExpressionContextScope *scope) const
Returns the index of the specified scope if it exists within the context.
Definition: qgsexpressioncontext.cpp:356

QgsExpressionContext::EXPR_GEOMETRY_PART_COUNT
static const QString EXPR_GEOMETRY_PART_COUNT
Inbuilt variable name for geometry part count variable.
Definition: qgsexpressioncontext.h:701

QgsProcessingContext
Contains information about the context in which a processing algorithm is executed.
Definition: qgsprocessingcontext.h:42

QgsExpressionContext::setOriginalValueVariable
void setOriginalValueVariable(const QVariant &value)
Sets the original value variable value for the context.
Definition: qgsexpressioncontext.cpp:534

QgsExpressionContextScope::filteredVariableNames
QStringList filteredVariableNames() const
Returns a filtered and sorted list of variable names contained within the scope.
Definition: qgsexpressioncontext.cpp:165

QgsExpressionContext::scopes
QList< QgsExpressionContextScope *> scopes()
Returns a list of scopes contained within the stack.
Definition: qgsexpressioncontext.h:481

QgsProject::fileName
QString fileName
Definition: qgsproject.h:89

QgsExpressionContextUtils::setGlobalVariables
static void setGlobalVariables(const QVariantMap &variables)
Sets all global context variables.
Definition: qgsexpressioncontext.cpp:598

QgsExpressionContext::function
QgsExpressionFunction * function(const QString &name) const
Fetches a matching function from the context.
Definition: qgsexpressioncontext.cpp:441

QgsScopedExpressionFunction
Expression function for use within a QgsExpressionContextScope.
Definition: qgsexpressioncontext.h:55

QgsMarkerSymbol::angle
double angle() const
Returns the marker angle for the whole symbol.
Definition: qgssymbol.cpp:1141

QgsGeometry::fromPointXY
static QgsGeometry fromPointXY(const QgsPointXY &point)
Creates a new geometry from a QgsPointXY object.
Definition: qgsgeometry.cpp:159

QgsCoordinateReferenceSystem::authid
QString authid() const
Returns the authority identifier for the CRS.
Definition: qgscoordinatereferencesystem.cpp:977

QgsAbstractMetadataBase::identifier
QString identifier() const
A reference, URI, URL or some other mechanism to identify the resource.
Definition: qgsabstractmetadatabase.cpp:21

QgsExpressionContextScope::StaticVariable::name
QString name
Variable name.
Definition: qgsexpressioncontext.h:156

QgsScopedExpressionFunction::referencedColumns
QSet< QString > referencedColumns(const QgsExpressionNodeFunction *node) const override
Returns a set of field names which are required for this function.
Definition: qgsexpressioncontext.cpp:1306

QgsSymbolLayerUtils::decodeColor
static QColor decodeColor(const QString &str)
Definition: qgssymbollayerutils.cpp:53

QgsRectangle::height
double height() const
Returns the height of the rectangle.
Definition: qgsrectangle.h:208

QgsLayoutItemPage
Item representing the paper in a layout.
Definition: qgslayoutitempage.h:54

qgslogger.h

QgsExpressionContextScope::StaticVariable::value
QVariant value
Variable value.
Definition: qgsexpressioncontext.h:159

qgsexpressionfunction.h