vendor/doctrine/collections/src/ArrayCollection.php line 49

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\Common\Collections;
  7. use ArrayIterator;
  8. use Closure;
  9. use Doctrine\Common\Collections\Expr\ClosureExpressionVisitor;
  10. use ReturnTypeWillChange;
  11. use Stringable;
  12. use Traversable;
  14. use function array_all;
  15. use function array_any;
  16. use function array_filter;
  17. use function array_find;
  18. use function array_key_exists;
  19. use function array_keys;
  20. use function array_map;
  21. use function array_reduce;
  22. use function array_reverse;
  23. use function array_search;
  24. use function array_slice;
  25. use function array_values;
  26. use function count;
  27. use function current;
  28. use function end;
  29. use function in_array;
  30. use function key;
  31. use function next;
  32. use function reset;
  33. use function spl_object_hash;
  34. use function uasort;
  36. use const ARRAY_FILTER_USE_BOTH;
  38. /**
  39. * An ArrayCollection is a Collection implementation that wraps a regular PHP array.
  40. *
  41. * Warning: Using (un-)serialize() on a collection is not a supported use-case
  42. * and may break when we change the internals in the future. If you need to
  43. * serialize a collection use {@link toArray()} and reconstruct the collection
  44. * manually.
  45. *
  46. * @phpstan-template TKey of array-key
  47. * @phpstan-template T
  48. * @template-implements Collection<TKey,T>
  49. * @template-implements Selectable<TKey,T>
  50. * @phpstan-consistent-constructor
  51. */
  52. class ArrayCollection implements Collection, Selectable, Stringable
  53. {
  54. /**
  55. * An array containing the entries of this collection.
  56. *
  57. * @phpstan-var array<TKey,T>
  58. * @var mixed[]
  59. */
  60. private array $elements = [];
  62. /**
  63. * Initializes a new ArrayCollection.
  64. *
  65. * @phpstan-param array<TKey,T> $elements
  66. */
  67. public function __construct(array $elements = [])
  68. {
  69. $this->elements = $elements;
  70. }
  72. /**
  73. * {@inheritDoc}
  74. */
  75. public function toArray()
  76. {
  77. return $this->elements;
  78. }
  80. /**
  81. * {@inheritDoc}
  82. */
  83. public function first()
  84. {
  85. return reset($this->elements);
  86. }
  88. /**
  89. * Creates a new instance from the specified elements.
  90. *
  91. * This method is provided for derived classes to specify how a new
  92. * instance should be created when constructor semantics have changed.
  93. *
  94. * @param array $elements Elements.
  95. * @phpstan-param array<K,V> $elements
  96. *
  97. * @return static
  98. * @phpstan-return static<K,V>
  99. *
  100. * @phpstan-template K of array-key
  101. * @phpstan-template V
  102. */
  103. protected function createFrom(array $elements)
  104. {
  105. return new static($elements);
  106. }
  108. /**
  109. * {@inheritDoc}
  110. */
  111. public function last()
  112. {
  113. return end($this->elements);
  114. }
  116. /**
  117. * {@inheritDoc}
  118. */
  119. public function key()
  120. {
  121. return key($this->elements);
  122. }
  124. /**
  125. * {@inheritDoc}
  126. */
  127. public function next()
  128. {
  129. return next($this->elements);
  130. }
  132. /**
  133. * {@inheritDoc}
  134. */
  135. public function current()
  136. {
  137. return current($this->elements);
  138. }
  140. /**
  141. * {@inheritDoc}
  142. */
  143. public function remove(string|int $key)
  144. {
  145. if (! isset($this->elements[$key]) && ! array_key_exists($key, $this->elements)) {
  146. return null;
  147. }
  149. $removed = $this->elements[$key];
  150. unset($this->elements[$key]);
  152. return $removed;
  153. }
  155. /**
  156. * {@inheritDoc}
  157. */
  158. public function removeElement(mixed $element)
  159. {
  160. $key = array_search($element, $this->elements, true);
  162. if ($key === false) {
  163. return false;
  164. }
  166. unset($this->elements[$key]);
  168. return true;
  169. }
  171. /**
  172. * Required by interface ArrayAccess.
  173. *
  174. * @param TKey $offset
  175. *
  176. * @return bool
  177. */
  178. #[ReturnTypeWillChange]
  179. public function offsetExists(mixed $offset)
  180. {
  181. return $this->containsKey($offset);
  182. }
  184. /**
  185. * Required by interface ArrayAccess.
  186. *
  187. * @param TKey $offset
  188. *
  189. * @return T|null
  190. */
  191. #[ReturnTypeWillChange]
  192. public function offsetGet(mixed $offset)
  193. {
  194. return $this->get($offset);
  195. }
  197. /**
  198. * Required by interface ArrayAccess.
  199. *
  200. * @param TKey|null $offset
  201. * @param T $value
  202. *
  203. * @return void
  204. */
  205. #[ReturnTypeWillChange]
  206. public function offsetSet(mixed $offset, mixed $value)
  207. {
  208. if ($offset === null) {
  209. $this->add($value);
  211. return;
  212. }
  214. $this->set($offset, $value);
  215. }
  217. /**
  218. * Required by interface ArrayAccess.
  219. *
  220. * @param TKey $offset
  221. *
  222. * @return void
  223. */
  224. #[ReturnTypeWillChange]
  225. public function offsetUnset(mixed $offset)
  226. {
  227. $this->remove($offset);
  228. }
  230. /**
  231. * {@inheritDoc}
  232. */
  233. public function containsKey(string|int $key)
  234. {
  235. return isset($this->elements[$key]) || array_key_exists($key, $this->elements);
  236. }
  238. /**
  239. * {@inheritDoc}
  240. */
  241. public function contains(mixed $element)
  242. {
  243. return in_array($element, $this->elements, true);
  244. }
  246. /**
  247. * {@inheritDoc}
  248. */
  249. public function exists(Closure $p)
  250. {
  251. return array_any(
  252. $this->elements,
  253. static fn (mixed $element, mixed $key): bool => (bool) $p($key, $element),
  254. );
  255. }
  257. /**
  258. * {@inheritDoc}
  259. *
  260. * @phpstan-param TMaybeContained $element
  261. *
  262. * @return int|string|false
  263. * @phpstan-return (TMaybeContained is T ? TKey|false : false)
  264. *
  265. * @template TMaybeContained
  266. */
  267. public function indexOf($element)
  268. {
  269. return array_search($element, $this->elements, true);
  270. }
  272. /**
  273. * {@inheritDoc}
  274. */
  275. public function get(string|int $key)
  276. {
  277. return $this->elements[$key] ?? null;
  278. }
  280. /**
  281. * {@inheritDoc}
  282. */
  283. public function getKeys()
  284. {
  285. return array_keys($this->elements);
  286. }
  288. /**
  289. * {@inheritDoc}
  290. */
  291. public function getValues()
  292. {
  293. return array_values($this->elements);
  294. }
  296. /**
  297. * {@inheritDoc}
  298. *
  299. * @return int<0, max>
  300. */
  301. #[ReturnTypeWillChange]
  302. public function count()
  303. {
  304. return count($this->elements);
  305. }
  307. /**
  308. * {@inheritDoc}
  309. */
  310. public function set(string|int $key, mixed $value)
  311. {
  312. $this->elements[$key] = $value;
  313. }
  315. /**
  316. * {@inheritDoc}
  317. *
  318. * This breaks assumptions about the template type, but it would
  319. * be a backwards-incompatible change to remove this method
  320. */
  321. public function add(mixed $element)
  322. {
  323. $this->elements[] = $element;
  324. }
  326. /**
  327. * {@inheritDoc}
  328. */
  329. public function isEmpty()
  330. {
  331. return empty($this->elements);
  332. }
  334. /**
  335. * {@inheritDoc}
  336. *
  337. * @return Traversable<int|string, mixed>
  338. * @phpstan-return Traversable<TKey, T>
  339. */
  340. #[ReturnTypeWillChange]
  341. public function getIterator()
  342. {
  343. return new ArrayIterator($this->elements);
  344. }
  346. /**
  347. * {@inheritDoc}
  348. *
  349. * @phpstan-param Closure(T):U $func
  350. *
  351. * @return static
  352. * @phpstan-return static<TKey, U>
  353. *
  354. * @phpstan-template U
  355. */
  356. public function map(Closure $func)
  357. {
  358. return $this->createFrom(array_map($func, $this->elements));
  359. }
  361. /**
  362. * {@inheritDoc}
  363. */
  364. public function reduce(Closure $func, $initial = null)
  365. {
  366. return array_reduce($this->elements, $func, $initial);
  367. }
  369. /**
  370. * {@inheritDoc}
  371. *
  372. * @phpstan-param Closure(T, TKey):bool $p
  373. *
  374. * @return static
  375. * @phpstan-return static<TKey,T>
  376. */
  377. public function filter(Closure $p)
  378. {
  379. return $this->createFrom(array_filter($this->elements, $p, ARRAY_FILTER_USE_BOTH));
  380. }
  382. /**
  383. * {@inheritDoc}
  384. */
  385. public function findFirst(Closure $p)
  386. {
  387. return array_find(
  388. $this->elements,
  389. static fn (mixed $element, mixed $key): bool => (bool) $p($key, $element),
  390. );
  391. }
  393. /**
  394. * {@inheritDoc}
  395. */
  396. public function forAll(Closure $p)
  397. {
  398. return array_all(
  399. $this->elements,
  400. static fn (mixed $element, mixed $key): bool => (bool) $p($key, $element),
  401. );
  402. }
  404. /**
  405. * {@inheritDoc}
  406. */
  407. public function partition(Closure $p)
  408. {
  409. $matches = $noMatches = [];
  411. foreach ($this->elements as $key => $element) {
  412. if ($p($key, $element)) {
  413. $matches[$key] = $element;
  414. } else {
  415. $noMatches[$key] = $element;
  416. }
  417. }
  419. return [$this->createFrom($matches), $this->createFrom($noMatches)];
  420. }
  422. /**
  423. * Returns a string representation of this object.
  424. * {@inheritDoc}
  425. *
  426. * @return string
  427. */
  428. #[ReturnTypeWillChange]
  429. public function __toString()
  430. {
  431. return self::class . '@' . spl_object_hash($this);
  432. }
  434. /**
  435. * {@inheritDoc}
  436. */
  437. public function clear()
  438. {
  439. $this->elements = [];
  440. }
  442. /**
  443. * {@inheritDoc}
  444. */
  445. public function slice(int $offset, int|null $length = null)
  446. {
  447. return array_slice($this->elements, $offset, $length, true);
  448. }
  450. /** @phpstan-return Collection<TKey, T>&Selectable<TKey,T> */
  451. public function matching(Criteria $criteria)
  452. {
  453. $expr = $criteria->getWhereExpression();
  454. $filtered = $this->elements;
  456. if ($expr) {
  457. $visitor = new ClosureExpressionVisitor();
  458. $filter = $visitor->dispatch($expr);
  459. $filtered = array_filter($filtered, $filter);
  460. }
  462. $orderings = $criteria->orderings();
  464. if ($orderings) {
  465. $next = null;
  466. foreach (array_reverse($orderings) as $field => $ordering) {
  467. $next = ClosureExpressionVisitor::sortByField($field, $ordering === Order::Descending ? -1 : 1, $next);
  468. }
  470. uasort($filtered, $next);
  471. }
  473. $offset = $criteria->getFirstResult();
  474. $length = $criteria->getMaxResults();
  476. if ($offset !== null && $offset > 0 || $length !== null && $length > 0) {
  477. $filtered = array_slice($filtered, (int) $offset, $length, true);
  478. }
  480. return $this->createFrom($filtered);
  481. }
  482. }