Innmind\Immutable\ObjectStorage

Complexity

Total Complexity

31

Size/Duplication

Total Lines	313
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	0	Features	4

26 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	2
A	toPrimitive()	0	5	1
A	merge()	0	8	1
A	attach()	0	7	1
A	contains()	0	4	1
A	detach()	0	7	1
A	getHash()	0	4	1
A	getInfo()	0	4	1
A	removeAll()	0	7	1
A	removeAllExcept()	0	7	1
A	setInfo()	0	8	1
A	count()	0	4	1
A	current()	0	4	1
A	next()	0	4	1
A	key()	0	4	1
A	rewind()	0	4	1
A	valid()	0	4	1
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	6	1
A	offsetUnset()	0	6	1
A	serialize()	0	4	1
A	unserialize()	0	7	1
A	filter()	0	16	3
A	each()	0	10	2
A	map()	0	14	2

<?php
declare(strict_types = 1);

namespace Innmind\Immutable;

use Innmind\Immutable\Exception\LogicException;

class ObjectStorage implements PrimitiveInterface, \Countable, \Iterator, \ArrayAccess, \Serializable
{
    private $objects;

    public function __construct(\SplObjectStorage $objects = null)
    {
        $this->objects = $objects ? clone $objects : new \SplObjectStorage;
        $this->objects->rewind();
    }

    /**
     * {@inheritdoc}
     */
    public function toPrimitive(): \SplObjectStorage
    {
        //so the inner SplObjectStorage object can't be modified
        return clone $this->objects;
    }

    /**
     * Merge storages
     *
     * @param self $storage
     *
     * @return self
     */
    public function merge(self $storage): self
    {
        $objects = new \SplObjectStorage;
        $objects->addAll($this->objects);
        $objects->addAll($storage->objects);

        return new self($objects);
    }

    /**
     * Attach a new element to the storage
     *
     * @param object $object
     * @param mixed $data
     *
     * @return self
     */
    public function attach($object, $data = null): self
    {
        $objects = clone $this->objects;
        $objects->attach($object, $data);

        return new self($objects);
    }

    /**
     * Check if the object is in this storage
     *
     * @param object $object
     *
     * @return bool
     */
    public function contains($object): bool
    {
        return $this->objects->contains($object);
    }

    /**
     * Remove the given object from the storage
     *
     * @param object $object
     *
     * @return self
     */
    public function detach($object): self
    {
        $objects = clone $this->objects;
        $objects->detach($object);

        return new self($objects);
    }

    /**
     * Get the internal has for the given object
     *
     * @param object $object
     *
     * @return string
     */
    public function getHash($object): string
    {
        return $this->objects->getHash($object);
    }

    /**
     * Return the info associated to the current object pointed by the internal pointer
     *
     * @return mixed
     */
    public function getInfo()
    {
        return $this->objects->getInfo();
    }

    /**
     * Remove all the elements contained in the given storage from the current one
     *
     * @param self $storage
     *
     * @return self
     */
    public function removeAll(self $storage): self
    {
        $objects = clone $this->objects;
        $objects->removeAll($storage->objects);

        return new self($objects);
    }

    /**
     * Remove all elements not contained in the given storage
     *
     * @param self $storage
     *
     * @return self
     */
    public function removeAllExcept(self $storage): self
    {
        $objects = clone $this->objects;
        $objects->removeAllExcept($storage->objects);

        return new self($objects);
    }

    /**
     * Associate data to the current object
     *
     * @param mixed $data
     *
     * @return self
     */
    public function setInfo($data): self
    {
        $current = $this->objects->current();
        $objects = clone $this->objects;
        $objects[$current] = $data;

        return new self($objects);
    }

    /**
     * {@inheritdoc}
     */
    public function count(): int
    {
        return $this->objects->count();
    }

    /**
     * {@inheritdoc}
     */
    public function current()
    {
        return $this->objects->current();
    }

    /**
     * {@inheritdoc}
     */
    public function next()
    {
        $this->objects->next();
    }

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

    /**
     * {@inheritdoc}
     */
    public function rewind()
    {
        $this->objects->rewind();
    }

    /**
     * {@inheritdoc}
     */
    public function valid(): bool
    {
        return $this->objects->valid();
    }

    /**
     * {@inheritdoc}
     */
    public function offsetExists($object): bool
    {
        return $this->objects->offsetExists($object);
    }

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

    /**
     * {@inheritdoc}
     */
    public function offsetSet($object, $data = null)
    {
        throw new LogicException(
            'You can\'t modify an immutable object storage'
        );
    }

    /**
     * {@inheritdoc}
     */
    public function offsetUnset($object)
    {
        throw new LogicException(
            'You can\'t modify an immutable object storage'
        );
    }

    /**
     * {@inheritdoc}
     */
    public function serialize(): string
    {
        return $this->objects->serialize();
    }

    /**
     * {@inheritdoc}
     */
    public function unserialize($serialized): self
    {
        $objects = clone $this->objects;
        $objects->unserialize($serialized);

        return new self($objects);
    }

    /**
     * Apply the given filter on the collection
     *
     * @param Closure $filterer
     *
     * @return self
     */
    public function filter(\Closure $filterer): self
    {
        $objects = new \SplObjectStorage;

        foreach ($this->objects as $object) {
            $data = $this->objects[$object];

            if ($filterer($object, $data) === true) {
                $objects->attach($object, $data);
            }
        }

        $this->rewind();

        return new self($objects);
    }

    /**
     * Run the given closure on each element
     *
     * @param Closure $callback
     *
     * @return self
     */
    public function each(\Closure $callback): self
    {
        foreach ($this->objects as $object) {
            $callback($object, $this->objects[$object]);
        }

        $this->rewind();

        return $this;
    }

    /**
     * Generate a new storage based on the given mapper
     *
     * @param Closure $mapper
     *
     * @return self
     */
    public function map(\Closure $mapper): self
    {
        $objects = new \SplObjectStorage;

        foreach ($this->objects as $object) {
            $objects->attach(
                $mapper($object, $this->objects[$object])
            );
        }

        $this->rewind();

        return new self($objects);
    }
}