Innmind\Immutable\Map\Uninitialized

Complexity

Total Complexity

21

Size/Duplication

Total Lines	200
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	size()	0	3	1
A	partition()	0	5	1
A	equals()	0	3	1
A	get()	0	3	1
A	foreach()	0	3	1
A	keys()	0	4	1
A	__invoke()	0	3	1
A	clearMap()	0	3	1
A	remove()	0	3	1
A	merge()	0	3	1
A	groupBy()	0	4	1
A	map()	0	3	1
A	count()	0	3	1
A	find()	0	4	1
A	empty()	0	3	1
A	filter()	0	3	1
A	open()	0	7	1
A	contains()	0	3	1
A	reduce()	0	3	1
A	values()	0	4	1
A	clear()	0	3	1

<?php
declare(strict_types = 1);

namespace Innmind\Immutable\Map;

use Innmind\Immutable\{
    Map,
    Sequence,
    Set,
    Pair,
    Maybe,
    SideEffect,
};

/**
 * @template T
 * @template S
 * @psalm-immutable
 */
final class Uninitialized implements Implementation
{
    /**
     * @param T $key

The type Innmind\Immutable\Map\T was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param S $value

The type Innmind\Immutable\Map\S was not found. Maybe you did not declare it correctly or list all dependencies?

     *
     * @return Implementation<T, S>
     */
    public function __invoke($key, $value): Implementation
    {
        return self::open($key, $value);
    }

    /**
     * @template A
     * @template B
     * @psalm-pure
     *
     * @param A $key

The type Innmind\Immutable\Map\A was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param B $value

The type Innmind\Immutable\Map\B was not found. Maybe you did not declare it correctly or list all dependencies?

     *
     * @return Implementation<A, B>
     */
    public static function open($key, $value): Implementation
    {
        return ObjectKeys::of($key, $value)
            ->otherwise(static fn() => Primitive::of($key, $value))
            ->match(
                static fn($implementation) => $implementation,
                static fn() => DoubleIndex::of($key, $value),
            );
    }

    public function size(): int
    {
        return 0;
    }

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

    /**
     * @param T $key
     *
     * @return Maybe<S>
     */
    public function get($key): Maybe
    {
        return Maybe::nothing();
    }

    /**
     * @param T $key
     */
    public function contains($key): bool
    {
        return false;
    }

    /**
     * @return self<T, S>
     */
    public function clear(): self
    {
        return $this;
    }

    /**
     * @param Implementation<T, S> $map
     */
    public function equals(Implementation $map): bool
    {
        return $map->empty();
    }

    /**
     * @param callable(T, S): bool $predicate
     *
     * @return self<T, S>
     */
    public function filter(callable $predicate): self
    {
        return $this;
    }

    /**
     * @param callable(T, S): void $function
     */
    public function foreach(callable $function): SideEffect
    {
        return new SideEffect;
    }

    /**
     * @template D
     *
     * @param callable(T, S): D $discriminator
     *
     * @return Map<D, Map<T, S>>
     */
    public function groupBy(callable $discriminator): Map
    {
        /** @var Map<D, Map<T, S>> */
        return Map::of();
    }

    /**
     * @return Set<T>
     */
    public function keys(): Set
    {
        /** @var Set<T> */
        return Set::of();
    }

    /**
     * @return Sequence<S>
     */
    public function values(): Sequence
    {
        /** @var Sequence<S> */
        return Sequence::of();
    }

    /**
     * @template B
     *
     * @param callable(T, S): B $function
     *
     * @return self<T, B>
     */
    public function map(callable $function): self
    {
        return new self;
    }

    /**
     * @param T $key
     *
     * @return self<T, S>
     */
    public function remove($key): self
    {
        return $this;
    }

    /**
     * @param Implementation<T, S> $map
     *
     * @return Implementation<T, S>
     */
    public function merge(Implementation $map): Implementation
    {
        return $map;
    }

    /**
     * @param callable(T, S): bool $predicate
     *
     * @return Map<bool, Map<T, S>>
     */
    public function partition(callable $predicate): Map
    {
        return Map::of(
            [true, $this->clearMap()],
            [false, $this->clearMap()],
        );
    }

    /**
     * @template R
     * @param R $carry

The type Innmind\Immutable\Map\R was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param callable(R, T, S): R $reducer
     *
     * @return R
     */
    public function reduce($carry, callable $reducer)
    {
        return $carry;
    }

    public function empty(): bool
    {
        return true;
    }

    public function find(callable $predicate): Maybe
    {
        /** @var Maybe<Pair<T, S>> */
        return Maybe::nothing();
    }

    /**
     * @return Map<T, S>
     */
    private function clearMap(): Map
    {
        return Map::of();
    }
}