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

ObjectKeys::empty() A

↳ Parent: ObjectKeys

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

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

<?php
declare(strict_types = 1);

namespace Innmind\Immutable\Map;

use Innmind\Immutable\{
    MapInterface,
    Map,
    Type,
    Str,
    Stream,
    StreamInterface,
    SetInterface,
    Set,
    Pair,
    Specification\ClassType,
    Exception\InvalidArgumentException,
    Exception\LogicException,
    Exception\ElementNotFoundException,
    Exception\GroupEmptyMapException
};

final class ObjectKeys implements MapInterface
{
    private $keyType;
    private $valueType;
    private $keySpecification;
    private $valueSpecification;
    private $values;

    /**
     * {@inheritdoc}
     */
    public function __construct(string $keyType, string $valueType)
    {
        $this->keySpecification = Type::of($keyType);

        if (!$this->keySpecification instanceof ClassType && $keyType !== 'object') {
            throw new LogicException;
        }

        $this->valueSpecification = Type::of($valueType);
        $this->keyType = new Str($keyType);
        $this->valueType = new Str($valueType);
        $this->values = new \SplObjectStorage;
    }

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

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

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

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

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

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

    /**
     * {@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
    {
        if (!is_object($offset)) {
            return false;
        }

        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 map');
    }

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

    /**
     * {@inheritdoc}
     */
    public function put($key, $value): MapInterface
    {
        $this->keySpecification->validate($key);
        $this->valueSpecification->validate($value);

        $map = clone $this;
        $map->values = clone $this->values;
        $map->values[$key] = $value;
        $map->rewind();

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function get($key)
    {
        if (!$this->offsetExists($key)) {
            throw new ElementNotFoundException;
        }

        return $this->values->offsetGet($key);
    }

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

    /**
     * {@inheritdoc}
     */
    public function clear(): MapInterface
    {
        $map = clone $this;
        $map->values = new \SplObjectStorage;

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function equals(MapInterface $map): bool
    {
        if ($map->size() !== $this->size()) {
            return false;
        }

        foreach ($this->values as $k) {
            $v = $this->values[$k];

            if (!$map->contains($k)) {
                return false;
            }

            if ($map->get($k) !== $v) {
                return false;
            }
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function filter(callable $predicate): MapInterface
    {
        $map = $this->clear();

        foreach ($this->values as $k) {
            $v = $this->values[$k];

            if ($predicate($k, $v) === true) {
                $map->values[$k] = $v;
            }
        }

        $map->rewind();

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function foreach(callable $function): MapInterface
    {
        foreach ($this->values as $k) {
            $v = $this->values[$k];

            $function($k, $v);
        }

        return $this;
    }

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

        $map = null;

        foreach ($this->values as $k) {
            $v = $this->values[$k];

            $key = $discriminator($k, $v);

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

            if ($map->contains($key)) {
                $map = $map->put(
                    $key,
                    $map->get($key)->put($k, $v)
                );
            } else {
                $map = $map->put(
                    $key,
                    $this->clear()->put($k, $v)
                );
            }
        }

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function keys(): SetInterface
    {
        return $this->reduce(
            Set::of((string) $this->keyType),
            static function(SetInterface $keys, $key): SetInterface {
                return $keys->add($key);
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function values(): StreamInterface
    {
        return $this->reduce(
            Stream::of((string) $this->valueType),
            static function(StreamInterface $values, $key, $value): StreamInterface {
                return $values->add($value);
            }
        );
    }

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

        foreach ($this->values as $k) {
            $v = $this->values[$k];

            $return = $function($k, $v);

            if ($return instanceof Pair) {
                $this->keySpecification->validate($return->key());

                $key = $return->key();
                $value = $return->value();
            } else {
                $key = $k;
                $value = $return;
            }

            $this->valueSpecification->validate($value);

            $map->values[$key] = $value;
        }

        $map->rewind();

        return $map;
    }

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

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

        $map = clone $this;
        $map->values = clone $this->values;
        $map->values->detach($key);
        $map->rewind();

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function merge(MapInterface $map): MapInterface
    {
        if (
            !$this->keyType()->equals($map->keyType()) ||
            !$this->valueType()->equals($map->valueType())
        ) {
            throw new InvalidArgumentException(
                'The 2 maps does not reference the same types'
            );
        }

        return $map->reduce(
            $this,
            function(self $carry, $key, $value): self {
                return $carry->put($key, $value);
            }
        );
    }

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

        foreach ($this->values as $k) {
            $v = $this->values[$k];

            $return = $predicate($k, $v);

            if ($return === true) {
                $truthy->values[$k] = $v;
            } else {
                $falsy->values[$k] = $v;
            }
        }

        $truthy->rewind();
        $falsy->rewind();

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

    /**
     * {@inheritdoc}
     */
    public function reduce($carry, callable $reducer)
    {
        foreach ($this->values as $k) {
            $v = $this->values[$k];

            $carry = $reducer($carry, $k, $v);
        }

        return $carry;
    }

    public function empty(): bool
    {
        $this->rewind();

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


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

Innmind / Immutable

GitHub Access Token became invalid

Push — develop ( 467194...701f25 )

ObjectKeys::empty() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like