qgsesriarcadescript.h

Go to the documentation of this file.

/***************************************************************************
    qgsesriarcadescript.h
    --------------------
    begin                : October 2026
    copyright            : (C) 2026 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 QGSESRIARCADESCRIPT_H
#define QGSESRIARCADESCRIPT_H
 
#include <memory>
 
#include "qgis_core.h"
#include "qgis_sip.h"
 
#include <QCoreApplication>
#include <QList>
#include <QMetaType>
#include <QString>
#include <QStringList>
#include <QVariant>
 
using namespace Qt::StringLiterals;
 
class QgsEsriArcadeVisitor;
class QgsEsriArcadeStatement;
class QgsEsriArcadeBlockStatement;
class QgsEsriArcadeAssignmentStatement;
class QgsEsriArcadeArrayLiteralExpression;
class QgsEsriArcadeDictionaryElement;
class QgsEsriArcadeDictionaryLiteralExpression;
class QgsEsriArcadeIfStatement;
class QgsEsriArcadeForStatement;
class QgsEsriArcadeForInStatement;
class QgsEsriArcadeWhileStatement;
class QgsEsriArcadeBreakStatement;
class QgsEsriArcadeContinueStatement;

class CORE_EXPORT QgsEsriArcadeNode
{
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    switch ( sipCpp->nodeType() )
    {
      case QgsEsriArcadeNode::NodeType::BlockStatement:
        sipType = sipType_QgsEsriArcadeBlockStatement;
        break;
      case QgsEsriArcadeNode::NodeType::VariableDeclarationStatement:
        sipType = sipType_QgsEsriArcadeVariableDeclarationStatement;
        break;
      case QgsEsriArcadeNode::NodeType::AssignmentStatement:
        sipType = sipType_QgsEsriArcadeAssignmentStatement;
        break;
      case QgsEsriArcadeNode::NodeType::ReturnStatement:
        sipType = sipType_QgsEsriArcadeReturnStatement;
        break;
      case QgsEsriArcadeNode::NodeType::FunctionDeclarationStatement:
        sipType = sipType_QgsEsriArcadeFunctionDeclarationStatement;
        break;
      case QgsEsriArcadeNode::NodeType::ExpressionStatement:
        sipType = sipType_QgsEsriArcadeExpressionStatement;
        break;
      case QgsEsriArcadeNode::NodeType::ArrayLiteralExpression:
        sipType = sipType_QgsEsriArcadeArrayLiteralExpression;
        break;
      case QgsEsriArcadeNode::NodeType::LiteralExpression:
        sipType = sipType_QgsEsriArcadeLiteralExpression;
        break;
      case QgsEsriArcadeNode::NodeType::VariableReferenceExpression:
        sipType = sipType_QgsEsriArcadeVariableReferenceExpression;
        break;
      case QgsEsriArcadeNode::NodeType::ProfileVariableReferenceExpression:
        sipType = sipType_QgsEsriArcadeProfileVariableReferenceExpression;
        break;
      case QgsEsriArcadeNode::NodeType::MemberAccessExpression:
        sipType = sipType_QgsEsriArcadeMemberAccessExpression;
        break;
      case QgsEsriArcadeNode::NodeType::BinaryOperatorExpression:
        sipType = sipType_QgsEsriArcadeBinaryOperatorExpression;
        break;
      case QgsEsriArcadeNode::NodeType::UnaryOperatorExpression:
        sipType = sipType_QgsEsriArcadeUnaryOperatorExpression;
        break;
      case QgsEsriArcadeNode::NodeType::FunctionCallExpression:
        sipType = sipType_QgsEsriArcadeFunctionCallExpression;
        break;
      case QgsEsriArcadeNode::NodeType::IndexExpression:
        sipType = sipType_QgsEsriArcadeIndexExpression;
        break;
      case QgsEsriArcadeNode::NodeType::DictionaryLiteralExpression:
        sipType = sipType_QgsEsriArcadeDictionaryLiteralExpression;
        break;
      case QgsEsriArcadeNode::NodeType::IfStatement:
        sipType = sipType_QgsEsriArcadeIfStatement;
        break;
      case QgsEsriArcadeNode::NodeType::ForStatement:
        sipType = sipType_QgsEsriArcadeForStatement;
        break;
      case QgsEsriArcadeNode::NodeType::ForInStatement:
        sipType = sipType_QgsEsriArcadeForInStatement;
        break;
      case QgsEsriArcadeNode::NodeType::WhileStatement:
        sipType = sipType_QgsEsriArcadeWhileStatement;
        break;
      case QgsEsriArcadeNode::NodeType::BreakStatement:
        sipType = sipType_QgsEsriArcadeBreakStatement;
        break;
      case QgsEsriArcadeNode::NodeType::ContinueStatement:
        sipType = sipType_QgsEsriArcadeContinueStatement;
        break;
      default:
        sipType = nullptr;
        break;
    }
  SIP_END
#endif
 
  public:
    enum class NodeType
    {
      BlockStatement,                     
      VariableDeclarationStatement,       
      ReturnStatement,                    
      AssignmentStatement,                
      FunctionDeclarationStatement,       
      ExpressionStatement,                
      LiteralExpression,                  
      VariableReferenceExpression,        
      ProfileVariableReferenceExpression, 
      MemberAccessExpression,             
      BinaryOperatorExpression,           
      UnaryOperatorExpression,            
      FunctionCallExpression,             
      IndexExpression,                    
      ArrayLiteralExpression,             
      DictionaryLiteralExpression,        
      IfStatement,                        
      ForStatement,                       
      ForInStatement,                     
      WhileStatement,                     
      BreakStatement,                     
      ContinueStatement,                  
    };
 
    virtual ~QgsEsriArcadeNode() = default;

    virtual QgsEsriArcadeNode::NodeType nodeType() const = 0;

    virtual QString dump() const = 0;

    virtual QgsEsriArcadeNode *clone() const = 0 SIP_FACTORY;

    virtual void accept( QgsEsriArcadeVisitor &visitor ) const = 0;
};

class CORE_EXPORT QgsEsriArcadeStatement : public QgsEsriArcadeNode
{
  public:
    ~QgsEsriArcadeStatement() override = default;
};

class CORE_EXPORT QgsEsriArcadeExpression : public QgsEsriArcadeNode
{
  public:
    ~QgsEsriArcadeExpression() override = default;
};

class CORE_EXPORT QgsEsriArcadeBlockStatement : public QgsEsriArcadeStatement
{
  public:
    QgsEsriArcadeBlockStatement() = default;

    explicit QgsEsriArcadeBlockStatement( const QList<QgsEsriArcadeStatement *> &statements SIP_TRANSFER );
 
    ~QgsEsriArcadeBlockStatement() override;
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::BlockStatement; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    void appendStatement( QgsEsriArcadeStatement *statement SIP_TRANSFER );

    QList<QgsEsriArcadeStatement *> statements() const { return mStatements; }

    int count() const { return mStatements.count(); }
 
  private:
    QgsEsriArcadeBlockStatement( const QgsEsriArcadeBlockStatement &other ) = delete;
    QgsEsriArcadeBlockStatement &operator=( const QgsEsriArcadeBlockStatement &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeBlockStatement( const QgsEsriArcadeBlockStatement &other );
#endif
 
    QList<QgsEsriArcadeStatement *> mStatements;
};

class CORE_EXPORT QgsEsriArcadeVariableDeclarationStatement : public QgsEsriArcadeStatement
{
  public:
    explicit QgsEsriArcadeVariableDeclarationStatement( const QString &variableName, QgsEsriArcadeExpression *initializer SIP_TRANSFER = nullptr );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::VariableDeclarationStatement; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QString variableName() const { return mVariableName; }

    QgsEsriArcadeExpression *initializer() const { return mInitializer.get(); }
 
  private:
    QgsEsriArcadeVariableDeclarationStatement( const QgsEsriArcadeVariableDeclarationStatement &other ) = delete;
    QgsEsriArcadeVariableDeclarationStatement &operator=( const QgsEsriArcadeVariableDeclarationStatement &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeVariableDeclarationStatement( const QgsEsriArcadeVariableDeclarationStatement &other );
#endif
 
    QString mVariableName;
    std::unique_ptr<QgsEsriArcadeExpression> mInitializer;
};

class CORE_EXPORT QgsEsriArcadeAssignmentStatement : public QgsEsriArcadeStatement
{
  public:
    enum class AssignmentOperator
    {
      Assign,         
      PlusAssign,     
      MinusAssign,    
      MultiplyAssign, 
      DivideAssign,   
    };

    static const char *ASSIGNMENT_OPERATOR_TEXT[] SIP_SKIP;

    QgsEsriArcadeAssignmentStatement( AssignmentOperator assignmentOperator, QgsEsriArcadeExpression *target SIP_TRANSFER, QgsEsriArcadeExpression *value SIP_TRANSFER );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::AssignmentStatement; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QgsEsriArcadeExpression *target() const { return mTarget.get(); }

    QgsEsriArcadeExpression *value() const { return mValue.get(); }

    AssignmentOperator assignmentOperator() const { return mAssignmentOperator; }
 
  private:
    QgsEsriArcadeAssignmentStatement( const QgsEsriArcadeAssignmentStatement &other ) = delete;
    QgsEsriArcadeAssignmentStatement &operator=( const QgsEsriArcadeAssignmentStatement &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeAssignmentStatement( const QgsEsriArcadeAssignmentStatement &other );
#endif
 
    std::unique_ptr<QgsEsriArcadeExpression> mTarget;
    std::unique_ptr<QgsEsriArcadeExpression> mValue;
    AssignmentOperator mAssignmentOperator = AssignmentOperator::Assign;
};

class CORE_EXPORT QgsEsriArcadeReturnStatement : public QgsEsriArcadeStatement
{
  public:
    explicit QgsEsriArcadeReturnStatement( QgsEsriArcadeExpression *expression SIP_TRANSFER = nullptr );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::ReturnStatement; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QgsEsriArcadeExpression *expression() const { return mExpression.get(); }
 
  private:
    QgsEsriArcadeReturnStatement( const QgsEsriArcadeReturnStatement &other ) = delete;
    QgsEsriArcadeReturnStatement &operator=( const QgsEsriArcadeReturnStatement &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeReturnStatement( const QgsEsriArcadeReturnStatement &other );
#endif
 
    std::unique_ptr<QgsEsriArcadeExpression> mExpression;
};

class CORE_EXPORT QgsEsriArcadeFunctionDeclarationStatement : public QgsEsriArcadeStatement
{
  public:
    QgsEsriArcadeFunctionDeclarationStatement( const QString &functionName, const QStringList &parameters, QgsEsriArcadeBlockStatement *body SIP_TRANSFER );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::FunctionDeclarationStatement; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QString functionName() const { return mFunctionName; }

    QStringList parameters() const { return mParameters; }

    QgsEsriArcadeBlockStatement *body() const { return mBody.get(); }
 
  private:
    QgsEsriArcadeFunctionDeclarationStatement( const QgsEsriArcadeFunctionDeclarationStatement &other ) = delete;
    QgsEsriArcadeFunctionDeclarationStatement &operator=( const QgsEsriArcadeFunctionDeclarationStatement &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeFunctionDeclarationStatement( const QgsEsriArcadeFunctionDeclarationStatement &other );
#endif
 
    QString mFunctionName;
    QStringList mParameters;
    std::unique_ptr<QgsEsriArcadeBlockStatement> mBody;
};

class CORE_EXPORT QgsEsriArcadeExpressionStatement : public QgsEsriArcadeStatement
{
  public:
    explicit QgsEsriArcadeExpressionStatement( QgsEsriArcadeExpression *expression SIP_TRANSFER );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::ExpressionStatement; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QgsEsriArcadeExpression *expression() const { return mExpression.get(); }
 
  private:
    QgsEsriArcadeExpressionStatement( const QgsEsriArcadeExpressionStatement &other ) = delete;
    QgsEsriArcadeExpressionStatement &operator=( const QgsEsriArcadeExpressionStatement &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeExpressionStatement( const QgsEsriArcadeExpressionStatement &other );
#endif
 
    std::unique_ptr<QgsEsriArcadeExpression> mExpression;
};

class CORE_EXPORT QgsEsriArcadeLiteralExpression : public QgsEsriArcadeExpression
{
  public:
    explicit QgsEsriArcadeLiteralExpression( const QVariant &value );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::LiteralExpression; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QVariant value() const { return mValue; }

    QString valueAsString() const;
 
  private:
    QVariant mValue;
};

class CORE_EXPORT QgsEsriArcadeVariableReferenceExpression : public QgsEsriArcadeExpression
{
  public:
    explicit QgsEsriArcadeVariableReferenceExpression( const QString &name );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::VariableReferenceExpression; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QString name() const { return mName; }
 
  private:
    QString mName;
};

class CORE_EXPORT QgsEsriArcadeProfileVariableReferenceExpression : public QgsEsriArcadeExpression
{
  public:
    explicit QgsEsriArcadeProfileVariableReferenceExpression( const QString &name );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::ProfileVariableReferenceExpression; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QString name() const { return mName; }
 
  private:
    QString mName;
};

class CORE_EXPORT QgsEsriArcadeMemberAccessExpression : public QgsEsriArcadeExpression
{
  public:
    QgsEsriArcadeMemberAccessExpression( QgsEsriArcadeExpression *containerExpression SIP_TRANSFER, const QString &memberName, bool isSafeAccess = false );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::MemberAccessExpression; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QgsEsriArcadeExpression *containerExpression() const { return mContainerExpression.get(); }

    QString memberName() const { return mMemberName; }

    bool isSafeAccess() const { return mIsSafeAccess; }

    void setIsSafeAccess( bool isSafeAccess ) { mIsSafeAccess = isSafeAccess; }
 
  private:
    QgsEsriArcadeMemberAccessExpression( const QgsEsriArcadeMemberAccessExpression &other ) = delete;
    QgsEsriArcadeMemberAccessExpression &operator=( const QgsEsriArcadeMemberAccessExpression &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeMemberAccessExpression( const QgsEsriArcadeMemberAccessExpression &other );
#endif
 
    std::unique_ptr<QgsEsriArcadeExpression> mContainerExpression;
    QString mMemberName;
    bool mIsSafeAccess = false;
};

class CORE_EXPORT QgsEsriArcadeBinaryOperatorExpression : public QgsEsriArcadeExpression
{
  public:
    enum class BinaryOperator
    {
      Plus,                      
      Minus,                     
      Multiply,                  
      Divide,                    
      Modulo,                    
      Equal,                     
      NotEqual,                  
      LessThan,                  
      GreaterThan,               
      LessThanOrEqual,           
      GreaterThanOrEqual,        
      LogicalAnd,                
      LogicalOr,                 
      BitwiseAnd,                
      BitwiseOr,                 
      BitwiseXor,                
      BitwiseLeftShift,          
      BitwiseSignedRightShift,   
      BitwiseUnsignedRightShift, 
    };

    static const char *BINARY_OPERATOR_TEXT[] SIP_SKIP;

    QgsEsriArcadeBinaryOperatorExpression( BinaryOperator binaryOperator, QgsEsriArcadeExpression *leftOperand SIP_TRANSFER, QgsEsriArcadeExpression *rightOperand SIP_TRANSFER );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::BinaryOperatorExpression; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    BinaryOperator binaryOperator() const { return mBinaryOperator; }

    QgsEsriArcadeExpression *leftOperand() const { return mLeftOperand.get(); }

    QgsEsriArcadeExpression *rightOperand() const { return mRightOperand.get(); }

    int precedence() const;

    bool leftAssociative() const;

    QString text() const;
 
  private:
    QgsEsriArcadeBinaryOperatorExpression( const QgsEsriArcadeBinaryOperatorExpression &other ) = delete;
    QgsEsriArcadeBinaryOperatorExpression &operator=( const QgsEsriArcadeBinaryOperatorExpression &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeBinaryOperatorExpression( const QgsEsriArcadeBinaryOperatorExpression &other );
#endif
 
    BinaryOperator mBinaryOperator;
    std::unique_ptr<QgsEsriArcadeExpression> mLeftOperand;
    std::unique_ptr<QgsEsriArcadeExpression> mRightOperand;
};

class CORE_EXPORT QgsEsriArcadeUnaryOperatorExpression : public QgsEsriArcadeExpression
{
  public:
    enum class UnaryOperator
    {
      Not,           
      Minus,         
      Plus,          
      BitwiseNot,    
      PreIncrement,  
      PreDecrement,  
      PostIncrement, 
      PostDecrement, 
    };

    static const char *UNARY_OPERATOR_TEXT[] SIP_SKIP;

    QgsEsriArcadeUnaryOperatorExpression( UnaryOperator unaryOperator, QgsEsriArcadeExpression *operand SIP_TRANSFER );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::UnaryOperatorExpression; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    UnaryOperator unaryOperator() const { return mUnaryOperator; }

    QgsEsriArcadeExpression *operand() const { return mOperand.get(); }

    QString text() const;
 
  private:
    QgsEsriArcadeUnaryOperatorExpression( const QgsEsriArcadeUnaryOperatorExpression &other ) = delete;
    QgsEsriArcadeUnaryOperatorExpression &operator=( const QgsEsriArcadeUnaryOperatorExpression &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeUnaryOperatorExpression( const QgsEsriArcadeUnaryOperatorExpression &other );
#endif
 
    UnaryOperator mUnaryOperator;
    std::unique_ptr<QgsEsriArcadeExpression> mOperand;
};

class CORE_EXPORT QgsEsriArcadeFunctionCallExpression : public QgsEsriArcadeExpression
{
  public:
    QgsEsriArcadeFunctionCallExpression( const QString &functionName, const QList<QgsEsriArcadeExpression *> &arguments SIP_TRANSFER );
 
    ~QgsEsriArcadeFunctionCallExpression() override;
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::FunctionCallExpression; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QString functionName() const { return mFunctionName; }

    QList<QgsEsriArcadeExpression *> arguments() const { return mArguments; }
 
  private:
    QgsEsriArcadeFunctionCallExpression( const QgsEsriArcadeFunctionCallExpression &other ) = delete;
    QgsEsriArcadeFunctionCallExpression &operator=( const QgsEsriArcadeFunctionCallExpression &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeFunctionCallExpression( const QgsEsriArcadeFunctionCallExpression &other );
#endif
 
    QString mFunctionName;
    QList<QgsEsriArcadeExpression *> mArguments;
};

class CORE_EXPORT QgsEsriArcadeIndexExpression : public QgsEsriArcadeExpression
{
  public:
    QgsEsriArcadeIndexExpression( QgsEsriArcadeExpression *containerExpression SIP_TRANSFER, QgsEsriArcadeExpression *indexExpression SIP_TRANSFER );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::IndexExpression; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QgsEsriArcadeExpression *containerExpression() const { return mContainerExpression.get(); }

    QgsEsriArcadeExpression *indexExpression() const { return mIndexExpression.get(); }
 
  private:
    QgsEsriArcadeIndexExpression( const QgsEsriArcadeIndexExpression &other ) = delete;
    QgsEsriArcadeIndexExpression &operator=( const QgsEsriArcadeIndexExpression &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeIndexExpression( const QgsEsriArcadeIndexExpression &other );
#endif
 
    std::unique_ptr<QgsEsriArcadeExpression> mContainerExpression;
    std::unique_ptr<QgsEsriArcadeExpression> mIndexExpression;
};

class CORE_EXPORT QgsEsriArcadeArrayLiteralExpression : public QgsEsriArcadeExpression
{
  public:
    explicit QgsEsriArcadeArrayLiteralExpression( const QList<QgsEsriArcadeExpression *> &elements SIP_TRANSFER );
 
    ~QgsEsriArcadeArrayLiteralExpression() override;
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::ArrayLiteralExpression; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QList<QgsEsriArcadeExpression *> elements() const { return mElements; }
 
  private:
    QgsEsriArcadeArrayLiteralExpression( const QgsEsriArcadeArrayLiteralExpression &other ) = delete;
    QgsEsriArcadeArrayLiteralExpression &operator=( const QgsEsriArcadeArrayLiteralExpression &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeArrayLiteralExpression( const QgsEsriArcadeArrayLiteralExpression &other );
#endif
 
    QList<QgsEsriArcadeExpression *> mElements;
};

class CORE_EXPORT QgsEsriArcadeDictionaryElement
{
  public:
    QgsEsriArcadeDictionaryElement( const QString &key, QgsEsriArcadeExpression *value SIP_TRANSFER, bool isAutoKey = false );
 
    ~QgsEsriArcadeDictionaryElement();

    QString key() const { return mKey; }

    QgsEsriArcadeExpression *value() const { return mValue.get(); }

    bool isAutoKey() const { return mIsAutoKey; }

    QgsEsriArcadeDictionaryElement *clone() const SIP_FACTORY;

    QString dump() const;
 
  private:
    QgsEsriArcadeDictionaryElement( const QgsEsriArcadeDictionaryElement &other ) = delete;
    QgsEsriArcadeDictionaryElement &operator=( const QgsEsriArcadeDictionaryElement &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeDictionaryElement( const QgsEsriArcadeDictionaryElement &other );
#endif
 
    QString mKey;
    std::unique_ptr<QgsEsriArcadeExpression> mValue;
    bool mIsAutoKey = false;
};

class CORE_EXPORT QgsEsriArcadeDictionaryLiteralExpression : public QgsEsriArcadeExpression
{
  public:
    explicit QgsEsriArcadeDictionaryLiteralExpression( const QList<QgsEsriArcadeDictionaryElement *> &elements SIP_TRANSFER );
    ~QgsEsriArcadeDictionaryLiteralExpression() override;
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::DictionaryLiteralExpression; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QList<QgsEsriArcadeDictionaryElement *> elements() const { return mElements; }
 
  private:
    QgsEsriArcadeDictionaryLiteralExpression( const QgsEsriArcadeDictionaryLiteralExpression &other ) = delete;
    QgsEsriArcadeDictionaryLiteralExpression &operator=( const QgsEsriArcadeDictionaryLiteralExpression &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeDictionaryLiteralExpression( const QgsEsriArcadeDictionaryLiteralExpression &other );
#endif
 
    QList<QgsEsriArcadeDictionaryElement *> mElements;
};

class CORE_EXPORT QgsEsriArcadeIfStatement : public QgsEsriArcadeStatement
{
  public:
    QgsEsriArcadeIfStatement( QgsEsriArcadeExpression *condition SIP_TRANSFER, QgsEsriArcadeBlockStatement *trueBlock SIP_TRANSFER, QgsEsriArcadeBlockStatement *falseBlock SIP_TRANSFER = nullptr );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::IfStatement; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QgsEsriArcadeExpression *condition() const { return mCondition.get(); }

    QgsEsriArcadeBlockStatement *trueBlock() const { return mTrueBlock.get(); }

    QgsEsriArcadeBlockStatement *falseBlock() const { return mFalseBlock.get(); }
 
  private:
    QgsEsriArcadeIfStatement( const QgsEsriArcadeIfStatement &other ) = delete;
    QgsEsriArcadeIfStatement &operator=( const QgsEsriArcadeIfStatement &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeIfStatement( const QgsEsriArcadeIfStatement &other );
#endif
 
    std::unique_ptr<QgsEsriArcadeExpression> mCondition;
    std::unique_ptr<QgsEsriArcadeBlockStatement> mTrueBlock;
    std::unique_ptr<QgsEsriArcadeBlockStatement> mFalseBlock;
};

class CORE_EXPORT QgsEsriArcadeForStatement : public QgsEsriArcadeStatement
{
  public:
    QgsEsriArcadeForStatement(
      QgsEsriArcadeStatement *initialization SIP_TRANSFER, QgsEsriArcadeExpression *condition SIP_TRANSFER, QgsEsriArcadeNode *step SIP_TRANSFER, QgsEsriArcadeBlockStatement *body SIP_TRANSFER
    );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::ForStatement; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QgsEsriArcadeStatement *initialization() const { return mInitialization.get(); }

    QgsEsriArcadeExpression *condition() const { return mCondition.get(); }

    QgsEsriArcadeNode *step() const { return mStep.get(); }

    QgsEsriArcadeBlockStatement *body() const { return mBody.get(); }
 
  private:
    QgsEsriArcadeForStatement( const QgsEsriArcadeForStatement &other ) = delete;
    QgsEsriArcadeForStatement &operator=( const QgsEsriArcadeForStatement &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeForStatement( const QgsEsriArcadeForStatement &other );
#endif
 
    std::unique_ptr<QgsEsriArcadeStatement> mInitialization;
    std::unique_ptr<QgsEsriArcadeExpression> mCondition;
    std::unique_ptr<QgsEsriArcadeNode> mStep;
    std::unique_ptr<QgsEsriArcadeBlockStatement> mBody;
};

class CORE_EXPORT QgsEsriArcadeForInStatement : public QgsEsriArcadeStatement
{
  public:
    enum class IterationType
    {
      ForIn, 
      ForOf, 
    };

    QgsEsriArcadeForInStatement(
      IterationType iterationType, const QString &variableName, bool isVariableDeclaration, QgsEsriArcadeExpression *collection SIP_TRANSFER, QgsEsriArcadeBlockStatement *body SIP_TRANSFER
    );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::ForInStatement; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    IterationType iterationType() const { return mIterationType; }

    QString variableName() const { return mVariableName; }

    bool isVariableDeclaration() const { return mIsVariableDeclaration; }

    QgsEsriArcadeExpression *collection() const { return mCollection.get(); }

    QgsEsriArcadeBlockStatement *body() const { return mBody.get(); }
 
  private:
    QgsEsriArcadeForInStatement( const QgsEsriArcadeForInStatement &other ) = delete;
    QgsEsriArcadeForInStatement &operator=( const QgsEsriArcadeForInStatement &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeForInStatement( const QgsEsriArcadeForInStatement &other );
#endif
 
    IterationType mIterationType = IterationType::ForIn;
    QString mVariableName;
    bool mIsVariableDeclaration = false;
    std::unique_ptr<QgsEsriArcadeExpression> mCollection;
    std::unique_ptr<QgsEsriArcadeBlockStatement> mBody;
};

class CORE_EXPORT QgsEsriArcadeWhileStatement : public QgsEsriArcadeStatement
{
  public:
    QgsEsriArcadeWhileStatement( QgsEsriArcadeExpression *condition SIP_TRANSFER, QgsEsriArcadeBlockStatement *body SIP_TRANSFER );
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::WhileStatement; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;

    QgsEsriArcadeExpression *condition() const { return mCondition.get(); }

    QgsEsriArcadeBlockStatement *body() const { return mBody.get(); }
 
  private:
    QgsEsriArcadeWhileStatement( const QgsEsriArcadeWhileStatement &other ) = delete;
    QgsEsriArcadeWhileStatement &operator=( const QgsEsriArcadeWhileStatement &other ) = delete;
 
#ifdef SIP_RUN
    QgsEsriArcadeWhileStatement( const QgsEsriArcadeWhileStatement &other );
#endif
 
    std::unique_ptr<QgsEsriArcadeExpression> mCondition;
    std::unique_ptr<QgsEsriArcadeBlockStatement> mBody;
};

class CORE_EXPORT QgsEsriArcadeBreakStatement : public QgsEsriArcadeStatement
{
  public:
    QgsEsriArcadeBreakStatement() = default;
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::BreakStatement; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;
};

class CORE_EXPORT QgsEsriArcadeContinueStatement : public QgsEsriArcadeStatement
{
  public:
    QgsEsriArcadeContinueStatement() = default;
 
    QgsEsriArcadeNode::NodeType nodeType() const override { return NodeType::ContinueStatement; }
    QString dump() const override;
    QgsEsriArcadeNode *clone() const override SIP_FACTORY;
    void accept( QgsEsriArcadeVisitor &visitor ) const override;
};
 

class CORE_EXPORT QgsEsriArcadeVisitor
{
  public:
    virtual ~QgsEsriArcadeVisitor() = default;

    virtual void visit( const QgsEsriArcadeBlockStatement &node ) = 0;
    virtual void visit( const QgsEsriArcadeVariableDeclarationStatement &node ) = 0;
    virtual void visit( const QgsEsriArcadeAssignmentStatement &node ) = 0;
    virtual void visit( const QgsEsriArcadeReturnStatement &node ) = 0;
    virtual void visit( const QgsEsriArcadeFunctionDeclarationStatement &node ) = 0;
    virtual void visit( const QgsEsriArcadeExpressionStatement &node ) = 0;
    virtual void visit( const QgsEsriArcadeLiteralExpression &node ) = 0;
    virtual void visit( const QgsEsriArcadeVariableReferenceExpression &node ) = 0;
    virtual void visit( const QgsEsriArcadeProfileVariableReferenceExpression &node ) = 0;
    virtual void visit( const QgsEsriArcadeMemberAccessExpression &node ) = 0;
    virtual void visit( const QgsEsriArcadeBinaryOperatorExpression &node ) = 0;
    virtual void visit( const QgsEsriArcadeUnaryOperatorExpression &node ) = 0;
    virtual void visit( const QgsEsriArcadeFunctionCallExpression &node ) = 0;
    virtual void visit( const QgsEsriArcadeIndexExpression &node ) = 0;
    virtual void visit( const QgsEsriArcadeDictionaryLiteralExpression &node ) = 0;
    virtual void visit( const QgsEsriArcadeArrayLiteralExpression &node ) = 0;
    virtual void visit( const QgsEsriArcadeIfStatement &node ) = 0;
    virtual void visit( const QgsEsriArcadeForStatement &node ) = 0;
    virtual void visit( const QgsEsriArcadeForInStatement &node ) = 0;
    virtual void visit( const QgsEsriArcadeWhileStatement &node ) = 0;
    virtual void visit( const QgsEsriArcadeBreakStatement &node ) = 0;
    virtual void visit( const QgsEsriArcadeContinueStatement &node ) = 0;
};

class CORE_EXPORT QgsEsriArcadeRecursiveVisitor : public QgsEsriArcadeVisitor
{
  public:
    QgsEsriArcadeRecursiveVisitor() = default;
 
    void visit( const QgsEsriArcadeBlockStatement &node ) override;
    void visit( const QgsEsriArcadeVariableDeclarationStatement &node ) override;
    void visit( const QgsEsriArcadeAssignmentStatement &node ) override;
    void visit( const QgsEsriArcadeReturnStatement &node ) override;
    void visit( const QgsEsriArcadeFunctionDeclarationStatement &node ) override;
    void visit( const QgsEsriArcadeExpressionStatement &node ) override;
    void visit( const QgsEsriArcadeLiteralExpression &node ) override;
    void visit( const QgsEsriArcadeVariableReferenceExpression &node ) override;
    void visit( const QgsEsriArcadeProfileVariableReferenceExpression &node ) override;
    void visit( const QgsEsriArcadeMemberAccessExpression &node ) override;
    void visit( const QgsEsriArcadeBinaryOperatorExpression &node ) override;
    void visit( const QgsEsriArcadeUnaryOperatorExpression &node ) override;
    void visit( const QgsEsriArcadeFunctionCallExpression &node ) override;
    void visit( const QgsEsriArcadeIndexExpression &node ) override;
    void visit( const QgsEsriArcadeArrayLiteralExpression &node ) override;
    void visit( const QgsEsriArcadeDictionaryLiteralExpression &node ) override;
    void visit( const QgsEsriArcadeIfStatement &node ) override;
    void visit( const QgsEsriArcadeForStatement &node ) override;
    void visit( const QgsEsriArcadeForInStatement &node ) override;
    void visit( const QgsEsriArcadeWhileStatement &node ) override;
    void visit( const QgsEsriArcadeBreakStatement &node ) override;
    void visit( const QgsEsriArcadeContinueStatement &node ) override;
};

class CORE_EXPORT QgsEsriArcadeScript
{
  public:
    explicit QgsEsriArcadeScript( const QString &scriptText = QString() );
 
    QgsEsriArcadeScript( const QgsEsriArcadeScript &other );
    QgsEsriArcadeScript &operator=( const QgsEsriArcadeScript &other );
 
    ~QgsEsriArcadeScript();

    bool hasParserError() const;

    QString parserErrorString() const;

    const QgsEsriArcadeBlockStatement *rootBlock() const;

    QString script() const;

    QString dump() const;

    void acceptVisitor( QgsEsriArcadeVisitor &visitor ) const;

    static QString quotedString( const QString &text );
 
  protected:
    std::unique_ptr<QgsEsriArcadeBlockStatement> mRootBlock;
    QString mScript;
    QString mParserErrorString;
};
 
#endif // QGSESRIARCADESCRIPT_H