Map.class.php

<?php

class spunQ_Map implements spunQ_IMap {

    private static $emptyMap;

    public static function emptyMap() {
        if (self::$emptyMap === NULL) {
            self::$emptyMap = new spunQ_ReadonlyMap();
        }
        return self::$emptyMap;
    }

    private $keys = array();

    private $values = array();

    private $iteratorIndex = 0;

    public function __construct($collection = array()) {
        if ($collection instanceof spunQ_Map) {
            $this->keys = $collection->keys;
            $this->values = $collection->values;
        } elseif (is_array($collection)) {
            $this->keys = array_keys($collection);
            $this->values = array_values($collection);
        }
        return NULL;
    }

    public function setKeysAndValues($keys, $values) {
        $this->keys = $keys;
        $this->values = $values;
        return $this;
    }

    public function getAnyKey() {
        if (count($this->keys) === 0) {
            return NULL;
        }
        return reset($this->keys);
    }

    public function getRandomKey() {
        $count = count($this->keys);
        if ($count === 0) {
            return NULL;
        }
        return $this->keys[rand(0, $count - 1)];
    }

    public function getKeys() {
        return $this->keys;
    }

    public function getValues() {
        return $this->values;
    }

    public function add($key, $value) {
        $index = array_search($key, $this->keys, true);
        if ($index !== false) {
            $this->values[$index] = $value;
        } else {
            $this->keys[] = $key;
            $this->values[] = $value;
        }
        return $this;
    }

    public function remove($key) {
        $index = array_search($key, $this->keys, true);
        if ($index !== false) {
            $this->keys[$index] = end($this->keys);
            $this->values[$index] = end($this->values);
            array_pop($this->keys);
            array_pop($this->values);
        }
        return $this;
    }

    public function removeMultiple(array $keys) {
        # We could have been using array_intersect() here, but nooo, PHP does
        # not have an array_intersect() version that can compare strictly
        # (i.e. using the type-safe comparison ===)
        foreach ($keys as $key) {
            $this->remove($key);
        }
        return $this;
    }

    public function extract($keys) {
        # see removeMultiple()
        $result = new spunQ_Map();
        $count = count($this->keys);
        for ($i = 0; $i < $count; $i++) {
            if (in_array($this->keys[$i], $keys, true)) {
                $result->add($this->keys[$i], $this->values[$i]);
            }
        }
        return $result;
    }

    public function intersect(spunQ_Map $otherMap) {
        return $this->extract($otherMap->keys);
    }

    public function equals(spunQ_Map $otherMap) {
        return $this->keys === $otherMap->keys
            && $this->values === $otherMap->values;
    }

    public function isEmpty() {
        return count($this->keys) === 0;
    }

    public function &get($key) {
        # XXX: Update getByKey() and getByValue() if you change this code.
        $index = array_search($key, $this->keys, true);
        if ($index === false) {
            $null = NULL;
            return $null;
        }
        return $this->values[$index];
    }

    public function &getByKey($key) {
        # XXX: Update getByValue() and get() if you change this code.
        $index = array_search($key, $this->keys, true);
        if ($index === false) {
            $null = NULL;
            return $null;
        }
        return $this->values[$index];
    }

    public function &getByValue($value) {
        # XXX: Update getByKey() and get() if you change this code.
        $index = array_search($value, $this->values, true);
        if ($index === false) {
            $null = NULL;
            return $null;
        }
        return $this->keys[$index];
    }

    public function getAllKeysByValue($value) {
        $keys = array_keys($this->values, $value, true);
        if (!isset($keys[0])) {
            return array();
        }
        return array_values(array_intersect_key($this->keys, array_combine($keys, array_fill(1, count($keys), NULL))));
    }

    public function getPairs() {
        $pairs = array();
        $count = count($this->keys);
        for ($i = 0; $i < $count; $i++) {
            $pairs[] = array($this->keys[$i], $this->values[$i]);
        }
        return $pairs;
    }

    public function getSize() {
        return count($this->keys);
    }

    public function toAssociativeArray() {
        if (count($this->keys) === 0) {
            return array();
        }
        return array_combine($this->keys, $this->values);
    }

    public function keyExists($key) {
        return in_array($key, $this->keys, true);
    }

    public function valueExists($value) {
        return in_array($value, $this->values, true);
    }

    public function copyFrom(spunQ_Map $otherMap) {
        foreach ($otherMap->getKeys() as $key) {
            $this->add($key, $otherMap->get($key));
        }
        return $this;
    }

    public function clear() {
        $this->keys = array();
        $this->values = array();
        return $this;
    }

    public function rewind() {
        $this->iteratorIndex = 0;
        return NULL;
    }

    public function valid() {
        return $this->iteratorIndex < count($this->keys);
    }

    public function current() {
        if ($this->iteratorIndex >= count($this->keys)) {
            return NULL;
        }
        return $this->values[$this->iteratorIndex];
    }

    public function key() {
        if ($this->iteratorIndex >= count($this->keys)) {
            return NULL;
        }
        return $this->keys[$this->iteratorIndex];
    }

    public function next() {
        $this->iteratorIndex++;
        return NULL;
    }

    public function offsetExists($key) {
        return $this->keyExists($key);
    }

    public function offsetGet($key) {
        return $this->getByKey($key);
    }

    public function offsetSet($key, $val) {
        return $this->add($key, $val);
    }

    public function offsetUnset($key) {
        return $this->remove($key);
    }

}

---