vendor/doctrine/collections/src/AbstractLazyCollection.php line 240

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\Common\Collections;
  7. use Closure;
  8. use LogicException;
  9. use ReturnTypeWillChange;
  10. use Traversable;
  12. /**
  13.  * Lazy collection that is backed by a concrete collection
  14.  *
  15.  * @psalm-template TKey of array-key
  16.  * @psalm-template T
  17.  * @template-implements Collection<TKey,T>
  18.  */
  19. abstract class AbstractLazyCollection implements Collection
  20. {
  21.     /**
  22.      * The backed collection to use
  23.      *
  24.      * @psalm-var Collection<TKey,T>|null
  25.      * @var Collection<mixed>|null
  26.      */
  27.     protected Collection|null $collection;
  29.     protected bool $initialized = false;
  31.     /**
  32.      * {@inheritDoc}
  33.      *
  34.      * @return int
  35.      */
  36.     #[ReturnTypeWillChange]
  37.     public function count()
  38.     {
  39.         $this->initialize();
  41.         return $this->collection->count();
  42.     }
  44.     /**
  45.      * {@inheritDoc}
  46.      */
  47.     public function add(mixed $element)
  48.     {
  49.         $this->initialize();
  51.         $this->collection->add($element);
  52.     }
  54.     /**
  55.      * {@inheritDoc}
  56.      */
  57.     public function clear()
  58.     {
  59.         $this->initialize();
  60.         $this->collection->clear();
  61.     }
  63.     /**
  64.      * {@inheritDoc}
  65.      *
  66.      * @template TMaybeContained
  67.      */
  68.     public function contains(mixed $element)
  69.     {
  70.         $this->initialize();
  72.         return $this->collection->contains($element);
  73.     }
  75.     /**
  76.      * {@inheritDoc}
  77.      */
  78.     public function isEmpty()
  79.     {
  80.         $this->initialize();
  82.         return $this->collection->isEmpty();
  83.     }
  85.     /**
  86.      * {@inheritDoc}
  87.      */
  88.     public function remove(string|int $key)
  89.     {
  90.         $this->initialize();
  92.         return $this->collection->remove($key);
  93.     }
  95.     /**
  96.      * {@inheritDoc}
  97.      */
  98.     public function removeElement(mixed $element)
  99.     {
  100.         $this->initialize();
  102.         return $this->collection->removeElement($element);
  103.     }
  105.     /**
  106.      * {@inheritDoc}
  107.      */
  108.     public function containsKey(string|int $key)
  109.     {
  110.         $this->initialize();
  112.         return $this->collection->containsKey($key);
  113.     }
  115.     /**
  116.      * {@inheritDoc}
  117.      */
  118.     public function get(string|int $key)
  119.     {
  120.         $this->initialize();
  122.         return $this->collection->get($key);
  123.     }
  125.     /**
  126.      * {@inheritDoc}
  127.      */
  128.     public function getKeys()
  129.     {
  130.         $this->initialize();
  132.         return $this->collection->getKeys();
  133.     }
  135.     /**
  136.      * {@inheritDoc}
  137.      */
  138.     public function getValues()
  139.     {
  140.         $this->initialize();
  142.         return $this->collection->getValues();
  143.     }
  145.     /**
  146.      * {@inheritDoc}
  147.      */
  148.     public function set(string|int $key, mixed $value)
  149.     {
  150.         $this->initialize();
  151.         $this->collection->set($key, $value);
  152.     }
  154.     /**
  155.      * {@inheritDoc}
  156.      */
  157.     public function toArray()
  158.     {
  159.         $this->initialize();
  161.         return $this->collection->toArray();
  162.     }
  164.     /**
  165.      * {@inheritDoc}
  166.      */
  167.     public function first()
  168.     {
  169.         $this->initialize();
  171.         return $this->collection->first();
  172.     }
  174.     /**
  175.      * {@inheritDoc}
  176.      */
  177.     public function last()
  178.     {
  179.         $this->initialize();
  181.         return $this->collection->last();
  182.     }
  184.     /**
  185.      * {@inheritDoc}
  186.      */
  187.     public function key()
  188.     {
  189.         $this->initialize();
  191.         return $this->collection->key();
  192.     }
  194.     /**
  195.      * {@inheritDoc}
  196.      */
  197.     public function current()
  198.     {
  199.         $this->initialize();
  201.         return $this->collection->current();
  202.     }
  204.     /**
  205.      * {@inheritDoc}
  206.      */
  207.     public function next()
  208.     {
  209.         $this->initialize();
  211.         return $this->collection->next();
  212.     }
  214.     /**
  215.      * {@inheritDoc}
  216.      */
  217.     public function exists(Closure $p)
  218.     {
  219.         $this->initialize();
  221.         return $this->collection->exists($p);
  222.     }
  224.     /**
  225.      * {@inheritDoc}
  226.      */
  227.     public function findFirst(Closure $p)
  228.     {
  229.         $this->initialize();
  231.         return $this->collection->findFirst($p);
  232.     }
  234.     /**
  235.      * @psalm-param Closure(T, TKey):bool $p
  236.      *
  237.      * @return ReadableCollection<mixed>
  238.      * @psalm-return ReadableCollection<TKey, T>
  239.      */
  240.     public function filter(Closure $p)
  241.     {
  242.         $this->initialize();
  244.         return $this->collection->filter($p);
  245.     }
  247.     /**
  248.      * {@inheritDoc}
  249.      */
  250.     public function forAll(Closure $p)
  251.     {
  252.         $this->initialize();
  254.         return $this->collection->forAll($p);
  255.     }
  257.     /**
  258.      * {@inheritDoc}
  259.      *
  260.      * @psalm-param Closure(T):U $func
  261.      *
  262.      * @return ReadableCollection<mixed>
  263.      * @psalm-return ReadableCollection<TKey, U>
  264.      *
  265.      * @psalm-template U
  266.      */
  267.     public function map(Closure $func)
  268.     {
  269.         $this->initialize();
  271.         return $this->collection->map($func);
  272.     }
  274.     /**
  275.      * {@inheritDoc}
  276.      */
  277.     public function reduce(Closure $func, mixed $initial = null)
  278.     {
  279.         $this->initialize();
  281.         return $this->collection->reduce($func, $initial);
  282.     }
  284.     /**
  285.      * {@inheritDoc}
  286.      */
  287.     public function partition(Closure $p)
  288.     {
  289.         $this->initialize();
  291.         return $this->collection->partition($p);
  292.     }
  294.     /**
  295.      * {@inheritDoc}
  296.      *
  297.      * @template TMaybeContained
  298.      */
  299.     public function indexOf(mixed $element)
  300.     {
  301.         $this->initialize();
  303.         return $this->collection->indexOf($element);
  304.     }
  306.     /**
  307.      * {@inheritDoc}
  308.      */
  309.     public function slice(int $offset, int|null $length = null)
  310.     {
  311.         $this->initialize();
  313.         return $this->collection->slice($offset, $length);
  314.     }
  316.     /**
  317.      * {@inheritDoc}
  318.      *
  319.      * @return Traversable<int|string, mixed>
  320.      * @psalm-return Traversable<TKey,T>
  321.      */
  322.     #[ReturnTypeWillChange]
  323.     public function getIterator()
  324.     {
  325.         $this->initialize();
  327.         return $this->collection->getIterator();
  328.     }
  330.     /**
  331.      * {@inheritDoc}
  332.      *
  333.      * @param TKey $offset
  334.      *
  335.      * @return bool
  336.      */
  337.     #[ReturnTypeWillChange]
  338.     public function offsetExists(mixed $offset)
  339.     {
  340.         $this->initialize();
  342.         return $this->collection->offsetExists($offset);
  343.     }
  345.     /**
  346.      * {@inheritDoc}
  347.      *
  348.      * @param TKey $offset
  349.      *
  350.      * @return T|null
  351.      */
  352.     #[ReturnTypeWillChange]
  353.     public function offsetGet(mixed $offset)
  354.     {
  355.         $this->initialize();
  357.         return $this->collection->offsetGet($offset);
  358.     }
  360.     /**
  361.      * {@inheritDoc}
  362.      *
  363.      * @param TKey|null $offset
  364.      * @param T         $value
  365.      *
  366.      * @return void
  367.      */
  368.     #[ReturnTypeWillChange]
  369.     public function offsetSet(mixed $offset, mixed $value)
  370.     {
  371.         $this->initialize();
  372.         $this->collection->offsetSet($offset, $value);
  373.     }
  375.     /**
  376.      * @param TKey $offset
  377.      *
  378.      * @return void
  379.      */
  380.     #[ReturnTypeWillChange]
  381.     public function offsetUnset(mixed $offset)
  382.     {
  383.         $this->initialize();
  384.         $this->collection->offsetUnset($offset);
  385.     }
  387.     /**
  388.      * Is the lazy collection already initialized?
  389.      *
  390.      * @return bool
  391.      *
  392.      * @psalm-assert-if-true Collection<TKey,T> $this->collection
  393.      */
  394.     public function isInitialized()
  395.     {
  396.         return $this->initialized;
  397.     }
  399.     /**
  400.      * Initialize the collection
  401.      *
  402.      * @return void
  403.      *
  404.      * @psalm-assert Collection<TKey,T> $this->collection
  405.      */
  406.     protected function initialize()
  407.     {
  408.         if ($this->initialized) {
  409.             return;
  410.         }
  412.         $this->doInitialize();
  413.         $this->initialized = true;
  415.         if ($this->collection === null) {
  416.             throw new LogicException('You must initialize the collection property in the doInitialize() method.');
  417.         }
  418.     }
  420.     /**
  421.      * Do the initialization logic
  422.      *
  423.      * @return void
  424.      */
  425.     abstract protected function doInitialize();
  426. }