ilAssLacConditionParser.php

Go to the documentation of this file.

<?php
 
require_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Exception/ilAssLacMissingBracket.php";
require_once "Modules/TestQuestionPool/classes/questions/LogicalAnswerCompare/Exception/ilAssLacConditionParserException.php";
 
class ilAssLacConditionParser {
 
        protected $condition;
 
        protected $expressions;
 
        protected $operators;
 
        protected $index;
 
        protected $spaces;
 
        public function __construct(){
                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";
        }
 
        public function parse($condition){
                $this->condition = $condition;
                $this->checkBrackets();
                $this->fetchExpressions();
                $this->fetchOperators();
                $this->cannonicalizeCondition();
                $nodes = $this->createNodeArray();
                $compositeBuilder = new ilAssLacCompositeBuilder();
                return $compositeBuilder->create($nodes);
        }
 
        protected function fetchExpressions(){
                $manufacturer = ilAssLacExpressionManufacturer::_getInstance();
                $this->expressions = $manufacturer->match($this->condition);
        }
 
        protected function fetchOperators(){
                $manufacturer = ilAssLacOperationManufacturer::_getInstance();
                $this->operators = $manufacturer->match($this->condition);
        }
 
        protected function cannonicalizeCondition(){
                $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);
                        }
                }
        }
 
        protected function checkBrackets()
        {
                $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("(");
                }
        }
 
        protected function createNodeArray()
        {
                $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);
        }
 
        public function getExpressions()
        {
                return $this->expressions;
        }
 
        protected function surroundNegationExpression($index)
        {
                $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);
                }
        }
 
        protected function isNegationSurroundedByBrackets($index)
        {
                $next_bracket = strpos($this->condition, "(", $index+1);
                $next_expression = strpos($this->condition, "n", $index+1);
 
                return $next_bracket !== false & $next_bracket < $next_expression;
        }
}