Foolz\SphinxQL\Drivers\MultiResultSet

Complexity

Total Complexity

25

Size/Duplication

Total Lines	211
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getStored()	0	6	1
A	offsetExists()	0	6	1
A	offsetGet()	0	6	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	next()	0	4	1
A	key()	0	4	1
A	rewind()	0	7	1
A	count()	0	6	1
A	valid()	0	8	2
A	current()	0	7	1
A	storedValid()	0	6	3
B	getNext()	0	18	5
B	store()	0	25	4

<?php

namespace Foolz\SphinxQL\Drivers;

use Foolz\SphinxQL\Exception\DatabaseException;

class MultiResultSet implements MultiResultSetInterface
{
    /**
     * @var null|array
     */
    protected $stored;

    /**
     * @var int
     */
    protected $cursor = 0;

    /**
     * @var int
     */
    protected $next_cursor = 0;

    /**
     * @var ResultSetInterface|null
     */
    protected $rowSet;

    /**
     * @var MultiResultSetAdapterInterface
     */
    protected $adapter;

    /**
     * @var bool
     */
    protected $valid = true;

    /**
     * @param MultiResultSetAdapterInterface $adapter
     */
    public function __construct(MultiResultSetAdapterInterface $adapter)
    {
        $this->adapter = $adapter;
    }

    /**
     * @inheritdoc
     */
    public function getStored()
    {
        $this->store();

        return $this->stored;

The expression $this->stored; of type null|array adds the type array to the return on line 54 which is incompatible with the return type declared by the interface Foolz\SphinxQL\Drivers\MultiResultSetInterface::getStored of type Foolz\SphinxQL\Drivers\ResultSetInterface[]|null.

    }

    /**
     * @inheritdoc
     */
    public function offsetExists($offset)
    {
        $this->store();

        return $this->storedValid($offset);
    }

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

        return $this->stored[$offset];
    }

    /**
     * @inheritdoc
     * @codeCoverageIgnore
     */
    public function offsetSet($offset, $value)
    {
        throw new \BadMethodCallException('Not implemented');
    }

    /**
     * @inheritdoc
     * @codeCoverageIgnore
     */
    public function offsetUnset($offset)
    {
        throw new \BadMethodCallException('Not implemented');
    }

    /**
     * @inheritdoc
     */
    public function next()
    {
        $this->rowSet = $this->getNext();

It seems like $this->getNext() can also be of type false. However, the property $rowSet is declared as type object<Foolz\SphinxQL\Drivers\ResultSetInterface>|null. Maybe add an additional type check?

    }

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

    /**
     * @inheritdoc
     */
    public function rewind()
    {
        // we actually can't roll this back unless it was stored first
        $this->cursor = 0;
        $this->next_cursor = 0;
        $this->rowSet = $this->getNext();

It seems like $this->getNext() can also be of type false. However, the property $rowSet is declared as type object<Foolz\SphinxQL\Drivers\ResultSetInterface>|null. Maybe add an additional type check?

    }

    /**
     * @inheritdoc
     */
    public function count()
    {
        $this->store();

        return count($this->stored);
    }

    /**
     * @inheritdoc
     */
    public function valid()
    {
        if ($this->stored !== null) {
            return $this->storedValid();
        }

        return $this->adapter->valid();
    }

    /**
     * @inheritdoc
     */
    public function current()
    {
        $rowSet = $this->rowSet;
        unset($this->rowSet);

        return $rowSet;
    }

    /**
     * @param null|int $cursor
     *
     * @return bool
     */
    protected function storedValid($cursor = null)
    {
        $cursor = (!is_null($cursor) ? $cursor : $this->cursor);

        return $cursor >= 0 && $cursor < count($this->stored);
    }

    /**
     * @inheritdoc
     */
    public function getNext()
    {
        $this->cursor = $this->next_cursor;

        if ($this->stored !== null) {
            $resultSet = !$this->storedValid() ? false : $this->stored[$this->cursor];
        } else {
            if ($this->next_cursor > 0) {
                $this->adapter->getNext();
            }

            $resultSet = !$this->adapter->valid() ? false : $this->adapter->current();
        }

        $this->next_cursor++;

        return $resultSet;
    }

    /**
     * @inheritdoc
     */
    public function store()
    {
        if ($this->stored !== null) {
            return $this;
        }

        // don't let users mix storage and driver cursors
        if ($this->next_cursor > 0) {
            throw new DatabaseException('The MultiResultSet is using the driver cursors, store() can\'t fetch all the data');
        }

        $store = array();
        while ($set = $this->getNext()) {
            // this relies on stored being null!
            $store[] = $set->store();
        }

        $this->cursor = 0;
        $this->next_cursor = 0;

        // if we write the array straight to $this->stored it won't be null anymore and functions relying on null will break
        $this->stored = $store;

        return $this;
    }
}