ilDclExpressionParser Class Reference

This file is part of ILIAS, a powerful learning management system published by ILIAS open source e-Learning e.V. More...

Collaboration diagram for ilDclExpressionParser:

Public Member Functions
	__construct (string $expression, ilDclBaseRecordModel $record, ilDclBaseFieldModel $field)
	parse ()
	Parse expression and return result. More...

Static Public Member Functions
static	getOperators ()
static	getFunctions ()

Data Fields
const	N_DECIMALS = 1
const	SCIENTIFIC_NOTATION_UPPER = 1000000000000
const	SCIENTIFIC_NOTATION_LOWER = 0.000000001

Protected Member Functions
	formatScientific ($value)
	isMathToken (string $token)
	Check if a given token is a math expression. More...
	calculateFunctions (string $token)
	Execute any math functions inside a token. More...
	getFunctionArgs (int $index, array $data)
	Helper method to return the function and its arguments from a preg_replace_all $result array. More...
	substituteFieldValues (array $tokens)
	Given an array of tokens, replace each token that is a placeholder (e.g. More...
	parseMath (array $tokens)
	Parse a math expression. More...
	calculateFunction (string $function, array $args=array())
	Calculate a function with its arguments. More...
	calculate (string $operator, $left, $right)

Protected Attributes
ilDclBaseRecordModel	$record
ilDclBaseFieldModel	$field
string	$expression

Static Protected Attributes
static array	$operators
static array	$cache_tokens = array()
static array	$cache_fields = array()
static array	$cache_math_tokens = array()
static array	$cache_math_function_tokens = array()
static array	$functions

Detailed Description

This file is part of ILIAS, a powerful learning management system published by ILIAS open source e-Learning e.V.

ILIAS is licensed with the GPL-3.0, see https://www.gnu.org/licenses/gpl-3.0.en.html You should have received a copy of said license along with the source code, too.

If this is not the case or you just want to try ILIAS, you'll find us at: https://www.ilias.de https://github.com/ILIAS-eLearning

Definition at line 19 of file class.ilDclExpressionParser.php.

Constructor & Destructor Documentation

__construct()

ilDclExpressionParser::__construct	(	string	$expression,
		ilDclBaseRecordModel	$record,
		ilDclBaseFieldModel	$field
	)

Definition at line 48 of file class.ilDclExpressionParser.php.

References $expression, $field, and $record.

    {
        $this->expression = $expression;
        $this->record = $record;
        $this->field = $field;
    }

Member Function Documentation

calculate()

ilDclExpressionParser::calculate ( string  $operator,   $left,   $right  )

protected

Parameters

string	$operator
float | int	$left
float | int	$right

Returns

float|int

Exceptions

ilException

Definition at line 355 of file class.ilDclExpressionParser.php.

Referenced by parseMath().

    {
        switch ($operator) {
            case '+':
                $result = $left + $right;
                break;
            case '-':
                $result = $left - $right;
                break;
            case '*':
                $result = $left * $right;
                break;
            case '/':
                $result = ($right == 0) ? 0 : $left / $right;
                break;
            case '^':
                $result = pow($left, $right);
                break;
            default:
                throw new ilException("Unrecognized operator '$operator'");
        }

        return $result;
    }

Here is the caller graph for this function:

calculateFunction()

ilDclExpressionParser::calculateFunction ( string  $function, array  $args = array()  )

protected

Calculate a function with its arguments.

Returns

float|int|number

Exceptions

ilException

Definition at line 330 of file class.ilDclExpressionParser.php.

Referenced by calculateFunctions().

    {
        switch ($function) {
            case 'AVERAGE':
                $count = count($args);

                return ($count) ? array_sum($args) / $count : 0;
            case 'SUM':
                return array_sum($args);
            case 'MIN':
                return min($args);
            case 'MAX':
                return max($args);
            default:
                throw new ilException("Unrecognized function '$function'");
        }
    }

Here is the caller graph for this function:

calculateFunctions()

ilDclExpressionParser::calculateFunctions ( string  $token )

protected

Execute any math functions inside a token.

Definition at line 148 of file class.ilDclExpressionParser.php.

References $token, calculateFunction(), getFunctionArgs(), and substituteFieldValues().

Referenced by parse().

                                                        : string
    {
        if (isset(self::$cache_math_function_tokens[$this->field->getId()][$token])) {
            $result = self::$cache_math_function_tokens[$this->field->getId()][$token];
            if ($result === false) {
                return $token;
            }
        } else {
            $pattern = '#';
            foreach (self::getFunctions() as $function) {
                $pattern .= "($function)\\(([^)]*)\\)|";
            }
            if (!preg_match_all(rtrim($pattern, '|') . '#', $token, $result)) {
                // No functions found inside token, just return token again
                self::$cache_math_function_tokens[$this->field->getId()][$token] = false;

                return $token;
            }
        }
        // Function found inside token, calculate!
        foreach ($result[0] as $k => $to_replace) {
            $function_args = $this->getFunctionArgs($k, $result);
            $function = $function_args['function'];
            $args = $this->substituteFieldValues($function_args['args']);
            $token = str_replace($to_replace, $this->calculateFunction($function, $args), $token);
        }

        return $token;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

formatScientific()

ilDclExpressionParser::formatScientific (   $value )

protected

Parameters

float | int

$value

Returns

string|int

Definition at line 101 of file class.ilDclExpressionParser.php.

Referenced by parse().

    {
        if (abs($value) >= self::SCIENTIFIC_NOTATION_UPPER) {
            return sprintf("%e", $value);
        }
        if (abs($value) <= self::SCIENTIFIC_NOTATION_LOWER && $value != 0) {
            return sprintf("%e", $value);
        }
        return $value;
    }

Here is the caller graph for this function:

getFunctionArgs()

ilDclExpressionParser::getFunctionArgs ( int  $index, array  $data  )

protected

Helper method to return the function and its arguments from a preg_replace_all $result array.

Definition at line 181 of file class.ilDclExpressionParser.php.

References $i, and $index.

Referenced by calculateFunctions().

                                                               : array
    {
        $return = array(
            'function' => '',
            'args' => array(),
        );
        for ($i = 1; $i < count($data); $i++) {
            $_data = $data[$i];
            if ($_data[$index]) {
                $function = $_data[$index];
                $args = explode(';', $data[$i + 1][$index]);
                $return['function'] = $function;
                $return['args'] = $args;
                break;
            }
        }

        return $return;
    }

Here is the caller graph for this function:

getFunctions()

static ilDclExpressionParser::getFunctions ( )

static

Definition at line 117 of file class.ilDclExpressionParser.php.

Referenced by ilDclFormulaFieldRepresentation\buildFieldCreationInput(), and ilDclTable\getFieldsForFormula().

                                         : array
    {
        return self::$functions;
    }

Here is the caller graph for this function:

getOperators()

static ilDclExpressionParser::getOperators ( )

static

Definition at line 112 of file class.ilDclExpressionParser.php.

Referenced by ilDclFormulaFieldRepresentation\buildFieldCreationInput(), ilDclTable\getFieldsForFormula(), and ilDclTokenizer\getMathTokens().

                                         : array
    {
        return self::$operators;
    }

Here is the caller graph for this function:

isMathToken()

ilDclExpressionParser::isMathToken ( string  $token )

protected

Check if a given token is a math expression.

Definition at line 125 of file class.ilDclExpressionParser.php.

References $functions, $operators, and $token.

Referenced by parse().

                                                 : bool
    {
        if (isset(self::$cache_math_tokens[$this->field->getId()][$token])) {
            return self::$cache_math_tokens[$this->field->getId()][$token];
        } else {
            if (strpos($token, '"') === 0) {
                return false;
            }
            $operators = array_keys(self::getOperators());
            $functions = self::getFunctions();
            $result = (bool) preg_match(
                '#(\\' . implode("|\\", $operators) . '|' . implode('|', $functions) . ')#',
                $token
            );
            self::$cache_math_tokens[$this->field->getId()][$token] = $result;

            return $result;
        }
    }

Here is the caller graph for this function:

parse()

ilDclExpressionParser::parse

(

)

Parse expression and return result.

This method loops the tokens and checks if Token is of type string or math. Concatenates results to produce resulting string of parsed expression.

Exceptions

ilException

Definition at line 61 of file class.ilDclExpressionParser.php.

References $token, calculateFunctions(), formatScientific(), ilDclTokenizer\getMathTokens(), ilDclTokenizer\getTokens(), isMathToken(), parseMath(), and substituteFieldValues().

                           : string
    {
        if (isset(self::$cache_tokens[$this->field->getId()])) {
            $tokens = self::$cache_tokens[$this->field->getId()];
        } else {
            $tokens = ilDclTokenizer::getTokens($this->expression);
            self::$cache_tokens[$this->field->getId()] = $tokens;
        }
        $parsed = '';
        foreach ($tokens as $token) {
            if (empty($token)) {
                continue;
            }
            if ($this->isMathToken($token)) {
                $token = $this->calculateFunctions($token);
                $math_tokens = ilDclTokenizer::getMathTokens($token);
                $value = $this->parseMath($this->substituteFieldValues($math_tokens));

                $value = $this->formatScientific($value);

                $parsed .= $value;
            } else {
                // Token is a string, either a field placeholder [[Field name]] or a string starting with "
                if (strpos($token, '"') === 0) {
                    $parsed .= strip_tags(trim($token, '"'));
                } elseif (strpos($token, '[[') === 0) {
                    $parsed .= trim(strip_tags($this->substituteFieldValue($token)));
                } else {
                    throw new ilException("Unrecognized string token: '$token'");
                }
            }
        }

        return $parsed;
    }

Here is the call graph for this function:

parseMath()

ilDclExpressionParser::parseMath ( array  $tokens )

protected

Parse a math expression.

Exceptions

Exception

Definition at line 254 of file class.ilDclExpressionParser.php.

References $operators, $token, and calculate().

Referenced by parse().

                                               : ?string
    {
        $operators = self::$operators;
        $precedence = 0;
        $stack = new ilDclStack();
        $precedences = new ilDclStack();
        $in_bracket = false;
        foreach ($tokens as $token) {
            if (empty($token) or is_null($token)) {
                $token = 0;
            }
            if (is_numeric($token) or $token === '(') {
                $stack->push($token);
                if ($token === '(') {
                    $in_bracket = true;
                }
            } elseif (in_array($token, array_keys($operators))) {
                $new_precedence = $operators[$token]['precedence'];
                if ($new_precedence > $precedence || $in_bracket) {
                    // Precedence of operator is higher, push operator on stack
                    $stack->push($token);
                    $precedences->push($new_precedence);
                    $precedence = $new_precedence;
                } else {
                    // Precedence is equal or lower, calculate result on stack
                    while ($new_precedence <= $precedence && $stack->count() > 1) {
                        $right = (float) $stack->pop();
                        $operator = $stack->pop();
                        $left = (float) $stack->pop();
                        $result = $this->calculate($operator, $left, $right);
                        $stack->push($result);
                        $precedence = $precedences->pop();
                    }
                    $stack->push($token);
                    $precedence = $new_precedence;
                    $precedences->push($new_precedence);
                }
            } elseif ($token === ')') {
                // Need to calculate stack back to opening bracket
                $_tokens = array();
                $elem = $stack->pop();
                while ($elem !== '(' && !$stack->isEmpty()) {
                    $_tokens[] = $elem;
                    $elem = $stack->pop();
                }
                // Get result within brackets recursive and push to stack
                $stack->push($this->parseMath(array_reverse($_tokens)));
                $in_bracket = false;
            } else {
                throw new ilException("Unrecognized token '$token'");
            }
            // $stack->debug();
        }
        // If one element is left on stack, we are done. Otherwise calculate
        if ($stack->count() == 1) {
            $result = $stack->pop();

            return (ctype_digit((string) $result)) ? $result : number_format($result, self::N_DECIMALS, '.', "'");
        } else {
            while ($stack->count() >= 2) {
                $right = $stack->pop();
                $operator = $stack->pop();
                $left = $stack->count() ? $stack->pop() : 0;
                $stack->push($this->calculate($operator, $left, $right));
            }
            $result = $stack->pop();

            return $result;
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

substituteFieldValues()

ilDclExpressionParser::substituteFieldValues ( array  $tokens )

protected

Given an array of tokens, replace each token that is a placeholder (e.g.

[[Field name]]) with it's value

Definition at line 204 of file class.ilDclExpressionParser.php.

References $DIC, $field, $lng, $token, ilDclBaseFieldModel\getId(), and ilDclCache\getTableCache().

Referenced by calculateFunctions(), and parse().

                                                           : array
    {
        $replaced = array();
        foreach ($tokens as $token) {
            if (strpos($token, '[[') === 0) {
                $replaced[] = $this->substituteFieldValue($token);
            } else {
                $replaced[] = $token;
            }
        }

        return $replaced;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

$cache_fields

array ilDclExpressionParser::$cache_fields = array()

staticprotected

Definition at line 37 of file class.ilDclExpressionParser.php.

$cache_math_function_tokens

array ilDclExpressionParser::$cache_math_function_tokens = array()

staticprotected

Definition at line 39 of file class.ilDclExpressionParser.php.

$cache_math_tokens

array ilDclExpressionParser::$cache_math_tokens = array()

staticprotected

Definition at line 38 of file class.ilDclExpressionParser.php.

$cache_tokens

array ilDclExpressionParser::$cache_tokens = array()

staticprotected

Definition at line 36 of file class.ilDclExpressionParser.php.

$expression

string ilDclExpressionParser::$expression

protected

Definition at line 27 of file class.ilDclExpressionParser.php.

Referenced by __construct().

$field

ilDclBaseFieldModel ilDclExpressionParser::$field

protected

Definition at line 26 of file class.ilDclExpressionParser.php.

Referenced by __construct(), and substituteFieldValues().

$functions

array ilDclExpressionParser::$functions

staticprotected

Initial value:

= array(
            'SUM',
            'AVERAGE',
            'MIN',
            'MAX',
        )

Definition at line 41 of file class.ilDclExpressionParser.php.

Referenced by isMathToken().

$operators

array ilDclExpressionParser::$operators

staticprotected

Initial value:

= array(
            '+' => array('precedence' => 1),
            '-' => array('precedence' => 1),
            '*' => array('precedence' => 2),
            '/' => array('precedence' => 2),
            '^' => array('precedence' => 3),
        )

Definition at line 29 of file class.ilDclExpressionParser.php.

Referenced by isMathToken(), and parseMath().

$record

ilDclBaseRecordModel ilDclExpressionParser::$record

protected

Definition at line 25 of file class.ilDclExpressionParser.php.

Referenced by __construct().

N_DECIMALS

const ilDclExpressionParser::N_DECIMALS = 1

Definition at line 21 of file class.ilDclExpressionParser.php.

SCIENTIFIC_NOTATION_LOWER

const ilDclExpressionParser::SCIENTIFIC_NOTATION_LOWER = 0.000000001

Definition at line 23 of file class.ilDclExpressionParser.php.

SCIENTIFIC_NOTATION_UPPER

const ilDclExpressionParser::SCIENTIFIC_NOTATION_UPPER = 1000000000000

Definition at line 22 of file class.ilDclExpressionParser.php.

---

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

• Modules/DataCollection/classes/Fields/Formula/class.ilDclExpressionParser.php