Fixtures\Innmind\Immutable\Set

Complexity

Total Complexity

9

Size/Duplication

Total Lines	64
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	filter()	0	3	1
A	take()	0	6	1
A	values()	0	9	3
A	generate()	0	11	2
A	__construct()	0	5	1
A	of()	0	3	1

<?php
declare(strict_types = 1);

namespace Fixtures\Innmind\Immutable;

use Innmind\BlackBox\Set as DataSet;
use Innmind\Immutable\Set as Structure;

/**
 * {@inheritdoc}
 * @template I
 */
final class Set implements DataSet
{
    private $type;
    private $set;
    private $sizes;

    public function __construct(string $type, DataSet $set, DataSet\Integers $sizes = null)

The type Innmind\BlackBox\Set\Integers was not found. Maybe you did not declare it correctly or list all dependencies?

    {
        $this->type = $type;
        $this->set = $set;
        $this->sizes = ($sizes ?? DataSet\Integers::between(0, 100))->take(100);
    }

    /**
     * @return Set<Structure<I>>
     */
    public static function of(string $type, DataSet $set, DataSet\Integers $sizes = null): self
    {
        return new self($type, $set, $sizes);
    }

    public function take(int $size): DataSet
    {
        $self = clone $this;
        $self->sizes = $this->sizes->take($size);

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function filter(callable $predicate): DataSet
    {
        throw new \LogicException('Set set can\'t be filtered, underlying set must be filtered beforehand');
    }

    /**
     * @return \Generator<Set\Value<Structure<I>>>
     */
    public function values(): \Generator
    {
        $immutable = $this->set->values()->current()->isImmutable();

        foreach ($this->sizes->values() as $size) {
            if ($immutable) {
                yield DataSet\Value::immutable($this->generate($size->unwrap()));

The type Innmind\BlackBox\Set\Value was not found. Maybe you did not declare it correctly or list all dependencies?

            } else {
                yield DataSet\Value::mutable(fn() => $this->generate($size->unwrap()));
            }
        }
    }

    private function generate(int $size): Structure
    {
        $set = Structure::of($this->type);
        $values = $this->set->take($size)->values();

        while ($set->size() < $size) {
            $set = ($set)($values->current()->unwrap());
            $values->next();
        }

        return $set;
    }
}