mpyw\Co\Internal\GeneratorContainer

Complexity

Total Complexity

31

Size/Duplication

Total Lines	188
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

97.3%

Importance

Changes	10
Bugs	2	Features	1

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	16	4
A	getOptions()	0	4	1
A	__toString()	0	4	1
A	valid()	0	10	4
A	key()	0	5	1
A	current()	0	5	1
A	send()	0	9	2
A	throw_()	0	9	2
A	throwAcceptable()	0	6	3
A	thrown()	0	4	2
B	getReturnOrThrown()	0	11	6
A	validateValidity()	0	6	2
A	validateInvalidity()	0	6	2

<?php

namespace mpyw\Co\Internal;
use mpyw\Co\CoInterface;
use mpyw\Co\Internal\CoOption;

class GeneratorContainer
{
    /**
     * Generator.
     * @var Generator
     */
    private $g;

    /**
     * Generator object hash.
     * @var string
     */
    private $h;

    /**
     * Thrown exception.
     * @var Throwable|Exception
     */
    private $e;

    /**
     * Default options.
     * @var CoOption
     */
    private $options;

    /**
     * Constructor.
     * @param Generator $g
     * @param CoOption  $options
     * @param mixed     $yield_key
     */
    public function __construct(\Generator $g, CoOption $options = null, $yield_key = null)
    {
        $this->g = $g;

It seems like $g of type object<Generator> is incompatible with the declared type object<mpyw\Co\Internal\Generator> of property $g.

        $this->h = spl_object_hash($g);
        if ($options === null) {
            $options = new CoOption;
        }
        if ($yield_key === CoInterface::SAFE) {
            $options = $options->reconfigure(['throw' => false]);
        }
        if ($yield_key === CoInterface::UNSAFE) {
            $options = $options->reconfigure(['throw' => true]);
        }
        $this->options = $options;
        $this->valid();
    }

    /**
     * Return options.
     * @return CoOption
     */
    public function getOptions()
    {
        return $this->options;
    }

    /**
     * Return generator hash.
     * @return string
     */
    public function __toString()
    {
        return $this->h;
    }

    /**
     * Return whether generator is actually working.
     * @return bool
     */
    public function valid()
    {
        try {
            $this->g->current();
            return $this->e === null && $this->g->valid() && $this->g->key() !== CoInterface::RETURN_WITH;
        } catch (\RuntimeException $e) {
            $this->e = $e;

It seems like $e of type object<RuntimeException> is incompatible with the declared type object<mpyw\Co\Internal\Throwable>|object<mpyw\Co\Internal\Exception> of property $e.

            return false;
        }
    }

    /**
     * Return current key.
     * @return mixed
     */
    public function key()
    {
        $this->validateValidity();
        return $this->g->key();
    }

    /**
     * Return current value.
     * @return mixed
     */
    public function current()
    {
        $this->validateValidity();
        return $this->g->current();
    }

    /**
     * Send value into generator.
     * @param mixed $value
     * @NOTE: This method returns nothing,
     *        while original generator returns something.
     */
    public function send($value)
    {
        $this->validateValidity();
        try {
            $this->g->send($value);
        } catch (\RuntimeException $e) {
            $this->e = $e;

It seems like $e of type object<RuntimeException> is incompatible with the declared type object<mpyw\Co\Internal\Throwable>|object<mpyw\Co\Internal\Exception> of property $e.

        }
    }

    /**
     * Throw exception into generator.
     * @param RuntimeException $e
     * @NOTE: This method returns nothing,
     *        while original generator returns something.
     */
    public function throw_(\RuntimeException $e)

The parameter $e is not used and could be removed.

    {
        $this->validateValidity();
        try {
            $this->g->throw($e);
        } catch (\RuntimeException $e) {
            $this->e = $e;

It seems like $e of type object<RuntimeException> is incompatible with the declared type object<mpyw\Co\Internal\Throwable>|object<mpyw\Co\Internal\Exception> of property $e.

        }
    }

    public function throwAcceptable()
    {
        $this->validateValidity();
        return $this->g->key() === CoInterface::UNSAFE ||
               $this->g->key() !== CoInterface::SAFE && $this->options['throw'];
    }

    /**
     * Return whether exception is thrown.
     * @return bool
     */
    public function thrown()
    {
        return $this->e !== null && $this->options['throw'];
    }

    /**
     * Return value that generator has returned or thrown.
     * @return mixed
     */
    public function getReturnOrThrown()
    {
        $this->validateInvalidity();
        if ($this->e === null && $this->g->valid() && !$this->valid()) {
            return $this->g->current();
        }
        if ($this->e) {
            return $this->e;
        }
        return method_exists($this->g, 'getReturn') ? $this->g->getReturn() : null;
    }

    /**
     * Validate that generator has finished running.
     * @throws LogicException
     */
    private function validateValidity()
    {
        if (!$this->valid()) {
            throw new \LogicException('Unreachable here.');
        }
    }

    /**
     * Validate that generator is still running.
     * @throws LogicException
     */
    private function validateInvalidity()
    {
        if ($this->valid()) {
            throw new \LogicException('Unreachable here.');
        }
    }
}