Storeman\Index

Complexity

Total Complexity

17

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	addObject()	0	21	4
A	getObjectByPath()	0	4	2
A	getObjectByBlobId()	0	12	3
A	equals()	0	9	3
A	isSubsetOf()	0	15	3
A	count()	0	4	1
A	getIterator()	0	4	1

<?php

namespace Storeman;

use Storeman\Exception\Exception;

/**
 * As the name suggests an index is a representation of the vault at some point in time.
 * It is implemented as a map from relative paths to object details.
 */
class Index implements \Countable, \IteratorAggregate
{
    /**
     * @var IndexObject[]
     */
    protected $pathMap = [];

    /**
     * Adds the given object to the index.
     *
     * @param IndexObject $indexObject
     * @return Index
     * @throws Exception
     */
    public function addObject(IndexObject $indexObject): Index
    {
        // ensure existence of containing directory
        if (substr_count($indexObject->getRelativePath(), DIRECTORY_SEPARATOR))
        {
            $parent = $this->getObjectByPath(dirname($indexObject->getRelativePath()));

            if ($parent === null)
            {
                throw new Exception();
            }
            elseif (!$parent->isDirectory())
            {
                throw new Exception();
            }
        }

        $this->pathMap[$indexObject->getRelativePath()] = $indexObject;

        return $this;
    }

    /**
     * Returns an index object by a given relative path.
     *
     * @param string $path
     * @return IndexObject|null
     */
    public function getObjectByPath(string $path): ?IndexObject
    {
        return isset($this->pathMap[$path]) ? $this->pathMap[$path] : null;
    }

    /**
     * Returns an index object by a given blob id.
     *
     * @param string $blobId
     * @return IndexObject|null
     */
    public function getObjectByBlobId(string $blobId): ?IndexObject
    {
        foreach ($this->pathMap as $object)
        {
            if ($object->getBlobId() === $blobId)
            {
                return $object;
            }
        }

        return null;
    }

    /**
     * Compares this index to the given index and returns the comparison result as boolean indicator.
     *
     * @param Index|null $other
     * @return bool
     */
    public function equals(Index $other = null): bool
    {
        if ($other === null)
        {
            return false;
        }

        return $this->isSubsetOf($other) && $other->isSubsetOf($this);
    }

    /**
     * Returns true if this index is a subset of the given index.
     *
     * @param Index $other
     * @return bool
     */
    public function isSubsetOf(Index $other): bool
    {
        foreach ($this as $indexObject)
        {
            /** @var IndexObject $indexObject */

            // we explicitly want to use equality instead of identity
            if ($other->getObjectByPath($indexObject->getRelativePath()) != $indexObject)
            {
                return false;
            }
        }

        return true;
    }

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

    /**
     * {@inheritdoc}
     */
    public function getIterator(): \Traversable
    {
        return new \ArrayIterator($this->pathMap);
    }
}