PHPTAL-NP-0.7.0/libs/Types/OHash.php

   1 <?php
   2 /* vim: set expandtab tabstop=4 shiftwidth=4: */
   3 //
   4 //  Copyright (c) 2003 Laurent Bedubourg
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License, or (at your option) any later version.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 //
  20 //  Authors: Laurent Bedubourg <laurent.bedubourg@free.fr>
  21 //
  22
  23 require_once PT_IP . "/Types.php";
  24 require_once PT_IP . "/Types/Errors.php";
  25 require_once PT_IP . "/Types/Ref.php";
  26
  27 /**
  28  * Wrapper for oriented object associative arrays.
  29  *
  30  * This class implements a simple interface quite like java to handle
  31  * associatives arrays (Hashtables).
  32  *
  33  * Note:
  34  *
  35  * Some problems may occurs with object references until php4.4 to avoid
  36  * unwanted object copy, use setRef() method with objects or pass Ref objects
  37  * to set().
  38  *
  39  * @author Laurent Bedubourg <laurent.bedubourg@free.fr>
  40  */
  41 class OHash
  42 {
  43     var $_hash;
  44
  45     /**
  46      * OHash constructor.
  47      *
  48      * php4.4 compliant constructor
  49      *
  50      * @param array $array optional -- An associative php array
  51      */
  52     function __construct($array=array())
  53     {
  54         $this->_hash = array();
  55         $keys = array_keys($array);
  56         foreach ($keys as $key) {
  57             $this->_hash[$key] = ref($array[$key]);
  58         }
  59     }
  60
  61     /**
  62      * OHash constructor.
  63      *
  64      * php4.4 compliant constructor
  65      *
  66      * @param array $array optional  -- An associative php array
  67      */
  68     function OHash($array=array())
  69     {
  70         $this->__construct($array);
  71     }
  72
  73     /**
  74      * Set a value in this hash.
  75      *
  76      * @param string $key
  77      * @param string $value
  78      */
  79     function set($key, $value)
  80     {
  81         $this->_hash[$key] = ref($value);
  82     }
  83
  84     /**
  85      * Reference set.
  86      *
  87      * Until php4.4, it's the only way to avoid object/variable copy.
  88      *
  89      * @param string $key
  90      * @param reference $value
  91      */
  92     function setRef($key, &$value)
  93     {
  94         $this->_hash[$key] = ref($value);
  95     }
  96
  97     /**
  98      * Set a map of values.
  99      *
 100      * @param mixed $hash An Hash object or an associative php array.
 101      */
 102     function setAll($hash)
 103     {
 104         if (!is_array($hash) && is_a($hash, 'OHash')) {
 105             $hash = $hash->toHash();
 106         }
 107         $keys = array_keys($hash);
 108         foreach ($keys as $key) {
 109             $this->_hash[$key] = ref($hash[$key]);
 110         }
 111     }
 112
 113     /**
 114      * Retrieve value associated to specified key.
 115      *
 116      * @param  string $key
 117      * @return reference
 118      */
 119     function &get($key)
 120     {
 121         if ($this->containsKey($key)) {
 122             return $this->_hash[$key]->obj;
 123         }
 124         return null;
 125     }
 126
 127     /**
 128      * Remove element associated to specified key from hash.
 129      *
 130      * @param string $key
 131      */
 132     function remove($key)
 133     {
 134         $keys = $this->keys();
 135         $i = array_search($key, $keys);
 136         if ($i !== false) {
 137             // unset hash element to fix many bugs that should appear while
 138             // iterating and using references to this element.
 139             unset($this->_hash[$key]);
 140             // return array_splice($this->_hash, $i, 1);
 141         }
 142     }
 143
 144     /**
 145      * Remove an element from the Hash.
 146      *
 147      * @param  mixed $o -- Element to remove from Hash
 148      */
 149     function removeElement(&$o)
 150     {
 151         $i = 0;
 152         $found = false;
 153         foreach ($this->_hash as $key => $value) {
 154             if ($value->obj === $o || $value == $o) {
 155                 $found = $i;
 156                 break;
 157             }
 158             $i++;
 159         }
 160         if ($found !== false) {
 161             return array_splice($this->_hash, $found, 1);
 162         }
 163     }
 164
 165     /**
 166      * Returns true is hashtable empty.
 167      *
 168      * @return boolean
 169      */
 170     function isEmpty()
 171     {
 172         return $this->size() == 0;
 173     }
 174
 175     /**
 176      * Retrieve hash size (number of elements).
 177      *
 178      * @return int
 179      */
 180     function size()
 181     {
 182         return count($this->_hash);
 183     }
 184
 185     /**
 186      * Retrieve hash values array.
 187      *
 188      * @return hashtable
 189      */
 190     function &values()
 191     {
 192         $v = array();
 193         foreach ($this->_hash as $key => $ref) {
 194             $v[] =& $ref->obj;
 195         }
 196         return $v;
 197     }
 198
 199     /**
 200      * Retrieve hash keys array.
 201      *
 202      * @return array
 203      */
 204     function keys()
 205     {
 206         return array_keys($this->_hash);
 207     }
 208
 209     /**
 210      * Retrieve an hash iterator ready to use.
 211      *
 212      * @return HashIterator
 213      */
 214     function getNewIterator()
 215     {
 216         return new HashIterator($this);
 217     }
 218
 219     /**
 220      * Test if this hash contains specified key.
 221      *
 222      * @param  string $key
 223      * @return boolean
 224      */
 225     function containsKey($key)
 226     {
 227         return array_key_exists($key, $this->_hash);
 228     }
 229
 230     /**
 231      * Test if this hash contains specified value.
 232      *
 233      * @param mixed $value -- The value to search
 234      * @return boolean
 235      */
 236     function containsValue($value)
 237     {
 238         foreach ($this->_hash as $k => $v) {
 239             if ($v->obj === $value || $v == $value) {
 240                 return true;
 241             }
 242         }
 243         return false;
 244     }
 245
 246     /**
 247      * Returns the php array (hashtable) handled by this object.
 248      *
 249      * @return hashtable
 250      */
 251     function &toHash()
 252     {
 253         $result = array();
 254         foreach ($this->_hash as $key => $value) {
 255             $result[$key] =& $value->obj;
 256         }
 257         return $result;
 258     }
 259
 260     /**
 261      * Create an Hash object from a simple php array variable.
 262      *
 263      * This method assumes that the array is composed of serial key, value
 264      * elements. For each pair of array element, the former will be used as key
 265      * and the latter as value.
 266      *
 267      * @param array $array -- php array.
 268      *
 269      * @return Hash
 270      * @static 1
 271      */
 272     function ArrayToHash($array)
 273     {
 274         $h = new OHash();
 275         while (count($array) > 1) {
 276             $key = array_shift($array);
 277             $h->set($key, array_shift($array));
 278         }
 279         return $h;
 280     }
 281
 282     /**
 283      * Generate and return a string representation of this hashtable.
 284      *
 285      * @return string
 286      */
 287     function toString()
 288     {
 289         return Types::_hashToString($this->toHash());
 290     }
 291
 292     /**
 293      * Sort hashtable on its keys.
 294      */
 295     function sort()
 296     {
 297         ksort($this->_hash);
 298     }
 299 }
 300
 301
 302 /**
 303  * Hash iterator.
 304  *
 305  * This kind of iterators are used to walk throug Hash objects.
 306  *
 307  * @author Laurent Bedubourg <laurent.bedubourg@free.fr>
 308  */
 309 class HashIterator
 310 {
 311     var $_src;
 312     var $_values;
 313     var $_keys;
 314     var $_key;
 315     var $_value;
 316     var $_i   = -1;
 317     var $_end = false;
 318
 319     /**
 320      * Iterator constructor.
 321      *
 322      * @param mixed $hash -- OHash object or associative php array.
 323      */
 324     function HashIterator(&$hash)
 325     {
 326         return $this->__construct($hash);
 327     }
 328
 329     /**
 330      * Iterator php4.4 compliant constructor.
 331      *
 332      * @param  mixed $hash -- OHash object or associative php array.
 333      *
 334      * @throws TypeError
 335      *         When $hash is not an array or an Hash object.
 336      */
 337     function __construct(&$hash)
 338     {
 339         if (is_array($hash)) {
 340             $this->_src = new OHash($hash);
 341         } else if (is_a($hash, 'ohash')) {
 342             $this->_src  = &$hash;
 343         } else {
 344             $err = new TypeError('HashIterator requires associative array or OHash');
 345             // return EX::raise($err);
 346             die($err->toString());
 347             return PEAR::raiseError($err);
 348         }
 349         $this->reset();
 350     }
 351
 352     //
 353     // iterator logics
 354     //
 355
 356     /**
 357      * Reset iterator to first element.
 358      */
 359     function reset()
 360     {
 361         // store a copy of hash references so a modification of source data
 362         // won't affect iterator.
 363         $this->_values = $this->_src->_hash;
 364         $this->_keys = $this->_src->keys();
 365
 366         if (count($this->_keys) == 0) {
 367             $this->_end = true;
 368             return;
 369         }
 370
 371         $this->_i = 0;
 372         $this->_end = false;
 373         $this->_key = $this->_keys[0];
 374         $this->_value = $this->_values[$this->_key];
 375     }
 376
 377     /**
 378      * Test is end of iterator is not reached.
 379      */
 380     function isValid()
 381     {
 382         return !$this->_end;
 383     }
 384
 385     /**
 386      * Return next Hash item.
 387      *
 388      * This method also set _key and _value.
 389      *
 390      * @return mixed (by reference) or false if end reached
 391      */
 392     function &next()
 393     {
 394         if ($this->_end || ++$this->_i >= count($this->_keys)){
 395             $this->_end = true;
 396             return null;
 397         }
 398
 399         $this->_key   = $this->_keys[$this->_i];
 400         $this->_value = $this->_values[$this->_key];
 401         return $this->_value->obj;
 402     }
 403
 404     //
 405     // getters
 406     //
 407
 408     /**
 409      * Return current iterator key.
 410      *
 411      * @return string
 412      */
 413     function key()
 414     {
 415         return $this->_key;
 416     }
 417
 418     /**
 419      * Return current index (position in iteration).
 420      *
 421      * @return int
 422      */
 423     function index()
 424     {
 425         return $this->_i;
 426     }
 427
 428     /**
 429      * Return current iterator value.
 430      *
 431      * @return mixed
 432      */
 433     function &value()
 434     {
 435         return $this->_value->obj;
 436     }
 437
 438     //
 439     // optional implementations
 440     //
 441
 442     /**
 443      * Remove current iterated item from source.
 444      */
 445     function remove()
 446     {
 447         $this->_src->remove($this->_key);
 448     }
 449 }
 450
 451 ?>