Ejemplo n.º 1
0
 /**
  * Process the setOutcomeValue/setTemplateValue rule.
  *
  * A RuleProcessingException will be thrown if:
  *
  * * The variable does not exist.
  * * The requested variable is not an OutcomeVariable/TemplateVariable.
  * * The variable's baseType does not match the baseType of the affected value.
  * * An error occurs while processing the related expression.
  *
  * @throws \qtism\runtime\rules\RuleProcessingException If one of the error described above arise.
  */
 public function process()
 {
     $state = $this->getState();
     $rule = $this->getRule();
     $identifier = $rule->getIdentifier();
     $var = $state->getVariable($identifier);
     if (is_null($var) === true) {
         $msg = "No variable with identifier '{$identifier}' to be set in the current state.";
         throw new RuleProcessingException($msg, $this, RuleProcessingException::NONEXISTENT_VARIABLE);
     } elseif (Reflection::isInstanceOf($var, $this->getVariableType()) === false) {
         $msg = "The variable to set '{$identifier}' is not an instance of '" . $this->getVariableType() . "'.";
         throw new RuleProcessingException($msg, $this, RuleProcessingException::WRONG_VARIABLE_TYPE);
     }
     // Process the expression.
     // Its result will be the value to set to the target variable.
     try {
         $expressionEngine = new ExpressionEngine($rule->getExpression(), $state);
         $val = $expressionEngine->process();
     } catch (ExpressionProcessingException $e) {
         $msg = "An error occured while processing the expression bound with the '" . Reflection::shortClassName($rule) . "' rule.";
         throw new RuleProcessingException($msg, $this, RuleProcessingException::RUNTIME_ERROR, $e);
     }
     // The variable exists, its new value is processed.
     try {
         // juggle a little bit (int -> float, float -> int)
         if ($val !== null && $var->getCardinality() === Cardinality::SINGLE) {
             $baseType = $var->getBaseType();
             if ($baseType === BaseType::INTEGER && $val instanceof Float) {
                 $val = new Integer(intval($val->getValue()));
             } elseif ($baseType === BaseType::FLOAT && $val instanceof Integer) {
                 $val = new Float(floatval($val->getValue()));
             }
         }
         $var->setValue($val);
     } catch (InvalidArgumentException $e) {
         $varBaseType = BaseType::getNameByConstant($var->getBaseType()) === false ? 'noBaseType' : BaseType::getNameByConstant($var->getBaseType());
         $varCardinality = Cardinality::getNameByConstant($var->getCardinality());
         // The affected value does not match the baseType of the variable $var.
         $msg = "Unable to set value {$val} to variable '{$identifier}' (cardinality = {$varCardinality}, baseType = {$varBaseType}).";
         throw new RuleProcessingException($msg, $this, RuleProcessingException::WRONG_VARIABLE_BASETYPE, $e);
     }
 }
 /**
  * Process the Gcd operator.
  * 
  * @return integer The integer value equal in value to the greatest common divisor of the sub-expressions. If any of the sub-expressions is NULL, the result is NULL.
  * @throws OperatorProcessingException
  */
 public function process()
 {
     $operands = $this->getOperands();
     if ($operands->containsNull() === true) {
         return null;
     }
     if ($operands->anythingButRecord() === false) {
         $msg = "The Gcd operator only accepts operands with a cardinality of single, multiple or ordered.";
         throw new OperatorProcessingException($msg, $this, OperatorProcessingException::WRONG_CARDINALITY);
     }
     if ($operands->exclusivelyInteger() === false) {
         $msg = "The Gcd operator only accepts operands with an integer baseType.";
         throw new OperatorProcessingException($msg, $this, OperatorProcessingException::WRONG_BASETYPE);
     }
     // Make a flat collection first.
     $flatCollection = new OperandsCollection();
     $zeroCount = 0;
     $valueCount = 0;
     foreach ($operands as $operand) {
         if ($operand instanceof Scalar) {
             $valueCount++;
             if ($operand->getValue() !== 0) {
                 $flatCollection[] = $operand;
             } else {
                 $zeroCount++;
             }
         } else {
             if ($operand->contains(null)) {
                 // Container with at least one null value inside.
                 // -> If any of the sub-expressions is null or not numeric, returns null.
                 return null;
             } else {
                 // Container with no null values.
                 foreach ($operand as $o) {
                     $valueCount++;
                     if ($o->getValue() !== 0) {
                         $flatCollection[] = $o;
                     } else {
                         $zeroCount++;
                     }
                 }
             }
         }
     }
     if ($zeroCount === $valueCount) {
         // All arguments of gcd() are 0.
         return new Integer(0);
     } else {
         $g = $flatCollection[0];
         $loopLimit = count($flatCollection) - 1;
         $i = 0;
         while ($i < $loopLimit) {
             $g = new Integer(Utils::gcd($g->getValue(), $flatCollection[$i + 1]->getValue()));
             $i++;
         }
         return $g;
     }
 }