Pool::openIterator() - Code Metrics - cycle/orm - Measure and Improve Code Quality continuously with Scrutinizer

Pool::openIterator() F
last analyzed 2025-05-04 11:19 UTC

↳ Parent: Pool

Complexity

Conditions	29
Paths	1099

Size

Total Lines	101
Code Lines	63

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	44
CRAP Score	32.0596

Importance

Changes

Metric	Value
cc	29
eloc	63
nc	1099
nop	0
dl	0
loc	101
ccs	44
cts	52
cp	0.8462
crap	32.0596
rs	0
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace Cycle\ORM\Transaction;

use Cycle\ORM\Exception\PoolException;
use Cycle\ORM\Heap\Node;
use Cycle\ORM\Heap\State;
use Cycle\ORM\ORMInterface;
use Cycle\ORM\Reference\ReferenceInterface;
use JetBrains\PhpStorm\ExpectedValues;

/**
 * @internal
 *
 * @psalm-suppress TypeDoesNotContainType
 * @psalm-suppress RedundantCondition
 */
final class Pool implements \Countable
{
    private TupleStorage $storage;
    private TupleStorage $all;
    private TupleStorage $priorityStorage;

    /**
     * @var Tuple[]
     *
     * @psalm-var list<Tuple>
     */
    private array $unprocessed;

    private bool $priorityEnabled = false;
    private bool $priorityAutoAttach = false;
    private int $happens = 0;

    /**
     * Indicates that Pool is now iterating
     */
    private bool $iterating = false;

    public function __construct(
        private ORMInterface $orm,
    ) {
        $this->storage = new TupleStorage();
        $this->all = new TupleStorage();
    }

    public function someHappens(): void
    {
        ++$this->happens;
    }

    public function attach(
        object $entity,
        #[ExpectedValues(values: [Tuple::TASK_STORE, Tuple::TASK_DELETE, Tuple::TASK_FORCE_DELETE])]
        int $task,
        bool $cascade,
        ?Node $node = null,
        ?State $state = null,
        ?int $status = null,
        bool $highPriority = false,
        bool $persist = false,
    ): Tuple {
        // Find existing
        $tuple = $this->offsetGet($entity);
        if ($tuple !== null) {
            $this->updateTuple($tuple, $task, $status, $cascade, $node, $state);
            if ($persist) {
                $this->snap($tuple, true);
            }
            return $tuple;
        }

        $tuple = new Tuple($task, $entity, $cascade, $status ?? Tuple::STATUS_PREPARING);
        if ($node !== null) {
            $tuple->node = $node;
        }
        if ($state !== null) {
            $tuple->state = $state;
        }

        return $this->smartAttachTuple($tuple, $highPriority, $persist);
    }

    public function attachStore(
        object $entity,
        bool $cascade,
        ?Node $node = null,
        ?State $state = null,
        bool $highPriority = false,
        bool $persist = false,
    ): Tuple {
        return $this->attach($entity, Tuple::TASK_STORE, $cascade, $node, $state, null, $highPriority, $persist);
    }

    public function attachDelete(
        object $entity,
        bool $cascade,
        ?Node $node = null,
        ?State $state = null,
    ): Tuple {
        return $this->attach($entity, Tuple::TASK_DELETE, $cascade, $node, $state);
    }

    public function offsetGet(object $entity): ?Tuple
    {
        return $this->all->contains($entity) ? $this->all->getTuple($entity) : null;
    }

    /**
     * Smart iterator
     *
     * @return \Traversable<object, Tuple>
     */
    public function openIterator(): \Traversable
    {
        if ($this->iterating) {
            throw new \RuntimeException('Iterator is already open.');
        }
        $this->iterating = true;
        $this->activatePriorityStorage();
        $this->unprocessed = [];

        // Snap all entities before store
        /** @var object $entity */
        foreach ($this->storage as $entity => $tuple) {
            $this->snap($tuple);
            if (!isset($tuple->node)) {
                $this->storage->detach($entity);
            }
        }

        $stage = 0;
        do {
            // High priority first
            if ($this->priorityStorage->count() > 0) {
                $priorityStorage = $this->priorityStorage;
                foreach ($priorityStorage as $entity => $tuple) {
                    yield $entity => $tuple;
                    $this->trashIt($entity, $tuple, $priorityStorage);
                }
                continue;
            }
            // Other
            if ($this->storage->count() === 0) {
                break;
            }
            $pool = $this->storage;
            if ($stage === 0) {
                foreach ($this->storage as $entity => $tuple) {
                    if ($tuple->status !== Tuple::STATUS_PREPARING) {
                        continue;
                    }

                    yield $entity => $tuple;
                    $this->trashIt($entity, $tuple, $pool);
                    // Check priority
                    if ($this->priorityStorage->count() > 0) {
                        continue 2;
                    }
                }
                $this->priorityAutoAttach = true;
                $stage = 1;
            }
            if ($stage === 1) {
                /** @var object $entity */
                foreach ($this->storage as $entity => $tuple) {
                    if ($tuple->status !== Tuple::STATUS_WAITING || $tuple->task === Tuple::TASK_DELETE) {
                        continue;
                    }

                    $tuple->status = Tuple::STATUS_WAITED;
                    yield $entity => $tuple;
                    $this->trashIt($entity, $tuple, $this->storage);
                    // Check priority
                    if ($this->priorityStorage->count() > 0) {
                        continue 2;
                    }
                }
                $stage = 2;
            }
            if ($stage === 2) {
                $this->happens = 0;
                /** @var object $entity */
                foreach ($this->storage as $entity => $tuple) {
                    if ($tuple->task === Tuple::TASK_DELETE) {
                        $tuple->task = Tuple::TASK_FORCE_DELETE;
                    }
                    if ($tuple->status === Tuple::STATUS_WAITING) {
                        $tuple->status = Tuple::STATUS_WAITED;
                    } elseif ($tuple->status === Tuple::STATUS_DEFERRED) {
                        $tuple->status = Tuple::STATUS_PROPOSED;
                    }
                    yield $entity => $tuple;
                    $this->trashIt($entity, $tuple, $this->storage);
                    // Check priority
                    if ($this->priorityStorage->count() > 0) {
                        continue 2;
                    }
                }
                $hasUnresolved = $this->unprocessed !== [];
                if ($this->happens !== 0 && $hasUnresolved) {
                    /** @psalm-suppress InvalidIterator */
                    foreach ($this->unprocessed as $item) {
                        $this->storage->attach($item);
                    }
                    $this->unprocessed = [];
                    continue;
                }
                if ($this->happens === 0 && (\count($pool) > 0 || $hasUnresolved)) {
                    throw new PoolException('Pool has gone into an infinite loop.');
                }
            }
        } while (true);
        $this->closeIterator();
    }

    public function count(): int
    {
        return \count($this->storage) + ($this->priorityEnabled ? $this->priorityStorage->count() : 0);
    }

    /**
     * Get unresolved entity tuples.
     *
     * @return iterable<Tuple>
     */
    public function getUnresolved(): iterable
    {
        if ($this->iterating) {
            return $this->unprocessed;
        }
        throw new PoolException('The Pool iterator isn\'t open.');
    }

    /**
     * @return iterable<object, Tuple> All valid tuples
     */
    public function getAllTuples(): iterable
    {
        foreach ($this->all as $entity => $tuple) {
            if (isset($tuple->node)) {
                yield $entity => $tuple;
            }
        }
    }

    /**
     * Close opened iterator
     */
    public function closeIterator(): void
    {
        $this->iterating = false;
        $this->priorityEnabled = false;
        $this->priorityAutoAttach = false;
        unset($this->priorityStorage, $this->unprocessed);
    }

    private function smartAttachTuple(Tuple $tuple, bool $highPriority = false, bool $snap = false): Tuple
    {
        if ($tuple->status === Tuple::STATUS_PROCESSED) {
            $this->all->attach($tuple);
            return $tuple;
        }
        if ($tuple->status === Tuple::STATUS_PREPARING && $this->all->contains($tuple->entity)) {
            return $this->all->getTuple($tuple->entity);
        }
        $this->all->attach($tuple);

        if ($this->iterating || $snap) {
            $this->snap($tuple);
        }

        if (isset($tuple->node) && $tuple->task === Tuple::TASK_DELETE) {
            $tuple->state->setStatus(Node::SCHEDULED_DELETE);
        }
        if (($this->priorityAutoAttach || $highPriority) && $tuple->status === Tuple::STATUS_PREPARING) {
            $this->priorityStorage->attach($tuple);
        } else {
            $this->storage->attach($tuple);
        }
        return $tuple;
    }

    /**
     * Make snapshot: create Node, State if not exists. Also attach Mapper
     */
    private function snap(Tuple $tuple, bool $forceUpdateState = false): void
    {
        $entity = $tuple->entity;
        /** @var Node|null $node */
        $node = $tuple->node ?? $this->orm->getHeap()->get($entity);

        if (($node === null && $tuple->task !== Tuple::TASK_STORE) || $entity instanceof ReferenceInterface) {
            return;
        }
        $tuple->mapper ??= $this->orm->getMapper($node?->getRole() ?? $entity);
        if ($node === null) {
            // Create new Node
            $node = new Node(Node::NEW, [], $tuple->mapper->getRole());
            if (isset($tuple->state)) {
                $tuple->state->setData($tuple->mapper->fetchFields($entity));
                $node->setState($tuple->state);
            }
            $this->orm->getHeap()->attach($entity, $node);
        }
        $tuple->node = $node;
        if (!isset($tuple->state)) {
            $tuple->state = $tuple->node->createState();
            $tuple->state->setData($tuple->mapper->fetchFields($entity));
        } elseif ($forceUpdateState) {
            $tuple->state->setData($tuple->mapper->fetchFields($entity));
        }

        // Backup State
        if (!$this->iterating) {
            $tuple->persist = clone $tuple->state;
        }
    }

    private function trashIt(object $entity, Tuple $tuple, TupleStorage $storage): void
    {
        if ($tuple->status === Tuple::STATUS_UNPROCESSED) {
            $storage->detach($entity);
            $tuple->status = Tuple::STATUS_PREPROCESSED;
            $this->unprocessed[] = $tuple;
            return;
        }

        if ($tuple->status >= Tuple::STATUS_PREPROCESSED) {
            $storage->detach($entity);
            $tuple->status = Tuple::STATUS_PROCESSED;
            ++$this->happens;
            return;
        }

        if ($tuple->status % 2 === 0) {
            ++$tuple->status;
            ++$this->happens;
        }

        if ($storage !== $this->storage) {
            $storage->detach($entity);
            $this->storage->attach($tuple);
        }
    }

    private function activatePriorityStorage(): void
    {
        if ($this->priorityEnabled === true) {
            return;
        }
        $this->priorityEnabled = true;
        $this->priorityStorage = new TupleStorage();
    }

    private function updateTuple(Tuple $tuple, int $task, ?int $status, bool $cascade, ?Node $node, ?State $state): void
    {
        if ($status !== null && $tuple->status !== $status) {
            if ($status === Tuple::STATUS_PROCESSED) {
                $this->storage->detach($tuple->entity);
                return;
            }
            if ($tuple->status === Tuple::STATUS_PREPARING) {
                $tuple->status = $status;
            }
        }
        if ($tuple->task !== $task) {
            if ($tuple->task === Tuple::TASK_DELETE) {
                $tuple->task = $task;
            } elseif ($task === Tuple::TASK_FORCE_DELETE) {
                $tuple->task = $task;
            }
        }

        $tuple->cascade = $tuple->cascade || $cascade;
        $node === null or $tuple->node = $tuple->node ?? $node;
        $state === null or $tuple->state = $tuple->state ?? $state;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Cycle\ORM\Transaction;
6
7		use Cycle\ORM\Exception\PoolException;
8		use Cycle\ORM\Heap\Node;
9		use Cycle\ORM\Heap\State;
10		use Cycle\ORM\ORMInterface;
11		use Cycle\ORM\Reference\ReferenceInterface;
12		use JetBrains\PhpStorm\ExpectedValues;
13
14		/**
15		* @internal
16		*
17		* @psalm-suppress TypeDoesNotContainType
18		* @psalm-suppress RedundantCondition
19		*/
20		final class Pool implements \Countable
21		{
22		private TupleStorage $storage;
23		private TupleStorage $all;
24		private TupleStorage $priorityStorage;
25
26		/**
27		* @var Tuple[]
28		*
29		* @psalm-var list<Tuple>
30		*/
31		private array $unprocessed;
32
33		private bool $priorityEnabled = false;
34		private bool $priorityAutoAttach = false;
35		private int $happens = 0;
36
37		/**
38		* Indicates that Pool is now iterating
39		*/
40		private bool $iterating = false;
41
42		public function __construct(
43		private ORMInterface $orm,
44		) {
45		$this->storage = new TupleStorage();
46		$this->all = new TupleStorage();
47	2918	}
48
49		public function someHappens(): void
50	2918	{
51	2918	++$this->happens;
52		}
53
54	2564	public function attach(
55		object $entity,
56	2564	#[ExpectedValues(values: [Tuple::TASK_STORE, Tuple::TASK_DELETE, Tuple::TASK_FORCE_DELETE])]
57		int $task,
58		bool $cascade,
59	2918	?Node $node = null,
60		?State $state = null,
61		?int $status = null,
62		bool $highPriority = false,
63		bool $persist = false,
64		): Tuple {
65		// Find existing
66		$tuple = $this->offsetGet($entity);
67		if ($tuple !== null) {
68		$this->updateTuple($tuple, $task, $status, $cascade, $node, $state);
69		if ($persist) {
70		$this->snap($tuple, true);
71	2918	}
72	2918	return $tuple;
73	650	}
74	650
75		$tuple = new Tuple($task, $entity, $cascade, $status ?? Tuple::STATUS_PREPARING);
76		if ($node !== null) {
77	650	$tuple->node = $node;
78		}
79		if ($state !== null) {
80	2918	$tuple->state = $state;
81	2918	}
82
83		return $this->smartAttachTuple($tuple, $highPriority, $persist);
84	2918	}
85
86		public function attachStore(
87		object $entity,
88	2918	bool $cascade,
89		?Node $node = null,
90		?State $state = null,
91	2918	bool $highPriority = false,
92		bool $persist = false,
93	2918	): Tuple {
94		return $this->attach($entity, Tuple::TASK_STORE, $cascade, $node, $state, null, $highPriority, $persist);
95		}
96
97	2918	public function attachDelete(
98		object $entity,
99		bool $cascade,
100	2918	?Node $node = null,
101		?State $state = null,
102	2918	): Tuple {
103	1884	return $this->attach($entity, Tuple::TASK_DELETE, $cascade, $node, $state);
104		}
105
106	2918	public function offsetGet(object $entity): ?Tuple
107	496	{
108		return $this->all->contains($entity) ? $this->all->getTuple($entity) : null;
109	2918	}
110
111		/**
112	2918	* Smart iterator
113		*
114	2918	* @return \Traversable<object, Tuple>
115		*/
116		public function openIterator(): \Traversable
117	2812	{
118		if ($this->iterating) {
119		throw new \RuntimeException('Iterator is already open.');
120		}
121		$this->iterating = true;
122		$this->activatePriorityStorage();
123		$this->unprocessed = [];
124
125	2812	// Snap all entities before store
126		/** @var object $entity */
127		foreach ($this->storage as $entity => $tuple) {
128	496	$this->snap($tuple);
129		if (!isset($tuple->node)) {
130		$this->storage->detach($entity);
131		}
132		}
133
134	496	$stage = 0;
135		do {
136		// High priority first
137	2918	if ($this->priorityStorage->count() > 0) {
138		$priorityStorage = $this->priorityStorage;
139	2918	foreach ($priorityStorage as $entity => $tuple) {
140		yield $entity => $tuple;
141		$this->trashIt($entity, $tuple, $priorityStorage);
142		}
143		continue;
144		}
145		// Other
146		if ($this->storage->count() === 0) {
147	2916	break;
148		}
149	2916	$pool = $this->storage;
150		if ($stage === 0) {
151		foreach ($this->storage as $entity => $tuple) {
152	2916	if ($tuple->status !== Tuple::STATUS_PREPARING) {
153	2916	continue;
154	2916	}
155
156		yield $entity => $tuple;
157	2916	$this->trashIt($entity, $tuple, $pool);
158		// Check priority
159	2900	if ($this->priorityStorage->count() > 0) {
160	2900	continue 2;
161	2900	}
162	80	}
163		$this->priorityAutoAttach = true;
164	2900	$stage = 1;
165		}
166		if ($stage === 1) {
167		/** @var object $entity */
168	2916	foreach ($this->storage as $entity => $tuple) {
169		if ($tuple->status !== Tuple::STATUS_WAITING \|\| $tuple->task === Tuple::TASK_DELETE) {
170		continue;
171	2916	}
172
173		$tuple->status = Tuple::STATUS_WAITED;
174		yield $entity => $tuple;
175		$this->trashIt($entity, $tuple, $this->storage);
176		// Check priority
177		if ($this->priorityStorage->count() > 0) {
178		continue 2;
179		}
180		}
181	2916	$stage = 2;
182	2804	}
183		if ($stage === 2) {
184	2900	$this->happens = 0;
185	2900	/** @var object $entity */
186	2900	foreach ($this->storage as $entity => $tuple) {
187		if ($tuple->task === Tuple::TASK_DELETE) {
188	2900	$tuple->task = Tuple::TASK_FORCE_DELETE;
189		}
190	2900	if ($tuple->status === Tuple::STATUS_WAITING) {
191		$tuple->status = Tuple::STATUS_WAITED;
192	2900	} elseif ($tuple->status === Tuple::STATUS_DEFERRED) {
193	2900	$tuple->status = Tuple::STATUS_PROPOSED;
194	2900	}
195	2900	yield $entity => $tuple;
196	1808	$this->trashIt($entity, $tuple, $this->storage);
197		// Check priority
198	2900	if ($this->priorityStorage->count() > 0) {
199	2860	continue 2;
200		}
201	2860	}
202		$hasUnresolved = $this->unprocessed !== [];
203		if ($this->happens !== 0 && $hasUnresolved) {
204		/** @psalm-suppress InvalidIterator */
205	2852	foreach ($this->unprocessed as $item) {
206	2852	$this->storage->attach($item);
207	2852	}
208		$this->unprocessed = [];
209	2852	continue;
210	2852	}
211		if ($this->happens === 0 && (\count($pool) > 0 \|\| $hasUnresolved)) {
212	1824	throw new PoolException('Pool has gone into an infinite loop.');
213	1824	}
214	1824	}
215	1824	} while (true);
216	957	$this->closeIterator();
217		}
218	1364
219	1364	public function count(): int
220	1348	{
221		return \count($this->storage) + ($this->priorityEnabled ? $this->priorityStorage->count() : 0);
222	1348	}
223
224		/**
225		* Get unresolved entity tuples.
226	2852	*
227	2852	* @return iterable<Tuple>
228		*/
229	2852	public function getUnresolved(): iterable
230	2852	{
231	2852	if ($this->iterating) {
232		return $this->unprocessed;
233	957	}
234	957	throw new PoolException('The Pool iterator isn\'t open.');
235	957	}
236	328
237		/**
238	957	* @return iterable<object, Tuple> All valid tuples
239	371	*/
240	693	public function getAllTuples(): iterable
241	605	{
242		foreach ($this->all as $entity => $tuple) {
243	957	if (isset($tuple->node)) {
244	957	yield $entity => $tuple;
245	949	}
246		}
247	949	}
248
249		/**
250		* Close opened iterator
251	2812	*/
252	2812	public function closeIterator(): void
253		{
254	24	$this->iterating = false;
255	24	$this->priorityEnabled = false;
256		$this->priorityAutoAttach = false;
257	24	unset($this->priorityStorage, $this->unprocessed);
258	24	}
259
260	2812	private function smartAttachTuple(Tuple $tuple, bool $highPriority = false, bool $snap = false): Tuple
261	24	{
262		if ($tuple->status === Tuple::STATUS_PROCESSED) {
263		$this->all->attach($tuple);
264		return $tuple;
265	2804	}
266		if ($tuple->status === Tuple::STATUS_PREPARING && $this->all->contains($tuple->entity)) {
267		return $this->all->getTuple($tuple->entity);
268		}
269		$this->all->attach($tuple);
270
271		if ($this->iterating \|\| $snap) {
272		$this->snap($tuple);
273		}
274
275		if (isset($tuple->node) && $tuple->task === Tuple::TASK_DELETE) {
276		$tuple->state->setStatus(Node::SCHEDULED_DELETE);
277		}
278	24	if (($this->priorityAutoAttach \|\| $highPriority) && $tuple->status === Tuple::STATUS_PREPARING) {
279		$this->priorityStorage->attach($tuple);
280	24	} else {
281	24	$this->storage->attach($tuple);
282		}
283		return $tuple;
284		}
285
286		/**
287		* Make snapshot: create Node, State if not exists. Also attach Mapper
288		*/
289	2916	private function snap(Tuple $tuple, bool $forceUpdateState = false): void
290		{
291	2916	$entity = $tuple->entity;
292	2900	/** @var Node\|null $node */
293	2900	$node = $tuple->node ?? $this->orm->getHeap()->get($entity);
294	2900
295		if (($node === null && $tuple->task !== Tuple::TASK_STORE) \|\| $entity instanceof ReferenceInterface) {
296		return;
297		}
298		$tuple->mapper ??= $this->orm->getMapper($node?->getRole() ?? $entity);
299		if ($node === null) {
300		// Create new Node
301		$node = new Node(Node::NEW, [], $tuple->mapper->getRole());
302	2916	if (isset($tuple->state)) {
303		$tuple->state->setData($tuple->mapper->fetchFields($entity));
304	2916	$node->setState($tuple->state);
305	2916	}
306	2916	$this->orm->getHeap()->attach($entity, $node);
307	2916	}
308		$tuple->node = $node;
309		if (!isset($tuple->state)) {
310		$tuple->state = $tuple->node->createState();
311		$tuple->state->setData($tuple->mapper->fetchFields($entity));
312		} elseif ($forceUpdateState) {
313		$tuple->state->setData($tuple->mapper->fetchFields($entity));
314	2916	}
315
316	2916	// Backup State
317		if (!$this->iterating) {
318	2916	$tuple->persist = clone $tuple->state;
319		}
320	2916	}
321	80
322		private function trashIt(object $entity, Tuple $tuple, TupleStorage $storage): void
323	2916	{
324	2916	if ($tuple->status === Tuple::STATUS_UNPROCESSED) {
325		$storage->detach($entity);
326	1578	$tuple->status = Tuple::STATUS_PREPROCESSED;
327	1578	$this->unprocessed[] = $tuple;
328		return;
329		}
330
331	1578	if ($tuple->status >= Tuple::STATUS_PREPROCESSED) {
332		$storage->detach($entity);
333	2916	$tuple->status = Tuple::STATUS_PROCESSED;
334	2916	++$this->happens;
335	2916	return;
336	2916	}
337
338		if ($tuple->status % 2 === 0) {
339		++$tuple->status;
340	2916	++$this->happens;
341	80	}
342
343		if ($storage !== $this->storage) {
344		$storage->detach($entity);
345	2860	$this->storage->attach($tuple);
346		}
347	2860	}
348
349	2860	private function activatePriorityStorage(): void
350	24	{
351	24	if ($this->priorityEnabled === true) {
352	24	return;
353		}
354		$this->priorityEnabled = true;
355	2860	$this->priorityStorage = new TupleStorage();
356	2828	}
357	2828
358	2828	private function updateTuple(Tuple $tuple, int $task, ?int $status, bool $cascade, ?Node $node, ?State $state): void
359		{
360		if ($status !== null && $tuple->status !== $status) {
361	1824	if ($status === Tuple::STATUS_PROCESSED) {
362	1196	$this->storage->detach($tuple->entity);
363	1196	return;
364		}
365	1824	if ($tuple->status === Tuple::STATUS_PREPARING) {
366		$tuple->status = $status;
367		}
368	2916	}
369		if ($tuple->task !== $task) {
370	2916	if ($tuple->task === Tuple::TASK_DELETE) {
371		$tuple->task = $task;
372		} elseif ($task === Tuple::TASK_FORCE_DELETE) {
373	2916	$tuple->task = $task;
374	2916	}
375		}
376
377	650	$tuple->cascade = $tuple->cascade \|\| $cascade;
378		$node === null or $tuple->node = $tuple->node ?? $node;
379	650	$state === null or $tuple->state = $tuple->state ?? $state;
380		}
381		}
382

cycle / orm

Pool::openIterator() F last analyzed 2025-05-04 11:19 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

Pool::openIterator() F
last analyzed 2025-05-04 11:19 UTC