vendor/doctrine/collections/lib/Doctrine/Common/Collections/ArrayCollection.php line 45

Open in your IDE?
  1. <?php
  3. namespace Doctrine\Common\Collections;
  5. use ArrayIterator;
  6. use Closure;
  7. use Doctrine\Common\Collections\Expr\ClosureExpressionVisitor;
  8. use ReturnTypeWillChange;
  9. use Traversable;
  11. use function array_filter;
  12. use function array_key_exists;
  13. use function array_keys;
  14. use function array_map;
  15. use function array_reverse;
  16. use function array_search;
  17. use function array_slice;
  18. use function array_values;
  19. use function count;
  20. use function current;
  21. use function end;
  22. use function in_array;
  23. use function key;
  24. use function next;
  25. use function reset;
  26. use function spl_object_hash;
  27. use function uasort;
  29. use const ARRAY_FILTER_USE_BOTH;
  31. /**
  32. * An ArrayCollection is a Collection implementation that wraps a regular PHP array.
  33. *
  34. * Warning: Using (un-)serialize() on a collection is not a supported use-case
  35. * and may break when we change the internals in the future. If you need to
  36. * serialize a collection use {@link toArray()} and reconstruct the collection
  37. * manually.
  38. *
  39. * @psalm-template TKey of array-key
  40. * @psalm-template T
  41. * @template-implements Collection<TKey,T>
  42. * @template-implements Selectable<TKey,T>
  43. * @psalm-consistent-constructor
  44. */
  45. class ArrayCollection implements Collection, Selectable
  46. {
  47. /**
  48. * An array containing the entries of this collection.
  49. *
  50. * @psalm-var array<TKey,T>
  51. * @var mixed[]
  52. */
  53. private $elements;
  55. /**
  56. * Initializes a new ArrayCollection.
  57. *
  58. * @param array $elements
  59. * @psalm-param array<TKey,T> $elements
  60. */
  61. public function __construct(array $elements = [])
  62. {
  63. $this->elements = $elements;
  64. }
  66. /**
  67. * {@inheritDoc}
  68. */
  69. public function toArray()
  70. {
  71. return $this->elements;
  72. }
  74. /**
  75. * {@inheritDoc}
  76. */
  77. public function first()
  78. {
  79. return reset($this->elements);
  80. }
  82. /**
  83. * Creates a new instance from the specified elements.
  84. *
  85. * This method is provided for derived classes to specify how a new
  86. * instance should be created when constructor semantics have changed.
  87. *
  88. * @param array $elements Elements.
  89. * @psalm-param array<K,V> $elements
  90. *
  91. * @return static
  92. * @psalm-return static<K,V>
  93. *
  94. * @psalm-template K of array-key
  95. * @psalm-template V
  96. */
  97. protected function createFrom(array $elements)
  98. {
  99. return new static($elements);
  100. }
  102. /**
  103. * {@inheritDoc}
  104. */
  105. public function last()
  106. {
  107. return end($this->elements);
  108. }
  110. /**
  111. * {@inheritDoc}
  112. */
  113. public function key()
  114. {
  115. return key($this->elements);
  116. }
  118. /**
  119. * {@inheritDoc}
  120. */
  121. public function next()
  122. {
  123. return next($this->elements);
  124. }
  126. /**
  127. * {@inheritDoc}
  128. */
  129. public function current()
  130. {
  131. return current($this->elements);
  132. }
  134. /**
  135. * {@inheritDoc}
  136. */
  137. public function remove($key)
  138. {
  139. if (! isset($this->elements[$key]) && ! array_key_exists($key, $this->elements)) {
  140. return null;
  141. }
  143. $removed = $this->elements[$key];
  144. unset($this->elements[$key]);
  146. return $removed;
  147. }
  149. /**
  150. * {@inheritDoc}
  151. */
  152. public function removeElement($element)
  153. {
  154. $key = array_search($element, $this->elements, true);
  156. if ($key === false) {
  157. return false;
  158. }
  160. unset($this->elements[$key]);
  162. return true;
  163. }
  165. /**
  166. * Required by interface ArrayAccess.
  167. *
  168. * @param TKey $offset
  169. *
  170. * @return bool
  171. */
  172. #[ReturnTypeWillChange]
  173. public function offsetExists($offset)
  174. {
  175. return $this->containsKey($offset);
  176. }
  178. /**
  179. * Required by interface ArrayAccess.
  180. *
  181. * @param TKey $offset
  182. *
  183. * @return mixed
  184. */
  185. #[ReturnTypeWillChange]
  186. public function offsetGet($offset)
  187. {
  188. return $this->get($offset);
  189. }
  191. /**
  192. * Required by interface ArrayAccess.
  193. *
  194. * @param TKey|null $offset
  195. * @param T $value
  196. *
  197. * @return void
  198. */
  199. #[ReturnTypeWillChange]
  200. public function offsetSet($offset, $value)
  201. {
  202. if (! isset($offset)) {
  203. $this->add($value);
  205. return;
  206. }
  208. $this->set($offset, $value);
  209. }
  211. /**
  212. * Required by interface ArrayAccess.
  213. *
  214. * @param TKey $offset
  215. *
  216. * @return void
  217. */
  218. #[ReturnTypeWillChange]
  219. public function offsetUnset($offset)
  220. {
  221. $this->remove($offset);
  222. }
  224. /**
  225. * {@inheritDoc}
  226. */
  227. public function containsKey($key)
  228. {
  229. return isset($this->elements[$key]) || array_key_exists($key, $this->elements);
  230. }
  232. /**
  233. * {@inheritDoc}
  234. *
  235. * @template TMaybeContained
  236. */
  237. public function contains($element)
  238. {
  239. return in_array($element, $this->elements, true);
  240. }
  242. /**
  243. * {@inheritDoc}
  244. */
  245. public function exists(Closure $p)
  246. {
  247. foreach ($this->elements as $key => $element) {
  248. if ($p($key, $element)) {
  249. return true;
  250. }
  251. }
  253. return false;
  254. }
  256. /**
  257. * {@inheritDoc}
  258. *
  259. * @psalm-param TMaybeContained $element
  260. *
  261. * @psalm-return (TMaybeContained is T ? TKey|false : false)
  262. *
  263. * @template TMaybeContained
  264. */
  265. public function indexOf($element)
  266. {
  267. return array_search($element, $this->elements, true);
  268. }
  270. /**
  271. * {@inheritDoc}
  272. */
  273. public function get($key)
  274. {
  275. return $this->elements[$key] ?? null;
  276. }
  278. /**
  279. * {@inheritDoc}
  280. */
  281. public function getKeys()
  282. {
  283. return array_keys($this->elements);
  284. }
  286. /**
  287. * {@inheritDoc}
  288. */
  289. public function getValues()
  290. {
  291. return array_values($this->elements);
  292. }
  294. /**
  295. * {@inheritDoc}
  296. *
  297. * @return int
  298. */
  299. #[ReturnTypeWillChange]
  300. public function count()
  301. {
  302. return count($this->elements);
  303. }
  305. /**
  306. * {@inheritDoc}
  307. */
  308. public function set($key, $value)
  309. {
  310. $this->elements[$key] = $value;
  311. }
  313. /**
  314. * {@inheritDoc}
  315. *
  316. * @psalm-suppress InvalidPropertyAssignmentValue
  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($element)
  322. {
  323. $this->elements[] = $element;
  325. return true;
  326. }
  328. /**
  329. * {@inheritDoc}
  330. */
  331. public function isEmpty()
  332. {
  333. return empty($this->elements);
  334. }
  336. /**
  337. * {@inheritDoc}
  338. *
  339. * @return Traversable<int|string, mixed>
  340. * @psalm-return Traversable<TKey,T>
  341. */
  342. #[ReturnTypeWillChange]
  343. public function getIterator()
  344. {
  345. return new ArrayIterator($this->elements);
  346. }
  348. /**
  349. * {@inheritDoc}
  350. *
  351. * @psalm-param Closure(T):U $func
  352. *
  353. * @return static
  354. * @psalm-return static<TKey, U>
  355. *
  356. * @psalm-template U
  357. */
  358. public function map(Closure $func)
  359. {
  360. return $this->createFrom(array_map($func, $this->elements));
  361. }
  363. /**
  364. * {@inheritDoc}
  365. *
  366. * @return static
  367. * @psalm-return static<TKey,T>
  368. */
  369. public function filter(Closure $p)
  370. {
  371. return $this->createFrom(array_filter($this->elements, $p, ARRAY_FILTER_USE_BOTH));
  372. }
  374. /**
  375. * {@inheritDoc}
  376. */
  377. public function forAll(Closure $p)
  378. {
  379. foreach ($this->elements as $key => $element) {
  380. if (! $p($key, $element)) {
  381. return false;
  382. }
  383. }
  385. return true;
  386. }
  388. /**
  389. * {@inheritDoc}
  390. */
  391. public function partition(Closure $p)
  392. {
  393. $matches = $noMatches = [];
  395. foreach ($this->elements as $key => $element) {
  396. if ($p($key, $element)) {
  397. $matches[$key] = $element;
  398. } else {
  399. $noMatches[$key] = $element;
  400. }
  401. }
  403. return [$this->createFrom($matches), $this->createFrom($noMatches)];
  404. }
  406. /**
  407. * Returns a string representation of this object.
  408. *
  409. * @return string
  410. */
  411. public function __toString()
  412. {
  413. return self::class . '@' . spl_object_hash($this);
  414. }
  416. /**
  417. * {@inheritDoc}
  418. */
  419. public function clear()
  420. {
  421. $this->elements = [];
  422. }
  424. /**
  425. * {@inheritDoc}
  426. */
  427. public function slice($offset, $length = null)
  428. {
  429. return array_slice($this->elements, $offset, $length, true);
  430. }
  432. /**
  433. * {@inheritDoc}
  434. */
  435. public function matching(Criteria $criteria)
  436. {
  437. $expr = $criteria->getWhereExpression();
  438. $filtered = $this->elements;
  440. if ($expr) {
  441. $visitor = new ClosureExpressionVisitor();
  442. $filter = $visitor->dispatch($expr);
  443. $filtered = array_filter($filtered, $filter);
  444. }
  446. $orderings = $criteria->getOrderings();
  448. if ($orderings) {
  449. $next = null;
  450. foreach (array_reverse($orderings) as $field => $ordering) {
  451. $next = ClosureExpressionVisitor::sortByField($field, $ordering === Criteria::DESC ? -1 : 1, $next);
  452. }
  454. uasort($filtered, $next);
  455. }
  457. $offset = $criteria->getFirstResult();
  458. $length = $criteria->getMaxResults();
  460. if ($offset || $length) {
  461. $filtered = array_slice($filtered, (int) $offset, $length);
  462. }
  464. return $this->createFrom($filtered);
  465. }
  466. }