Final Class Yiisoft\Cookies\CookieCollection

                public function __construct(array $cookies = [])
{
    foreach ($cookies as $cookie) {
        if (!($cookie instanceof Cookie)) {
            throw new InvalidArgumentException('CookieCollection can contain only Cookie instances.');
        }
        $this->cookies[$cookie->getName()] = $cookie;
    }
}

            

                public function add(Cookie $cookie): void
{
    $this->cookies[$cookie->getName()] = $cookie;
}

            

                public function addToResponse(ResponseInterface $response): ResponseInterface
{
    foreach ($this->cookies as $cookie) {
        $response = $cookie->addToResponse($response);
    }
    return $response;
}

            

                public function clear(): void
{
    $this->cookies = [];
}

            

                public function contains(Cookie $cookie): bool
{
    return in_array($cookie, $this->cookies, true);
}

            

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

            

                public function exists(callable $p): bool
{
    foreach ($this->cookies as $name => $cookie) {
        if ($p($cookie, $name)) {
            return true;
        }
    }
    return false;
}

            

                public function expire(string $name): void
{
    if (!isset($this->cookies[$name])) {
        return;
    }
    $this->cookies[$name] = $this->cookies[$name]->expire();
}

            

                public static function fromArray(array $array): self
{
    if (empty($array)) {
        return new self();
    }
    // Check if associative array with 'name' => 'value' pairs is passed.
    if (count(array_filter(array_keys($array), 'is_string')) !== count($array)) {
        throw new InvalidArgumentException('Invalid array format. It must be "name" => "value" pairs.');
    }
    /** @psalm-var array<string,string> $array */
    return new self(array_map(
        static fn (string $name, string $value) => new Cookie($name, $value),
        array_keys($array),
        $array
    ));
}

            

                public static function fromResponse(ResponseInterface $response): self
{
    $collection = new self();
    foreach ($response->getHeader(Header::SET_COOKIE) as $setCookieString) {
        $cookie = Cookie::fromCookieString($setCookieString);
        $collection->add($cookie);
    }
    return $collection;
}

            

                public function get(string $name): ?Cookie
{
    return $this->cookies[$name] ?? null;
}

            

                public function getIterator(): ArrayIterator
{
    return new ArrayIterator($this->cookies);
}

            

                public function getKeys(): array
{
    return array_keys($this->cookies);
}

            

                public function getValue(string $name, ?string $defaultValue = null): ?string
{
    return isset($this->cookies[$name]) ? $this->cookies[$name]->getValue() : $defaultValue;
}

            

                public function getValues(): array
{
    return array_values($this->cookies);
}

            

                public function has(string $name): bool
{
    return isset($this->cookies[$name]);
}

            

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

            

                public function offsetExists($name): bool
{
    return $this->has($name);
}

            

                public function offsetGet($name): ?Cookie
{
    return $this->get($name);
}

            

                public function offsetSet($name, $cookie): void
{
    $this->add($cookie);
}

            

                public function offsetUnset($name): void
{
    $this->remove($name);
}

            

                public function remove(string $name): ?Cookie
{
    if (!isset($this->cookies[$name])) {
        return null;
    }
    $removed = $this->cookies[$name];
    unset($this->cookies[$name]);
    return $removed;
}

            

                public function setToResponse(ResponseInterface $response): ResponseInterface
{
    $response = $response->withoutHeader(Header::SET_COOKIE);
    return $this->addToResponse($response);
}

            

                public function toArray(): array
{
    return $this->cookies;
}

            

                public function walk(callable $callback): void
{
    /** @psalm-suppress MixedPropertyTypeCoercion */
    array_walk($this->cookies, $callback);
}