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

Open in your IDE?
  1. <?php
  3. namespace Doctrine\Common\Collections;
  5. use Closure;
  7. /**
  8.  * Lazy collection that is backed by a concrete collection
  9.  *
  10.  * @phpstan-template TKey
  11.  * @psalm-template TKey of array-key
  12.  * @psalm-template T
  13.  * @template-implements Collection<TKey,T>
  14.  */
  15. abstract class AbstractLazyCollection implements Collection
  16. {
  17.     /**
  18.      * The backed collection to use
  19.      *
  20.      * @psalm-var Collection<TKey,T>
  21.      * @var Collection
  22.      */
  23.     protected $collection;
  25.     /** @var bool */
  26.     protected $initialized = false;
  28.     /**
  29.      * {@inheritDoc}
  30.      */
  31.     public function count()
  32.     {
  33.         $this->initialize();
  35.         return $this->collection->count();
  36.     }
  38.     /**
  39.      * {@inheritDoc}
  40.      */
  41.     public function add($element)
  42.     {
  43.         $this->initialize();
  45.         return $this->collection->add($element);
  46.     }
  48.     /**
  49.      * {@inheritDoc}
  50.      */
  51.     public function clear()
  52.     {
  53.         $this->initialize();
  54.         $this->collection->clear();
  55.     }
  57.     /**
  58.      * {@inheritDoc}
  59.      */
  60.     public function contains($element)
  61.     {
  62.         $this->initialize();
  64.         return $this->collection->contains($element);
  65.     }
  67.     /**
  68.      * {@inheritDoc}
  69.      */
  70.     public function isEmpty()
  71.     {
  72.         $this->initialize();
  74.         return $this->collection->isEmpty();
  75.     }
  77.     /**
  78.      * {@inheritDoc}
  79.      */
  80.     public function remove($key)
  81.     {
  82.         $this->initialize();
  84.         return $this->collection->remove($key);
  85.     }
  87.     /**
  88.      * {@inheritDoc}
  89.      */
  90.     public function removeElement($element)
  91.     {
  92.         $this->initialize();
  94.         return $this->collection->removeElement($element);
  95.     }
  97.     /**
  98.      * {@inheritDoc}
  99.      */
  100.     public function containsKey($key)
  101.     {
  102.         $this->initialize();
  104.         return $this->collection->containsKey($key);
  105.     }
  107.     /**
  108.      * {@inheritDoc}
  109.      */
  110.     public function get($key)
  111.     {
  112.         $this->initialize();
  114.         return $this->collection->get($key);
  115.     }
  117.     /**
  118.      * {@inheritDoc}
  119.      */
  120.     public function getKeys()
  121.     {
  122.         $this->initialize();
  124.         return $this->collection->getKeys();
  125.     }
  127.     /**
  128.      * {@inheritDoc}
  129.      */
  130.     public function getValues()
  131.     {
  132.         $this->initialize();
  134.         return $this->collection->getValues();
  135.     }
  137.     /**
  138.      * {@inheritDoc}
  139.      */
  140.     public function set($key, $value)
  141.     {
  142.         $this->initialize();
  143.         $this->collection->set($key, $value);
  144.     }
  146.     /**
  147.      * {@inheritDoc}
  148.      */
  149.     public function toArray()
  150.     {
  151.         $this->initialize();
  153.         return $this->collection->toArray();
  154.     }
  156.     /**
  157.      * {@inheritDoc}
  158.      */
  159.     public function first()
  160.     {
  161.         $this->initialize();
  163.         return $this->collection->first();
  164.     }
  166.     /**
  167.      * {@inheritDoc}
  168.      */
  169.     public function last()
  170.     {
  171.         $this->initialize();
  173.         return $this->collection->last();
  174.     }
  176.     /**
  177.      * {@inheritDoc}
  178.      */
  179.     public function key()
  180.     {
  181.         $this->initialize();
  183.         return $this->collection->key();
  184.     }
  186.     /**
  187.      * {@inheritDoc}
  188.      */
  189.     public function current()
  190.     {
  191.         $this->initialize();
  193.         return $this->collection->current();
  194.     }
  196.     /**
  197.      * {@inheritDoc}
  198.      */
  199.     public function next()
  200.     {
  201.         $this->initialize();
  203.         return $this->collection->next();
  204.     }
  206.     /**
  207.      * {@inheritDoc}
  208.      */
  209.     public function exists(Closure $p)
  210.     {
  211.         $this->initialize();
  213.         return $this->collection->exists($p);
  214.     }
  216.     /**
  217.      * {@inheritDoc}
  218.      */
  219.     public function filter(Closure $p)
  220.     {
  221.         $this->initialize();
  223.         return $this->collection->filter($p);
  224.     }
  226.     /**
  227.      * {@inheritDoc}
  228.      */
  229.     public function forAll(Closure $p)
  230.     {
  231.         $this->initialize();
  233.         return $this->collection->forAll($p);
  234.     }
  236.     /**
  237.      * {@inheritDoc}
  238.      */
  239.     public function map(Closure $func)
  240.     {
  241.         $this->initialize();
  243.         return $this->collection->map($func);
  244.     }
  246.     /**
  247.      * {@inheritDoc}
  248.      */
  249.     public function partition(Closure $p)
  250.     {
  251.         $this->initialize();
  253.         return $this->collection->partition($p);
  254.     }
  256.     /**
  257.      * {@inheritDoc}
  258.      */
  259.     public function indexOf($element)
  260.     {
  261.         $this->initialize();
  263.         return $this->collection->indexOf($element);
  264.     }
  266.     /**
  267.      * {@inheritDoc}
  268.      */
  269.     public function slice($offset, $length = null)
  270.     {
  271.         $this->initialize();
  273.         return $this->collection->slice($offset, $length);
  274.     }
  276.     /**
  277.      * {@inheritDoc}
  278.      */
  279.     public function getIterator()
  280.     {
  281.         $this->initialize();
  283.         return $this->collection->getIterator();
  284.     }
  286.     /**
  287.      * {@inheritDoc}
  288.      *
  289.      * @psalm-param TKey $offset
  290.      */
  291.     public function offsetExists($offset)
  292.     {
  293.         $this->initialize();
  295.         return $this->collection->offsetExists($offset);
  296.     }
  298.     /**
  299.      * {@inheritDoc}
  300.      *
  301.      * @param int|string $offset
  302.      *
  303.      * @return mixed
  304.      *
  305.      * @psalm-param TKey $offset
  306.      */
  307.     public function offsetGet($offset)
  308.     {
  309.         $this->initialize();
  311.         return $this->collection->offsetGet($offset);
  312.     }
  314.     /**
  315.      * {@inheritDoc}
  316.      *
  317.      * @param mixed $value
  318.      *
  319.      * @psalm-param TKey $offset
  320.      */
  321.     public function offsetSet($offset, $value)
  322.     {
  323.         $this->initialize();
  324.         $this->collection->offsetSet($offset, $value);
  325.     }
  327.     /**
  328.      * {@inheritDoc}
  329.      *
  330.      * @psalm-param TKey $offset
  331.      */
  332.     public function offsetUnset($offset)
  333.     {
  334.         $this->initialize();
  335.         $this->collection->offsetUnset($offset);
  336.     }
  338.     /**
  339.      * Is the lazy collection already initialized?
  340.      *
  341.      * @return bool
  342.      */
  343.     public function isInitialized()
  344.     {
  345.         return $this->initialized;
  346.     }
  348.     /**
  349.      * Initialize the collection
  350.      *
  351.      * @return void
  352.      */
  353.     protected function initialize()
  354.     {
  355.         if ($this->initialized) {
  356.             return;
  357.         }
  359.         $this->doInitialize();
  360.         $this->initialized = true;
  361.     }
  363.     /**
  364.      * Do the initialization logic
  365.      *
  366.      * @return void
  367.      */
  368.     abstract protected function doInitialize();
  369. }