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

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.  * @psalm-template TKey of array-key
  11.  * @psalm-template T
  12.  * @template-implements Collection<TKey,T>
  13.  */
  14. abstract class AbstractLazyCollection implements Collection
  15. {
  16.     /**
  17.      * The backed collection to use
  18.      *
  19.      * @psalm-var Collection<TKey,T>
  20.      * @var Collection
  21.      */
  22.     protected $collection;
  24.     /** @var bool */
  25.     protected $initialized = false;
  27.     /**
  28.      * {@inheritDoc}
  29.      */
  30.     public function count()
  31.     {
  32.         $this->initialize();
  34.         return $this->collection->count();
  35.     }
  37.     /**
  38.      * {@inheritDoc}
  39.      */
  40.     public function add($element)
  41.     {
  42.         $this->initialize();
  44.         return $this->collection->add($element);
  45.     }
  47.     /**
  48.      * {@inheritDoc}
  49.      */
  50.     public function clear()
  51.     {
  52.         $this->initialize();
  53.         $this->collection->clear();
  54.     }
  56.     /**
  57.      * {@inheritDoc}
  58.      */
  59.     public function contains($element)
  60.     {
  61.         $this->initialize();
  63.         return $this->collection->contains($element);
  64.     }
  66.     /**
  67.      * {@inheritDoc}
  68.      */
  69.     public function isEmpty()
  70.     {
  71.         $this->initialize();
  73.         return $this->collection->isEmpty();
  74.     }
  76.     /**
  77.      * {@inheritDoc}
  78.      */
  79.     public function remove($key)
  80.     {
  81.         $this->initialize();
  83.         return $this->collection->remove($key);
  84.     }
  86.     /**
  87.      * {@inheritDoc}
  88.      */
  89.     public function removeElement($element)
  90.     {
  91.         $this->initialize();
  93.         return $this->collection->removeElement($element);
  94.     }
  96.     /**
  97.      * {@inheritDoc}
  98.      */
  99.     public function containsKey($key)
  100.     {
  101.         $this->initialize();
  103.         return $this->collection->containsKey($key);
  104.     }
  106.     /**
  107.      * {@inheritDoc}
  108.      */
  109.     public function get($key)
  110.     {
  111.         $this->initialize();
  113.         return $this->collection->get($key);
  114.     }
  116.     /**
  117.      * {@inheritDoc}
  118.      */
  119.     public function getKeys()
  120.     {
  121.         $this->initialize();
  123.         return $this->collection->getKeys();
  124.     }
  126.     /**
  127.      * {@inheritDoc}
  128.      */
  129.     public function getValues()
  130.     {
  131.         $this->initialize();
  133.         return $this->collection->getValues();
  134.     }
  136.     /**
  137.      * {@inheritDoc}
  138.      */
  139.     public function set($key, $value)
  140.     {
  141.         $this->initialize();
  142.         $this->collection->set($key, $value);
  143.     }
  145.     /**
  146.      * {@inheritDoc}
  147.      */
  148.     public function toArray()
  149.     {
  150.         $this->initialize();
  152.         return $this->collection->toArray();
  153.     }
  155.     /**
  156.      * {@inheritDoc}
  157.      */
  158.     public function first()
  159.     {
  160.         $this->initialize();
  162.         return $this->collection->first();
  163.     }
  165.     /**
  166.      * {@inheritDoc}
  167.      */
  168.     public function last()
  169.     {
  170.         $this->initialize();
  172.         return $this->collection->last();
  173.     }
  175.     /**
  176.      * {@inheritDoc}
  177.      */
  178.     public function key()
  179.     {
  180.         $this->initialize();
  182.         return $this->collection->key();
  183.     }
  185.     /**
  186.      * {@inheritDoc}
  187.      */
  188.     public function current()
  189.     {
  190.         $this->initialize();
  192.         return $this->collection->current();
  193.     }
  195.     /**
  196.      * {@inheritDoc}
  197.      */
  198.     public function next()
  199.     {
  200.         $this->initialize();
  202.         return $this->collection->next();
  203.     }
  205.     /**
  206.      * {@inheritDoc}
  207.      */
  208.     public function exists(Closure $p)
  209.     {
  210.         $this->initialize();
  212.         return $this->collection->exists($p);
  213.     }
  215.     /**
  216.      * {@inheritDoc}
  217.      */
  218.     public function filter(Closure $p)
  219.     {
  220.         $this->initialize();
  222.         return $this->collection->filter($p);
  223.     }
  225.     /**
  226.      * {@inheritDoc}
  227.      */
  228.     public function forAll(Closure $p)
  229.     {
  230.         $this->initialize();
  232.         return $this->collection->forAll($p);
  233.     }
  235.     /**
  236.      * {@inheritDoc}
  237.      */
  238.     public function map(Closure $func)
  239.     {
  240.         $this->initialize();
  242.         return $this->collection->map($func);
  243.     }
  245.     /**
  246.      * {@inheritDoc}
  247.      */
  248.     public function partition(Closure $p)
  249.     {
  250.         $this->initialize();
  252.         return $this->collection->partition($p);
  253.     }
  255.     /**
  256.      * {@inheritDoc}
  257.      */
  258.     public function indexOf($element)
  259.     {
  260.         $this->initialize();
  262.         return $this->collection->indexOf($element);
  263.     }
  265.     /**
  266.      * {@inheritDoc}
  267.      */
  268.     public function slice($offset, $length = null)
  269.     {
  270.         $this->initialize();
  272.         return $this->collection->slice($offset, $length);
  273.     }
  275.     /**
  276.      * {@inheritDoc}
  277.      */
  278.     public function getIterator()
  279.     {
  280.         $this->initialize();
  282.         return $this->collection->getIterator();
  283.     }
  285.     /**
  286.      * {@inheritDoc}
  287.      */
  288.     public function offsetExists($offset)
  289.     {
  290.         $this->initialize();
  292.         return $this->collection->offsetExists($offset);
  293.     }
  295.     /**
  296.      * {@inheritDoc}
  297.      */
  298.     public function offsetGet($offset)
  299.     {
  300.         $this->initialize();
  302.         return $this->collection->offsetGet($offset);
  303.     }
  305.     /**
  306.      * {@inheritDoc}
  307.      */
  308.     public function offsetSet($offset, $value)
  309.     {
  310.         $this->initialize();
  311.         $this->collection->offsetSet($offset, $value);
  312.     }
  314.     /**
  315.      * {@inheritDoc}
  316.      */
  317.     public function offsetUnset($offset)
  318.     {
  319.         $this->initialize();
  320.         $this->collection->offsetUnset($offset);
  321.     }
  323.     /**
  324.      * Is the lazy collection already initialized?
  325.      *
  326.      * @return bool
  327.      */
  328.     public function isInitialized()
  329.     {
  330.         return $this->initialized;
  331.     }
  333.     /**
  334.      * Initialize the collection
  335.      *
  336.      * @return void
  337.      */
  338.     protected function initialize()
  339.     {
  340.         if ($this->initialized) {
  341.             return;
  342.         }
  344.         $this->doInitialize();
  345.         $this->initialized = true;
  346.     }
  348.     /**
  349.      * Do the initialization logic
  350.      *
  351.      * @return void
  352.      */
  353.     abstract protected function doInitialize();
  354. }