Source for file IsMySQLClass.class.php

Documentation is available at IsMySQLClass.class.php

  1. <?php
  2. /**
  3.  * R.E. DBObjects
  4.  *
  5.  * @author Takács Ákos (Rimelek), programmer [at] rimelek [dot] hu
  6.  * @copyright Copyright (C) 2010, Takács Ákos
  7.  * @version 2.1
  8.  * @license http://www.gnu.org/licenses/lgpl.html
  9.  * @package REDBObjects
  10.  */
  11.  
  12. /**
  13.  * @ignore
  14.  */
  15. require_once dirname(__FILE__).'/../ADBClass.class.php';
  16.  
  17. /**
  18.  * @ignore
  19.  */
  20. require_once dirname(__FILE__).'/../IIsDBClass.class.php';
  21.  
  22. /**
  23.  * Adatbázis táblákat megvalósító osztály
  24.  *
  25.  * Az osztály, ami ezt az osztályt örökli, a konstruktorban megadott tábla, és mezőlista alapján elkészíti
  26.  * saját tulajdonságait a mezőkkel azonos néven. Lehetőség van külön jelölni azt is, hogy pontosan melyik
  27.  * tábla mezőjéről van szó, ha azonos mezőnevek is szerepelnek. Amennyiben ez nem történik meg, értékadáskor
  28.  * az összes táblában megkapja az új értéket az adott nevű mező. Érték lekérdezésekor pedig kivételt dob. <br />
  29.  * Alapesetben ilyenkor a tulajdonságot a 'T_' karakterlánccal kell kezdeni, majd a táblanevet és a
  30.  * mezőnevet egy '_' karakter választja el egymástól. Ez azonban testre szabható. A 'T_' előtag
  31.  * a {@link $tableName_signal} tulajdonságban, míg a táblát és mezőt elválasztó karakterlánc a
  32.  * {@link $table_field_sep} tulajdonságban.<br />
  33.  *
  34.  * <b>Az osztály helyes használata:</b><br />
  35.  * <code>
  36.  * require_once 'REDBObjects/REDBObjects.class.php';
  37.  * REDBObjects::uses('mysql');
  38.  *
  39.  * mysql_connect('localhost', 'root', 'password');
  40.  * mysql_select_db('teszt');
  41.  * 
  42.  * class MyClass extends IsMySQLClass {}
  43.  * $user = new MyClass(array(
  44.  *     'users'=>array('useremail','username'),
  45.  *     'profile'=>array('firstname','lastname','useremail')));
  46.  * $user->keyName = 'userid';
  47.  * $user->init(12);  //Valamilyen kapcsoló mező értéke alapján
  48.  * //Vagy sql lekérdezés alapján. Ekkor a második paraméter true kell legyen.
  49.  * //Első paraméter pedig az sql lekérdezés FROM kulcsszó utáni része
  50.  * //$user->init("users left join profile where users.useremail = 'valami@ize.hu'",true);
  51.  * print "A nevem: ".$user->lastname." ".$user->firstname."<br />";
  52.  * $user->lastname = 'Új vezetéknév';
  53.  * $user->firstname 'Új keresztnév';
  54.  * //Vagy akár így is:
  55.  * //$user['lastname'] = 'Új vezetéknév';
  56.  * $user->T_profile_useremail = 'Új publikus emailcím';
  57.  * //Ez a metódus végzi el a frissítést. Enélkül nem kerül adatbázisba az új adat
  58.  * $user->update();
  59.  * </code>
  60.  *
  61.  * @property string $tableName_signal Táblanevet jelző prefix
  62.  * @property string $table_field_sep Táblanevet és mezőnevet elválasztó jel
  63.  *
  64.  * @author Takács Ákos (Rimelek), programmer [at] rimelek [dot] hu
  65.  * @copyright Copyright (C) 2010, Takács Ákos
  66.  * @license http://www.gnu.org/licenses/lgpl.html
  67.  * @package REDBObjects
  68.  */
  69. class IsMySQLClass extends ADBClass implements IIsDBClass, Iterator, ArrayAccess
  70. {
  71.     /**
  72.     *    Az értékadás feltöltődő asszociatív tömb
  73.     *
  74.     *    @var array $new_properties 
  75.     */
  76.     public $new_properties = array();
  77.  
  78.     /**
  79.     *    A táblákat összekapcsoló mező értéke
  80.     *
  81.     *    Ezt a mezőt csak az {@link IsDBList} osztály használja, hogy visszaadja az utoljára hozzáadott rekord
  82.     *    összekapcsoló mezőjének értékét.
  83.     *
  84.     *    @var string $keyValue; 
  85.     */
  86.     public $keyValue="";
  87.  
  88.     /**
  89.     *    Sql kérés volt-e megadva az init() paramétereként.
  90.     *
  91.     *    @var string $isSqlQuery 
  92.     */
  93.     protected $isSqlQuery = false;
  94.  
  95.     /**
  96.     *    IsMySQLClass osztály konstruktora
  97.     *
  98.     *    @param array $tablelist Két dimenziós tömb. Formátuma:
  99.     *      array('table1'=>array('field1'[,field2]...)[,'table2'=>array('field1'[,'field2']...)]... )
  100.     *    @param bool $list Ha false, akkor nem kérdezi le a mezőneveket előre.
  101.     */
  102.     public function __construct($tablelist,$list=false)
  103.     {
  104.         $this->tablelist = $tablelist;
  105.         if (!$list) {
  106.             $this->getFields();
  107.         }
  108.     }
  109.  
  110.     /**
  111.      * @return int Objektum tulajdonságainak száma
  112.      */
  113.     public function count()
  114.     {
  115.         return count($this->properties);
  116.     }
  117.  
  118.     /**
  119.      * Objektum inicializálása
  120.      *
  121.      * Ez a metódus választja ki a táblákból azt az egy rekordot, amiből létrehozza az objektumtulajdonságokat.
  122.      *
  123.      * @param mixed $rowid Azonosító, ami minden táblában azonos értékű
  124.      * @param bool $bool Ha true, akkor a $rowid lehet sql utasítás ( csak a from kulcsszó utáni rész )
  125.      */
  126.     public function init($rowid,$bool=false)
  127.     {
  128.         //ha sql lekérdezéssel inicializáljuk az objektumot
  129.         if ($bool) {
  130.             $this->isSqlQuery=true;
  131.             $afields = array();
  132.             //végig kell menni a táblalistánés összeállítani a lekérdezendő mezőlistát
  133.             foreach($this->tablelist as $tableName=>$fieldList)
  134.             {
  135.                 //egy táblán belül az összes mező felvétele táblanevet tartalmazó aliassal
  136.                 foreach ($fieldList as $field)
  137.                 {
  138.                     $afields[] = "`$tableName`.`$field` as `$tableName.$field`";
  139.                 }
  140.                 //ha az elsődleges kulcs mezőt nem kértük le, akkor automatikusan lekérdezéshez adódik
  141.                 if (!isset($fieldList[key($this->priKeys[$tableName])])) {
  142.                     $afields[] = "`$tableName`.`".
  143.                         key($this->priKeys[$tableName]).
  144.                         "` as `$tableName.".key($this->priKeys[$tableName])."`";
  145.  
  146.                 }
  147.             }
  148.             $fields = implode(",\n",$afields);
  149.             $i=0;
  150.             $sql = "select $fields from $rowid";
  151.             if($fetch = mysql_fetch_assoc(mysql_query($sql))) {
  152.                 $afields = array();
  153.                 //itt az eredményt be kell tölteni a properties tulajdonságba
  154.                 foreach($this->tablelist as $tableName=>$fieldList)
  155.                 {
  156.                     foreach ($fieldList as $field)
  157.                     {
  158.                         $this->properties[$tableName][$field] = $fetch[$tableName.'.'.$field];
  159.                     }
  160.                     //az elsődleges kulcsok értékeit külön is tárolni kell egy tömbben
  161.                     $this->priKeys[$tableName][key($this->priKeys[$tableName])] =
  162.                         $fetch[$tableName.'.'.key($this->priKeys[$tableName])];
  163.                 }
  164.             }
  165.             return;
  166.         }
  167.         //Ez a rész már csak akkor fut le, ha nem sql lekérdezéssel, hanem mező értékkel  inicializáltuk az objektumot
  168.  
  169.         //A kapcsoló mező nevére szükség van. Ezért ha nincs megadva, kivételt kell dobni
  170.         if (trim($this->keyName) == "") throw new NotIssetPropertyException(__CLASS__."::keyName nincs beállítva!");
  171.  
  172.         $this->keyValue = $rowid;
  173.         //végig kell menni ciklusban az összes táblán, és lekérdezni a mezők értékeit
  174.         foreach ($this->tablelist as $tableName=>$fieldList) {
  175.             $fields = '`'.implode('`, `',$fieldList).'`';
  176.             $t = (isset($this->tableAliases[$tableName])) ? $this->tableAliases[$tableName] : $tableName;
  177.             $sql = "select $fields from `$t` where `".$this->keyName."` = '$rowid' limit 1";
  178.             if($fetch = mysql_fetch_assoc(mysql_query($sql)))
  179.             {
  180.                 $this->properties[$tableName] = $fetch;
  181.             }
  182.         }
  183.     }
  184.  
  185.     /**
  186.      * A táblalista szerint az összes lehetséges mező nevének lekérdezése,
  187.      * és beállítása tulajdonságnak
  188.      */
  189.     public function getFields()
  190.     {
  191.         //a táblákat végigjárva az összes mezőjének nevét lekérdezi, így az indexek mindig léteznek,
  192.         //és az update() metódus akor is kiszűri a nem létező neveket, ha nem volt inicializálva az objektum
  193.         $fields = array();
  194.         foreach($this->tablelist as $tableName => $fieldList)
  195.         {
  196.             $tn = $from = $tableName;
  197.             $exp = explode(' ',$tableName);
  198.             if (count($exp) == 3 and trim(strtolower($exp[1])) == 'as' )
  199.             {
  200.                 $from = trim($exp[0]);
  201.                 $this->tableAliases[$exp[2]] = $from;
  202.                 $alias = trim($exp[2]);
  203.                 $this->tablelist[$alias] = $this->tablelist[$tableName];
  204.                 unset($this->tablelist[$tableName]);
  205.                 $tableName = $alias;
  206.             }
  207.             $query = mysql_query("show columns from `".$from."`");
  208.             $in = false;
  209.             while ($field = mysql_fetch_assoc($query))
  210.             {
  211.                 //ha az összes mezőt * karakterrel jelöltük
  212.                 if (($_in = $in) !== false or ($in = array_search('*',$fieldList)) !== false)
  213.                 {
  214.                     //akkor törölhető a lista és felvehetők az mezőnevek egyenként
  215.                     if ($_in === false) $this->tablelist[$tableName] = array();
  216.                     $this->tablelist[$tableName][] = $field['Field'];
  217.  
  218.                 }
  219.                 if (array_search($field['Field'],$this->tablelist[$tableName]) !== false)
  220.                 {
  221.                     $this->properties[$tableName][$field['Field']] = '';
  222.                 }
  223.                 //Ha ez az elsődleges kulcs mező, akkor visszaadja a primary_key
  224.                 //tulajdonságnak, hogy a kapcsoló mező elsődleges kulcs
  225.                 if ($this->keyName == $field['Field'])
  226.                 {
  227.                     $this->primary_key = $field['Field'];
  228.                 }
  229.                 //minden elsődleges kulcs mező értékét külön is tároljuk,
  230.                 //ezért előtte biztositjuk a helyet neki üres értékkel
  231.                 if ($field['Key'] == 'PRI')
  232.                 {
  233.                     $this->priKeys[$tableName] = array($field['Field']=>'');
  234.                 }
  235.             }
  236.             //Mivel elsődleges kulcs mezőkre mindenképp szükség van,
  237.             //ezért kivételt kell dobni, ha egy tábla nem tartalmaz olyan mezőt.
  238.             if ( !isset($this->priKeys[$tableName]) )
  239.             {
  240.                 require_once dirname(__FILE__).'/../exceptions/IncompatibleTable.class.php';
  241.                 throw new IncompatibleTable("Egyedi elsődleges kulcs mező használata kötelező! Tábla: ".$tableName);
  242.             }
  243.         }
  244.     }
  245.     /**
  246.      * Hozzáférés a mező értékeihez
  247.      *
  248.      * Ez a mágikus metódus szabályozza az értékek lekérdezését.
  249.      *
  250.      * @param string $var Mezőnév
  251.      * @ignore
  252.      */
  253.     public function __get($var)
  254.     {
  255.         $table=''; $field=''; $hit=false;
  256.         //Meg kell állapítani a mező és táblanevet, ha a tulajdonság lekérdezésekor a táblanevet is megadtuk
  257.         $issep = $this->sep_table_field($var,$table,$field);
  258.         //amennyiben tényleg megadták a táblanevet, a meghatározott mezőnevet be kell állítani
  259.         if ($issep)
  260.         {
  261.             $var = $field;
  262.         }
  263.         //Jöhet a táblák pásztázása egyenként
  264.         foreach ($this->tablelist as $tableName=>$fieldList)
  265.         {
  266.             $tbl = $tableName;
  267.             //ha a táblanevet is megadták, de épp nem ez az a tábla,
  268.             //akkor tovább lehet menni a következő táblára
  269.             if ($issep and $tableName != $table) { continue; }
  270.             //ha a lekérdezendő mezők közt van a $var változó értéke
  271.             if (array_key_exists($var,$this->properties[$tableName])) {
  272.                 //Akkor ha már volt ilyen mező más táblában is, kivételt dobunk
  273.                 //mert nem tudni melyiket kell lekérdezni
  274.                 if ($hit)
  275.                 {
  276.                     require_once dirname(__FILE__).'/../exceptions/AmbiguousException.class.php';
  277.                     throw new AmbiguousException(get_class($this)."::$var nem egyértelmű!");
  278.                 }
  279.                 //a visszatérési értéket be lehet állítani előre
  280.                 $return = $this->properties[$tableName][$var]; $hit=true;
  281.             }
  282.         }
  283.         //Ha volt találat, vissza lehet adni
  284.         if ($hit) return $return;
  285.         //Ha nem volt találat, és van ilyen tulajdonsága az objektumnak, akkor azt kell visszaadni
  286.         if (isset($this->$var)) {
  287.             return $this->$var;
  288.         //de ha még az objektumnak sincs ilyen tulajdonsága, akkor kivételt dobunk
  289.         } else {
  290.             require_once dirname(__FILE__).'/../exceptions/NotIssetPropertyException.class.php';
  291.             throw new NotIssetPropertyException(get_class($this)."::$var nem létezik!");
  292.         }
  293.     }
  294.  
  295.     /**
  296.      * Mezők értékeinek beállítása
  297.      *
  298.      * Ez a mágikus metódus szabályozza értékadáskor, hogy az értékek
  299.      * a {@link $new_properties} tömbben megfelelő helyre kerüljenek
  300.      *
  301.      * @param string $var Mezőnév
  302.      * @param mixed $value Mező új értéke
  303.      * @ignore
  304.      */
  305.     public function __set($var,$value)
  306.     {     $table=''; $field=''; $hit=false;
  307.         //Meg kell állapítani a mező és táblanevet, ha értékadáskor a táblanevet is megadtuk
  308.         $issep = $this->sep_table_field($var,$table,$field);
  309.         //amennyiben tényleg megadták a táblanevet, a meghatározott mezőnevet be kell állítani
  310.         if ($issep) {
  311.             $var = $field;
  312.         }
  313.         //Jöhet a táblák pásztázása egyenként
  314.         foreach ($this->tablelist as $tableName=>$fieldList)
  315.         {
  316.             //ha a táblanevet is megadták, de épp nem ez az a tábla,
  317.             //akkor tovább lehet menni a következő táblára
  318.             if($issep and $tableName != $table)
  319.             {
  320.                 continue;
  321.             }
  322.             //függetlenül attól, más táblának is volt-e ilyen mezője
  323.             //átadható az érték az új értékeknek
  324.             if (array_key_exists($var,$this->properties[$tableName])) {
  325.                 $this->new_properties[$tableName][$var] = $value;
  326.                 $hit=true;
  327.                 //De ha meg volt adva a táblanév is, akkor kész vagyunk. A program leáll
  328.                 if ($issep) {
  329.                     return;
  330.                 }
  331.             }
  332.         }
  333.         //Ha volt találat, kiléphetünk a programból
  334.         if ($hit) return;
  335.         //ha nem votl találat, de vagy a tableName_signal vagy a table_field_sep változó üres
  336.         if (($var == 'tableName_signal' or $var == 'table_field_sep') and trim($value) == '') {
  337.             //kivételt kell dobni, mert azok nem lehetnek sosem üresek
  338.             require_once dirname(__FILE__).'/../exceptions/NotIssetPropertyException.class.php';
  339.             throw new NotIssetPropertyException(get_class($this)."::$var nem maradhat üresen!");
  340.         }
  341.         //végül az objektum tulajdonságnak kell átadni az értéket, ha másnak nem lehetett
  342.         $this->$var = $value;
  343.     }
  344.  
  345.     /**
  346.      * Visszaadja, hogy létezik-e egy objektum tulajdonság, vagy sem
  347.      *
  348.      * @param mixed $var Vizsgálandó tulajdonság neve
  349.      * @return boolean 
  350.      * @ignore
  351.      */
  352.     public function __isset($var)
  353.     {
  354.         if (isset($this->$var)) {
  355.             return true;
  356.         }
  357.  
  358.         $table=''; $field=''; $hit=false;
  359.         //Meg kell állapítani a mező és táblanevet, ha a tulajdonság lekérdezésekor a táblanevet is megadtuk
  360.         $issep = $this->sep_table_field($var,$table,$field);
  361.         //amennyiben tényleg megadták a táblanevet, a meghatározott mezőnevet be kell állítani
  362.         if ($issep)
  363.         {
  364.             $var = $field;
  365.         }
  366.         //Jöhet a táblák pásztázása egyenként
  367.         foreach ($this->tablelist as $tableName=>$fieldList)
  368.         {
  369.             //ha a táblanevet is megadták, de épp nem ez az a tábla,
  370.             //akkor tovább lehet menni a következő táblára
  371.             if ($issep and $tableName != $table) { continue; }
  372.             //ha a lekérdezendő mezők közt van a $var változó értéke
  373.             if (isset($this->properties[$tableName]) and
  374.                 array_key_exists($var,$this->properties[$tableName])) {
  375.                 //Akkor ha már volt ilyen mező más táblában is, kivételt dobunk
  376.                 //mert nem tudni melyiket kell lekérdezni
  377.                 if ($hit)
  378.                 {
  379.                     require_once dirname(__FILE__).'/../exceptions/AmbiguousException.class.php';
  380.                     throw new AmbiguousException(get_class($this)."::$var nem egyértelmű!");
  381.                 }
  382.                 //a visszatérési értéket be lehet állítani előre
  383.                 $return = array_key_exists($var,$this->properties[$tableName]); $hit=true;
  384.             }
  385.         }
  386.         //Ha volt találat, vissza lehet adni
  387.         if ($hit) return $return;
  388.     }
  389.  
  390.     /**
  391.      * Adatok frissítése
  392.      *
  393.      * Ha a metódust a false paraméterrel hívjuk meg, Nem kerül be adatbázisba a módosítás,<br />
  394.      * csak lekérdezhetővé teszi az új értékeket
  395.      *
  396.      * @param bool $refreshDB 
  397.      */
  398.     function update($refreshDB=true)
  399.     {
  400.         //Az összes táblán végig kell menni
  401.         foreach ($this->tablelist as $tableName => $fieldList)
  402.         {
  403.             $query=false;
  404.             //ha az új értékek változó nem tömb, ki kell lépni, mert a ciklus tömböt vár
  405.             if (!isset($this->new_properties[$tableName]) or !is_array($this->new_properties[$tableName])) continue;
  406.             //most az új értékeken kell végigmenni
  407.             foreach ($this->new_properties[$tableName] as $fieldName => $value)
  408.             {
  409.                 //ha nem volt ilyen mező a properties tulajdonságban, akkor átugorjuk
  410.                 if (!array_key_exists($fieldName,$this->properties[$tableName])) { continue; }
  411.                 //egyébként escapeljük az értéket
  412.                 $this->new_properties[$tableName][$fieldName] = $value;
  413.             }
  414.             //csak azokat az értékeket hagyjuk meg amik különböznek az eredetitől
  415.             $this->new_properties[$tableName] = array_diff_assoc($this->new_properties[$tableName],$this->properties[$tableName]);
  416.             //ha frissíteni is szeretnénk az adatbázist, nem csak az objektumot
  417.             if ($refreshDB) {
  418.                 //Akkor ha van mit frissíteni
  419.                 if (count($this->new_properties[$tableName])) {
  420.                     //el kell dönteni mi az updatelés feltétele. hhez kell a keyValue, és a keyName
  421.                     $keyName = ($this->isSqlQuery) ? key($this->priKeys[$tableName]) : $this->keyName;
  422.                     $keyValue = ($this->isSqlQuery) ? current($this->priKeys[$tableName]) : $this->keyValue;
  423.                     $update = array();
  424.                     //most már lehet összeállítani az sql utasítást
  425.                     foreach ($this->new_properties[$tableName] as $fieldName=>$value )
  426.                     {
  427.                         $update[] = "`$fieldName` = '".mysql_real_escape_string($value)."' ";
  428.                     }
  429.                     $update = implode(', ',$update);
  430.                     $t = (isset($this->tableAliases[$tableName])) ? $this->tableAliases[$tableName] : $tableName;
  431.                     $sql = "update `$t` set $update where `".$keyName."` = '".$keyValue."'";
  432.                     $query = mysql_query($sql);
  433.                 }
  434.             }
  435.             //ha frissíteni akartuk az adatbázist és a frissítés sikeres is lett, vagy nem akartuk frissíteni
  436.             if (!$refreshDB or $query)
  437.             {
  438.                 //akkor beállítható a lekérdezhető tulajdonságokhoz is az érték
  439.                 foreach ($this->new_properties[$tableName] as $fieldName => $value)
  440.                 {
  441.                     $this->properties[$tableName][$fieldName] = $value;
  442.                 }
  443.             }
  444.             //ha frissíteni akartuk az adatbázist, akkor törölni kell az uj értékek listáját
  445.             if ($refreshDB)    {
  446.                 $this->new_properties[$tableName] = array();
  447.             }
  448.         }
  449.     }
  450.  
  451.     /**
  452.      * Iteráció alaphelyzetbe állítása
  453.      *
  454.      * @ignore
  455.      */
  456.     public function rewind()
  457.     {
  458.         //Az első tábla
  459.         reset($this->properties);
  460.         $this->itTableIndex=1;
  461.         //Első mezője
  462.         reset($this->properties[key($this->properties)]);
  463.         $this->itFieldIndex=1;
  464.     }
  465.  
  466.     /**
  467.      * Az aktuális elem visszaadása
  468.      *
  469.      * @return mixed 
  470.      * @ignore
  471.      */
  472.     public function current()
  473.     {
  474.         $k1 = key($this->properties);
  475.         $k2 = key($this->properties[key($this->properties)]);
  476.         if ($k1 === null or $k2 === null)
  477.         {
  478.             require_once dirname(__FILE__).'/../exceptions/IteratorEndException.class.php';
  479.             throw new IteratorEndException();
  480.         }
  481.         return current($this->properties[$k1]);
  482.     }
  483.  
  484.     /**
  485.      * Következő elem visszaadása
  486.      *
  487.      * @return mixed 
  488.      * @ignore
  489.      */
  490.     public function next()
  491.     {
  492.         //Ha már nincs több mező az aktuális táblában
  493.         if ($this->itFieldIndex >= count($this->properties[key($this->properties)])) {
  494.             //akkor ha még van több tábla
  495.             if ($this->itTableIndex < count($this->properties)) {
  496.                 //Ugrás a következő tábla első mezőjére
  497.                 $this->itTableIndex++;
  498.                 $this->itFieldIndex=1;
  499.                 next($this->properties);
  500.                 return $this->properties[key($this->properties)];
  501.             }
  502.         }
  503.         //Egyébként az aktuális táblában a következő mezőre ugrás
  504.         $fields = &$this->properties[ key( $this->properties) ];
  505.  
  506.         $ret = next($fields);
  507.         $this->itFieldIndex++;
  508.         return $ret;
  509.     }
  510.  
  511.     /**
  512.      * Aktuális elem kulcsa
  513.      *
  514.      * @return string 
  515.      * @ignore
  516.      */
  517.     public function key()
  518.     {
  519.         return key($this->properties[key($this->properties)]);
  520.     }
  521.  
  522.     /**
  523.      * Iteráció kilépési feltétele
  524.      *
  525.      * @return bool 
  526.      * @ignore
  527.      */
  528.     public function valid()
  529.     {
  530.         require_once dirname(__FILE__).'/../exceptions/IteratorEndException.class.php';
  531.         try
  532.         {
  533.             $this->current();
  534.             return true;
  535.         }
  536.         catch (IteratorEndException $e){}
  537.         return false;
  538.     }
  539.  
  540.     /**
  541.      * Létezik-e egy megadott index a listában
  542.      *
  543.      * @param string $index 
  544.      * @return bool 
  545.      * @ignore
  546.      */
  547.     public function offsetExists($index)
  548.     {
  549.         $exists = false;
  550.         foreach ($this->properties as &$table) {
  551.             if($exists = array_key_exists($index,$table)) break;
  552.         }
  553.         return $exists;
  554.     }
  555.     
  556.     /**
  557.      * Adott indexű elem lekérdezése
  558.      *
  559.      * @param string $index 
  560.      * @return mixed 
  561.      * @ignore
  562.      */
  563.     public function offsetGet($index)
  564.     {
  565.         return $this->$index;
  566.     }
  567.  
  568.     /**
  569.      * Adott indexű elem értékének beállítása
  570.      *
  571.      * @param string $index 
  572.      * @param mixed $value 
  573.      */
  574.     public function offsetSet($index,$value)
  575.     {
  576.         $this->$index = $value;
  577.     }
  578.  
  579.     /**
  580.      * Adott indexű elem érvénytelenítése
  581.      *
  582.      * @param string $index 
  583.      */
  584.     public function offsetUnset($index)
  585.     {
  586.         foreach ($this->properties as &$table) {
  587.             if($exists = array_key_exists($index,$table)) {
  588.                 unset($table[$index]);
  589.             }
  590.         }
  591.     }
  592. }
  593. ?>

Documentation generated on Fri, 02 Apr 2010 17:34:18 +0200 by phpDocumentor 1.4.1