OHash.php

Go to the documentation of this file.

<?php
/* vim: set expandtab tabstop=4 shiftwidth=4: */
//  
//  Copyright (c) 2003 Laurent Bedubourg
//  
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License, or (at your option) any later version.
//  
//  This library 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
//  Lesser General Public License for more details.
//  
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//  
//  Authors: Laurent Bedubourg <laurent.bedubourg@free.fr>
//  

require_once PT_IP . "/Types.php";
require_once PT_IP . "/Types/Errors.php";
require_once PT_IP . "/Types/Ref.php";

class OHash 
{
    var $_hash;

    function __construct($array=array())
    {
        $this->_hash = array();
        $keys = array_keys($array);
        foreach ($keys as $key) {
            $this->_hash[$key] = ref($array[$key]);
        }                        
    }

    function OHash($array=array())
    {
        $this->__construct($array);
    }

    function set($key, $value)
    {
        $this->_hash[$key] = ref($value);
    }

    function setRef($key, &$value)
    {
        $this->_hash[$key] = ref($value);
    }

    function setAll($hash)
    {
        if (!is_array($hash) && is_a($hash, 'OHash')) {
            $hash = $hash->toHash();
        }
        $keys = array_keys($hash);
        foreach ($keys as $key) {
            $this->_hash[$key] = ref($hash[$key]);
        }
    }

    function &get($key)
    {
        if ($this->containsKey($key)) {
            return $this->_hash[$key]->obj;
        }
        return null;
    }

    function remove($key)
    {
        $keys = $this->keys();
        $i = array_search($key, $keys);
        if ($i !== false) {
            // unset hash element to fix many bugs that should appear while
            // iterating and using references to this element.
            unset($this->_hash[$key]);
            // return array_splice($this->_hash, $i, 1);
        }
    }

    function removeElement(&$o)
    {
        $i = 0;
        $found = false;
        foreach ($this->_hash as $key => $value) {
            if ($value->obj === $o || $value == $o) {
                $found = $i;
                break;
            }
            $i++;
        }
        if ($found !== false) {
            return array_splice($this->_hash, $found, 1);
        }
    }

    function isEmpty()
    {
        return $this->size() == 0;
    }

    function size()
    {
        return count($this->_hash);
    }

    function &values()
    {
        $v = array();
        foreach ($this->_hash as $key => $ref) {
            $v[] =& $ref->obj;
        }
        return $v;
    }

    function keys()
    {
        return array_keys($this->_hash);
    }

    function getNewIterator()
    {
        return new HashIterator($this);
    }

    function containsKey($key)
    {
        return array_key_exists($key, $this->_hash);
    }

    function containsValue($value)
    {
        foreach ($this->_hash as $k => $v) {
            if ($v->obj === $value || $v == $value) { 
                return true; 
            }
        }
        return false;
    }

    function &toHash()
    {
        $result = array();
        foreach ($this->_hash as $key => $value) {
            $result[$key] =& $value->obj;
        }
        return $result;
    }

    function ArrayToHash($array)
    {
        $h = new OHash();
        while (count($array) > 1) {
            $key = array_shift($array);
            $h->set($key, array_shift($array));
        }
        return $h;
    }

    function toString()
    {
        return Types::_hashToString($this->toHash());
    }

    function sort()
    {
        ksort($this->_hash);
    }
}


class HashIterator 
{
    var $_src;
    var $_values;
    var $_keys;
    var $_key;
    var $_value;
    var $_i   = -1;
    var $_end = false;

    function HashIterator(&$hash)
    {
        return $this->__construct($hash);
    }
    
    function __construct(&$hash)
    {
        if (is_array($hash)) {
            $this->_src = new OHash($hash);
        } else if (is_a($hash, 'ohash')) {
            $this->_src  = &$hash;
        } else {
            $err = new TypeError('HashIterator requires associative array or OHash');
            // return EX::raise($err);
            die($err->toString());
            return PEAR::raiseError($err);
        }
        $this->reset();
    }

    //
    // iterator logics
    //

    function reset()
    {
        // store a copy of hash references so a modification of source data
        // won't affect iterator.
        $this->_values = $this->_src->_hash;
        $this->_keys = $this->_src->keys();
        
        if (count($this->_keys) == 0) {
            $this->_end = true;
            return;
        }

        $this->_i = 0;        
        $this->_end = false;
        $this->_key = $this->_keys[0];
        $this->_value = $this->_values[$this->_key];
    }

    function isValid()
    {
        return !$this->_end;
    }

    function &next()
    {
        if ($this->_end || ++$this->_i >= count($this->_keys)){
            $this->_end = true;
            return null;
        }

        $this->_key   = $this->_keys[$this->_i];
        $this->_value = $this->_values[$this->_key];
        return $this->_value->obj;
    }

    // 
    // getters
    // 

    function key()
    {
        return $this->_key;
    }

    function index()
    {
        return $this->_i;
    }

    function &value()
    {
        return $this->_value->obj;
    }

    // 
    // optional implementations
    // 
    
    function remove()
    {
        $this->_src->remove($this->_key);
    }
}

?>

---