Collections\Dictionary

Complexity

Total Complexity

22

Size/Duplication

Total Lines	140
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Test Coverage

Coverage

89.13%

Importance

Changes	9
Bugs	0	Features	2

14 Methods

Rating	Name	Duplication	Size	Complexity
A	at()	0	4	1
A	set()	0	6	1
A	get()	0	8	2
A	add()	0	9	2
A	containsKey()	0	4	1
A	contains()	0	4	1
A	remove()	0	7	1
A	removeKey()	0	4	1
A	offsetExists()	0	4	2
A	offsetGet()	0	4	1
A	offsetUnset()	0	4	1
A	getIterator()	0	4	1
B	addAll()	0	13	5
A	offsetSet()	0	8	2

<?php

// Copyright (c) Lellys Informática. All rights reserved. See License.txt in the project root for license information.
namespace Collections;

use Collections\Exception\KeyException;
use Collections\Iterator\MapIterator;
use Collections\Traits\GuardTrait;
use Collections\Traits\StrictKeyedIterableTrait;
use InvalidArgumentException;
use Symfony\Component\PropertyAccess\Exception\OutOfBoundsException;
use Traversable;

/**
 * Represents a collection of keys and values.
 */
class Dictionary extends AbstractCollectionArray implements MapInterface, \ArrayAccess
{
    use StrictKeyedIterableTrait,
        GuardTrait;

    public function at($k)
    {
        return $this[$k];
    }

    public function set($key, $value)
    {
        $this->container[$key] = $value;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function get($index)
    {
        if ($this->containsKey($index) === false) {
            throw new OutOfBoundsException('No element at position ' . $index);
        }

        return $this->container[$index];
    }

    /**
     * {@inheritdoc}
     */
    public function add($key, $value)
    {
        if ($this->containsKey($key)) {
            throw new KeyException('The key ' . $key . ' already exists!');
        }
        $this->set($key, $value);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function addAll($items)
    {
        if (!is_array($items) && !$items instanceof Traversable) {
            throw new \InvalidArgumentException('The items must be an array or Traversable');
        }

        foreach ($items as $key => $value) {
            if (is_array($value)) {
                $value = Dictionary::fromArray($value);
            }
            $this->add($key, $value);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function containsKey($key)
    {
        return array_key_exists($key, $this->container);
    }

    /**
     * {@inheritdoc}
     */
    public function contains($element)
    {
        return in_array($element, $this->container, true);
    }

    /**
     * {@inheritdoc}
     */
    public function remove($element)
    {
        $this->validateKeyBounds($element);
        unset($this->container[$element]);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function removeKey($key)
    {
        return $this->remove($key);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetExists($offset)
    {
        return isset($this->container[$offset]) || array_key_exists($offset, $this->container);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetGet($offset)
    {
        return $this->get($offset);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value)
    {
        if (is_null($offset)) {
            $this->add($offset, $value);
        } else {
            $this->set($offset, $value);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function offsetUnset($offset)
    {
        $this->removeKey($offset);
    }

    /**
     * Gets the collection's iterator
     * @return MapIterator
     */
    public function getIterator()
    {
        return new MapIterator($this->container);
    }

}

According to PSR2, the closing brace of classes should be placed on the next line directly after the body.