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.         /** @phpstan-var TKey $offset */
  215.         $this->set($offset, $value);
  216.     }
  218.     /**
  219.      * Required by interface ArrayAccess.
  220.      *
  221.      * @param TKey $offset
  222.      *
  223.      * @return void
  224.      */
  225.     #[ReturnTypeWillChange]
  226.     public function offsetUnset(mixed $offset)
  227.     {
  228.         $this->remove($offset);
  229.     }
  231.     /**
  232.      * {@inheritDoc}
  233.      */
  234.     public function containsKey(string|int $key)
  235.     {
  236.         return isset($this->elements[$key]) || array_key_exists($key, $this->elements);
  237.     }
  239.     /**
  240.      * {@inheritDoc}
  241.      */
  242.     public function contains(mixed $element)
  243.     {
  244.         return in_array($element, $this->elements, true);
  245.     }
  247.     /**
  248.      * {@inheritDoc}
  249.      */
  250.     public function exists(Closure $p)
  251.     {
  252.         return array_any(
  253.             $this->elements,
  254.             static fn (mixed $element, mixed $key): bool => (bool) $p($key, $element),
  255.         );
  256.     }
  258.     /**
  259.      * {@inheritDoc}
  260.      *
  261.      * @phpstan-param TMaybeContained $element
  262.      *
  263.      * @return int|string|false
  264.      * @phpstan-return (TMaybeContained is T ? TKey|false : false)
  265.      *
  266.      * @template TMaybeContained
  267.      */
  268.     public function indexOf($element)
  269.     {
  270.         return array_search($element, $this->elements, true);
  271.     }
  273.     /**
  274.      * {@inheritDoc}
  275.      */
  276.     public function get(string|int $key)
  277.     {
  278.         return $this->elements[$key] ?? null;
  279.     }
  281.     /**
  282.      * {@inheritDoc}
  283.      */
  284.     public function getKeys()
  285.     {
  286.         return array_keys($this->elements);
  287.     }
  289.     /**
  290.      * {@inheritDoc}
  291.      */
  292.     public function getValues()
  293.     {
  294.         return array_values($this->elements);
  295.     }
  297.     /**
  298.      * {@inheritDoc}
  299.      *
  300.      * @return int<0, max>
  301.      */
  302.     #[ReturnTypeWillChange]
  303.     public function count()
  304.     {
  305.         return count($this->elements);
  306.     }
  308.     /**
  309.      * {@inheritDoc}
  310.      */
  311.     public function set(string|int $key, mixed $value)
  312.     {
  313.         $this->elements[$key] = $value;
  314.     }
  316.     /**
  317.      * {@inheritDoc}
  318.      *
  319.      * This breaks assumptions about the template type, but it would
  320.      * be a backwards-incompatible change to remove this method
  321.      */
  322.     public function add(mixed $element)
  323.     {
  324.         $this->elements[] = $element;
  325.     }
  327.     /**
  328.      * {@inheritDoc}
  329.      */
  330.     public function isEmpty()
  331.     {
  332.         return empty($this->elements);
  333.     }
  335.     /**
  336.      * {@inheritDoc}
  337.      *
  338.      * @return Traversable<int|string, mixed>
  339.      * @phpstan-return Traversable<TKey, T>
  340.      */
  341.     #[ReturnTypeWillChange]
  342.     public function getIterator()
  343.     {
  344.         return new ArrayIterator($this->elements);
  345.     }
  347.     /**
  348.      * {@inheritDoc}
  349.      *
  350.      * @phpstan-param Closure(T):U $func
  351.      *
  352.      * @return static
  353.      * @phpstan-return static<TKey, U>
  354.      *
  355.      * @phpstan-template U
  356.      */
  357.     public function map(Closure $func)
  358.     {
  359.         return $this->createFrom(array_map($func, $this->elements));
  360.     }
  362.     /**
  363.      * {@inheritDoc}
  364.      */
  365.     public function reduce(Closure $func, $initial = null)
  366.     {
  367.         return array_reduce($this->elements, $func, $initial);
  368.     }
  370.     /**
  371.      * {@inheritDoc}
  372.      *
  373.      * @phpstan-param Closure(T, TKey):bool $p
  374.      *
  375.      * @return static
  376.      * @phpstan-return static<TKey,T>
  377.      */
  378.     public function filter(Closure $p)
  379.     {
  380.         return $this->createFrom(array_filter($this->elements, $p, ARRAY_FILTER_USE_BOTH));
  381.     }
  383.     /**
  384.      * {@inheritDoc}
  385.      */
  386.     public function findFirst(Closure $p)
  387.     {
  388.         return array_find(
  389.             $this->elements,
  390.             static fn (mixed $element, mixed $key): bool => (bool) $p($key, $element),
  391.         );
  392.     }
  394.     /**
  395.      * {@inheritDoc}
  396.      */
  397.     public function forAll(Closure $p)
  398.     {
  399.         return array_all(
  400.             $this->elements,
  401.             static fn (mixed $element, mixed $key): bool => (bool) $p($key, $element),
  402.         );
  403.     }
  405.     /**
  406.      * {@inheritDoc}
  407.      */
  408.     public function partition(Closure $p)
  409.     {
  410.         $matches = $noMatches = [];
  412.         foreach ($this->elements as $key => $element) {
  413.             if ($p($key, $element)) {
  414.                 $matches[$key] = $element;
  415.             } else {
  416.                 $noMatches[$key] = $element;
  417.             }
  418.         }
  420.         return [$this->createFrom($matches), $this->createFrom($noMatches)];
  421.     }
  423.     /**
  424.      * Returns a string representation of this object.
  425.      * {@inheritDoc}
  426.      *
  427.      * @return string
  428.      */
  429.     #[ReturnTypeWillChange]
  430.     public function __toString()
  431.     {
  432.         return self::class . '@' . spl_object_hash($this);
  433.     }
  435.     /**
  436.      * {@inheritDoc}
  437.      */
  438.     public function clear()
  439.     {
  440.         $this->elements = [];
  441.     }
  443.     /**
  444.      * {@inheritDoc}
  445.      */
  446.     public function slice(int $offset, int|null $length = null)
  447.     {
  448.         return array_slice($this->elements, $offset, $length, true);
  449.     }
  451.     /** @phpstan-return Collection<TKey, T>&Selectable<TKey,T> */
  452.     public function matching(Criteria $criteria)
  453.     {
  454.         $accessRawFieldValues = $criteria->isRawFieldValueAccessEnabled();
  456.         $expr     = $criteria->getWhereExpression();
  457.         $filtered = $this->elements;
  459.         if ($expr) {
  460.             $visitor  = new ClosureExpressionVisitor($accessRawFieldValues);
  461.             $filter   = $visitor->dispatch($expr);
  462.             $filtered = array_filter($filtered, $filter);
  463.         }
  465.         $orderings = $criteria->orderings();
  467.         if ($orderings) {
  468.             $next = null;
  469.             foreach (array_reverse($orderings) as $field => $ordering) {
  470.                 $next = ClosureExpressionVisitor::sortByField($field, $ordering === Order::Descending ? -1 : 1, $next, $accessRawFieldValues);
  471.             }
  473.             uasort($filtered, $next);
  474.         }
  476.         $offset = $criteria->getFirstResult();
  477.         $length = $criteria->getMaxResults();
  479.         if ($offset !== null && $offset > 0 || $length !== null && $length > 0) {
  480.             $filtered = array_slice($filtered, (int) $offset, $length, true);
  481.         }
  483.         return $this->createFrom($filtered);
  484.     }
  485. }