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

Open in your IDE?
  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. }