Collaboration diagram for ilAssLacConditionParser:

Public Member Functions
	__construct ()
	Construct requirements. More...

	parse ($condition)
	Parses the delivered condition and creates a composite tree Structure. More...

	getExpressions ()

Protected Member Functions
	fetchExpressions ()
	Matches all expressions in the current condition and assign these to the class attribute ConditionParser::$expressions. More...

	fetchOperators ()
	Matches all operators in the current condition and assign these to the class attribute ConditionParser::$operators. More...

	cannonicalizeCondition ()
	Cannonicalize the condition into a more general form. More...

	checkBrackets ()

	createNodeArray ()
	Creates an array representing all Nodes in a condition based on the fetched expressions and operators. More...

	surroundNegationExpression ($index)

	isNegationSurroundedByBrackets ($index)

Protected Attributes
	$condition

	$expressions

	$operators

	$index

	$spaces

Detailed Description

Definition at line 14 of file ilAssLacConditionParser.php.

Constructor & Destructor Documentation

◆ __construct()

ilAssLacConditionParser::__construct ( )

Construct requirements.

Definition at line 56 of file ilAssLacConditionParser.php.

                                      {
                 include_once 'Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Factory/ilAssLacExpressionManufacturer.php';
                 include_once 'Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Factory/ilAssLacOperationManufacturer.php';
                 include_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/ilAssLacCompositeBuilder.php";
         }

Member Function Documentation

◆ cannonicalizeCondition()

ilAssLacConditionParser::cannonicalizeCondition ( )

protected

Cannonicalize the condition into a more general form.

It replaces all expression with "n" and all orperators with "o"
so that the result of an condition after cannonicalization could be:

(n o n) o (n o n) o n

Definition at line 112 of file ilAssLacConditionParser.php.

References $condition, ilAssLacExpressionManufacturer\_getInstance(), ilAssLacOperationManufacturer\_getInstance(), isNegationSurroundedByBrackets(), and surroundNegationExpression().

Referenced by parse().

                                                    {
                 $manufacturer = ilAssLacExpressionManufacturer::_getInstance();
                 $this->condition = preg_replace($manufacturer->getPattern(), 'n', $this->condition);
                 $manufacturer = ilAssLacOperationManufacturer::_getInstance();
                 $this->condition = preg_replace($manufacturer->getPattern(), 'o', $this->condition);
                 $this->condition = preg_replace("/no/", "n o", $this->condition);
                 $this->condition = preg_replace("/on/", "o n", $this->condition);
 
                 for($i = 0; $i < strlen($this->condition); $i++)
                 {
                         if($this->condition[$i] == "!" && !$this->isNegationSurroundedByBrackets($i))
                         {
                                 $this->surroundNegationExpression($i);
                         }
                 }
         }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkBrackets()

ilAssLacConditionParser::checkBrackets ( )

protected

Definition at line 129 of file ilAssLacConditionParser.php.

Referenced by parse().

         {
                 $num_brackets_open = substr_count($this->condition, "(");
                 $num_brackets_close = substr_count($this->condition, ")");
 
                 if($num_brackets_open > $num_brackets_close)
                 {
                         throw new ilAssLacMissingBracket(")");
                 }
                 if($num_brackets_open < $num_brackets_close)
                 {
                         throw new ilAssLacMissingBracket("(");
                 }
         }

Here is the caller graph for this function:

◆ createNodeArray()

ilAssLacConditionParser::createNodeArray ( )

protected

Creates an array representing all Nodes in a condition based on the fetched expressions and operators.

The array has a tree representation which depth is dependent to the bracketing in the condition
The array contains of four main keys to identify the elements:

Key	Values	Description
type	"group", "expression", "operator"	The type of the node - Group is used to introduce the next tree depth
value	mixed	Contains an extracted expression or operation from a condition
nodes	array	Contains an node array

Returns: array

Definition at line 166 of file ilAssLacConditionParser.php.

References $index, and array.

Referenced by parse().

         {
                 $expected = array("n", "(", "!");
                 $group = array();
                 $negation = false;
 
                 while($this->index < strlen($this->condition))
                 {
                         $a = $this->condition[$this->index];
                         if(trim($this->condition[$this->index]) != "" && in_array($this->condition[$this->index], $expected))
                         {
                                 if ($this->condition[$this->index] == ')')
                                 {
                                         return $group;
                                 }
                                 else if ($this->condition[$this->index] == 'n')
                                 {
                                         $group[] = array('type' => 'expression', 'value' => array_shift($this->expressions));
                                         $expected = array("o", ")");
                                 }
                                 else if ($this->condition[$this->index] == 'o')
                                 {
                                         $group[] = array('type' => 'operator', 'value' => array_shift($this->operators));
                                         $expected = array("n", "(", "!");
                                 }
                                 else if ($this->condition[$this->index] == '(')
                                 {
                                         $this->index++;
                                         $elements = $this->createNodeArray();
                                         $group[] = array('type' => "group", "negated" => $negation, 'nodes' => $elements);
                                         $negation = false;
                                         $expected = array("o",")");
                                 }
                                 else if($this->condition[$this->index] == "!")
                                 {
                                         $negation = true;
                                 }
                         }
                         elseif(trim($this->condition[$this->index]) != "")
                         {
                                 throw new ilAssLacConditionParserException($this->index-$this->spaces+1);
                         }
                         else
                         {
                                 $this->spaces++;
                         }
 
                         $this->index++;
                 }
                 return array('type' => 'group', "negated" => $negation, 'nodes' => $group);
         }

Here is the caller graph for this function:

◆ fetchExpressions()

ilAssLacConditionParser::fetchExpressions ( )

protected

Matches all expressions in the current condition and assign these to the class attribute ConditionParser::$expressions.

See also: AbstractManufacturer::match(); ExpressionManufacturer::getPattern(); Parser::$expressions

Definition at line 88 of file ilAssLacConditionParser.php.

References ilAssLacExpressionManufacturer\_getInstance().

Referenced by parse().

                                              {
                 $manufacturer = ilAssLacExpressionManufacturer::_getInstance();
                 $this->expressions = $manufacturer->match($this->condition);
         }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fetchOperators()

ilAssLacConditionParser::fetchOperators ( )

protected

Matches all operators in the current condition and assign these to the class attribute ConditionParser::$operators.

See also: AbstractManufacturer::match(); OperationManufacturer::getPattern(); Parser::$operators

Definition at line 100 of file ilAssLacConditionParser.php.

References ilAssLacOperationManufacturer\_getInstance().

Referenced by parse().

                                            {
                 $manufacturer = ilAssLacOperationManufacturer::_getInstance();
                 $this->operators = $manufacturer->match($this->condition);
         }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getExpressions()

ilAssLacConditionParser::getExpressions ( )

Returns: array

Definition at line 221 of file ilAssLacConditionParser.php.

References $expressions.

         {
                 return $this->expressions;
         }

◆ isNegationSurroundedByBrackets()

ilAssLacConditionParser::isNegationSurroundedByBrackets ( $index )

protected

Parameters

int $index

Returns: boolean

Definition at line 250 of file ilAssLacConditionParser.php.

References $index.

Referenced by cannonicalizeCondition().

         {
                 $next_bracket = strpos($this->condition, "(", $index+1);
                 $next_expression = strpos($this->condition, "n", $index+1);
 
                 return $next_bracket !== false & $next_bracket < $next_expression;
         }

Here is the caller graph for this function:

◆ parse()

ilAssLacConditionParser::parse ( $condition )

Parses the delivered condition and creates a composite tree Structure.

Parameters

$condition

See also: CompositeBuilder::create()

Returns: array

Definition at line 70 of file ilAssLacConditionParser.php.

References $condition, cannonicalizeCondition(), checkBrackets(), createNodeArray(), fetchExpressions(), and fetchOperators().

                                          {
                 $this->condition = $condition;
                 $this->checkBrackets();
                 $this->fetchExpressions();
                 $this->fetchOperators();
                 $this->cannonicalizeCondition();
                 $nodes = $this->createNodeArray();
                 $compositeBuilder = new ilAssLacCompositeBuilder();
                 return $compositeBuilder->create($nodes);
         }

Here is the call graph for this function:

◆ surroundNegationExpression()

ilAssLacConditionParser::surroundNegationExpression ( $index )

protected

Parameters

int $index

Definition at line 229 of file ilAssLacConditionParser.php.

References $index, and $start.

Referenced by cannonicalizeCondition().

         {
                 $start = strpos($this->condition, "n", $index + 1);
                 $end = false;
 
                 if($start !== false)
                 {
                         $end   = strpos($this->condition, "n", $start + 1);
                 }
 
                 if($start !== false && $end !== false)
                 {
                         $this->condition = substr_replace($this->condition, "(n o n)", $start, $end - $start + 1);
                 }
         }