EventStore\StreamFeed\StreamFeedIterator

Complexity

Total Complexity

16

Size/Duplication

Total Lines	160
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
A	current()	0	4	1
A	key()	0	4	1
A	valid()	0	4	1
A	forward()	0	10	1
A	backward()	0	12	1
A	next()	0	17	2
A	rewind()	0	22	3
B	createInnerIterator()	0	47	5

<?php
namespace EventStore\StreamFeed;

use ArrayIterator;
use EventStore\EventStoreInterface;

final class StreamFeedIterator implements \Iterator
{
    private $eventStore;

    private $streamName;

    private $feed;

    private $innerIterator;

    private $startingRelation;

    private $navigationRelation;

    private $arraySortingFunction;

    private $rewinded;

    private function __construct(
        EventStoreInterface $eventStore,
        $streamName,
        LinkRelation $startingRelation,
        LinkRelation $navigationRelation,
        callable $arraySortingFunction
    ) {
        $this->eventStore = $eventStore;
        $this->streamName = $streamName;
        $this->startingRelation = $startingRelation;
        $this->navigationRelation = $navigationRelation;
        $this->arraySortingFunction = $arraySortingFunction;
    }

    public static function forward(EventStoreInterface $eventStore, $streamName)
    {
        return new self(
            $eventStore,
            $streamName,
            LinkRelation::LAST(),
            LinkRelation::PREVIOUS(),
            'array_reverse'
        );
    }

    public static function backward(EventStoreInterface $eventStore, $streamName)
    {
        return new self(
            $eventStore,
            $streamName,
            LinkRelation::FIRST(),
            LinkRelation::NEXT(),
            function (array $array) {
                return $array;
            }
        );
    }

    public function current()
    {
        return $this->innerIterator->current();
    }

    public function next()
    {
        $this->rewinded = false;
        $this->innerIterator->next();

        if (!$this->innerIterator->valid()) {
            $this->feed = $this
                ->eventStore
                ->navigateStreamFeed(
                    $this->feed,
                    $this->navigationRelation
                )
            ;

            $this->createInnerIterator();
        }
    }

    public function key()
    {
        return $this->innerIterator->current()->getEntry()->getTitle();
    }

    public function valid()
    {
        return $this->innerIterator->valid();
    }

    public function rewind()
    {
        if ($this->rewinded) {
            return;
        }

        $this->feed = $this->eventStore->openStreamFeed($this->streamName);

        if ($this->feed->hasLink($this->startingRelation)) {
            $this->feed = $this
                ->eventStore
                ->navigateStreamFeed(
                    $this->feed,
                    $this->startingRelation
                )
            ;
        }

        $this->createInnerIterator();

        $this->rewinded = true;
    }

    private function createInnerIterator()
    {
        if (null !== $this->feed) {
            $entries = $this->feed->getEntries();
        } else {
            $entries = [];
        }

        if (empty($entries)) {
            $this->innerIterator = new ArrayIterator([]);

            return;
        }

        $entries = call_user_func(
            $this->arraySortingFunction,
            $entries
        );

        $urls = array_map(
            function ($entry) {
                return $entry->getEventUrl();
            },
            $entries
        );

        $this->innerIterator = new ArrayIterator(
            array_filter(
                array_map(
                    function ($entry, $event) {
                        if ($entry === null || $event === null) {
                            return null;
                        }
                        return new EntryWithEvent(
                            $entry,
                            $event
                        );
                    },
                    $entries,
                    $this->eventStore->readEventBatch($urls)

The method readEventBatch() does not exist on EventStore\EventStoreInterface. Did you maybe mean readEvent()?

                ),
                function ($entryWithEvent) {
                    return ($entryWithEvent !== null);
                }
            )
        );
    }
}