A lot of improvements on the module loading side + some other fixes.

[AOOS.git] / AOOSModel.php

<?php
require_once("AOOSException.php");
require_once("AOOSModule.php");

/**
 * AOOSModel
 * @author Sebastian Skejø
 */

class AOOSModel extends AOOSModule
{
    private $_rows = 0;
    private $_data = array();
    private $_model = array();
    private $_updated = false;
    private $_columnIndex = array();
    private $_escape = true;
    private $_quote = false;

    private function _fixRange(&$start, &$end, $count)
    {
        if ($start === null) { $start = 0; }
        if ($end === null) { $end = $count-1; }

        if (!is_int($start) || !is_int($end))
        {
            throw new AOOSException($this->core(), $this->tr("not_int"), "", true, 1);
            return false;
        }

        if ($start >= $count || $end >= $count)
        {
            throw new AOOSException($this->core(), $this->tr("row_out_of_bounds"), "", true, 1);
            return false;
        }

        if ($start > $end && !($end < 0))
        {
            throw new AOOSException($this->core(), $this->tr("start_bigger_than_end"), "", true, 1);
            return false;
        }

        // If start is > 0 we count from the end
        if ($start < 0)
        {
            $start = $count + $start;
        }
        // Same goes for end
        if ($end < 0)
        {
            $end = $count + $end;
        }

        return true;
    }

    /**
     * Adds a row before $row.
     * @param int $row The row which the new row should be inserted before. If given -1 it will be inserted at the end of the model.
     * @return bool
     */
    public function addRow($row = -1)
    {
        if ($row > count($this->_data) || $row < -1)
        {
            throw new AOOSException($this->core(), $this->tr("row_out_of_bounds"), "", true, 1);
            return false;
        }

        if ($row == -1 || count($this->_data) == 0)
        {
            $this->_data[] = null;
        }
        else 
        {
            $tmp = $this->_data;
            $this->_data[$row] = null;

            $count = count($this->_data);
            while ($row < $count)
            {
                $val = $tmp[$row];
                $row++;
                $this->_data[$row] = $val;
            }
        }
        $this->_updated = false;
        $this->_rows++;
        return true;
    }

    /**
     * Removes a row from the model.
     * @param int $row The row to remove. Given -1 the last row is removed.
     * @return bol
     */
    public function removeRow($row = -1)
    {
        if ($row < -1 || $row >= count($this->_data))
        {
            throw new AOOSException($this->core(), $this->tr("row_out_of_bounds"), "", true, 2);
            return false;
        }
        
        if ($row == -1)
        {
            $row = count($this->_data) - 1;
        }
        $tmp = $this->_data;
        $this->_data = array();

        // Reinsert rows before $row
        for ($i = 0; $i < $row; $i++)
        {
            $this->_data[] = $tmp[$i];
        }

        $row++;

        // Reinsert rows after $row
        for ($c = count($tmp); $row < $c; $row++)
        {
            $this->_data[] = $tmp[$row];
        }
        
        $this->_updated = false;
        $this->_rows--;
        return true;
    }

    /**
     * Sets the data of a specified row and column.
     * @param int $row The row in which the column is selected from
     * @param int|string $col The column in which the data should be added
     * @param $data The data that should be added.
     * @return bool
     */
    public function setData($data, $row = -1, $col = -1)
    {
        if ($row >= count($this->_data))
        {
            throw new AOOSException($this->core(), $this->tr("row_out_of_bounds"), "", true, 1);
            return false;
        }
        if ($row == -1)
        {
            $row = count($this->_data) - 1;
        }

        if ($col >= count($this->_data[$row]) || $col == -1)
        {
            $col = count($this->_data[$row]);
        }
        if (is_string($col))
        {
            $i = 0;
            foreach ($this->_columnIndex as $index)
            {
                if ($index == $col)
                {
                    $col = $i;
                    break;
                }
                $i++;
            }
        }

        $this->_data[$row][$col] = $data;
        $this->_updated = false;
        return true;
    }

    /**
     * Sets column index
     * @param int $col Column
     * @param string $index Column index
     * @return bool
     */
    public function setColumnIndex()
    {
        $count = func_num_args();
        $arg1 = func_get_arg(0);
        switch ($count)
        {
        case (2):
            $arg2 = func_get_arg(1);
            $this->_setColumnIndexSingle($arg1, $arg2);
            break;
        case(1):
            $this->_setColumnIndexArray($arg1);
            break;
        }
        $this->_updated = false;
    }

    private function _setColumnIndexSingle($col, $index)
    {
        if (!is_int($col))
        {
            throw new AOOSException($this->core(), $this->tr("not_integer"), "", true, 1);
            return false;
        }
        if (!is_string($index))
        {
            throw new AOOSException($this->core(), $this->tr("not_string"), "", true, 1);
            return false;
        }
        $this->_columnIndex[$col] = $index;
    }

    private function _setColumnIndexArray($index)
    {
        if (!is_array($index))
        {
            throw new AOOSException($this->core(), $this->tr("not_array"), "", true, 1);
            return false;
        }

        $c = 0;
        foreach ($index as $i)
        {
            $this->_columnIndex[$c] = $i;
            $c++;
        }
    }

    /**
     * Returns everything in the model
     * @return data|false
     */
    public function data()
    {
        $data       = array();
        $rowIndex   = 0;

        if ($this->_updated) // If the model is updated we don't need to iterate through the data
        {
            return $this->_model;
        }

        foreach ($this->_data as $row)
        {
            $index = 0;
            foreach ($this->_columnIndex as $colIndex)
            {
                if ($index >= count($row))
                {
                    $row[$index] = "";
                }

                $col = $row[$index];
                if ($this->escape())
                {
                    $col = mysql_real_escape_string($col);
                }

                if ($this->quote())
                {
                    $col = "\"".$col."\"";
                }

                $data[$rowIndex][$colIndex] = $col;
                $index++;
            }
            $rowIndex++;
        }
        $this->_updated = true;
        $this->_model = $data;
        return $this->_model;
    }

    /**
     * Returns a given column
     * @param string $index The column index
     * @param int $start "From row"
     * @param int $end "To row". Inclusive.
     * @return array
     */
    public function getColumn($index, $start = null, $end = null)
    {
        $data = $this->data();
        $count = count($data);
        $column = array();

        if (!in_array($index, $this->_columnIndex))
        {
            throw new AOOSException($this->core(), $this->tr("not_in_column_index"), "", true, 1);
            return false;
        }

        $this->_fixRange($start, $end, $count);

        for ($i = $start; $i <= $end; $i++)
        {
            $column[] = $data[$i][$index];
        }

        return $column;
    }

    /**
     * Returns rows
     * @param int $start "From row"
     * @param int $end "To row". Inclusive.
     * @return array
     */
    public function getRows($start = null, $end = null)
    {
        $data = $this->data();
        $count = count($data);
        $rows = array();

        $this->_fixRange($start, $end, $count);

        for ($i = $start; $i <= $end; $i++)
        {
            $rows[] = $data[$i];
        }

        return $rows;
    }

    /**
     * Returns a single row
     * @param int $id Row id
     * @return array
     */
    public function getRow($id)
    {
        $tmp = $this->getRows($id, $id);
        return $tmp[0];
    }


    /**
     * Returns the column index
     * @return array
     */
    public function columnIndex()
    {
        return $this->_columnIndex;
    }

    /**
     * Returns the row count
     * @return int
     */
    public function rows()
    {
        return $this->_rows;
    }

    /**
     * Returns the column count
     * @return int
     */
    public function columns()
    {
        return count($this->_columnIndex);
    }

    /**
     * Is the given value in the given column?
     * @param string $col Column id
     * @param value $val Value
     * @return bool
     */
    public function inColumn($col, $val)
    {
        $c = $this->getColumn($col);
        if (!in_array($val, $c))
        {
            return false;
        }
        return true;
    }

    /**
     * Is the given value a column index?
     * @param string $name
     * @return bool
     */
    public function inColumnIndex($name)
    {
        if (!in_array($name, $this->columnIndex()))
        {
            return false;
        }
        return true;
    }

    /**
     * Appends given values to the end of the model. The number of keys is the number of values added.
     * @param array $values Values to append.
     * @param auto|null $key If "auto" is given the column ids we be determined automatically. If not the function expects the array to be a hash which keys is used as column indexes(default).
     * @return bool
     */
    public function append($values, $key = null)
    {
        $keys = array();
        $c = 0;

        if (!is_array($values))
        {
            throw new AOOSException($this->core(), $this->tr("not_array"));
            return false;
        }

        if ($key == "auto")
        {
            $keys = $this->columnIndex();
        }
        else
        {
            $keys = array_keys($values);
            $values = array_values($values);
        }

        $this->addRow();
        $c = count($keys);
        for ($i=0; $i<$c; $i++)
        {
            $this->setData($values[$i], -1, $keys[$i]);
        }
        return true;
    }

    /**
     * Returns the row index in which the given field has the given value. Returns false if none is found
     * @param string $name Field name
     * @param string $value Field value
     * @return int|false
     */
    public function getRowFromValue($name, $value)
    {
        if (!$this->inColumnIndex($name))
        {
            throw new AOOSException($this->core(), $this->tr("not_in_column_index"), "", true, 2);
            return false;
        }

        $c = $this->getColumn($name);
        $r = null;
        for($i = 0; $i < count($c); $i++)
        {
            if ($c[$i] == $value)
            {
                $r = $i;
            }
        }

        if ($r === null)
        {
            throw new AOOSException($this->core(), $this->tr("value_not_in_row"), "", true, 2);
            return false;
        }

        return $r;
    }

    /**
     * Returns a given field. Calls getColum.
     * @param int $row The row
     * @param string $column Column index
     * @return value|false
     */
    public function getField($row, $column)
    {
        return $this->getColumn($column, $row, $row);
    }

    /**
     * When set to true all data is escaped. Escaping is done in the data() call, which means *all* data is escaped, not only newly added data.
     * Default is true.
     * @param bool $state Should data be escaped or not?
     * @return bool
     */
    public function setEscape($state)
    {
        if (!is_bool($state))
        {
            throw new AOOSException($this->core(), $this->tr("not_bool"));
            return false;
        }
        $this->_escape = $state;
        $this->_updated = false;
        return true;
    }

    /**
     * Is data being escaped?
     * @return bool
     */
    public function escape()
    {
        return $this->_escape;
    }

    /**
     * When set to true all data have quotes around it. Like setEscape(), quotes are added during the data() call. This means that all data, and not only newly added data, is quoted.
     * Default is false.
     * @param bool $state Should data have quotes or not?
     * @return bool
     */
    public function setQuote($state)
    {
        if (!is_bool($state))
        {
            throw new AOOSException($this->core(), $this->tr("not_bool"));
            return false;
        }
        $this->_quote = $state;
        $this->_updated = false;
        return true;
    }
    
    /**
     * Is data being quoted?
     * @return bool
     */
    public function quote()
    {
        return $this->_quote;
    }
}

?>