EnhancedPathFormula Class Reference

#include <EnhancedPathFormula.h>

Public Types
enum	Error {   ErrorNone , ErrorValue , ErrorParse , ErrorCompile ,   ErrorName }
	The possible error code returned by error() More...
enum	Function {   FunctionUnknown , FunctionAbs , FunctionSqrt , FunctionSin ,   FunctionCos , FunctionTan , FunctionAtan , FunctionAtan2 ,   FunctionMin , FunctionMax , FunctionIf }
	predefined functions More...

Public Member Functions
	EnhancedPathFormula (const QString &text, EnhancedPathShape *parent)
	Constructs a new formula from the specified string representation.
Error	error () const
	Returns the last occurred error.
qreal	evaluate ()
QString	toString () const
	returns string representation of the formula
	~EnhancedPathFormula ()
	Destroys the formula.

Private Member Functions
bool	compile (const TokenList &tokens)
	Compiles the formula tokens into byte code.
void	debugOpcodes ()
	Prints byte code.
void	debugTokens (const TokenList &tokens)
	Prints token list.
qreal	evaluateFunction (Function function, const QList< qreal > &arguments) const
TokenList	scan (const QString &formula) const
	Separates the given formula text into tokens.

Private Attributes
QList< Opcode >	m_codes
	the compiled byte code
bool	m_compiled
	flag that shows if function was compiled
QList< QVariant >	m_constants
	constant values
Error	m_error
	the last occurred error
EnhancedPathShape *	m_parent
QString	m_text
	the formula text representation
bool	m_valid
	flag that shows if function is valid, i.e the function was compiled successfully

Detailed Description

Definition at line 99 of file EnhancedPathFormula.h.

Member Enumeration Documentation

Error

enum EnhancedPathFormula::Error

The possible error code returned by error()

Enumerator
ErrorNone	no error
ErrorValue	error when converting value
ErrorParse	parsing error
ErrorCompile	compiling error
ErrorName	invalid function name value

Definition at line 121 of file EnhancedPathFormula.h.

               {
        ErrorNone,    
        ErrorValue,   
        ErrorParse,   
        ErrorCompile, 
        ErrorName     
    };

Function

enum EnhancedPathFormula::Function

predefined functions

Enumerator
FunctionUnknown
FunctionAbs
FunctionSqrt
FunctionSin
FunctionCos
FunctionTan
FunctionAtan
FunctionAtan2
FunctionMin
FunctionMax
FunctionIf

Definition at line 103 of file EnhancedPathFormula.h.

                  {
        FunctionUnknown,
        // unary functions
        FunctionAbs,
        FunctionSqrt,
        FunctionSin,
        FunctionCos,
        FunctionTan,
        FunctionAtan,
        // binary functions
        FunctionAtan2,
        FunctionMin,
        FunctionMax,
        // ternary functions
        FunctionIf
    };

Constructor & Destructor Documentation

EnhancedPathFormula()

EnhancedPathFormula::EnhancedPathFormula	(	const QString &	text,
		EnhancedPathShape *	parent )

Constructs a new formula from the specified string representation.

Definition at line 99 of file EnhancedPathFormula.cpp.

    : m_valid(false)
    , m_compiled(false)
    , m_error(ErrorNone)
    , m_text(text)
    , m_parent(parent)
{
    Q_ASSERT(m_parent);
}

References m_parent.

~EnhancedPathFormula()

EnhancedPathFormula::~EnhancedPathFormula

(

)

Destroys the formula.

Definition at line 109 of file EnhancedPathFormula.cpp.

{
}

Member Function Documentation

compile()

bool EnhancedPathFormula::compile ( const TokenList & tokens )

private

Compiles the formula tokens into byte code.

Definition at line 426 of file EnhancedPathFormula.cpp.

{
    // sanity check
    if (tokens.count() == 0) {
        return false;
    }
 
    FormulaTokenStack syntaxStack;
    QStack<int> argStack;
    unsigned argCount = 1;
 
    for (int i = 0; i <= tokens.count(); i++) {
        // helper token: InvalidOp is end-of-formula
        FormulaToken token = (i < tokens.count()) ? tokens[i] : FormulaToken(FormulaToken::TypeOperator);
        FormulaToken::Type tokenType = token.type();
 
        // unknown token is invalid
        if (tokenType == FormulaToken::TypeUnknown) {
            break;
        }
 
        // for constants, push immediately to stack
        // generate code to load from a constant
        if (tokenType == FormulaToken::TypeNumber) {
            syntaxStack.push(token);
            m_constants.append(QVariant(token.asNumber()));
            m_codes.append(Opcode(Opcode::Load, m_constants.count() - 1));
        }
        // for identifier, push immediately to stack
        // generate code to load from reference
        if (tokenType == FormulaToken::TypeFunction || tokenType == FormulaToken::TypeReference) {
            syntaxStack.push(token);
            m_constants.append(QVariant(token.text()));
            m_codes.append(Opcode(Opcode::Ref, m_constants.count() - 1));
        }
        // are we entering a function ?
        // if token is operator, and stack already has: id (arg
        if (tokenType == FormulaToken::TypeOperator && syntaxStack.itemCount() >= 3) {
            FormulaToken arg = syntaxStack.top();
            FormulaToken par = syntaxStack.top(1);
            FormulaToken id = syntaxStack.top(2);
            if (!arg.isOperator() &&
                    par.asOperator() == FormulaToken::OperatorLeftPar &&
                    id.isFunction()) {
                argStack.push(argCount);
                argCount = 1;
            }
        }
        // for any other operator, try to apply all parsing rules
        if (tokenType == FormulaToken::TypeOperator) {
            // repeat until no more rule applies
            for (;;) {
                bool ruleFound = false;
 
                // rule for function arguments, if token is , or)
                // id (arg1 , arg2 -> id (arg
                if (!ruleFound)
                    if (syntaxStack.itemCount() >= 5)
                        if ((token.asOperator() == FormulaToken::OperatorRightPar) ||
                                (token.asOperator() == FormulaToken::OperatorComma)) {
                            FormulaToken arg2 = syntaxStack.top();
                            FormulaToken sep = syntaxStack.top(1);
                            FormulaToken arg1 = syntaxStack.top(2);
                            FormulaToken par = syntaxStack.top(3);
                            FormulaToken id = syntaxStack.top(4);
                            if (!arg2.isOperator())
                                if (sep.asOperator() == FormulaToken::OperatorComma)
                                    if (!arg1.isOperator())
                                        if (par.asOperator() == FormulaToken::OperatorLeftPar)
                                            if (id.isFunction()) {
                                                ruleFound = true;
                                                syntaxStack.pop();
                                                syntaxStack.pop();
                                                argCount++;
                                            }
                        }
                // rule for function last argument:
                //  id (arg) -> arg
                if (!ruleFound)
                    if (syntaxStack.itemCount() >= 4) {
                        FormulaToken par2 = syntaxStack.top();
                        FormulaToken arg = syntaxStack.top(1);
                        FormulaToken par1 = syntaxStack.top(2);
                        FormulaToken id = syntaxStack.top(3);
                        if (par2.asOperator() == FormulaToken::OperatorRightPar)
                            if (!arg.isOperator())
                                if (par1.asOperator() == FormulaToken::OperatorLeftPar)
                                    if (id.isFunction()) {
                                        ruleFound = true;
                                        syntaxStack.pop();
                                        syntaxStack.pop();
                                        syntaxStack.pop();
                                        syntaxStack.pop();
                                        syntaxStack.push(arg);
                                        m_codes.append(Opcode(Opcode::Function, argCount));
                                        argCount = argStack.empty() ? 0 : argStack.pop();
                                    }
                    }
 
                // rule for parenthesis:  (Y) -> Y
                if (!ruleFound)
                    if (syntaxStack.itemCount() >= 3) {
                        FormulaToken right = syntaxStack.top();
                        FormulaToken y = syntaxStack.top(1);
                        FormulaToken left = syntaxStack.top(2);
                        if (right.isOperator())
                            if (!y.isOperator())
                                if (left.isOperator())
                                    if (right.asOperator() == FormulaToken::OperatorRightPar)
                                        if (left.asOperator() == FormulaToken::OperatorLeftPar) {
                                            ruleFound = true;
                                            syntaxStack.pop();
                                            syntaxStack.pop();
                                            syntaxStack.pop();
                                            syntaxStack.push(y);
                                        }
                    }
 
                // rule for binary operator:  A (op) B -> A
                // conditions: precedence of op >= precedence of token
                // action: push (op) to result
                // e.g. "A * B" becomes 'A' if token is operator '+'
                if (!ruleFound)
                    if (syntaxStack.itemCount() >= 3) {
                        FormulaToken b = syntaxStack.top();
                        FormulaToken op = syntaxStack.top(1);
                        FormulaToken a = syntaxStack.top(2);
                        if (!a.isOperator())
                            if (!b.isOperator())
                                if (op.isOperator())
                                    if (token.asOperator() != FormulaToken::OperatorLeftPar)
                                        if (opPrecedence(op.asOperator()) >= opPrecedence(token.asOperator())) {
                                            ruleFound = true;
                                            syntaxStack.pop();
                                            syntaxStack.pop();
                                            syntaxStack.pop();
                                            syntaxStack.push(b);
                                            switch (op.asOperator()) {
                                            // simple binary operations
                                            case FormulaToken::OperatorAdd: m_codes.append(Opcode::Add); break;
                                            case FormulaToken::OperatorSub: m_codes.append(Opcode::Sub); break;
                                            case FormulaToken::OperatorMul: m_codes.append(Opcode::Mul); break;
                                            case FormulaToken::OperatorDiv: m_codes.append(Opcode::Div); break;
                                            default: break;
                                            }
                                        }
                    }
 
                // rule for unary operator:  (op1) (op2) X -> (op1) X
                // conditions: op2 is unary, token is not '('
                // action: push (op2) to result
                // e.g.  "* - 2" becomes '*'
                if (!ruleFound)
                    if (token.asOperator() != FormulaToken::OperatorLeftPar)
                        if (syntaxStack.itemCount() >= 3) {
                            FormulaToken x = syntaxStack.top();
                            FormulaToken op2 = syntaxStack.top(1);
                            FormulaToken op1 = syntaxStack.top(2);
                            if (!x.isOperator())
                                if (op1.isOperator())
                                    if (op2.isOperator())
                                        if ((op2.asOperator() == FormulaToken::OperatorAdd)
                                                || (op2.asOperator() == FormulaToken::OperatorSub)) {
                                            ruleFound = true;
                                            syntaxStack.pop();
                                            syntaxStack.pop();
                                            syntaxStack.push(x);
                                            if (op2.asOperator() == FormulaToken::OperatorSub) {
                                                m_codes.append(Opcode(Opcode::Neg));
                                            }
                                        }
                        }
 
                // auxiliary rule for unary operator:  (op) X -> X
                // conditions: op is unary, op is first in syntax stack, token is not '('
                // action: push (op) to result
                if (!ruleFound)
                    if (token.asOperator() != FormulaToken::OperatorLeftPar)
                        if (syntaxStack.itemCount() == 2) {
                            FormulaToken x = syntaxStack.top();
                            FormulaToken op = syntaxStack.top(1);
                            if (!x.isOperator())
                                if (op.isOperator())
                                    if ((op.asOperator() == FormulaToken::OperatorAdd)
                                            || (op.asOperator() == FormulaToken::OperatorSub)) {
                                        ruleFound = true;
                                        syntaxStack.pop();
                                        syntaxStack.pop();
                                        syntaxStack.push(x);
                                        if (op.asOperator() == FormulaToken::OperatorSub) {
                                            m_codes.append(Opcode(Opcode::Neg));
                                        }
                                    }
                        }
 
                if (!ruleFound) {
                    break;
                }
            }
 
            syntaxStack.push(token);
        }
    }
 
    // syntaxStack must left only one operand and end-of-formula (i.e. InvalidOp)
    m_valid = false;
    if (syntaxStack.itemCount() == 2)
        if (syntaxStack.top().isOperator())
            if (syntaxStack.top().asOperator() == FormulaToken::OperatorInvalid)
                if (!syntaxStack.top(1).isOperator()) {
                    m_valid = true;
                }
 
    // bad parsing ? clean-up everything
    if (!m_valid) {
        m_constants.clear();
        m_codes.clear();
        qWarning() << "compiling of " << m_text << " failed";
    }
 
    return m_valid;
}

References Opcode::Add, FormulaToken::asNumber(), FormulaToken::asOperator(), Opcode::Div, Opcode::Function, FormulaToken::isOperator(), FormulaTokenStack::itemCount(), Opcode::Load, m_codes, m_constants, m_text, m_valid, Opcode::Mul, Opcode::Neg, FormulaToken::OperatorAdd, FormulaToken::OperatorComma, FormulaToken::OperatorDiv, FormulaToken::OperatorInvalid, FormulaToken::OperatorLeftPar, FormulaToken::OperatorMul, FormulaToken::OperatorRightPar, FormulaToken::OperatorSub, opPrecedence(), FormulaTokenStack::pop(), FormulaTokenStack::push(), Opcode::Ref, Opcode::Sub, FormulaToken::text(), FormulaTokenStack::top(), FormulaToken::type(), FormulaToken::TypeFunction, FormulaToken::TypeNumber, FormulaToken::TypeOperator, FormulaToken::TypeReference, and FormulaToken::TypeUnknown.

debugOpcodes()

void EnhancedPathFormula::debugOpcodes ( )

private

Prints byte code.

Definition at line 828 of file EnhancedPathFormula.cpp.

{
#ifndef NDEBUG
    foreach (const Opcode &c, m_codes) {
        QString ctext;
        switch (c.type) {
        case Opcode::Load: ctext = QString("Load #%1").arg(c.index); break;
        case Opcode::Ref: ctext = QString("Ref #%1").arg(c.index); break;
        case Opcode::Function: ctext = QString("Function (%1)").arg(c.index); break;
        case Opcode::Add: ctext = "Add"; break;
        case Opcode::Sub: ctext = "Sub"; break;
        case Opcode::Mul: ctext = "Mul"; break;
        case Opcode::Div: ctext = "Div"; break;
        case Opcode::Neg: ctext = "Neg"; break;
        default: ctext = "Unknown"; break;
        }
        qDebug() << ctext;
    }
#endif
}

References Opcode::Add, Opcode::Div, Opcode::Function, Opcode::index, Opcode::Load, m_codes, Opcode::Mul, Opcode::Neg, Opcode::Ref, Opcode::Sub, and Opcode::type.

debugTokens()

void EnhancedPathFormula::debugTokens ( const TokenList & tokens )

private

Prints token list.

Definition at line 817 of file EnhancedPathFormula.cpp.

{
#ifndef NDEBUG
    for (int i = 0; i < tokens.count(); i++) {
        qDebug() << tokens[i].text();
    }
#else
    Q_UNUSED(tokens);
#endif
}

error()

Error EnhancedPathFormula::error ( ) const

inline

Returns the last occurred error.

Definition at line 144 of file EnhancedPathFormula.h.

    {
        return m_error;
    }

References m_error.

evaluate()

qreal EnhancedPathFormula::evaluate

(

)

Evaluates the formula using the given path as possible input.

Parameters

path	the path to use as input

Returns

the evaluated result

prepare function arguments

Definition at line 113 of file EnhancedPathFormula.cpp.

{
    // shortcut
    if (m_error != ErrorNone) {
        return 0.0;
    }
 
    // lazy evaluation
    if (!m_compiled) {
        TokenList tokens = scan(m_text);
        if (!compile(tokens)) {
            debugOpcodes();
            m_error = ErrorCompile;
            return 0.0;
        }
        m_compiled = true;
    }
 
    QStack<QVariant> stack;
    // stack.reserve(3) here so that the stack is not resized all the time
    // this reduces the number of a/de/re-llocations for documents with
    // a lot of enhanced path shapes quite a lot.
    stack.reserve(3);
    int index = 0;
 
    if (!m_valid) {
        m_error = ErrorParse;
        return 0.0;
    }
 
    for (int pc = 0; pc < m_codes.count(); pc++) {
        QVariant ret;   // for the function caller
        Opcode &opcode = m_codes[pc];
        index = opcode.index;
        switch (opcode.type) {
        // no operation
        case Opcode::Nop:
            break;
 
        // load a constant, push to stack
        case Opcode::Load:
            stack.push(m_constants[index]);
            break;
 
        // unary operation
        case Opcode::Neg: {
            bool success = false;
            qreal value = stack.pop().toDouble(&success);
            if (success) { // do nothing if we got an error
                value *= -1.0;
            }
            stack.push(QVariant(value));
            break;
        }
 
        // binary operation: take two values from stack, do the operation,
        // push the result to stack
        case Opcode::Add: {
            qreal val2 = stack.pop().toDouble();
            qreal val1 = stack.pop().toDouble();
            stack.push(QVariant(val1 + val2));
            break;
        }
 
        case Opcode::Sub: {
            qreal val2 = stack.pop().toDouble();
            qreal val1 = stack.pop().toDouble();
            stack.push(QVariant(val1 - val2));
            break;
        }
 
        case Opcode::Mul: {
            qreal val2 = stack.pop().toDouble();
            qreal val1 = stack.pop().toDouble();
            stack.push(QVariant(val1 * val2));
            break;
        }
 
        case Opcode::Div: {
            qreal val2 = stack.pop().toDouble();
            qreal val1 = stack.pop().toDouble();
            stack.push(QVariant(val1 / val2));
            break;
        }
 
        case Opcode::Ref: {
            QString reference = m_constants[index].toString();
            // push function name if it is a function, else push evaluated reference
            Function function = matchFunction(reference);
            if (FunctionUnknown == function) {
                stack.push(QVariant(m_parent->evaluateReference(reference)));
            } else {
                stack.push(function);
            }
            break;
        }
 
        // calling function
        case Opcode::Function: {
            // sanity check, this should not happen unless opcode is wrong
            // (i.e. there's a bug in the compile() function)
            if (stack.count() < index) {
                qWarning() << "not enough arguments for function " << m_text;
                m_error = ErrorValue; // not enough arguments
                return 0.0;
            }
 
            QList<qreal> args;
            for (; index; index--) {
                qreal value = stack.pop().toDouble();
                args.push_front(value);
            }
 
            // function identifier as int value
            int function = stack.pop().toInt();
            stack.push(QVariant(evaluateFunction((Function)function, args)));
            break;
        }
 
        default:
            break;
        }
    }
 
    // more than one value in stack ? unsuccessful execution...
    if (stack.count() != 1) {
        m_error = ErrorValue;
        return 0.0;
    }
 
    return stack.pop().toDouble();
}

References Opcode::Add, compile(), debugOpcodes(), Opcode::Div, ErrorCompile, ErrorNone, ErrorParse, ErrorValue, evaluateFunction(), EnhancedPathShape::evaluateReference(), Opcode::Function, FunctionUnknown, Opcode::index, Opcode::Load, m_codes, m_compiled, m_constants, m_error, m_parent, m_text, m_valid, matchFunction(), Opcode::Mul, Opcode::Neg, Opcode::Nop, Opcode::Ref, scan(), Opcode::Sub, Opcode::type, and value().

evaluateFunction()

qreal EnhancedPathFormula::evaluateFunction ( Function function, const QList< qreal > & arguments ) const

private

Evaluates a predefined function.

Parameters

function	the identifier of the function to evaluate
arguments	the functions arguments

Definition at line 247 of file EnhancedPathFormula.cpp.

{
    switch (function) {
    case EnhancedPathFormula::FunctionAbs:
        return fabs(arguments[0]);
        break;
    case EnhancedPathFormula::FunctionSqrt:
        return sqrt(arguments[0]);
        break;
    case EnhancedPathFormula::FunctionSin:
        return sin(arguments[0]);
        break;
    case EnhancedPathFormula::FunctionCos:
        return cos(arguments[0]);
        break;
    case EnhancedPathFormula::FunctionTan:
        return tan(arguments[0]);
        break;
    case EnhancedPathFormula::FunctionAtan:
        return atan(arguments[0]);
        break;
    case EnhancedPathFormula::FunctionAtan2:
        // TODO atan2 with one argument as in odf spec ???
        return atan2(arguments[0], arguments[1]);
        break;
    case EnhancedPathFormula::FunctionMin:
        return qMin(arguments[0], arguments[1]);
        break;
    case EnhancedPathFormula::FunctionMax:
        return qMax(arguments[0], arguments[1]);
        break;
    case EnhancedPathFormula::FunctionIf:
        if (arguments[0] > 0.0) {
            return arguments[1];
        } else {
            return arguments[2];
        }
        break;
    default:
        ;
    }
 
    return 0.0;
}

References FunctionAbs, FunctionAtan, FunctionAtan2, FunctionCos, FunctionIf, FunctionMax, FunctionMin, FunctionSin, FunctionSqrt, and FunctionTan.

scan()

TokenList EnhancedPathFormula::scan ( const QString & formula ) const

private

Separates the given formula text into tokens.

Definition at line 292 of file EnhancedPathFormula.cpp.

{
    // parsing state
    enum {
        Start,
        Finish,
        Bad,
        InNumber,
        InDecimal,
        InExpIndicator,
        InExponent,
        InString,
        InIdentifier
    } state;
 
    TokenList tokens;
 
    int i = 0;
    state = Start;
    int tokenStart = 0;
    QString tokenText;
    QString expr = formula + QChar();
 
    // main loop
    while ((state != Bad) && (state != Finish) && (i < expr.length())) {
        QChar ch = expr[i];
 
        switch (state) {
        case Start:
            tokenStart = i;
 
            // skip any whitespaces
            if (ch.isSpace()) {
                i++;
            } else if (ch.isDigit()) { // check for number
                state = InNumber;
            }
            // beginning with alphanumeric ?
            // could be identifier, function, function reference, modifier reference
            else if (isIdentifier(ch)) {
                state = InIdentifier;
            } else if (ch == '.') { // decimal dot ?
                tokenText.append(expr[i++]);
                state = InDecimal;
            } else if (ch == QChar::Null) { // terminator character
                state = Finish;
            } else { // look for operator match
                QString opString(ch);
                int op = matchOperator(opString);
 
                // any matched operator ?
                if (op != FormulaToken::OperatorInvalid) {
                    i++;
                    tokens.append(FormulaToken(FormulaToken::TypeOperator, opString, tokenStart));
                } else {
                    state = Bad;
                }
            }
            break;
        case InIdentifier:
            // consume as long as alpha, dollar sign, question mark, or digit
            if (isIdentifier(ch) || ch.isDigit()) {
                tokenText.append(expr[i++]);
            } else if (ch == '(') { // a '(' ? then this must be a function identifier
                tokens.append(FormulaToken(FormulaToken::TypeFunction, tokenText, tokenStart));
                tokenStart = i;
                tokenText.clear();
                state = Start;
            } else { // we're done with identifier
                tokens.append(FormulaToken(FormulaToken::TypeReference, tokenText, tokenStart));
                tokenStart = i;
                tokenText.clear();
                state = Start;
            }
            break;
        case InNumber:
            // consume as long as it's digit
            if (ch.isDigit()) {
                tokenText.append(expr[i++]);
            } else if (ch == '.') { // decimal dot ?
                tokenText.append('.');
                i++;
                state = InDecimal;
            } else if (ch.toUpper() == 'E') { // exponent ?
                tokenText.append('E');
                i++;
                state = InExpIndicator;
            } else { // we're done with integer number
                tokens.append(FormulaToken(FormulaToken::TypeNumber, tokenText, tokenStart));
                tokenText.clear();
                state = Start;
            };
            break;
        case InDecimal:
            // consume as long as it's digit
            if (ch.isDigit()) {
                tokenText.append(expr[i++]);
            } else if (ch.toUpper() == 'E') { // exponent ?
                tokenText.append('E');
                i++;
                state = InExpIndicator;
            } else { // we're done with floating-point number
                tokens.append(FormulaToken(FormulaToken::TypeNumber, tokenText, tokenStart));
                tokenText.clear();
                state = Start;
            };
            break;
        case InExpIndicator:
            // possible + or - right after E, e.g 1.23E+12 or 4.67E-8
            if ((ch == '+') || (ch == '-')) {
                tokenText.append(expr[i++]);
            } else if (ch.isDigit()) { // consume as long as it's digit
                state = InExponent;
            } else { // invalid thing here
                state = Bad;
            }
            break;
        case InExponent:
            // consume as long as it's digit
            if (ch.isDigit()) {
                tokenText.append(expr[i++]);
            } else { // we're done with floating-point number
                tokens.append(FormulaToken(FormulaToken::TypeNumber, tokenText, tokenStart));
                tokenText.clear();
                state = Start;
            }
            break;
        default:
            break;
        }
    }
    return tokens;
}

References isIdentifier(), matchOperator(), FormulaToken::OperatorInvalid, FormulaToken::TypeFunction, FormulaToken::TypeNumber, FormulaToken::TypeOperator, and FormulaToken::TypeReference.

toString()

QString EnhancedPathFormula::toString

(

)

const

returns string representation of the formula

Definition at line 649 of file EnhancedPathFormula.cpp.

{
    return m_text;
}

References m_text.

Member Data Documentation

m_codes

QList<Opcode> EnhancedPathFormula::m_codes

private

the compiled byte code

Definition at line 176 of file EnhancedPathFormula.h.

m_compiled

bool EnhancedPathFormula::m_compiled

private

flag that shows if function was compiled

Definition at line 172 of file EnhancedPathFormula.h.

m_constants

QList<QVariant> EnhancedPathFormula::m_constants

private

constant values

Definition at line 175 of file EnhancedPathFormula.h.

m_error

Error EnhancedPathFormula::m_error

private

the last occurred error

Definition at line 173 of file EnhancedPathFormula.h.

m_parent

EnhancedPathShape* EnhancedPathFormula::m_parent

private

Definition at line 177 of file EnhancedPathFormula.h.

m_text

QString EnhancedPathFormula::m_text

private

the formula text representation

Definition at line 174 of file EnhancedPathFormula.h.

m_valid

bool EnhancedPathFormula::m_valid

private

flag that shows if function is valid, i.e the function was compiled successfully

Definition at line 171 of file EnhancedPathFormula.h.

---

The documentation for this class was generated from the following files:

• plugins/flake/pathshapes/enhancedpath/EnhancedPathFormula.h
• plugins/flake/pathshapes/enhancedpath/EnhancedPathFormula.cpp