ilAssLacCompositeValidator 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 ilAssLacCompositeValidator:

Public Member Functions
	__construct ($object_loader)
	validate (ilAssLacAbstractComposite $composite)

Protected Member Functions
	getNonShuffler ()

Protected Attributes
	$object_loader

Private Member Functions
	validateSubTree (ilAssLacAbstractComposite $composite)
	validateClozeTest ($answer_index, $question, $answer_expression, $question_index)
	checkIfAnswerIndexOfQuestionExists ($question, $question_index, $answer_index)
	checkQuestionExists ($question, $index)
	isResultOfAnswerExpression ($expression)
	checkAnswerExpressionExist ($expressions, $answer_expression, $question_index)
	checkOperatorExistForExpression ($operators, $answer_expression, $pattern)

Private Attributes
RandomGroup	$randomGroup

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 Class CompositeValidator

Date: 04.12.13 Time: 14:19

Author

Thomas Joußen tjous.nosp@m.sen@.nosp@m.datab.nosp@m.ay.d.nosp@m.e

Definition at line 28 of file ilAssLacCompositeValidator.php.

Constructor & Destructor Documentation

__construct()

ilAssLacCompositeValidator::__construct

(

$object_loader

)

Parameters

ilAssLacQuestionProvider

$object_loader

Definition at line 42 of file ilAssLacCompositeValidator.php.

References $DIC, and $object_loader.

    {
        global $DIC;

        $this->object_loader = $object_loader;
        $this->randomGroup = $DIC->refinery()->random();
    }

Member Function Documentation

checkAnswerExpressionExist()

ilAssLacCompositeValidator::checkAnswerExpressionExist (   $expressions,   $answer_expression,   $question_index  )

private

Parameters

array	$expressions
ilAssLacExpressionInterface	$answer_expression
int	$question_index

Exceptions

ilAssLacExpressionNotSupportedByQuestion

Definition at line 238 of file ilAssLacCompositeValidator.php.

Referenced by validateSubTree().

                                                                                                  : void
    {
        if (!in_array($answer_expression::$identifier, $expressions)) {
            throw new ilAssLacExpressionNotSupportedByQuestion($answer_expression->getValue(), $question_index);
        }
    }

Here is the caller graph for this function:

checkIfAnswerIndexOfQuestionExists()

ilAssLacCompositeValidator::checkIfAnswerIndexOfQuestionExists (   $question,   $question_index,   $answer_index  )

private

Parameters

iQuestionCondition	$question
int	$question_index
int	$answer_index

Exceptions

ilAssLacAnswerIndexNotExist

Definition at line 190 of file ilAssLacCompositeValidator.php.

Referenced by validateSubTree().

                                                                                                  : void
    {
        $answer_options = $question->getAvailableAnswerOptions($answer_index);
        if ($answer_options == null) {
            throw new ilAssLacAnswerIndexNotExist($question_index, $answer_index + 1);
        }
    }

Here is the caller graph for this function:

checkOperatorExistForExpression()

ilAssLacCompositeValidator::checkOperatorExistForExpression (   $operators,   $answer_expression,   $pattern  )

private

Parameters

array	$operators
ilAssLacExpressionInterface	$answer_expression
string	$pattern

Exceptions

ilAssLacOperatorNotSupportedByExpression

Definition at line 252 of file ilAssLacCompositeValidator.php.

Referenced by validateSubTree().

                                                                                              : void
    {
        if (!in_array($pattern, $operators)) {
            throw new ilAssLacOperatorNotSupportedByExpression($answer_expression->getValue(), $pattern);
        }
    }

Here is the caller graph for this function:

checkQuestionExists()

ilAssLacCompositeValidator::checkQuestionExists (   $question,   $index  )

private

Parameters

assQuestion | null	$question
int	$index

Exceptions

ilAssLacQuestionNotExist

Definition at line 204 of file ilAssLacCompositeValidator.php.

Referenced by validateSubTree().

                                                           : void
    {
        if ($question == null) {
            throw new ilAssLacQuestionNotExist($index);
        }
    }

Here is the caller graph for this function:

getNonShuffler()

ilAssLacCompositeValidator::getNonShuffler ( )

protected

Definition at line 259 of file ilAssLacCompositeValidator.php.

                                       : \ILIAS\Refinery\Transformation
    {
        return $this->randomGroup->dontShuffle();
    }

isResultOfAnswerExpression()

ilAssLacCompositeValidator::isResultOfAnswerExpression (   $expression )

private

Parameters

ilAssLacExpressionInterface

$expression

Returns

bool

Definition at line 216 of file ilAssLacCompositeValidator.php.

Referenced by validateSubTree().

                                                            : bool
    {
        // @PHP8-CR I suspect this cluster of typizations is broken in some way. I still leave these remarks "intact"
        // to assist a more thorough analysis.
        if ($expression instanceof ilAssLacResultOfAnswerOfQuestionExpression) {
            return true;
        }

        if ($expression instanceof ilAssLacResultOfAnswerOfCurrentQuestionExpression) {
            return true;
        }

        return false;
    }

Here is the caller graph for this function:

validate()

ilAssLacCompositeValidator::validate

(

ilAssLacAbstractComposite

$composite

)

Definition at line 50 of file ilAssLacCompositeValidator.php.

References validateSubTree().

                                                                  : void
    {
        if (count($composite->nodes) > 0) {
            $this->validate($composite->nodes[0]);
            $this->validate($composite->nodes[1]);
            $this->validateSubTree($composite);
        }

        return;
    }

Here is the call graph for this function:

validateClozeTest()

ilAssLacCompositeValidator::validateClozeTest (   $answer_index,   $question,   $answer_expression,   $question_index  )

private

Parameters

int	$answer_index
assQuestion | iQuestionCondition	$question
ilAssLacExpressionInterface	$answer_expression
int	$question_index

Exceptions

ilAssLacAnswerValueNotExist

Definition at line 137 of file ilAssLacCompositeValidator.php.

Referenced by validateSubTree().

                                                                                                     : void
    {
        if ($answer_index !== null) {
            $options = $question->getAvailableAnswerOptions($answer_index);
            $found = false;
            switch ($options->getType()) {
                case 0: // text
                    if (
                        $answer_expression instanceof ilAssLacStringResultExpression
                    ) {
                        $found = true;
                    }

                    break;
                case 1: // select

                    if ($answer_expression instanceof ilAssLacStringResultExpression) {
                        foreach ($options->getItems($this->getNonShuffler()) as $item) {
                            if ($item->getAnswertext() == $answer_expression->getText()) {
                                $found = true;
                            }
                        }
                    } elseif ($answer_expression instanceof ilAssLacNumberOfResultExpression) {
                        foreach ($options->getItems($question->getShuffler()) as $item) {
                            if ($item->getOrder() == $answer_expression->getNumericValue() - 1) {
                                $found = true;
                            }
                        }
                    }
                    break;
                case 2: // numeric
                    if ($answer_expression instanceof ilAssLacNumericResultExpression) {
                        $found = true;
                    }
                    break;
            }

            if ($answer_expression instanceof ilAssLacEmptyAnswerExpression) {
                $found = true;
            }
            if (!$found && !($answer_expression instanceof ilAssLacPercentageResultExpression)) {
                throw new ilAssLacAnswerValueNotExist($question_index, $answer_expression->getValue(), $answer_index + 1);
            }
        }
    }

Here is the caller graph for this function:

validateSubTree()

ilAssLacCompositeValidator::validateSubTree ( ilAssLacAbstractComposite  $composite )

private

Definition at line 61 of file ilAssLacCompositeValidator.php.

References checkAnswerExpressionExist(), checkIfAnswerIndexOfQuestionExists(), checkOperatorExistForExpression(), checkQuestionExists(), isResultOfAnswerExpression(), and validateClozeTest().

Referenced by validate().

                                                                          : void
    {
        if ($composite->nodes[0] instanceof ilAssLacQuestionExpressionInterface &&
            $composite->nodes[1] instanceof ilAssLacSolutionExpressionInterface
        ) {
            $question_expression = $composite->nodes[0];
            $answer_expression = $composite->nodes[1];
            $question_index = $composite->nodes[0]->getQuestionIndex();
            $answer_index = null;
            $question = $this->object_loader->getQuestion($question_index);

            $this->checkQuestionExists($question, $question_index);
            //$this->checkQuestionIsReachable($question, $question_index);

            if ($this->isResultOfAnswerExpression($question_expression)) {
                $answer_index = $question_expression->getAnswerIndex() - 1;
                // @PHP8-CR I suspect this cluster of typizations is broken in some way. I still leave these remarks "intact"
                // to assist a more thorough analysis.
                $this->checkIfAnswerIndexOfQuestionExists($question, $question_index, $answer_index);
            }
            if ($answer_expression instanceof ilAssLacNumberOfResultExpression && !($question instanceof assClozeTest)) {
                // @PHP8-CR I suspect this cluster of typizations is broken in some way. I still leave these remarks "intact"
                // to assist a more thorough analysis.
                $this->checkIfAnswerIndexOfQuestionExists($question, $question_index, $answer_expression->getNumericValue() - 1);
            }

            $this->checkAnswerExpressionExist($question->getExpressionTypes(), $answer_expression, $question_index);
            $this->checkOperatorExistForExpression($question->getOperators($answer_expression::$identifier), $answer_expression, $composite::$pattern);

            if ($answer_expression instanceof ilAssLacOrderingResultExpression &&
                ($question instanceof assOrderingHorizontal || $question instanceof assOrderingQuestion)
            ) {
                foreach ($answer_expression->getOrdering() as $order) {
                    $count = 0;
                    foreach ($answer_expression->getOrdering() as $element) {
                        if ($element == $order) {
                            $count++;
                        }
                    }
                    if ($count > 1) {
                        throw new ilAssLacDuplicateElement($order);
                    }

                    $this->checkIfAnswerIndexOfQuestionExists($question, $question_index, $order - 1);
                }
            }
            if ($question instanceof assClozeTest) {
                $this->validateClozeTest($answer_index, $question, $answer_expression, $question_index);
            } elseif (
                $answer_expression instanceof ilAssLacPercentageResultExpression &&
                // @PHP8-CR I suspect this cluster of typizations is broken in some way. I still leave these remarks "intact"
                // to assist a more thorough analysis.
                $this->isResultOfAnswerExpression($question_expression) &&
                !($question instanceof assFormulaQuestion)
            ) {
                throw new ilAssLacExpressionNotSupportedByQuestion($answer_expression->getValue(), $question_index . "[" . ($answer_index + 1) . "]");
            }
        } elseif (
            ($composite->nodes[0] instanceof ilAssLacAbstractOperation &&
            $composite->nodes[1] instanceof ilAssLacExpressionInterface) ||
            ($composite->nodes[0] instanceof ilAssLacExpressionInterface &&
            $composite->nodes[1] instanceof ilAssLacAbstractOperation) ||
            ($composite->nodes[0] instanceof ilAssLacSolutionExpressionInterface)
        ) {
            throw new ilAssLacUnableToParseCondition("");
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

$object_loader

ilAssLacCompositeValidator::$object_loader

protected

Definition at line 35 of file ilAssLacCompositeValidator.php.

Referenced by __construct().

$randomGroup

RandomGroup ilAssLacCompositeValidator::$randomGroup

private

Definition at line 37 of file ilAssLacCompositeValidator.php.

---

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

• components/ILIAS/TestQuestionPool/classes/questions/LogicalAnswerCompare/ilAssLacCompositeValidator.php