api/qgsexpressionnodeimpl_8h_source.html

/***************************************************************************

                               qgsexpressionnodeimpl.h

                             -------------------

    begin                : May 2017

    copyright            : (C) 2017 Matthias Kuhn

    email                : matthias@opengis.ch

 ***************************************************************************

 *                                                                         *

 *   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 QGSEXPRESSIONNODEIMPL_H

#define QGSEXPRESSIONNODEIMPL_H


#include "qgsexpressionnode.h"

#include "qgsinterval.h"


class CORE_EXPORT QgsExpressionNodeUnaryOperator : public QgsExpressionNode

{

  public:


    enum UnaryOperator

    {

      uoNot,

      uoMinus,

    };

    enum UnaryOperator {…};


    QgsExpressionNodeUnaryOperator( QgsExpressionNodeUnaryOperator::UnaryOperator op, QgsExpressionNode *operand SIP_TRANSFER )

      : mOp( op )

      , mOperand( operand )

    {}

    QgsExpressionNodeUnaryOperator( QgsExpressionNodeUnaryOperator::UnaryOperator op, QgsExpressionNode *operand SIP_TRANSFER ) {…}


#ifdef SIP_RUN

    SIP_PYOBJECT __repr__();

    % MethodCode

    QString str = QStringLiteral( "<QgsExpressionNodeUnaryOperator: %1>" ).arg( sipCpp->text() );

    sipRes = PyUnicode_FromString( str.toUtf8().constData() );

    % End

#endif


    QgsExpressionNodeUnaryOperator::UnaryOperator op() const { return mOp; }


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


    QgsExpressionNode::NodeType nodeType() const override;

    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QString dump() const override;


    QSet<QString> referencedColumns() const override;

    QSet<QString> referencedVariables() const override;

    QSet<QString> referencedFunctions() const override;

    QList<const QgsExpressionNode *> nodes() const override; SIP_SKIP

    bool needsGeometry() const override;

    QgsExpressionNode *clone() const override SIP_FACTORY;


    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;


    QString text() const;


  private:


    QgsExpressionNodeUnaryOperator( const QgsExpressionNodeUnaryOperator &other ) = delete;

    QgsExpressionNodeUnaryOperator &operator=( const QgsExpressionNodeUnaryOperator &other ) = delete;


#ifdef SIP_RUN

    QgsExpressionNodeUnaryOperator( const QgsExpressionNodeUnaryOperator &other );

#endif


    UnaryOperator mOp;

    std::unique_ptr<QgsExpressionNode> mOperand;


    static const char *UNARY_OPERATOR_TEXT[];

};

class CORE_EXPORT QgsExpressionNodeUnaryOperator : public QgsExpressionNode {…};


class CORE_EXPORT QgsExpressionNodeBinaryOperator : public QgsExpressionNode

{

  public:


    enum BinaryOperator

    {

      // logical

      boOr,

      boAnd,


      // comparison

      boEQ,

      boNE,

      boLE,

      boGE,

      boLT,

      boGT,

      boRegexp,

      boLike,

      boNotLike,

      boILike,

      boNotILike,

      boIs,

      boIsNot,


      // math

      boPlus,

      boMinus,

      boMul,

      boDiv,

      boIntDiv,

      boMod,

      boPow,


      // strings

      boConcat,

    };

    enum BinaryOperator {…};


    QgsExpressionNodeBinaryOperator( QgsExpressionNodeBinaryOperator::BinaryOperator op, QgsExpressionNode *opLeft SIP_TRANSFER, QgsExpressionNode *opRight SIP_TRANSFER )

      : mOp( op )

      , mOpLeft( opLeft )

      , mOpRight( opRight )

    {}

    QgsExpressionNodeBinaryOperator( QgsExpressionNodeBinaryOperator::BinaryOperator op, QgsExpressionNode *opLeft SIP_TRANSFER, QgsExpressionNode *opRight SIP_TRANSFER ) {…}


#ifdef SIP_RUN

    SIP_PYOBJECT __repr__();

    % MethodCode

    QString str = QStringLiteral( "<QgsExpressionNodeBinaryOperator: %1>" ).arg( sipCpp->text() );

    sipRes = PyUnicode_FromString( str.toUtf8().constData() );

    % End

#endif


    QgsExpressionNodeBinaryOperator::BinaryOperator op() const { return mOp; }


    QgsExpressionNode *opLeft() const { return mOpLeft.get(); }


    QgsExpressionNode *opRight() const { return mOpRight.get(); }


    QgsExpressionNode::NodeType nodeType() const override;

    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QString dump() const override;


    QSet<QString> referencedColumns() const override;

    QSet<QString> referencedVariables() const override;

    QSet<QString> referencedFunctions() const override;

    QList<const QgsExpressionNode *> nodes( ) const override; SIP_SKIP


    bool needsGeometry() const override;

    QgsExpressionNode *clone() const override SIP_FACTORY;

    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;


    int precedence() const;


    bool leftAssociative() const;


    QString text() const;


  private:


    QgsExpressionNodeBinaryOperator( const QgsExpressionNodeBinaryOperator &other ) = delete;

    QgsExpressionNodeBinaryOperator &operator=( const QgsExpressionNodeBinaryOperator &other ) = delete;


#ifdef SIP_RUN

    QgsExpressionNodeBinaryOperator( const QgsExpressionNodeBinaryOperator &other );

#endif


    bool compare( double diff );

    qlonglong computeInt( qlonglong x, qlonglong y );

    double computeDouble( double x, double y );


    QDateTime computeDateTimeFromInterval( const QDateTime &d, QgsInterval *i );


    BinaryOperator mOp;

    std::unique_ptr<QgsExpressionNode> mOpLeft;

    std::unique_ptr<QgsExpressionNode> mOpRight;


    static const char *BINARY_OPERATOR_TEXT[];

};

class CORE_EXPORT QgsExpressionNodeBinaryOperator : public QgsExpressionNode {…};


class CORE_EXPORT QgsExpressionNodeIndexOperator : public QgsExpressionNode

{

  public:


    QgsExpressionNodeIndexOperator( QgsExpressionNode *container SIP_TRANSFER, QgsExpressionNode *index SIP_TRANSFER )

      : mContainer( container )

      , mIndex( index )

    {}

    QgsExpressionNodeIndexOperator( QgsExpressionNode *container SIP_TRANSFER, QgsExpressionNode *index SIP_TRANSFER ) {…}


    QgsExpressionNode *container() const { return mContainer.get(); }


    QgsExpressionNode *index() const { return mIndex.get(); }


    QgsExpressionNode::NodeType nodeType() const override;

    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QString dump() const override;


    QSet<QString> referencedColumns() const override;

    QSet<QString> referencedVariables() const override;

    QSet<QString> referencedFunctions() const override;

    QList<const QgsExpressionNode *> nodes( ) const override; SIP_SKIP


    bool needsGeometry() const override;

    QgsExpressionNode *clone() const override SIP_FACTORY;

    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;


  private:


    QgsExpressionNodeIndexOperator( const QgsExpressionNodeIndexOperator &other ) = delete;

    QgsExpressionNodeIndexOperator &operator=( const QgsExpressionNodeIndexOperator &other ) = delete;


#ifdef SIP_RUN

    QgsExpressionNodeIndexOperator( const QgsExpressionNodeIndexOperator &other );

#endif


    std::unique_ptr<QgsExpressionNode> mContainer;

    std::unique_ptr<QgsExpressionNode> mIndex;


};

class CORE_EXPORT QgsExpressionNodeIndexOperator : public QgsExpressionNode {…};


class CORE_EXPORT QgsExpressionNodeBetweenOperator: public QgsExpressionNode

{

  public:


    QgsExpressionNodeBetweenOperator( QgsExpressionNode *node SIP_TRANSFER, QgsExpressionNode *nodeLowerBound SIP_TRANSFER, QgsExpressionNode *nodeHigherBound SIP_TRANSFER, bool negate = false )

      : mNode( node )

      , mLowerBound( nodeLowerBound )

      , mHigherBound( nodeHigherBound )

      , mNegate( negate )

    {}

    QgsExpressionNodeBetweenOperator( QgsExpressionNode *node SIP_TRANSFER, QgsExpressionNode *nodeLowerBound SIP_TRANSFER, QgsExpressionNode *nodeHigherBound SIP_TRANSFER, bool negate = false ) {…}


    ~QgsExpressionNodeBetweenOperator() override;


    QgsExpressionNode *node() const { return mNode.get(); }


    QgsExpressionNode::NodeType nodeType() const override;

    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QString dump() const override;


    QSet<QString> referencedColumns() const override;

    QSet<QString> referencedVariables() const override;

    QSet<QString> referencedFunctions() const override;

    QList<const QgsExpressionNode *> nodes() const override; SIP_SKIP

    bool needsGeometry() const override;

    QgsExpressionNode *clone() const override SIP_FACTORY;

    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;


    QgsExpressionNode *lowerBound() const;


    QgsExpressionNode *higherBound() const;


    bool negate() const;


  private:


    QgsExpressionNodeBetweenOperator( const QgsExpressionNodeBetweenOperator &other ) = delete;

    QgsExpressionNodeBetweenOperator &operator=( const QgsExpressionNodeBetweenOperator &other ) = delete;


#ifdef SIP_RUN

    QgsExpressionNodeBetweenOperator( const QgsExpressionNodeBetweenOperator &other );

#endif


    std::unique_ptr<QgsExpressionNode> mNode;

    std::unique_ptr<QgsExpressionNode> mLowerBound;

    std::unique_ptr<QgsExpressionNode> mHigherBound;

    bool mNegate = false;


};

class CORE_EXPORT QgsExpressionNodeBetweenOperator: public QgsExpressionNode {…};


class CORE_EXPORT QgsExpressionNodeInOperator : public QgsExpressionNode

{

  public:


    QgsExpressionNodeInOperator( QgsExpressionNode *node SIP_TRANSFER, QgsExpressionNode::NodeList *list SIP_TRANSFER, bool notin = false )

      : mNode( node )

      , mList( list )

      , mNotIn( notin )

    {}

    QgsExpressionNodeInOperator( QgsExpressionNode *node SIP_TRANSFER, QgsExpressionNode::NodeList *list SIP_TRANSFER, bool notin = false ) {…}

    ~QgsExpressionNodeInOperator() override;


    QgsExpressionNode *node() const { return mNode.get(); }


    bool isNotIn() const { return mNotIn; }


    QgsExpressionNode::NodeList *list() const { return mList.get(); }


    QgsExpressionNode::NodeType nodeType() const override;

    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QString dump() const override;


    QSet<QString> referencedColumns() const override;

    QSet<QString> referencedVariables() const override;

    QSet<QString> referencedFunctions() const override;

    QList<const QgsExpressionNode *> nodes() const override; SIP_SKIP

    bool needsGeometry() const override;

    QgsExpressionNode *clone() const override SIP_FACTORY;

    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;


  private:


    QgsExpressionNodeInOperator( const QgsExpressionNodeInOperator &other ) = delete;

    QgsExpressionNodeInOperator &operator=( const QgsExpressionNodeInOperator &other ) = delete;


#ifdef SIP_RUN

    QgsExpressionNodeInOperator( const QgsExpressionNodeInOperator &other );

#endif


    std::unique_ptr<QgsExpressionNode> mNode;

    std::unique_ptr<QgsExpressionNodeInOperator::NodeList> mList;

    bool mNotIn;

};

class CORE_EXPORT QgsExpressionNodeInOperator : public QgsExpressionNode {…};


class CORE_EXPORT QgsExpressionNodeFunction : public QgsExpressionNode

{

  public:


    QgsExpressionNodeFunction( int fnIndex, QgsExpressionNode::NodeList *args SIP_TRANSFER );


    ~QgsExpressionNodeFunction() override;


#ifdef SIP_RUN

    SIP_PYOBJECT __repr__();

    % MethodCode

    QString function;

    if ( QgsExpressionFunction *fd = QgsExpression::QgsExpression::Functions()[sipCpp->fnIndex()] )

    {

      function = fd->name();

    }

    else

    {

      function = QString::number( sipCpp->fnIndex() );

    }


    QString str = QStringLiteral( "<QgsExpressionNodeFunction: %1>" ).arg( function );

    sipRes = PyUnicode_FromString( str.toUtf8().constData() );

    % End

#endif


    int fnIndex() const { return mFnIndex; }


    QgsExpressionNode::NodeList *args() const { return mArgs.get(); }


    QgsExpressionNode::NodeType nodeType() const override;

    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QString dump() const override;


    QSet<QString> referencedColumns() const override;

    QSet<QString> referencedVariables() const override;

    QSet<QString> referencedFunctions() const override;


    QList<const QgsExpressionNode *> nodes() const override; SIP_SKIP

    bool needsGeometry() const override;

    QgsExpressionNode *clone() const override SIP_FACTORY;

    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;


    static bool validateParams( int fnIndex, QgsExpressionNode::NodeList *args, QString &error );


  private:


    QgsExpressionNodeFunction( const QgsExpressionNodeFunction &other ) = delete;

    QgsExpressionNodeFunction &operator=( const QgsExpressionNodeFunction &other ) = delete;


#ifdef SIP_RUN

    QgsExpressionNodeFunction( const QgsExpressionNodeFunction &other );

#endif


    int mFnIndex;

    std::unique_ptr<NodeList> mArgs;

};

class CORE_EXPORT QgsExpressionNodeFunction : public QgsExpressionNode {…};


class CORE_EXPORT QgsExpressionNodeLiteral : public QgsExpressionNode

{

  public:


    QgsExpressionNodeLiteral( const QVariant &value )

      : mValue( value )

    {}

    QgsExpressionNodeLiteral( const QVariant &value ) {…}


#ifdef SIP_RUN

    SIP_PYOBJECT __repr__();

    % MethodCode

    QString str = QStringLiteral( "<QgsExpressionNodeLiteral: %1>" ).arg( sipCpp->valueAsString() );

    sipRes = PyUnicode_FromString( str.toUtf8().constData() );

    % End

#endif


    inline QVariant value() const { return mValue; }


    QgsExpressionNode::NodeType nodeType() const override;

    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QString dump() const override;


    QSet<QString> referencedColumns() const override;

    QSet<QString> referencedVariables() const override;

    QSet<QString> referencedFunctions() const override;


    QList<const QgsExpressionNode *> nodes() const override; SIP_SKIP

    bool needsGeometry() const override;

    QgsExpressionNode *clone() const override SIP_FACTORY;

    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;


    QString valueAsString() const;


  private:

    QVariant mValue;

};

class CORE_EXPORT QgsExpressionNodeLiteral : public QgsExpressionNode {…};


class CORE_EXPORT QgsExpressionNodeColumnRef : public QgsExpressionNode

{

  public:


    QgsExpressionNodeColumnRef( const QString &name )

      : mName( name )

      , mIndex( -1 )

    {}

    QgsExpressionNodeColumnRef( const QString &name ) {…}


#ifdef SIP_RUN

    SIP_PYOBJECT __repr__();

    % MethodCode

    QString str = QStringLiteral( "<QgsExpressionNodeColumnRef: \"%1\">" ).arg( sipCpp->name() );

    sipRes = PyUnicode_FromString( str.toUtf8().constData() );

    % End

#endif


    QString name() const { return mName; }


    QgsExpressionNode::NodeType nodeType() const override;

    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QString dump() const override;


    QSet<QString> referencedColumns() const override;

    QSet<QString> referencedVariables() const override;

    QSet<QString> referencedFunctions() const override;

    QList<const QgsExpressionNode *> nodes( ) const override; SIP_SKIP


    bool needsGeometry() const override;


    QgsExpressionNode *clone() const override SIP_FACTORY;

    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;


  private:

    QString mName;

    int mIndex;

};

class CORE_EXPORT QgsExpressionNodeColumnRef : public QgsExpressionNode {…};


class CORE_EXPORT QgsExpressionNodeCondition : public QgsExpressionNode

{

  public:


    class CORE_EXPORT WhenThen

    {

      public:


        WhenThen( QgsExpressionNode *whenExp, QgsExpressionNode *thenExp );

        ~WhenThen();


        WhenThen( const WhenThen &rh ) = delete;

        WhenThen &operator=( const WhenThen &rh ) = delete;


        QgsExpressionNodeCondition::WhenThen *clone() const SIP_FACTORY;


        QgsExpressionNode *whenExp() const { return mWhenExp.get(); }


        QgsExpressionNode *thenExp() const { return mThenExp.get(); }


      private:

#ifdef SIP_RUN

        WhenThen( const QgsExpressionNodeCondition::WhenThen &rh );

#endif

        std::unique_ptr<QgsExpressionNode> mWhenExp;

        std::unique_ptr<QgsExpressionNode> mThenExp;


        friend class QgsExpressionNodeCondition;

    };

    class CORE_EXPORT WhenThen {…};

    typedef QList<QgsExpressionNodeCondition::WhenThen *> WhenThenList;


    QgsExpressionNodeCondition( QgsExpressionNodeCondition::WhenThenList *conditions, QgsExpressionNode *elseExp = nullptr );


    QgsExpressionNodeCondition( const QgsExpressionNodeCondition::WhenThenList &conditions, QgsExpressionNode *elseExp = nullptr ) SIP_SKIP

  : mConditions( conditions )

    , mElseExp( elseExp )

    {}

    QgsExpressionNodeCondition( const QgsExpressionNodeCondition::WhenThenList &conditions, QgsExpressionNode *elseExp = nullptr ) SIP_SKIP {…}


    ~QgsExpressionNodeCondition() override;


    QgsExpressionNode::NodeType nodeType() const override;

    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;

    QString dump() const override;


    WhenThenList conditions() const { return mConditions; }


    QgsExpressionNode *elseExp() const { return mElseExp.get(); }


    QSet<QString> referencedColumns() const override;

    QSet<QString> referencedVariables() const override;

    QSet<QString> referencedFunctions() const override;


    QList<const QgsExpressionNode *> nodes() const override; SIP_SKIP


    bool needsGeometry() const override;

    QgsExpressionNode *clone() const override SIP_FACTORY;

    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;


  private:


    QgsExpressionNodeCondition( const QgsExpressionNodeCondition &other ) = delete;

    QgsExpressionNodeCondition &operator=( const QgsExpressionNodeCondition &other ) = delete;


#ifdef SIP_RUN

    QgsExpressionNodeCondition( const QgsExpressionNodeCondition &other );

#endif


    WhenThenList mConditions;

    std::unique_ptr<QgsExpressionNode> mElseExp;

};

class CORE_EXPORT QgsExpressionNodeCondition : public QgsExpressionNode {…};


#endif // QGSEXPRESSIONNODEIMPL_H

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

QgsExpressionFunction
An abstract base class for defining QgsExpression functions.
Definition qgsexpressionfunction.h:41

QgsExpressionNodeBetweenOperator
SQL-like BETWEEN and NOT BETWEEN predicates.
Definition qgsexpressionnodeimpl.h:302

QgsExpressionNodeBetweenOperator::node
QgsExpressionNode * node() const
Returns the expression node.
Definition qgsexpressionnodeimpl.h:320

QgsExpressionNodeBetweenOperator::QgsExpressionNodeBetweenOperator
QgsExpressionNodeBetweenOperator(QgsExpressionNode *node, QgsExpressionNode *nodeLowerBound, QgsExpressionNode *nodeHigherBound, bool negate=false)
This node tests if the result of node is between the result of nodeLowerBound and nodeHigherBound nod...
Definition qgsexpressionnodeimpl.h:308

QgsExpressionNodeBinaryOperator
A binary expression operator, which operates on two values.
Definition qgsexpressionnodeimpl.h:107

QgsExpressionNodeBinaryOperator::opLeft
QgsExpressionNode * opLeft() const
Returns the node to the left of the operator.
Definition qgsexpressionnodeimpl.h:174

QgsExpressionNodeBinaryOperator::opRight
QgsExpressionNode * opRight() const
Returns the node to the right of the operator.
Definition qgsexpressionnodeimpl.h:180

QgsExpressionNodeBinaryOperator::op
QgsExpressionNodeBinaryOperator::BinaryOperator op() const
Returns the binary operator.
Definition qgsexpressionnodeimpl.h:168

QgsExpressionNodeBinaryOperator::QgsExpressionNodeBinaryOperator
QgsExpressionNodeBinaryOperator(QgsExpressionNodeBinaryOperator::BinaryOperator op, QgsExpressionNode *opLeft, QgsExpressionNode *opRight)
Binary combination of the left and the right with op.
Definition qgsexpressionnodeimpl.h:151

QgsExpressionNodeBinaryOperator::BinaryOperator
BinaryOperator
list of binary operators
Definition qgsexpressionnodeimpl.h:115

QgsExpressionNodeBinaryOperator::boILike
@ boILike
Definition qgsexpressionnodeimpl.h:130

QgsExpressionNodeBinaryOperator::boOr
@ boOr
Definition qgsexpressionnodeimpl.h:117

QgsExpressionNodeBinaryOperator::boIs
@ boIs
Definition qgsexpressionnodeimpl.h:132

QgsExpressionNodeBinaryOperator::boDiv
@ boDiv
Definition qgsexpressionnodeimpl.h:139

QgsExpressionNodeBinaryOperator::boNotLike
@ boNotLike
Definition qgsexpressionnodeimpl.h:129

QgsExpressionNodeBinaryOperator::boGE
@ boGE
>=
Definition qgsexpressionnodeimpl.h:124

QgsExpressionNodeBinaryOperator::boMod
@ boMod
Definition qgsexpressionnodeimpl.h:141

QgsExpressionNodeBinaryOperator::boMul
@ boMul
Definition qgsexpressionnodeimpl.h:138

QgsExpressionNodeBinaryOperator::boConcat
@ boConcat
Definition qgsexpressionnodeimpl.h:145

QgsExpressionNodeBinaryOperator::boAnd
@ boAnd
Definition qgsexpressionnodeimpl.h:118

QgsExpressionNodeBinaryOperator::boEQ
@ boEQ
=
Definition qgsexpressionnodeimpl.h:121

QgsExpressionNodeBinaryOperator::boMinus
@ boMinus
Definition qgsexpressionnodeimpl.h:137

QgsExpressionNodeBinaryOperator::boPlus
@ boPlus
Definition qgsexpressionnodeimpl.h:136

QgsExpressionNodeBinaryOperator::boNotILike
@ boNotILike
Definition qgsexpressionnodeimpl.h:131

QgsExpressionNodeBinaryOperator::boNE
@ boNE
<>
Definition qgsexpressionnodeimpl.h:122

QgsExpressionNodeBinaryOperator::boPow
@ boPow
Definition qgsexpressionnodeimpl.h:142

QgsExpressionNodeBinaryOperator::boRegexp
@ boRegexp
Definition qgsexpressionnodeimpl.h:127

QgsExpressionNodeBinaryOperator::boLike
@ boLike
Definition qgsexpressionnodeimpl.h:128

QgsExpressionNodeBinaryOperator::boLE
@ boLE
<=
Definition qgsexpressionnodeimpl.h:123

QgsExpressionNodeBinaryOperator::boGT
@ boGT
‍
Definition qgsexpressionnodeimpl.h:126

QgsExpressionNodeBinaryOperator::boLT
@ boLT
<
Definition qgsexpressionnodeimpl.h:125

QgsExpressionNodeBinaryOperator::boIsNot
@ boIsNot
Definition qgsexpressionnodeimpl.h:133

QgsExpressionNodeBinaryOperator::boIntDiv
@ boIntDiv
Definition qgsexpressionnodeimpl.h:140

QgsExpressionNodeColumnRef
An expression node which takes its value from a feature's field.
Definition qgsexpressionnodeimpl.h:560

QgsExpressionNodeColumnRef::QgsExpressionNodeColumnRef
QgsExpressionNodeColumnRef(const QString &name)
Constructor for QgsExpressionNodeColumnRef, referencing the column with the specified name.
Definition qgsexpressionnodeimpl.h:567

QgsExpressionNodeColumnRef::name
QString name() const
The name of the column.
Definition qgsexpressionnodeimpl.h:581

QgsExpressionNodeCondition::WhenThen
Represents a "WHEN... THEN..." portation of a CASE WHEN clause in an expression.
Definition qgsexpressionnodeimpl.h:616

QgsExpressionNodeCondition::WhenThen::operator=
WhenThen & operator=(const WhenThen &rh)=delete

QgsExpressionNodeCondition::WhenThen::WhenThen
WhenThen(const WhenThen &rh)=delete

QgsExpressionNodeCondition::WhenThen::thenExp
QgsExpressionNode * thenExp() const
The expression node that makes the THEN result part of the condition.
Definition qgsexpressionnodeimpl.h:644

QgsExpressionNodeCondition
An expression node for CASE WHEN clauses.
Definition qgsexpressionnodeimpl.h:608

QgsExpressionNodeCondition::QgsExpressionNodeCondition
QgsExpressionNodeCondition(const QgsExpressionNodeCondition::WhenThenList &conditions, QgsExpressionNode *elseExp=nullptr)
Create a new node with the given list of conditions and an optional elseExp expression.
Definition qgsexpressionnodeimpl.h:665

QgsExpressionNodeCondition::WhenThenList
QList< QgsExpressionNodeCondition::WhenThen * > WhenThenList
Definition qgsexpressionnodeimpl.h:655

QgsExpressionNodeCondition::elseExp
QgsExpressionNode * elseExp() const
The ELSE expression used for the condition.
Definition qgsexpressionnodeimpl.h:687

QgsExpressionNodeCondition::conditions
WhenThenList conditions() const
The list of WHEN THEN expression parts of the expression.
Definition qgsexpressionnodeimpl.h:681

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

QgsExpressionNodeFunction::fnIndex
int fnIndex() const
Returns the index of the node's function.
Definition qgsexpressionnodeimpl.h:465

QgsExpressionNodeFunction::args
QgsExpressionNode::NodeList * args() const
Returns a list of arguments specified for the function.
Definition qgsexpressionnodeimpl.h:470

QgsExpressionNodeInOperator
An expression node for value IN or NOT IN clauses.
Definition qgsexpressionnodeimpl.h:373

QgsExpressionNodeInOperator::node
QgsExpressionNode * node() const
Returns the expression node.
Definition qgsexpressionnodeimpl.h:389

QgsExpressionNodeInOperator::QgsExpressionNodeInOperator
QgsExpressionNodeInOperator(QgsExpressionNode *node, QgsExpressionNode::NodeList *list, bool notin=false)
This node tests if the result of node is in the result of list.
Definition qgsexpressionnodeimpl.h:379

QgsExpressionNodeInOperator::list
QgsExpressionNode::NodeList * list() const
Returns the list of nodes to search for matching values within.
Definition qgsexpressionnodeimpl.h:399

QgsExpressionNodeInOperator::isNotIn
bool isNotIn() const
Returns true if this node is a "NOT IN" operator, or false if the node is a normal "IN" operator.
Definition qgsexpressionnodeimpl.h:394

QgsExpressionNodeIndexOperator
An indexing expression operator, which allows use of square brackets [] to reference map and array it...
Definition qgsexpressionnodeimpl.h:245

QgsExpressionNodeIndexOperator::QgsExpressionNodeIndexOperator
QgsExpressionNodeIndexOperator(QgsExpressionNode *container, QgsExpressionNode *index)
Constructor for QgsExpressionNodeIndexOperator.
Definition qgsexpressionnodeimpl.h:251

QgsExpressionNodeIndexOperator::index
QgsExpressionNode * index() const
Returns the index node, representing an array element index or map key.
Definition qgsexpressionnodeimpl.h:266

QgsExpressionNodeIndexOperator::container
QgsExpressionNode * container() const
Returns the container node, representing an array or map value.
Definition qgsexpressionnodeimpl.h:260

QgsExpressionNodeLiteral
An expression node for literal values.
Definition qgsexpressionnodeimpl.h:509

QgsExpressionNodeLiteral::value
QVariant value() const
The value of the literal.
Definition qgsexpressionnodeimpl.h:528

QgsExpressionNodeLiteral::QgsExpressionNodeLiteral
QgsExpressionNodeLiteral(const QVariant &value)
Constructor for QgsExpressionNodeLiteral, with the specified literal value.
Definition qgsexpressionnodeimpl.h:515

QgsExpressionNodeUnaryOperator
A unary node is either negative as in boolean (not) or as in numbers (minus).
Definition qgsexpressionnodeimpl.h:28

QgsExpressionNodeUnaryOperator::op
QgsExpressionNodeUnaryOperator::UnaryOperator op() const
Returns the unary operator.
Definition qgsexpressionnodeimpl.h:60

QgsExpressionNodeUnaryOperator::QgsExpressionNodeUnaryOperator
QgsExpressionNodeUnaryOperator(QgsExpressionNodeUnaryOperator::UnaryOperator op, QgsExpressionNode *operand)
A node unary operator is modifying the value of operand by negating it with op.
Definition qgsexpressionnodeimpl.h:44

QgsExpressionNodeUnaryOperator::operand
QgsExpressionNode * operand() const
Returns the node the operator will operate upon.
Definition qgsexpressionnodeimpl.h:65

QgsExpressionNodeUnaryOperator::UnaryOperator
UnaryOperator
list of unary operators
Definition qgsexpressionnodeimpl.h:36

QgsExpressionNodeUnaryOperator::uoNot
@ uoNot
Definition qgsexpressionnodeimpl.h:37

QgsExpressionNodeUnaryOperator::uoMinus
@ uoMinus
Definition qgsexpressionnodeimpl.h:38

QgsExpressionNode::NodeList
A list of expression nodes.
Definition qgsexpressionnode.h:121

QgsExpressionNode
Abstract base class for all nodes that can appear in an expression.
Definition qgsexpressionnode.h:35

QgsExpressionNode::dump
virtual QString dump() const =0
Dump this node into a serialized (part) of an expression.

QgsExpressionNode::clone
virtual QgsExpressionNode * clone() const =0
Generate a clone of this node.

QgsExpressionNode::referencedColumns
virtual QSet< QString > referencedColumns() const =0
Abstract virtual method which returns a list of columns required to evaluate this node.

QgsExpressionNode::nodeType
virtual QgsExpressionNode::NodeType nodeType() const =0
Gets the type of this node.

QgsExpressionNode::referencedVariables
virtual QSet< QString > referencedVariables() const =0
Returns a set of all variables which are used in this expression.

QgsExpressionNode::NodeType
NodeType
Known node types.
Definition qgsexpressionnode.h:78

QgsExpressionNode::needsGeometry
virtual bool needsGeometry() const =0
Abstract virtual method which returns if the geometry is required to evaluate this expression.

QgsExpressionNode::nodes
virtual QList< const QgsExpressionNode * > nodes() const =0
Returns a list of all nodes which are used in this expression.

QgsExpressionNode::referencedFunctions
virtual QSet< QString > referencedFunctions() const =0
Returns a set of all functions which are used in this expression.

QgsExpression
Handles parsing and evaluation of expressions (formerly called "search strings").
Definition qgsexpression.h:190

QgsInterval
A representation of the interval between two datetime values.
Definition qgsinterval.h:46

SIP_SKIP
#define SIP_SKIP
Definition qgis_sip.h:126

SIP_TRANSFER
#define SIP_TRANSFER
Definition qgis_sip.h:36

SIP_FACTORY
#define SIP_FACTORY
Definition qgis_sip.h:76

qgsexpressionnode.h

qgsinterval.h