Modules/TestQuestionPool/classes/class.assClozeGap.php

Go to the documentation of this file.

<?php
 /*
   +----------------------------------------------------------------------------+
   | ILIAS open source                                                          |
   +----------------------------------------------------------------------------+
   | Copyright (c) 1998-2001 ILIAS open source, University of Cologne           |
   |                                                                            |
   | This program is free software; you can redistribute it and/or              |
   | modify it under the terms of the GNU General Public License                |
   | as published by the Free Software Foundation; either version 2             |
   | of the License, or (at your option) any later version.                     |
   |                                                                            |
   | This program is distributed in the hope that it will be useful,            |
   | but WITHOUT ANY WARRANTY; without even the implied warranty of             |
   | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              |
   | GNU General Public License for more details.                               |
   |                                                                            |
   | You should have received a copy of the GNU General Public License          |
   | along with this program; if not, write to the Free Software                |
   | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | 
   +----------------------------------------------------------------------------+
*/

include_once "./Modules/Test/classes/inc.AssessmentConstants.php";

class assClozeGap 
{
        var $type;

        var $items;

        var $shuffle;

        function assClozeGap($a_type)
        {
                $this->type = $a_type;
                $this->items = array();
                $this->shuffle = FALSE;
        }
  
        function getType() 
        {
                return $this->type;
        }

  function setType($a_type = 0) 
        {
                $this->type = $a_type;
        }

  function getItems() 
        {
                if ($this->shuffle)
                {
                        return $this->arrayShuffle($this->items);
                }
                else
                {
                        return $this->items;
                }
        }

        function getItemsRaw()
        {
                return $this->items;
        }
  
        function getItemCount() 
        {
                return count($this->items);
        }

        function addItem($a_item) 
        {
                array_push($this->items, $a_item);
        }

        function setItemPoints($order, $points) 
        {
                foreach ($this->items as $key => $item)
                {
                        if ($item->getOrder() == $order)
                        {
                                $item->setPoints($points);
                        }
                }
        }

        function deleteItem($order) 
        {
                if (array_key_exists($order, $this->items))
                {
                        unset($this->items[$order]);
                        $order = 0;
                        foreach ($this->items as $key => $item)
                        {
                                $this->items[$key]->setOrder($order);
                                $order++;
                        }
                }
        }

        function setItemLowerBound($order, $bound) 
        {
                foreach ($this->items as $key => $item)
                {
                        if ($item->getOrder() == $order)
                        {
                                $item->setLowerBound($bound);
                        }
                }
        }

        function setItemUpperBound($order, $bound) 
        {
                foreach ($this->items as $key => $item)
                {
                        if ($item->getOrder() == $order)
                        {
                                $item->setUpperBound($bound);
                        }
                }
        }

        function getItem($a_index) 
        {
                if (array_key_exists($a_index, $this->items))
                {
                        return $this->items[$a_index];
                }
                else
                {
                        return NULL;
                }
        }

        function clearItems() 
        {
                $this->items = array();
        }

        function setShuffle($a_shuffle = TRUE) 
        {
                $this->shuffle = $a_shuffle ? TRUE : FALSE;
        }

        function getShuffle() 
        {
                return $this->shuffle;
        }

        function arrayShuffle($array)
        {
                mt_srand((double)microtime()*1000000);
                $i = count($array);
                if ($i > 0)
                {
                        while(--$i)
                        {
                                $j = mt_rand(0, $i);
                                if ($i != $j)
                                {
                                        // swap elements
                                        $tmp = $array[$j];
                                        $array[$j] = $array[$i];
                                        $array[$i] = $tmp;
                                }
                        }
                }
                return $array;
        }

        function getMaxWidth()
        {
                $maxwidth = 0;
                foreach ($this->items as $item)
                {
                        if (strlen($item->getAnswerText()) > $maxwidth)
                        {
                                $maxwidth = strlen($item->getAnswerText());
                        }
                }
                return $maxwidth;
        }
        
        function getBestSolutionIndexes()
        {
                $maxpoints = 0;
                foreach ($this->items as $key => $item)
                {
                        if ($item->getPoints() > $maxpoints)
                        {
                                $maxpoints = $item->getPoints();
                        }
                }
                $keys = array();
                foreach ($this->items as $key => $item)
                {
                        if ($item->getPoints() == $maxpoints)
                        {
                                array_push($keys, $key);
                        }
                }
                return $keys;
        }
        
        function getBestSolutionOutput()
        {
                global $lng;
                switch ($this->getType())
                {
                        case CLOZE_TEXT:
                        case CLOZE_SELECT:
                                $best_solutions = array();
                                foreach ($this->getItems() as $answer)
                                {
                                        if (is_array($best_solutions[$answer->getPoints()]))
                                        {
                                                array_push($best_solutions[$answer->getPoints()], $answer->getAnswertext());
                                        }
                                        else
                                        {
                                                $best_solutions[$answer->getPoints()] = array();
                                                array_push($best_solutions[$answer->getPoints()], $answer->getAnswertext());
                                        }
                                }
                                krsort($best_solutions, SORT_NUMERIC);
                                reset($best_solutions);
                                $found = current($best_solutions);
                                return join(" " . $lng->txt("or") . " ", $found);
                                break;
                        case CLOZE_NUMERIC:
                                $maxpoints = 0;
                                $foundvalue = "";
                                foreach ($this->getItems() as $answer)
                                {
                                        if ($answer->getPoints() >= $maxpoints)
                                        {
                                                $maxpoints = $answer->getPoints();
                                                $foundvalue = $answer->getAnswertext();
                                        }
                                }
                                return $foundvalue;
                                break;
                        default:
                                return "";
                }
        }
}

?>