Stream::empty() - Code Metrics - Inspection of "use map optimized for object keys instead of doubl..." - Innmind/Immutable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 467194...701f25 )

by Baptiste

created 2018-12-13 18:36 UTC

Stream::empty() A

↳ Parent: Stream

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php
declare(strict_types = 1);

namespace Innmind\Immutable;

use Innmind\Immutable\Exception\{
    LogicException,
    GroupEmptySequenceException,
    InvalidArgumentException
};

/**
 * {@inheritdoc}
 */
class Stream implements StreamInterface
{
    private $type;
    private $spec;
    private $values;

    public function __construct(string $type)
    {
        $this->type = new Str($type);
        $this->spec = Type::of($type);
        $this->values = new Sequence;
    }

    public static function of(string $type, ...$values): self
    {
        $self = new self($type);
        $self->values = new Sequence(...$values);
        $self->values->foreach(static function($element) use ($self): void {
            $self->spec->validate($element);
        });

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function type(): Str
    {
        return $this->type;
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function toPrimitive()
    {
        return $this->values->toPrimitive();
    }

    /**
     * {@inheritdoc}
     */
    public function current()
    {
        return $this->values->current();
    }

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

    /**
     * {@inheritdoc}
     */
    public function next()
    {
        $this->values->next();
    }

    /**
     * {@inheritdoc}
     */
    public function rewind()
    {
        $this->values->rewind();
    }

    /**
     * {@inheritdoc}
     */
    public function valid()
    {
        return $this->values->valid();
    }

    /**
     * {@inheritdoc}
     */
    public function offsetExists($offset): bool
    {
        return $this->values->offsetExists($offset);
    }

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

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value)
    {
        throw new LogicException('You can\'t modify a stream');
    }

    /**
     * {@inheritdoc}
     */
    public function offsetUnset($offset)
    {
        throw new LogicException('You can\'t modify a stream');
    }

    /**
     * {@inheritdoc}
     */
    public function get(int $index)
    {
        return $this->values->get($index);
    }

    /**
     * {@inheritdoc}
     */
    public function diff(StreamInterface $stream): StreamInterface
    {
        $this->validate($stream);

        $newStream = clone $this;
        $newStream->values = $this->values->diff(
            new Sequence(...$stream)
        );

        return $newStream;
    }

    /**
     * {@inheritdoc}
     */
    public function distinct(): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->distinct();

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function drop(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->drop($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function dropEnd(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->dropEnd($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function equals(StreamInterface $stream): bool
    {
        $this->validate($stream);

        return $this->values->equals(
            new Sequence(...$stream)
        );
    }

    /**
     * {@inheritdoc}
     */
    public function filter(callable $predicate): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->filter($predicate);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function foreach(callable $function): StreamInterface
    {
        $this->values->foreach($function);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function groupBy(callable $discriminator): MapInterface
    {
        if ($this->size() === 0) {
            throw new GroupEmptySequenceException;
        }

        $map = null;

        foreach ($this->values as $value) {
            $key = $discriminator($value);

            if ($map === null) {
                $map = new Map(
                    Type::determine($key),
                    StreamInterface::class
                );
            }

            if ($map->contains($key)) {
                $map = $map->put(
                    $key,
                    $map->get($key)->add($value)
                );
            } else {
                $map = $map->put(
                    $key,
                    (new self((string) $this->type))->add($value)
                );
            }
        }

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function first()
    {
        return $this->values->first();
    }

    /**
     * {@inheritdoc}
     */
    public function last()
    {
        return $this->values->last();
    }

    /**
     * {@inheritdoc}
     */
    public function contains($element): bool
    {
        return $this->values->contains($element);
    }

    /**
     * {@inheritdoc}
     */
    public function indexOf($element): int
    {
        return $this->values->indexOf($element);
    }

    /**
     * {@inheritdoc}
     */
    public function indices(): StreamInterface
    {
        return $this->values->indices();
    }

    /**
     * {@inheritdoc}
     */
    public function map(callable $function): StreamInterface
    {
        $self = clone $this;
        $self->values = $this->values->map($function);
        $self->values->foreach(function($element): void {
            $this->spec->validate($element);
        });

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function pad(int $size, $element): StreamInterface
    {
        $this->spec->validate($element);

        $stream = clone $this;
        $stream->values = $this->values->pad($size, $element);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function partition(callable $predicate): MapInterface
    {
        $truthy = [];
        $falsy = [];

        foreach ($this->values as $value) {
            if ($predicate($value) === true) {
                $truthy[] = $value;
            } else {
                $falsy[] = $value;
            }
        }

        $true = $this->clear();
        $true->values = new Sequence(...$truthy);
        $false = $this->clear();
        $false->values = new Sequence(...$falsy);

        return Map::of('bool', StreamInterface::class)
            (true, $true)
            (false, $false);
    }

    /**
     * {@inheritdoc}
     */
    public function slice(int $from, int $until): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->slice($from, $until);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function splitAt(int $position): StreamInterface
    {
        $stream = new self(StreamInterface::class);
        $splitted = $this->values->splitAt($position);
        $first = new self((string) $this->type);
        $second = new self((string) $this->type);
        $first->values = $splitted->first();
        $second->values = $splitted->last();

        return $stream->add($first)->add($second);
    }

    /**
     * {@inheritdoc}
     */
    public function take(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->take($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function takeEnd(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->takeEnd($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function append(StreamInterface $stream): StreamInterface
    {
        $this->validate($stream);

        $self = clone $this;
        $self->values = $this->values->append(
            new Sequence(...$stream)
        );

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function intersect(StreamInterface $stream): StreamInterface
    {
        $this->validate($stream);

        $self = clone $this;
        $self->values = $this->values->intersect(
            new Sequence(...$stream)
        );

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function join(string $separator): Str
    {
        return new Str((string) $this->values->join($separator));
    }

    /**
     * {@inheritdoc}
     */
    public function add($element): StreamInterface
    {
        $this->spec->validate($element);

        $stream = clone $this;
        $stream->values = $this->values->add($element);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function sort(callable $function): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->sort($function);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function reduce($carry, callable $reducer)
    {
        return $this->values->reduce($carry, $reducer);
    }

    /**
     * {@inheritdoc}
     */
    public function clear(): StreamInterface
    {
        $self = clone $this;
        $self->values = new Sequence;

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function reverse(): StreamInterface
    {
        $self = clone $this;
        $self->values = $this->values->reverse();

        return $self;
    }

    public function empty(): bool
    {
        return $this->values->empty();
    }

    /**
     * Make sure the stream is compatible with the current one
     *
     * @param StreamInterface $stream
     *
     * @throws InvalidArgumentException
     *
     * @return void
     */
    private function validate(StreamInterface $stream)
    {
        if (!$stream->type()->equals($this->type)) {
            throw new InvalidArgumentException(
                'The 2 streams does not reference the same type'
            );
        }
    }
}


1		<?php
2		declare(strict_types = 1);
3
4		namespace Innmind\Immutable;
5
6		use Innmind\Immutable\Exception\{
7		LogicException,
8		GroupEmptySequenceException,
9		InvalidArgumentException
10		};
11
12		/**
13		* {@inheritdoc}
14		*/
15		class Stream implements StreamInterface
16		{
17		private $type;
18		private $spec;
19		private $values;
20
21	306	public function __construct(string $type)
22		{
23	306	$this->type = new Str($type);
24	306	$this->spec = Type::of($type);
25	306	$this->values = new Sequence;
26	306	}
27
28	90	public static function of(string $type, ...$values): self
29		{
30	90	$self = new self($type);
31	90	$self->values = new Sequence(...$values);
32	90	$self->values->foreach(static function($element) use ($self): void {
33	72	$self->spec->validate($element);
34	90	});
35
36	90	return $self;
37		}
38
39		/**
40		* {@inheritdoc}
41		*/
42	102	public function type(): Str
43		{
44	102	return $this->type;
45		}
46
47		/**
48		* {@inheritdoc}
49		*/
50	46	public function size(): int
51		{
52	46	return $this->values->size();
53		}
54
55		/**
56		* {@inheritdoc}
57		*/
58	10	public function count(): int
59		{
60	10	return $this->values->size();
61		}
62
63		/**
64		* {@inheritdoc}
65		*/
66	136	public function toPrimitive()
67		{
68	136	return $this->values->toPrimitive();
69		}
70
71		/**
72		* {@inheritdoc}
73		*/
74	78	public function current()
75		{
76	78	return $this->values->current();
77		}
78
79		/**
80		* {@inheritdoc}
81		*/
82	62	public function key()
83		{
84	62	return $this->values->key();
85		}
86
87		/**
88		* {@inheritdoc}
89		*/
90	74	public function next()
91		{
92	74	$this->values->next();
93	74	}
94
95		/**
96		* {@inheritdoc}
97		*/
98	78	public function rewind()
99		{
100	78	$this->values->rewind();
101	78	}
102
103		/**
104		* {@inheritdoc}
105		*/
106	78	public function valid()
107		{
108	78	return $this->values->valid();
109		}
110
111		/**
112		* {@inheritdoc}
113		*/
114	2	public function offsetExists($offset): bool
115		{
116	2	return $this->values->offsetExists($offset);
117		}
118
119		/**
120		* {@inheritdoc}
121		*/
122	18	public function offsetGet($offset)
123		{
124	18	return $this->get($offset);
125		}
126
127		/**
128		* {@inheritdoc}
129		*/
130	2	public function offsetSet($offset, $value)
131		{
132	2	throw new LogicException('You can\'t modify a stream');
133		}
134
135		/**
136		* {@inheritdoc}
137		*/
138	2	public function offsetUnset($offset)
139		{
140	2	throw new LogicException('You can\'t modify a stream');
141		}
142
143		/**
144		* {@inheritdoc}
145		*/
146	56	public function get(int $index)
147		{
148	56	return $this->values->get($index);
149		}
150
151		/**
152		* {@inheritdoc}
153		*/
154	4	public function diff(StreamInterface $stream): StreamInterface
155		{
156	4	$this->validate($stream);
157
158	4	$newStream = clone $this;
159	4	$newStream->values = $this->values->diff(
160	4	new Sequence(...$stream)
161		);
162
163	4	return $newStream;
164		}
165
166		/**
167		* {@inheritdoc}
168		*/
169	62	public function distinct(): StreamInterface
170		{
171	62	$stream = clone $this;
172	62	$stream->values = $this->values->distinct();
173
174	62	return $stream;
175		}
176
177		/**
178		* {@inheritdoc}
179		*/
180	8	public function drop(int $size): StreamInterface
181		{
182	8	$stream = clone $this;
183	8	$stream->values = $this->values->drop($size);
184
185	8	return $stream;
186		}
187
188		/**
189		* {@inheritdoc}
190		*/
191	2	public function dropEnd(int $size): StreamInterface
192		{
193	2	$stream = clone $this;
194	2	$stream->values = $this->values->dropEnd($size);
195
196	2	return $stream;
197		}
198
199		/**
200		* {@inheritdoc}
201		*/
202	14	public function equals(StreamInterface $stream): bool
203		{
204	14	$this->validate($stream);
205
206	12	return $this->values->equals(
207	12	new Sequence(...$stream)
208		);
209		}
210
211		/**
212		* {@inheritdoc}
213		*/
214	4	public function filter(callable $predicate): StreamInterface
215		{
216	4	$stream = clone $this;
217	4	$stream->values = $this->values->filter($predicate);
218
219	4	return $stream;
220		}
221
222		/**
223		* {@inheritdoc}
224		*/
225	4	public function foreach(callable $function): StreamInterface
226		{
227	4	$this->values->foreach($function);
228
229	4	return $this;
230		}
231
232		/**
233		* {@inheritdoc}
234		*/
235	6	public function groupBy(callable $discriminator): MapInterface
236		{
237	6	if ($this->size() === 0) {
238	2	throw new GroupEmptySequenceException;
239		}
240
241	4	$map = null;
242
243	4	foreach ($this->values as $value) {
244	4	$key = $discriminator($value);
245
246	4	if ($map === null) {
247	4	$map = new Map(
248	4	Type::determine($key),
249	4	StreamInterface::class
250		);
251		}
252
253	4	if ($map->contains($key)) {
254	4	$map = $map->put(
255	4	$key,
256	4	$map->get($key)->add($value)
257		);
258		} else {
259	4	$map = $map->put(
260	4	$key,
261	4	(new self((string) $this->type))->add($value)
262		);
263		}
264		}
265
266	4	return $map;
267		}
268
269		/**
270		* {@inheritdoc}
271		*/
272	4	public function first()
273		{
274	4	return $this->values->first();
275		}
276
277		/**
278		* {@inheritdoc}
279		*/
280	4	public function last()
281		{
282	4	return $this->values->last();
283		}
284
285		/**
286		* {@inheritdoc}
287		*/
288	116	public function contains($element): bool
289		{
290	116	return $this->values->contains($element);
291		}
292
293		/**
294		* {@inheritdoc}
295		*/
296	38	public function indexOf($element): int
297		{
298	38	return $this->values->indexOf($element);
299		}
300
301		/**
302		* {@inheritdoc}
303		*/
304	4	public function indices(): StreamInterface
305		{
306	4	return $this->values->indices();
307		}
308
309		/**
310		* {@inheritdoc}
311		*/
312	6	public function map(callable $function): StreamInterface
313		{
314	6	$self = clone $this;
315	6	$self->values = $this->values->map($function);
316	6	$self->values->foreach(function($element): void {
317	6	$this->spec->validate($element);
318	6	});
319
320	4	return $self;
321		}
322
323		/**
324		* {@inheritdoc}
325		*/
326	4	public function pad(int $size, $element): StreamInterface
327		{
328	4	$this->spec->validate($element);
329
330	2	$stream = clone $this;
331	2	$stream->values = $this->values->pad($size, $element);
332
333	2	return $stream;
334		}
335
336		/**
337		* {@inheritdoc}
338		*/
339	4	public function partition(callable $predicate): MapInterface
340		{
341	4	$truthy = [];
342	4	$falsy = [];
343
344	4	foreach ($this->values as $value) {
345	4	if ($predicate($value) === true) {
346	4	$truthy[] = $value;
347		} else {
348	4	$falsy[] = $value;
349		}
350		}
351
352	4	$true = $this->clear();
353	4	$true->values = new Sequence(...$truthy);
354	4	$false = $this->clear();
355	4	$false->values = new Sequence(...$falsy);
356
357	4	return Map::of('bool', StreamInterface::class)
358	4	(true, $true)
359	4	(false, $false);
360		}
361
362		/**
363		* {@inheritdoc}
364		*/
365	6	public function slice(int $from, int $until): StreamInterface
366		{
367	6	$stream = clone $this;
368	6	$stream->values = $this->values->slice($from, $until);
369
370	6	return $stream;
371		}
372
373		/**
374		* {@inheritdoc}
375		*/
376	2	public function splitAt(int $position): StreamInterface
377		{
378	2	$stream = new self(StreamInterface::class);
379	2	$splitted = $this->values->splitAt($position);
380	2	$first = new self((string) $this->type);
381	2	$second = new self((string) $this->type);
382	2	$first->values = $splitted->first();
383	2	$second->values = $splitted->last();
384
385	2	return $stream->add($first)->add($second);
386		}
387
388		/**
389		* {@inheritdoc}
390		*/
391	8	public function take(int $size): StreamInterface
392		{
393	8	$stream = clone $this;
394	8	$stream->values = $this->values->take($size);
395
396	8	return $stream;
397		}
398
399		/**
400		* {@inheritdoc}
401		*/
402	2	public function takeEnd(int $size): StreamInterface
403		{
404	2	$stream = clone $this;
405	2	$stream->values = $this->values->takeEnd($size);
406
407	2	return $stream;
408		}
409
410		/**
411		* {@inheritdoc}
412		*/
413	14	public function append(StreamInterface $stream): StreamInterface
414		{
415	14	$this->validate($stream);
416
417	12	$self = clone $this;
418	12	$self->values = $this->values->append(
419	12	new Sequence(...$stream)
420		);
421
422	12	return $self;
423		}
424
425		/**
426		* {@inheritdoc}
427		*/
428	24	public function intersect(StreamInterface $stream): StreamInterface
429		{
430	24	$this->validate($stream);
431
432	22	$self = clone $this;
433	22	$self->values = $this->values->intersect(
434	22	new Sequence(...$stream)
435		);
436
437	22	return $self;
438		}
439
440		/**
441		* {@inheritdoc}
442		*/
443	20	public function join(string $separator): Str
444		{
445	20	return new Str((string) $this->values->join($separator));
446		}
447
448		/**
449		* {@inheritdoc}
450		*/
451	216	public function add($element): StreamInterface
452		{
453	216	$this->spec->validate($element);
454
455	214	$stream = clone $this;
456	214	$stream->values = $this->values->add($element);
457
458	214	return $stream;
459		}
460
461		/**
462		* {@inheritdoc}
463		*/
464	4	public function sort(callable $function): StreamInterface
465		{
466	4	$stream = clone $this;
467	4	$stream->values = $this->values->sort($function);
468
469	4	return $stream;
470		}
471
472		/**
473		* {@inheritdoc}
474		*/
475	10	public function reduce($carry, callable $reducer)
476		{
477	10	return $this->values->reduce($carry, $reducer);
478		}
479
480		/**
481		* {@inheritdoc}
482		*/
483	28	public function clear(): StreamInterface
484		{
485	28	$self = clone $this;
486	28	$self->values = new Sequence;
487
488	28	return $self;
489		}
490
491		/**
492		* {@inheritdoc}
493		*/
494	4	public function reverse(): StreamInterface
495		{
496	4	$self = clone $this;
497	4	$self->values = $this->values->reverse();
498
499	4	return $self;
500		}
501
502	6	public function empty(): bool
503		{
504	6	return $this->values->empty();
505		}
506
507		/**
508		* Make sure the stream is compatible with the current one
509		*
510		* @param StreamInterface $stream
511		*
512		* @throws InvalidArgumentException
513		*
514		* @return void
515		*/
516	52	private function validate(StreamInterface $stream)
517		{
518	52	if (!$stream->type()->equals($this->type)) {
519	6	throw new InvalidArgumentException(
520	6	'The 2 streams does not reference the same type'
521		);
522		}
523	46	}
524		}
525

Innmind / Immutable

GitHub Access Token became invalid

Push — develop ( 467194...701f25 )

Stream::empty() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like