Set::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

Set::empty() A

↳ Parent: Set

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\InvalidArgumentException;

class Set implements SetInterface
{
    private $type;
    private $spec;
    private $values;

    /**
     * {@inheritdoc}
     */
    public function __construct(string $type)
    {
        $this->type = new Str($type);
        $this->spec = Type::of($type);
        $this->values = new Stream($type);
    }

    public static function of(string $type, ...$values): self
    {
        $self = new self($type);
        $self->values = Stream::of($type, ...$values)->distinct();

        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 intersect(SetInterface $set): SetInterface
    {
        $this->validate($set);

        $newSet = clone $this;
        $newSet->values = $this->values->intersect(
            Stream::of((string) $this->type, ...$set)
        );

        return $newSet;
    }

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

        if ($this->contains($element)) {
            return $this;
        }

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

        return $set;
    }

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

    /**
     * {@inheritdoc}
     */
    public function remove($element): SetInterface
    {
        if (!$this->contains($element)) {
            return $this;
        }

        $index = $this->values->indexOf($element);
        $set = clone $this;
        $set->values = $this
            ->values
            ->clear()
            ->append($this->values->slice(0, $index))
            ->append($this->values->slice($index + 1, $this->size()));

        return $set;
    }

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

        $newSet = clone $this;
        $newSet->values = $this->values->diff(
            Stream::of((string) $this->type, ...$set)
        );

        return $newSet;
    }

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

        if ($this->size() !== $set->size()) {
            return false;
        }

        return $this->intersect($set)->size() === $this->size();
    }

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

        return $set;
    }

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

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function groupBy(callable $discriminator): MapInterface
    {
        $map = $this->values->groupBy($discriminator);

        return $map->reduce(
            new Map((string) $map->keyType(), SetInterface::class),
            function(Map $carry, $key, StreamInterface $values): Map {
                $set = $this->clear();
                $set->values = $values;

                return $carry->put($key, $set);
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function map(callable $function): SetInterface
    {
        return $this->reduce(
            $this->clear(),
            function(self $carry, $value) use ($function): self {
                return $carry->add($function($value));
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function partition(callable $predicate): MapInterface
    {
        $truthy = $this->clear();
        $falsy = $this->clear();
        $partitions = $this->values->partition($predicate);
        $truthy->values = $partitions->get(true);
        $falsy->values = $partitions->get(false);

        return Map::of('bool', SetInterface::class)
            (true, $truthy)
            (false, $falsy);
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function merge(SetInterface $set): SetInterface
    {
        $this->validate($set);

        return $set->reduce(
            $this,
            function(self $carry, $value): self {
                return $carry->add($value);
            }
        );
    }

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

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

        return $self;
    }

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

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


1		<?php
2		declare(strict_types = 1);
3
4		namespace Innmind\Immutable;
5
6		use Innmind\Immutable\Exception\InvalidArgumentException;
7
8		class Set implements SetInterface
9		{
10		private $type;
11		private $spec;
12		private $values;
13
14		/**
15		* {@inheritdoc}
16		*/
17	104	public function __construct(string $type)
18		{
19	104	$this->type = new Str($type);
20	104	$this->spec = Type::of($type);
21	104	$this->values = new Stream($type);
22	104	}
23
24	60	public static function of(string $type, ...$values): self
25		{
26	60	$self = new self($type);
27	60	$self->values = Stream::of($type, ...$values)->distinct();
28
29	60	return $self;
30		}
31
32		/**
33		* {@inheritdoc}
34		*/
35	42	public function type(): Str
36		{
37	42	return $this->type;
38		}
39
40		/**
41		* {@inheritdoc}
42		*/
43	22	public function size(): int
44		{
45	22	return $this->values->size();
46		}
47
48		/**
49		* {@inheritdoc}
50		*/
51	2	public function count(): int
52		{
53	2	return $this->values->size();
54		}
55
56		/**
57		* {@inheritdoc}
58		*/
59	76	public function toPrimitive()
60		{
61	76	return $this->values->toPrimitive();
62		}
63
64		/**
65		* {@inheritdoc}
66		*/
67	24	public function current()
68		{
69	24	return $this->values->current();
70		}
71
72		/**
73		* {@inheritdoc}
74		*/
75	24	public function key()
76		{
77	24	return $this->values->key();
78		}
79
80		/**
81		* {@inheritdoc}
82		*/
83	24	public function next()
84		{
85	24	$this->values->next();
86	24	}
87
88		/**
89		* {@inheritdoc}
90		*/
91	24	public function rewind()
92		{
93	24	$this->values->rewind();
94	24	}
95
96		/**
97		* {@inheritdoc}
98		*/
99	24	public function valid()
100		{
101	24	return $this->values->valid();
102		}
103
104		/**
105		* {@inheritdoc}
106		*/
107	22	public function intersect(SetInterface $set): SetInterface
108		{
109	22	$this->validate($set);
110
111	20	$newSet = clone $this;
112	20	$newSet->values = $this->values->intersect(
113	20	Stream::of((string) $this->type, ...$set)
114		);
115
116	20	return $newSet;
117		}
118
119		/**
120		* {@inheritdoc}
121		*/
122	54	public function add($element): SetInterface
123		{
124	54	$this->spec->validate($element);
125
126	52	if ($this->contains($element)) {
127	4	return $this;
128		}
129
130	52	$set = clone $this;
131	52	$set->values = $this->values->add($element);
132
133	52	return $set;
134		}
135
136		/**
137		* {@inheritdoc}
138		*/
139	52	public function contains($element): bool
140		{
141	52	return $this->values->contains($element);
142		}
143
144		/**
145		* {@inheritdoc}
146		*/
147	2	public function remove($element): SetInterface
148		{
149	2	if (!$this->contains($element)) {
150		return $this;
151		}
152
153	2	$index = $this->values->indexOf($element);
154	2	$set = clone $this;
155	2	$set->values = $this
156	2	->values
157	2	->clear()
158	2	->append($this->values->slice(0, $index))
159	2	->append($this->values->slice($index + 1, $this->size()));
160
161	2	return $set;
162		}
163
164		/**
165		* {@inheritdoc}
166		*/
167	4	public function diff(SetInterface $set): SetInterface
168		{
169	4	$this->validate($set);
170
171	2	$newSet = clone $this;
172	2	$newSet->values = $this->values->diff(
173	2	Stream::of((string) $this->type, ...$set)
174		);
175
176	2	return $newSet;
177		}
178
179		/**
180		* {@inheritdoc}
181		*/
182	20	public function equals(SetInterface $set): bool
183		{
184	20	$this->validate($set);
185
186	18	if ($this->size() !== $set->size()) {
187	4	return false;
188		}
189
190	18	return $this->intersect($set)->size() === $this->size();
191		}
192
193		/**
194		* {@inheritdoc}
195		*/
196	2	public function filter(callable $predicate): SetInterface
197		{
198	2	$set = clone $this;
199	2	$set->values = $this->values->filter($predicate);
200
201	2	return $set;
202		}
203
204		/**
205		* {@inheritdoc}
206		*/
207	2	public function foreach(callable $function): SetInterface
208		{
209	2	$this->values->foreach($function);
210
211	2	return $this;
212		}
213
214		/**
215		* {@inheritdoc}
216		*/
217	2	public function groupBy(callable $discriminator): MapInterface
218		{
219	2	$map = $this->values->groupBy($discriminator);
220
221	2	return $map->reduce(
222	2	new Map((string) $map->keyType(), SetInterface::class),
223	2	function(Map $carry, $key, StreamInterface $values): Map {
224	2	$set = $this->clear();
225	2	$set->values = $values;
226
227	2	return $carry->put($key, $set);
228	2	}
229		);
230		}
231
232		/**
233		* {@inheritdoc}
234		*/
235	4	public function map(callable $function): SetInterface
236		{
237	4	return $this->reduce(
238	4	$this->clear(),
239	4	function(self $carry, $value) use ($function): self {
240	4	return $carry->add($function($value));
241	4	}
242		);
243		}
244
245		/**
246		* {@inheritdoc}
247		*/
248	2	public function partition(callable $predicate): MapInterface
249		{
250	2	$truthy = $this->clear();
251	2	$falsy = $this->clear();
252	2	$partitions = $this->values->partition($predicate);
253	2	$truthy->values = $partitions->get(true);
254	2	$falsy->values = $partitions->get(false);
255
256	2	return Map::of('bool', SetInterface::class)
257	2	(true, $truthy)
258	2	(false, $falsy);
259		}
260
261		/**
262		* {@inheritdoc}
263		*/
264	2	public function join(string $separator): Str
265		{
266	2	return $this->values->join($separator);
267		}
268
269		/**
270		* {@inheritdoc}
271		*/
272	2	public function sort(callable $function): StreamInterface
273		{
274	2	return $this->values->sort($function);
275		}
276
277		/**
278		* {@inheritdoc}
279		*/
280	4	public function merge(SetInterface $set): SetInterface
281		{
282	4	$this->validate($set);
283
284	2	return $set->reduce(
285	2	$this,
286	2	function(self $carry, $value): self {
287	2	return $carry->add($value);
288	2	}
289		);
290		}
291
292		/**
293		* {@inheritdoc}
294		*/
295	8	public function reduce($carry, callable $reducer)
296		{
297	8	return $this->values->reduce($carry, $reducer);
298		}
299
300		/**
301		* {@inheritdoc}
302		*/
303	8	public function clear(): SetInterface
304		{
305	8	$self = clone $this;
306	8	$self->values = $this->values->clear();
307
308	8	return $self;
309		}
310
311	2	public function empty(): bool
312		{
313	2	return $this->values->empty();
314		}
315
316		/**
317		* Make sure the set is compatible with the current one
318		*
319		* @param SetInterface $set
320		*
321		* @throws InvalidArgumentException
322		*
323		* @return void
324		*/
325	30	private function validate(SetInterface $set)
326		{
327	30	if (!$set->type()->equals($this->type)) {
328	8	throw new InvalidArgumentException(
329	8	'The 2 sets does not reference the same type'
330		);
331		}
332	22	}
333		}
334

Innmind / Immutable

GitHub Access Token became invalid

Push — develop ( 467194...701f25 )

Set::empty() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like