Archivr\SynchronizationList

Complexity

Total Complexity

15

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
A	addSynchronization()	0	11	2
A	getLastSynchronization()	0	4	2
A	getSynchronizationByRevision()	0	4	2
A	getSynchronizationByTime()	0	16	3
A	getSynchronizationsByIdentity()	0	7	1
A	getRevisions()	0	8	1
A	count()	0	4	1
A	getIterator()	0	4	1

<?php

namespace Archivr;

use Archivr\Exception\Exception;

class SynchronizationList implements \Countable, \IteratorAggregate
{
    /**
     * Chronologically ordered list of synchronizations (earliest to latest).
     *
     * @var Synchronization[]
     */
    protected $synchronizations = [];

    /**
     * @param Synchronization[] $synchronizations
     */
    public function __construct(array $synchronizations = [])
    {
        foreach ($synchronizations as $synchronization)
        {
            $this->addSynchronization($synchronization);
        }
    }

    /**
     * @param Synchronization $synchronization
     *
     * @return SynchronizationList
     * @throws Exception
     */
    public function addSynchronization(Synchronization $synchronization): SynchronizationList
    {
        if (isset($this->synchronizations[$synchronization->getRevision()]))
        {
            throw new Exception();
        }

        $this->synchronizations[$synchronization->getRevision()] = $synchronization;

        return $this;
    }

    /**
     * @return Synchronization
     */
    public function getLastSynchronization()
    {
        return empty($this->synchronizations) ? null : $this->synchronizations[count($this->synchronizations)];
    }

    /**
     * @param int $revision
     *
     * @return Synchronization
     */
    public function getSynchronizationByRevision(int $revision)
    {
        return isset($this->synchronizations[$revision]) ? $this->synchronizations[$revision] : null;
    }

    /**
     * Returns the synchronization that was the current one for the given date.
     *
     * @param \DateTime $time
     *
     * @return Synchronization
     */
    public function getSynchronizationByTime(\DateTime $time)
    {
        $current = null;

        foreach ($this->synchronizations as $synchronization)
        {
            if ($synchronization->getTime() > $time)
            {
                break;
            }

            $current = $synchronization;
        }

        return $current;
    }

    /**
     * Returns new synchronization list containing only those synchronizations that were performed by the given identity.
     *
     * @param string $identity
     * @return SynchronizationList
     */
    public function getSynchronizationsByIdentity(string $identity): SynchronizationList
    {
        return new static(array_filter(iterator_to_array($this->getIterator()), function(Synchronization $synchronization) use ($identity) {

            return $synchronization->getIdentity() === $identity;
        }));
    }

    /**
     * Returns set of revisions contained in this list.
     *
     * @return int[]
     */
    public function getRevisions(): array
    {
        return array_values(array_map(function(Synchronization $synchronization) {

            return $synchronization->getRevision();

        }, iterator_to_array($this->getIterator())));
    }

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

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