AOOSModel.php

   1 <?php
   2 require_once("AOOSException.php");
   3 require_once("AOOSModule.php");
   4
   5 /**
   6  * AOOSModel
   7  * A table-like model for containing data
   8  * @author Sebastian Skejø
   9  */
  10
  11 class AOOSModel extends AOOSModule
  12 {
  13     private $_rows = 0;
  14     private $_data = array();
  15     private $_model = array();
  16     private $_updated = false;
  17     private $_columnIndex = array();
  18     private $_escape = true;
  19     private $_quote = false;
  20     private $_equal = "{'}";
  21     private $_seperator = "]'[";
  22
  23     public function __toString() {
  24         $string = "";
  25         foreach ($this->data() as $row) {
  26             $string .= print_r($row, true);
  27             $string .= "<br />";
  28         }
  29         return $string;
  30     }
  31
  32     private function _fixRange(&$start, &$end, $count)
  33     {
  34         if ($start === null) { $start = 0; }
  35         if ($end === null) { $end = $count-1; }
  36
  37         if (!is_int($start) || !is_int($end))
  38         {
  39             throw new AOOSException($this->core(), $this->tr("not_int"), "", true, 1);
  40             return false;
  41         }
  42
  43         if ($start >= $count || $end >= $count)
  44         {
  45             throw new AOOSException($this->core(), $this->tr("row_out_of_bounds"), "", true, 1);
  46             return false;
  47         }
  48
  49         if ($start > $end && !($end < 0))
  50         {
  51             throw new AOOSException($this->core(), $this->tr("start_bigger_than_end"), "", true, 1);
  52             return false;
  53         }
  54
  55         // If start is > 0 we count from the end
  56         if ($start < 0)
  57         {
  58             $start = $count + $start;
  59         }
  60         // Same goes for end
  61         if ($end < 0)
  62         {
  63             $end = $count + $end;
  64         }
  65
  66         return true;
  67     }
  68
  69     /**
  70      * Adds a row before $row.
  71      * @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.
  72      * @return bool
  73      */
  74     public function addRow($row = -1)
  75     {
  76         if ($row > count($this->_data) || $row < -1)
  77         {
  78             throw new AOOSException($this->core(), $this->tr("row_out_of_bounds"), "", true, 1);
  79             return false;
  80         }
  81
  82         if ($row == -1 || count($this->_data) == 0)
  83         {
  84             $this->_data[] = null;
  85         }
  86         else
  87         {
  88             $tmp = $this->_data;
  89             $this->_data[$row] = null;
  90
  91             $count = count($this->_data);
  92             while ($row < $count)
  93             {
  94                 $val = $tmp[$row];
  95                 $row++;
  96                 $this->_data[$row] = $val;
  97             }
  98         }
  99         $this->_updated = false;
 100         $this->_rows++;
 101         return true;
 102     }
 103
 104     /**
 105      * Removes a row from the model.
 106      * @param int $row The row to remove. Given -1 the last row is removed.
 107      * @return bol
 108      */
 109     public function removeRow($row = -1)
 110     {
 111         if ($row < -1 || $row >= count($this->_data))
 112         {
 113             throw new AOOSException($this->core(), $this->tr("row_out_of_bounds"), "", true, 2);
 114             return false;
 115         }
 116
 117         if ($row == -1)
 118         {
 119             $row = count($this->_data) - 1;
 120         }
 121         $tmp = $this->_data;
 122         $this->_data = array();
 123
 124         // Reinsert rows before $row
 125         for ($i = 0; $i < $row; $i++)
 126         {
 127             $this->_data[] = $tmp[$i];
 128         }
 129
 130         $row++;
 131
 132         // Reinsert rows after $row
 133         for ($c = count($tmp); $row < $c; $row++)
 134         {
 135             $this->_data[] = $tmp[$row];
 136         }
 137
 138         $this->_updated = false;
 139         $this->_rows--;
 140         return true;
 141     }
 142
 143     /**
 144      * Sets the data of a specified row and column.
 145      * @param int $row The row in which the column is selected from
 146      * @param int|string $col The column in which the data should be added
 147      * @param $data The data that should be added.
 148      * @return bool
 149      */
 150     public function setData($data, $row = -1, $col = -1)
 151     {
 152         if ($row >= count($this->_data))
 153         {
 154             throw new AOOSException($this->core(), $this->tr("row_out_of_bounds"), "", true, 1);
 155             return false;
 156         }
 157         if ($row == -1)
 158         {
 159             $row = $this->rows() -1;
 160         }
 161
 162         if (is_string($col))
 163         {
 164             $i = 0;
 165             foreach ($this->_columnIndex as $index)
 166             {
 167                 if ($index == $col)
 168                 {
 169                     $col = $i;
 170                     break;
 171                 }
 172                 $i++;
 173             }
 174         }
 175         if ($col >= count($this->_data[$row]) || $col == -1)
 176         {
 177             $col = count($this->_data[$row]);
 178         }
 179
 180         $this->_data[$row][$col] = $data;
 181         $this->_updated = false;
 182         return true;
 183     }
 184
 185     /**
 186      * Sets column index
 187      * @param int $col Column
 188      * @param string $index Column index
 189      * @return bool
 190      */
 191     public function setColumnIndex()
 192     {
 193         $count = func_num_args();
 194         $arg1 = func_get_arg(0);
 195         switch ($count)
 196         {
 197         case (2):
 198             $arg2 = func_get_arg(1);
 199             $this->_setColumnIndexSingle($arg1, $arg2);
 200             break;
 201         case(1):
 202             $this->_setColumnIndexArray($arg1);
 203             break;
 204         }
 205         $this->_updated = false;
 206     }
 207
 208     private function _setColumnIndexSingle($col, $index)
 209     {
 210         if (!is_int($col))
 211         {
 212             throw new AOOSException($this->core(), $this->tr("not_integer"), "", true, 1);
 213             return false;
 214         }
 215         if (!is_string($index))
 216         {
 217             throw new AOOSException($this->core(), $this->tr("not_string"), "", true, 1);
 218             return false;
 219         }
 220         $this->_columnIndex[$col] = $index;
 221     }
 222
 223     private function _setColumnIndexArray($index)
 224     {
 225         if (!is_array($index))
 226         {
 227             throw new AOOSException($this->core(), $this->tr("not_array"), "", true, 1);
 228             return false;
 229         }
 230
 231         $c = 0;
 232         foreach ($index as $i)
 233         {
 234             $this->_columnIndex[$c] = $i;
 235             $c++;
 236         }
 237     }
 238
 239     /**
 240      * Returns everything in the model
 241      * @return data|false
 242      */
 243     public function data()
 244     {
 245         $data       = array();
 246         $rowIndex   = 0;
 247
 248         if ($this->_updated) // If the model is updated we don't need to iterate through the data
 249         {
 250             return $this->_model;
 251         }
 252
 253         foreach ($this->_data as $row)
 254         {
 255             $index = 0;
 256             foreach ($this->_columnIndex as $colIndex)
 257             {
 258                 if ($index >= count($row))
 259                 {
 260                     $row[$index] = "";
 261                 }
 262
 263                 $col = $row[$index];
 264                 if ($this->escape())
 265                 {
 266                     $col = mysql_real_escape_string($col);
 267                 }
 268
 269                 if ($this->quote())
 270                 {
 271                     $col = "\"".$col."\"";
 272                 }
 273
 274                 $data[$rowIndex][$colIndex] = $col;
 275                 $index++;
 276             }
 277             $rowIndex++;
 278         }
 279         $this->_updated = true;
 280         $this->_model = $data;
 281         return $this->_model;
 282     }
 283
 284     /**
 285      * Returns a given column
 286      * @param string $index The column index
 287      * @param int $start "From row"
 288      * @param int $end "To row". Inclusive.
 289      * @return array
 290      */
 291     public function getColumn($index, $start = null, $end = null)
 292     {
 293         $data = $this->data();
 294         $count = count($data);
 295         $column = array();
 296
 297         if (!in_array($index, $this->_columnIndex))
 298         {
 299             throw new AOOSException($this->core(), $this->tr("not_in_column_index"), "", true, 1);
 300             return false;
 301         }
 302
 303         $this->_fixRange($start, $end, $count);
 304
 305         for ($i = $start; $i <= $end; $i++)
 306         {
 307             $column[] = $data[$i][$index];
 308         }
 309
 310         return $column;
 311     }
 312
 313     public function getColumns($fields, $start = null, $end = null)
 314     {
 315         $cols = array();
 316         foreach ($fields as $index)
 317         {
 318             $cols[] = $this->getColumn($index, $start, $end);
 319         }
 320         return $cols;
 321     }
 322
 323     /**
 324      * Returns rows
 325      * @param int $start "From row"
 326      * @param int $end "To row". Inclusive.
 327      * @param int $cutoff If set to true the $end row will be adjusted to fit within the number of rows if the given $end is bigger.
 328      * @return array
 329      */
 330     public function getRows($start = null, $end = null, $cutoff = false)
 331     {
 332         $data = $this->data();
 333         $count = count($data);
 334         $rows = array();
 335
 336         if ($this->rows() == 0)
 337         {
 338             throw new AOOSException($this->core(), $this->tr("model_empty"), "", true, 2);
 339             return false;
 340         }
 341
 342         if ($cutoff && $end > $this->rows())
 343         {
 344             $end = $this->rows();
 345         }
 346
 347         $this->_fixRange($start, $end, $count);
 348
 349         for ($i = $start; $i <= $end; $i++)
 350         {
 351             $rows[] = $data[$i];
 352         }
 353
 354         return $rows;
 355     }
 356
 357     /**
 358      * Returns a single row
 359      * @param int $id Row id
 360      * @return array
 361      */
 362     public function getRow($id)
 363     {
 364         $tmp = $this->getRows($id, $id);
 365         return $tmp[0];
 366     }
 367
 368
 369     /**
 370      * Returns the column index
 371      * @return array
 372      */
 373     public function columnIndex()
 374     {
 375         return $this->_columnIndex;
 376     }
 377
 378     /**
 379      * Returns the row count
 380      * @return int
 381      */
 382     public function rows()
 383     {
 384         return $this->_rows;
 385     }
 386
 387     /**
 388      * Returns the column count
 389      * @return int
 390      */
 391     public function columns()
 392     {
 393         return count($this->_columnIndex);
 394     }
 395
 396     /**
 397      * Is the given value in the given column?
 398      * @param string $col Column id
 399      * @param value $val Value
 400      * @return bool
 401      */
 402     public function inColumn($col, $val)
 403     {
 404         $c = $this->getColumn($col);
 405         if (!in_array($val, $c))
 406         {
 407             return false;
 408         }
 409         return true;
 410     }
 411
 412     /**
 413      * Is the given value a column index?
 414      * @param string $name
 415      * @return bool
 416      */
 417     public function inColumnIndex($name)
 418     {
 419         if (!in_array($name, $this->columnIndex()))
 420         {
 421             return false;
 422         }
 423         return true;
 424     }
 425
 426     /**
 427      * Appends given values to the end of the model. The number of keys is the number of values added.
 428      * @param array $values Values to append.
 429      * @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).
 430      * @return bool
 431      */
 432     public function append($values, $key = null)
 433     {
 434         $keys = array();
 435         $c = 0;
 436
 437         if (!is_array($values))
 438         {
 439             throw new AOOSException($this->core(), $this->tr("not_array"));
 440             return false;
 441         }
 442
 443         if ($key == "auto")
 444         {
 445             $keys = $this->columnIndex();
 446         }
 447         else
 448         {
 449             $keys = array_keys($values);
 450             $values = array_values($values);
 451         }
 452
 453         $this->addRow();
 454         $c = count($keys);
 455         for ($i=0; $i<$c; $i++)
 456         {
 457             $this->setData($values[$i], -1, $keys[$i]);
 458         }
 459         return true;
 460     }
 461
 462     /**
 463      * Returns the row index in which the given field has the given value. Returns false if none is found
 464      * @param string $name Field name
 465      * @param string $value Field value
 466      * @return int|false
 467      */
 468     public function getRowFromValue($name, $value)
 469     {
 470         if (!$this->inColumnIndex($name))
 471         {
 472             throw new AOOSException($this->core(), $this->tr("not_in_column_index"), "", true, 2);
 473             return false;
 474         }
 475
 476         $c = $this->getColumn($name);
 477         $r = null;
 478         for($i = 0; $i < count($c); $i++)
 479         {
 480             if ($c[$i] == $value)
 481             {
 482                 $r = $i;
 483             }
 484         }
 485
 486         if ($r === null)
 487         {
 488             throw new AOOSException($this->core(), $this->tr("value_not_in_row"), $this->tr("given_value").":". $value, true, 2);
 489             return false;
 490         }
 491
 492         return $r;
 493     }
 494
 495     /**
 496      * Returns a given field. Calls getColum.
 497      * @param int $row The row
 498      * @param string $column Column index
 499      * @return value|false
 500      */
 501     public function getField($row, $column)
 502     {
 503         return $this->getColumn($column, $row, $row);
 504     }
 505
 506     /**
 507      * 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.
 508      * Default is true.
 509      * @param bool $state Should data be escaped or not?
 510      * @return bool
 511      */
 512     public function setEscape($state)
 513     {
 514         if (!is_bool($state))
 515         {
 516             throw new AOOSException($this->core(), $this->tr("not_bool"));
 517             return false;
 518         }
 519         $this->_escape = $state;
 520         $this->_updated = false;
 521         return true;
 522     }
 523
 524     /**
 525      * Is data being escaped?
 526      * @return bool
 527      */
 528     public function escape()
 529     {
 530         return $this->_escape;
 531     }
 532
 533     /**
 534      * 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.
 535      * Default is false.
 536      * @param bool $state Should data have quotes or not?
 537      * @return bool
 538      */
 539     public function setQuote($state)
 540     {
 541         if (!is_bool($state))
 542         {
 543             throw new AOOSException($this->core(), $this->tr("not_bool"));
 544             return false;
 545         }
 546         $this->_quote = $state;
 547         $this->_updated = false;
 548         return true;
 549     }
 550
 551     /**
 552      * Is data being quoted?
 553      * @return bool
 554      */
 555     public function quote()
 556     {
 557         return $this->_quote;
 558     }
 559
 560     /**
 561      * Sort using mergesort
 562      * @param string $name The column the data should be sorted by.
 563      * @param ASC|DESC $order Should data be sorting in ascending or descending order?
 564      * @return bool
 565      */
 566     public function sort($name, $order)
 567     {
 568         return true;
 569     }
 570
 571     /**
 572      * Merges the selected data to a string
 573      * @param ROW|COL $type Should data be selected from row or column?
 574      * @param id $id Identifier.
 575      */
 576     public function merge($type, $id)
 577     {
 578         switch ($type)
 579         {
 580         case("ROW"):
 581             $data = $this->getRow($id);
 582             break;
 583         case("COL"):
 584             $data = $this->getColumn($id);
 585             break;
 586         default:
 587             throw new AOOSException($this->core(), $this->tr("not_ROW_or_COL"), "", true, 1);
 588             return false;
 589         }
 590
 591         $pairs = array();
 592         foreach ($data as $key => $value)
 593         {
 594             $pairs[] = $key.$this->_equal.$value;
 595         }
 596         $string = implode($pairs, $this->_seperator);
 597         return $string;
 598     }
 599
 600     /**
 601      * Splits the given string and appends it to the current model
 602      * $param string $string The string to be splittet
 603      */
 604     public function split($string)
 605     {
 606         $f = array();
 607         $a = explode($this->_seperator, $string);
 608         foreach($a as $col)
 609         {
 610             $s = explode($this->_equal, $col);
 611             $f[$s[0]] = $s[1];
 612         }
 613         $colindex = $this->columnIndex();
 614         foreach(array_keys($f) as $index) {
 615             $colindex[] = $index;
 616         }
 617         $this->setColumnIndex($colindex);
 618         $this->append($f);
 619     }
 620 }
 621
 622 ?>