qgsexpressionnode.h

Go to the documentation of this file.

/***************************************************************************
                               qgsexpressionnode.h
                             -------------------
    begin                : May 2017
    copyright            : (C) 2017 Matthias Kuhn
    email                : [email protected]
 ***************************************************************************
 *                                                                         *
 *   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 QGSEXPRESSIONNODE_H
#define QGSEXPRESSIONNODE_H
 
#include <QSet>
#include <QVariant>
#include <QCoreApplication>
 
#include "qgis.h"
 
class QgsExpression;
class QgsExpressionContext;
 
class CORE_EXPORT QgsExpressionNode SIP_ABSTRACT
{
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    switch ( sipCpp->nodeType() )
    {
      case QgsExpressionNode::ntUnaryOperator:
        sipType = sipType_QgsExpressionNodeUnaryOperator;
        break;
      case QgsExpressionNode::ntBinaryOperator:
        sipType = sipType_QgsExpressionNodeBinaryOperator;
        break;
      case QgsExpressionNode::ntInOperator:
        sipType = sipType_QgsExpressionNodeInOperator;
        break;
      case QgsExpressionNode::ntFunction:
        sipType = sipType_QgsExpressionNodeFunction;
        break;
      case QgsExpressionNode::ntLiteral:
        sipType = sipType_QgsExpressionNodeLiteral;
        break;
      case QgsExpressionNode::ntColumnRef:
        sipType = sipType_QgsExpressionNodeColumnRef;
        break;
      case QgsExpressionNode::ntCondition:
        sipType = sipType_QgsExpressionNodeCondition;
        break;
      case QgsExpressionNode::ntBetweenOperator:
        sipType = sipType_QgsExpressionNodeBetweenOperator;
        break;
      default:
        sipType = 0;
        break;
    }
    SIP_END
#endif
 
    Q_DECLARE_TR_FUNCTIONS( QgsExpressionNode )
 
  public:
 
    enum NodeType
    {
      ntUnaryOperator, 
      ntBinaryOperator, 
      ntInOperator, 
      ntFunction,  
      ntLiteral, 
      ntColumnRef, 
      ntCondition, 
      ntIndexOperator, 
      ntBetweenOperator, 
    };
 
 
    struct NamedNode
    {
      public:
 
        NamedNode( const QString &name, QgsExpressionNode *node )
          : name( name )
          , node( node )
        {}
 
        QString name;
 
        QgsExpressionNode *node = nullptr;
    };
 
    class CORE_EXPORT NodeList
    {
      public:
        virtual ~NodeList();
        void append( QgsExpressionNode *node SIP_TRANSFER ) { mList.append( node ); mNameList.append( QString() ); }
 
        void append( QgsExpressionNode::NamedNode *node SIP_TRANSFER );
 
        int count() const { return mList.count(); }
 
        void reserve( int size ) { mList.reserve( size ); }
 
        bool hasNamedNodes() const { return mHasNamedNodes; }
 
        QList<QgsExpressionNode *> list() { return mList; }
 
        QgsExpressionNode *at( int i ) { return mList.at( i ); }
 
        QStringList names() const { return mNameList; }
 
        QgsExpressionNode::NodeList *clone() const SIP_FACTORY;
 
        virtual QString dump() const;
 
      private:
        QList<QgsExpressionNode *> mList;
        QStringList mNameList;
 
        bool mHasNamedNodes = false;
 
        static QString cleanNamedNodeName( const QString &name );
 
      public:
    };
 
    virtual ~QgsExpressionNode() = default;
 
    virtual QgsExpressionNode::NodeType nodeType() const = 0;
 
    virtual QString dump() const = 0;
 
    QVariant eval( QgsExpression *parent, const QgsExpressionContext *context );
 
    virtual QgsExpressionNode *clone() const = 0;
 
    virtual QSet<QString> referencedColumns() const = 0;
 
    virtual QSet<QString> referencedVariables() const = 0;
 
    virtual QSet<QString> referencedFunctions() const = 0;
 
    virtual QList<const QgsExpressionNode *> nodes( ) const = 0; SIP_SKIP
 
    virtual bool needsGeometry() const = 0;
 
    virtual bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const = 0;
 
    bool prepare( QgsExpression *parent, const QgsExpressionContext *context );
 
    int parserFirstLine = 0;
 
    int parserFirstColumn = 0;
 
    int parserLastLine = 0;
 
    int parserLastColumn = 0;
 
    bool hasCachedStaticValue() const { return mHasCachedValue; }
 
    QVariant cachedStaticValue() const { return mCachedStaticValue; }
 
    void setCachedStaticValue( const QVariant &value ) const SIP_SKIP;
 
    const QgsExpressionNode *effectiveNode() const { return mCompiledSimplifiedNode ? mCompiledSimplifiedNode.get() : this; }
 
  protected:
 
    QgsExpressionNode() = default;
 
    QgsExpressionNode( const QgsExpressionNode &other );
    QgsExpressionNode &operator=( const QgsExpressionNode &other );
 
    void cloneTo( QgsExpressionNode *target ) const SIP_SKIP;
 
#ifndef SIP_RUN
 
    mutable bool mHasCachedValue = false;
 
    mutable QVariant mCachedStaticValue;
 
    mutable std::unique_ptr< QgsExpressionNode > mCompiledSimplifiedNode;
#endif
 
  private:
 
    virtual bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) = 0;
 
    virtual QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) = 0;
 
};
 
Q_DECLARE_METATYPE( QgsExpressionNode * )
 
#endif // QGSEXPRESSIONNODE_H