HASHMAP EN PHP AVEC LA SPL

<?php
namespace System::Iterator

/**
 * @abstract
 * @name HashMapIterator
 * @author Dorian
 * @since 09/12/2008
 * @version 1.0.0
 */
abstract class MapIterator implements Iterator, Countable, ArrayAccess
{
  /**
   * Tableau MAP
   *
   * @access protected
   * @var array
   */
  protected $_aMap;

  /**
   * Nombre d'élément du tableau
   *
   * @access private
   * @var integer
   */
  private $_iCount;

  /**
   * Index de l'itérateur
   *
   * @access private
   * @var integer
   */
  private $_iIndex;
  
  /**
   * Défini si on peut modifier les éléments du tableau
   *
   * @access private
   * @var boolean
   */
  private $_bWritable;

  /**
   * Constructeur de la classe
   * Initialise le tableau et le compteur
   * 
   * @access public
   * @param array $aMap
   * @param boolean $bWritable
   * @return void
   */
  public function __construct(array $aMap = array(), $bWritable = true)
  {
    $this->_iIndex    = 0;
    $this->_aMap      = array();
    $this->_bWritable = $bWritable;

    if( count($aMap) > 0 )
    {
      $this->add($aMap);
    }

    $this->_iCount = count($this->_aMap);
  }

  /**
   * Retourne le nombre d'élément du tableau
   *
   * @access public
   * @return integer
   */
  public function count()
  {
    return $this->_iCount;
  }

  /**
   * Retourne l'élément suivant
   * 
   * @access public
   * @return mixed
   */
  public function current()
  {
    return current($this->_aMap);
  }

  /**
   * Retourne la clé de l'élément courant
   *
   * @access public
   * @return mixed
   */
  public function key()
  {
    return key($this->_aMap);
  }

  /**
   * Passe le pointeur sur l'élément suivant
   *
   * @access public
   * @return void
   */
  public function next()
  {
    next($this->_aMap);
    $this->_iIndex++;
  }

  /**
   * Met le pointeur au début du tableau
   *
   * @access public
   * @return void
   */
  public function rewind()
  {
    reset($this->_aMap);
    $this->_iIndex = 0;
  }

  /**
   * Test si l'iterateur est valide
   *
   * @access public
   * @return boolean
   */
  public function valid()
  {
    return $this->_iIndex < $this->_iCount;
  }
  
  /**
   * Test l'existance de l'élément dans le tableau
   *
   * @access public
   * @param mixed $mOffset
   * @return boolean
   */
  public function offsetExists($mOffset) 
  { 
    return array_key_exists($mOffset, $this->_aMap); 
  } 
  
  /**
   * Retourne un élément du tableau
   *
   * @param mixed $mOffset
   * @return mixed
   */
  public function offsetGet($mOffset) 
  {
    return $this->get($mOffset); 
  } 
  
  /**
   * Modifie un élément du tableau
   *
   * @access public
   * @param mixed $mOffset
   * @param mixed $mValue
   * @return void
   */
  public function offsetSet($mOffset, $mValue) 
  { 
    $this->set($mOffset, $mValue);
  } 
    
  /**
   * Efface un élément du tableau
   * 
   * @access public
   * @param mixed $mKey
   * @return void
   */
  public function offsetUnset($mOffset) 
  { 
    return $this->remove($mOffset);
  } 
  
  /**
   * Ajoute un tableau
   *
   * @access public
   * @param array $aMap
   * @return void
   */
  public function add(array $aMap)
  {
    $sClass = get_called_class();
    
    foreach( $aMap as $mKey => $mValue ) 
    {
      if( is_array($mValue) )
      {
        $this->_aMap[$mKey] = new $sClass($mValue);
      } 
      else 
      {
        $this->_aMap[$mKey] = $mValue;
      }
    }
    
    $this->_iCount = count($this->_aMap);
  }
  
  /**
   * Retourne un élément du tableau
   *
   * @access public
   * @param mixed $mKey
   * @return mixed
   */
  public function get($mKey)
  {
    if( array_key_exists($mKey, $this->_aMap) )
    {
      return $this->_aMap[$mKey];
    }
    
    return null;
  }
  
  /**
   * Ajoute un élément au tableau
   *
   * @access public
   * @param mixed $mKey
   * @param mixed $mValue
   * @return void
   */
  public function set($mKey, $mValue)
  {
    if( false === $this->_bWritable )
    {
      throw new Exception('Vous n\'avez pas les droits d\'écriture.', E_ERROR);
    }
    
    $sClass = get_called_class();
    
    if( is_array($mValue) )
    {
      $this->_aMap[$mKey] = new $sClass($mValue);
    }
    else 
    {
      $this->_aMap[$mKey] = $mValue;
    }
      
    $this->_iCount = count($this->_aMap);
  }
  
  /**
   * Retourne un tableau contenant les clé
   *
   * @access public
   * @return array
   */
  public function getKeys()
  {
    return array_keys($this->_aMap);
  }
  
  /**
   * Combine une autre instance de la class
   *
   * @access public
   * @param object $merge
   * @return object
   */
  public function merge($oMerge)
  {
    $sClass     = get_called_class();
    $oReflexion = new ReflectionClass($sClass);
    
    if(! $oReflexion->isSubclassOf($this) )
    {
      throw new Exception('Vous devez passer en paramètre une classe enfant de MapIterator.', E_ERROR);
    }
    
    foreach($oMerge as $mKey => $mItem) 
    {
      if(array_key_exists($mKey, $this->_aMap)) 
      {
        if($mItem instanceof $sClass && $this->$mKey instanceof $sClass) 
        {
          $this->$mKey = $this->$mKey->merge($mItem);
        } 
        else 
        {
          $this->$mKey = $mItem;
        }
      } 
      else 
      {
        $this->$mKey = $mItem;
      }
    }

    return $this;
  }
  
  /**
   * Efface un élément du tableau
   * 
   * @access public
   * @param mixed $mKey
   * @return object|boolean
   */
  public function remove($mKey)
  {
    if( false === $this->_bWritable )
    {
      throw new Exception('Vous n\'avez pas les droits d\'écriture.', E_ERROR);
    }
    
    if(array_key_exists($mKey, $this->_aMap)) 
    {
      unset($this->_aMap[$mKey]);
      $this->_iCount = count($this->_aMap);
      
      return $this;
    }
    
    return false;
  }

  /**
   * Clone l'object
   *
   * @access public
   * @return void
   */
  public function __clone()
  {
    $aArray = array();
    $sClass = get_called_class();

    foreach( $this->_aMap as $mKey => $mValue )
    {
      if( $mValue instanceof $sClass )
      {
        $aArray[$mKey] = clone $mValue;
      }
      else
      {
        $aArray[$mKey] = $mValue;
      }
    }
    
    $this->_aMap = $aArray;
  }

  /**
   * Transforme l'object en tableau
   *
   * @access public
   * @return array
   */
  public function __toArray()
  {
    $aArray = array();

    foreach( $this->_aMap as $mKey => $mValue )
    {
      if( $mValue instanceof MapIterator )
      {
        $aArray[$mKey] = $mValue->__toArray();
      }
      else
      {
        $aArray[$mKey] = $mValue;
      }
    }

    return $aArray;
  }

  /**
   * Test si l'élément existe
   *
   * @access public
   * @param mixed $mKey
   * @return boolean
   */
  public function __isset($mKey)
  {
    return isset($this->_aMap[$mKey]);
  }

  /**
   * Efface un élément du tableau
   * 
   * @access public
   * @param mixed $mKey
   * @return object
   */
  public function __unset($mKey)
  {
    if( false === $this->_bWritable )
    {
      throw new Exception('Vous n\'avez pas les droits d\'écriture.', E_ERROR);
    }
    
    return $this->remove($mKey);
  }
  
  /**
   * Retourne un élément du tableau
   *
   * @access public
   * @param mixed $mKey
   * @return mixed
   */
  abstract public function __get($mKey);
  
  /**
   * Ajoute un élément au tableau
   *
   * @access public
   * @param mixed $mKey
   * @param mixed $mValue
   * @return void
   */
  abstract public function __set($mKey, $mValue);
}
?>

<?php
namespace System::Collection

/**
 * @name HashMap
 * @author aberthelot
 * @copyright Copyright (c) 2008, Alexandre Berthelot
 * @since 07/12/2008
 * @package System::Collection
 * @version 4.0.0 - AXB - 07/12/2008
 */
class HashMap extends MapIterator 
{
  /**
   * Constructeur de la classe
   * Initialise le HashMap
   * 
   * @access public
   * @param array $aMap
   * @return void
   */
  public function __construct(array $aMap = array())
  {
    parent::__construct($aMap);
  }
  
  /**
   * Modifie un élément de la config
   *
   * @access public
   * @param mixed $mKey
   * @param mixed $mValue
   * @return object
   */
  public function __set($mKey, $mValue)
  {
    $this->set($mKey, $mValue);
  }

  /**
   * Retourne un élément de la configuration
   *
   * @access public
   * @param mixed $mKey
   * @return mixed var
   */
  public function __get($mKey)
  {
    return $this->get($mKey);
  }
}
?>