vendor/doctrine/collections/lib/Doctrine/Common/Collections/AbstractLazyCollection.php line 250

Open in your IDE?
  1. <?php
  3. namespace Doctrine\Common\Collections;
  5. use Closure;
  6. use LogicException;
  7. use ReturnTypeWillChange;
  8. use Traversable;
  10. /**
  11.  * Lazy collection that is backed by a concrete collection
  12.  *
  13.  * @psalm-template TKey of array-key
  14.  * @psalm-template T
  15.  * @template-implements Collection<TKey,T>
  16.  */
  17. abstract class AbstractLazyCollection implements Collection
  18. {
  19.     /**
  20.      * The backed collection to use
  21.      *
  22.      * @psalm-var Collection<TKey,T>|null
  23.      * @var Collection<mixed>|null
  24.      */
  25.     protected $collection;
  27.     /** @var bool */
  28.     protected $initialized = false;
  30.     /**
  31.      * {@inheritDoc}
  32.      *
  33.      * @return int
  34.      */
  35.     #[ReturnTypeWillChange]
  36.     public function count()
  37.     {
  38.         $this->initialize();
  40.         return $this->collection->count();
  41.     }
  43.     /**
  44.      * {@inheritDoc}
  45.      */
  46.     public function add($element)
  47.     {
  48.         $this->initialize();
  50.         return $this->collection->add($element);
  51.     }
  53.     /**
  54.      * {@inheritDoc}
  55.      */
  56.     public function clear()
  57.     {
  58.         $this->initialize();
  59.         $this->collection->clear();
  60.     }
  62.     /**
  63.      * {@inheritDoc}
  64.      *
  65.      * @template TMaybeContained
  66.      */
  67.     public function contains($element)
  68.     {
  69.         $this->initialize();
  71.         return $this->collection->contains($element);
  72.     }
  74.     /**
  75.      * {@inheritDoc}
  76.      */
  77.     public function isEmpty()
  78.     {
  79.         $this->initialize();
  81.         return $this->collection->isEmpty();
  82.     }
  84.     /**
  85.      * {@inheritDoc}
  86.      */
  87.     public function remove($key)
  88.     {
  89.         $this->initialize();
  91.         return $this->collection->remove($key);
  92.     }
  94.     /**
  95.      * {@inheritDoc}
  96.      */
  97.     public function removeElement($element)
  98.     {
  99.         $this->initialize();
  101.         return $this->collection->removeElement($element);
  102.     }
  104.     /**
  105.      * {@inheritDoc}
  106.      */
  107.     public function containsKey($key)
  108.     {
  109.         $this->initialize();
  111.         return $this->collection->containsKey($key);
  112.     }
  114.     /**
  115.      * {@inheritDoc}
  116.      */
  117.     public function get($key)
  118.     {
  119.         $this->initialize();
  121.         return $this->collection->get($key);
  122.     }
  124.     /**
  125.      * {@inheritDoc}
  126.      */
  127.     public function getKeys()
  128.     {
  129.         $this->initialize();
  131.         return $this->collection->getKeys();
  132.     }
  134.     /**
  135.      * {@inheritDoc}
  136.      */
  137.     public function getValues()
  138.     {
  139.         $this->initialize();
  141.         return $this->collection->getValues();
  142.     }
  144.     /**
  145.      * {@inheritDoc}
  146.      */
  147.     public function set($key, $value)
  148.     {
  149.         $this->initialize();
  150.         $this->collection->set($key, $value);
  151.     }
  153.     /**
  154.      * {@inheritDoc}
  155.      */
  156.     public function toArray()
  157.     {
  158.         $this->initialize();
  160.         return $this->collection->toArray();
  161.     }
  163.     /**
  164.      * {@inheritDoc}
  165.      */
  166.     public function first()
  167.     {
  168.         $this->initialize();
  170.         return $this->collection->first();
  171.     }
  173.     /**
  174.      * {@inheritDoc}
  175.      */
  176.     public function last()
  177.     {
  178.         $this->initialize();
  180.         return $this->collection->last();
  181.     }
  183.     /**
  184.      * {@inheritDoc}
  185.      */
  186.     public function key()
  187.     {
  188.         $this->initialize();
  190.         return $this->collection->key();
  191.     }
  193.     /**
  194.      * {@inheritDoc}
  195.      */
  196.     public function current()
  197.     {
  198.         $this->initialize();
  200.         return $this->collection->current();
  201.     }
  203.     /**
  204.      * {@inheritDoc}
  205.      */
  206.     public function next()
  207.     {
  208.         $this->initialize();
  210.         return $this->collection->next();
  211.     }
  213.     /**
  214.      * {@inheritDoc}
  215.      */
  216.     public function exists(Closure $p)
  217.     {
  218.         $this->initialize();
  220.         return $this->collection->exists($p);
  221.     }
  223.     /**
  224.      * {@inheritDoc}
  225.      */
  226.     public function filter(Closure $p)
  227.     {
  228.         $this->initialize();
  230.         return $this->collection->filter($p);
  231.     }
  233.     /**
  234.      * {@inheritDoc}
  235.      */
  236.     public function forAll(Closure $p)
  237.     {
  238.         $this->initialize();
  240.         return $this->collection->forAll($p);
  241.     }
  243.     /**
  244.      * {@inheritDoc}
  245.      */
  246.     public function map(Closure $func)
  247.     {
  248.         $this->initialize();
  250.         return $this->collection->map($func);
  251.     }
  253.     /**
  254.      * {@inheritDoc}
  255.      */
  256.     public function partition(Closure $p)
  257.     {
  258.         $this->initialize();
  260.         return $this->collection->partition($p);
  261.     }
  263.     /**
  264.      * {@inheritDoc}
  265.      *
  266.      * @template TMaybeContained
  267.      */
  268.     public function indexOf($element)
  269.     {
  270.         $this->initialize();
  272.         return $this->collection->indexOf($element);
  273.     }
  275.     /**
  276.      * {@inheritDoc}
  277.      */
  278.     public function slice($offset, $length = null)
  279.     {
  280.         $this->initialize();
  282.         return $this->collection->slice($offset, $length);
  283.     }
  285.     /**
  286.      * {@inheritDoc}
  287.      *
  288.      * @return Traversable<int|string, mixed>
  289.      * @psalm-return Traversable<TKey,T>
  290.      */
  291.     #[ReturnTypeWillChange]
  292.     public function getIterator()
  293.     {
  294.         $this->initialize();
  296.         return $this->collection->getIterator();
  297.     }
  299.     /**
  300.      * @param TKey $offset
  301.      *
  302.      * @return bool
  303.      */
  304.     #[ReturnTypeWillChange]
  305.     public function offsetExists($offset)
  306.     {
  307.         $this->initialize();
  309.         return $this->collection->offsetExists($offset);
  310.     }
  312.     /**
  313.      * @param TKey $offset
  314.      *
  315.      * @return mixed
  316.      */
  317.     #[ReturnTypeWillChange]
  318.     public function offsetGet($offset)
  319.     {
  320.         $this->initialize();
  322.         return $this->collection->offsetGet($offset);
  323.     }
  325.     /**
  326.      * @param TKey|null $offset
  327.      * @param T         $value
  328.      *
  329.      * @return void
  330.      */
  331.     #[ReturnTypeWillChange]
  332.     public function offsetSet($offset, $value)
  333.     {
  334.         $this->initialize();
  335.         $this->collection->offsetSet($offset, $value);
  336.     }
  338.     /**
  339.      * @param TKey $offset
  340.      *
  341.      * @return void
  342.      */
  343.     #[ReturnTypeWillChange]
  344.     public function offsetUnset($offset)
  345.     {
  346.         $this->initialize();
  347.         $this->collection->offsetUnset($offset);
  348.     }
  350.     /**
  351.      * Is the lazy collection already initialized?
  352.      *
  353.      * @return bool
  354.      *
  355.      * @psalm-assert-if-true Collection<TKey,T> $this->collection
  356.      */
  357.     public function isInitialized()
  358.     {
  359.         return $this->initialized;
  360.     }
  362.     /**
  363.      * Initialize the collection
  364.      *
  365.      * @return void
  366.      *
  367.      * @psalm-assert Collection<TKey,T> $this->collection
  368.      */
  369.     protected function initialize()
  370.     {
  371.         if ($this->initialized) {
  372.             return;
  373.         }
  375.         $this->doInitialize();
  376.         $this->initialized = true;
  378.         if ($this->collection === null) {
  379.             throw new LogicException('You must initialize the collection property in the doInitialize() method.');
  380.         }
  381.     }
  383.     /**
  384.      * Do the initialization logic
  385.      *
  386.      * @return void
  387.      */
  388.     abstract protected function doInitialize();
  389. }