EnhancedPathFormula.h

Go to the documentation of this file.

/* This file is part of the KDE project
 * SPDX-FileCopyrightText: 2007 Jan Hambrecht <jaham@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
#ifndef KOENHANCEDPATHFORMULA_H
#define KOENHANCEDPATHFORMULA_H
 
#include <QString>
#include <QVariant>
 
class EnhancedPathShape;
 
class FormulaToken
{
public:
    enum Type {
        TypeUnknown = 0, 
        TypeNumber,      
        TypeOperator,    
        TypeReference,   
        TypeFunction     
    };
 
    enum Operator {
        OperatorInvalid,   
        OperatorAdd,       
        OperatorSub,       
        OperatorMul,       
        OperatorDiv,       
        OperatorLeftPar,   
        OperatorRightPar,  
        OperatorComma      
    };
 
    explicit FormulaToken(Type type = TypeUnknown, const QString &text = QString(), int position = -1);
 
    FormulaToken(const FormulaToken &token);
 
    FormulaToken &operator=(const FormulaToken &token);
 
    Type type() const
    {
        return m_type;
    }
    QString text() const
    {
        return m_text;
    }
    int position() const
    {
        return m_position;
    }
 
    bool isNumber() const
    {
        return m_type == TypeNumber;
    }
    bool isOperator() const
    {
        return m_type == TypeOperator;
    }
    bool isFunction() const
    {
        return m_type == TypeFunction;
    }
    bool isReference() const
    {
        return m_type == TypeReference;
    }
 
    qreal asNumber() const;
    Operator asOperator() const;
private:
    Type m_type {TypeUnknown};    
    QString m_text; 
    int m_position {-1}; 
};
 
typedef QList<FormulaToken> TokenList;
 
class Opcode;
 
class EnhancedPathFormula
{
public:
    enum Function {
        FunctionUnknown,
        // unary functions
        FunctionAbs,
        FunctionSqrt,
        FunctionSin,
        FunctionCos,
        FunctionTan,
        FunctionAtan,
        // binary functions
        FunctionAtan2,
        FunctionMin,
        FunctionMax,
        // ternary functions
        FunctionIf
    };
 
    enum Error {
        ErrorNone,    
        ErrorValue,   
        ErrorParse,   
        ErrorCompile, 
        ErrorName     
    };
 
    EnhancedPathFormula(const QString &text, EnhancedPathShape *parent);
 
    ~EnhancedPathFormula();
 
    qreal evaluate();
 
    Error error() const
    {
        return m_error;
    }
 
    QString toString() const;
private:
    TokenList scan(const QString &formula) const;
 
    bool compile(const TokenList &tokens);
 
    qreal evaluateFunction(Function function, const QList<qreal> &arguments) const;
 
    void debugTokens(const TokenList &tokens);
    void debugOpcodes();
 
    bool m_valid;    
    bool m_compiled; 
    Error m_error;   
    QString m_text; 
    QList<QVariant> m_constants; 
    QList<Opcode> m_codes; 
    EnhancedPathShape *m_parent;
};
 
#endif // KOENHANCEDPATHFORMULA_H