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

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. }