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

Open in your IDE?
  1. <?php
  3. namespace Doctrine\Common\Collections;
  5. use Closure;
  6. use ReturnTypeWillChange;
  7. use Traversable;
  9. /**
  10.  * Lazy collection that is backed by a concrete collection
  11.  *
  12.  * @psalm-template TKey of array-key
  13.  * @psalm-template T
  14.  * @template-implements Collection<TKey,T>
  15.  */
  16. abstract class AbstractLazyCollection implements Collection
  17. {
  18.     /**
  19.      * The backed collection to use
  20.      *
  21.      * @psalm-var Collection<TKey,T>
  22.      * @var Collection<mixed>
  23.      */
  24.     protected $collection;
  26.     /** @var bool */
  27.     protected $initialized = false;
  29.     /**
  30.      * {@inheritDoc}
  31.      *
  32.      * @return int
  33.      */
  34.     #[ReturnTypeWillChange]
  35.     public function count()
  36.     {
  37.         $this->initialize();
  39.         return $this->collection->count();
  40.     }
  42.     /**
  43.      * {@inheritDoc}
  44.      */
  45.     public function add($element)
  46.     {
  47.         $this->initialize();
  49.         return $this->collection->add($element);
  50.     }
  52.     /**
  53.      * {@inheritDoc}
  54.      */
  55.     public function clear()
  56.     {
  57.         $this->initialize();
  58.         $this->collection->clear();
  59.     }
  61.     /**
  62.      * {@inheritDoc}
  63.      */
  64.     public function contains($element)
  65.     {
  66.         $this->initialize();
  68.         return $this->collection->contains($element);
  69.     }
  71.     /**
  72.      * {@inheritDoc}
  73.      */
  74.     public function isEmpty()
  75.     {
  76.         $this->initialize();
  78.         return $this->collection->isEmpty();
  79.     }
  81.     /**
  82.      * {@inheritDoc}
  83.      */
  84.     public function remove($key)
  85.     {
  86.         $this->initialize();
  88.         return $this->collection->remove($key);
  89.     }
  91.     /**
  92.      * {@inheritDoc}
  93.      */
  94.     public function removeElement($element)
  95.     {
  96.         $this->initialize();
  98.         return $this->collection->removeElement($element);
  99.     }
  101.     /**
  102.      * {@inheritDoc}
  103.      */
  104.     public function containsKey($key)
  105.     {
  106.         $this->initialize();
  108.         return $this->collection->containsKey($key);
  109.     }
  111.     /**
  112.      * {@inheritDoc}
  113.      */
  114.     public function get($key)
  115.     {
  116.         $this->initialize();
  118.         return $this->collection->get($key);
  119.     }
  121.     /**
  122.      * {@inheritDoc}
  123.      */
  124.     public function getKeys()
  125.     {
  126.         $this->initialize();
  128.         return $this->collection->getKeys();
  129.     }
  131.     /**
  132.      * {@inheritDoc}
  133.      */
  134.     public function getValues()
  135.     {
  136.         $this->initialize();
  138.         return $this->collection->getValues();
  139.     }
  141.     /**
  142.      * {@inheritDoc}
  143.      */
  144.     public function set($key, $value)
  145.     {
  146.         $this->initialize();
  147.         $this->collection->set($key, $value);
  148.     }
  150.     /**
  151.      * {@inheritDoc}
  152.      */
  153.     public function toArray()
  154.     {
  155.         $this->initialize();
  157.         return $this->collection->toArray();
  158.     }
  160.     /**
  161.      * {@inheritDoc}
  162.      */
  163.     public function first()
  164.     {
  165.         $this->initialize();
  167.         return $this->collection->first();
  168.     }
  170.     /**
  171.      * {@inheritDoc}
  172.      */
  173.     public function last()
  174.     {
  175.         $this->initialize();
  177.         return $this->collection->last();
  178.     }
  180.     /**
  181.      * {@inheritDoc}
  182.      */
  183.     public function key()
  184.     {
  185.         $this->initialize();
  187.         return $this->collection->key();
  188.     }
  190.     /**
  191.      * {@inheritDoc}
  192.      */
  193.     public function current()
  194.     {
  195.         $this->initialize();
  197.         return $this->collection->current();
  198.     }
  200.     /**
  201.      * {@inheritDoc}
  202.      */
  203.     public function next()
  204.     {
  205.         $this->initialize();
  207.         return $this->collection->next();
  208.     }
  210.     /**
  211.      * {@inheritDoc}
  212.      */
  213.     public function exists(Closure $p)
  214.     {
  215.         $this->initialize();
  217.         return $this->collection->exists($p);
  218.     }
  220.     /**
  221.      * {@inheritDoc}
  222.      */
  223.     public function filter(Closure $p)
  224.     {
  225.         $this->initialize();
  227.         return $this->collection->filter($p);
  228.     }
  230.     /**
  231.      * {@inheritDoc}
  232.      */
  233.     public function forAll(Closure $p)
  234.     {
  235.         $this->initialize();
  237.         return $this->collection->forAll($p);
  238.     }
  240.     /**
  241.      * {@inheritDoc}
  242.      */
  243.     public function map(Closure $func)
  244.     {
  245.         $this->initialize();
  247.         return $this->collection->map($func);
  248.     }
  250.     /**
  251.      * {@inheritDoc}
  252.      */
  253.     public function partition(Closure $p)
  254.     {
  255.         $this->initialize();
  257.         return $this->collection->partition($p);
  258.     }
  260.     /**
  261.      * {@inheritDoc}
  262.      */
  263.     public function indexOf($element)
  264.     {
  265.         $this->initialize();
  267.         return $this->collection->indexOf($element);
  268.     }
  270.     /**
  271.      * {@inheritDoc}
  272.      */
  273.     public function slice($offset, $length = null)
  274.     {
  275.         $this->initialize();
  277.         return $this->collection->slice($offset, $length);
  278.     }
  280.     /**
  281.      * {@inheritDoc}
  282.      *
  283.      * @return Traversable<int|string, mixed>
  284.      * @psalm-return Traversable<TKey,T>
  285.      */
  286.     #[ReturnTypeWillChange]
  287.     public function getIterator()
  288.     {
  289.         $this->initialize();
  291.         return $this->collection->getIterator();
  292.     }
  294.     /**
  295.      * {@inheritDoc}
  296.      *
  297.      * @psalm-param TKey $offset
  298.      *
  299.      * @return bool
  300.      */
  301.     #[ReturnTypeWillChange]
  302.     public function offsetExists($offset)
  303.     {
  304.         $this->initialize();
  306.         return $this->collection->offsetExists($offset);
  307.     }
  309.     /**
  310.      * {@inheritDoc}
  311.      *
  312.      * @param int|string $offset
  313.      * @psalm-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.      * {@inheritDoc}
  327.      *
  328.      * @param mixed $value
  329.      * @psalm-param TKey $offset
  330.      *
  331.      * @return void
  332.      */
  333.     #[ReturnTypeWillChange]
  334.     public function offsetSet($offset, $value)
  335.     {
  336.         $this->initialize();
  337.         $this->collection->offsetSet($offset, $value);
  338.     }
  340.     /**
  341.      * {@inheritDoc}
  342.      *
  343.      * @psalm-param TKey $offset
  344.      *
  345.      * @return void
  346.      */
  347.     #[ReturnTypeWillChange]
  348.     public function offsetUnset($offset)
  349.     {
  350.         $this->initialize();
  351.         $this->collection->offsetUnset($offset);
  352.     }
  354.     /**
  355.      * Is the lazy collection already initialized?
  356.      *
  357.      * @return bool
  358.      */
  359.     public function isInitialized()
  360.     {
  361.         return $this->initialized;
  362.     }
  364.     /**
  365.      * Initialize the collection
  366.      *
  367.      * @return void
  368.      */
  369.     protected function initialize()
  370.     {
  371.         if ($this->initialized) {
  372.             return;
  373.         }
  375.         $this->doInitialize();
  376.         $this->initialized = true;
  377.     }
  379.     /**
  380.      * Do the initialization logic
  381.      *
  382.      * @return void
  383.      */
  384.     abstract protected function doInitialize();
  385. }