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

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_filter;
  15. use function array_key_exists;
  16. use function array_keys;
  17. use function array_map;
  18. use function array_reduce;
  19. use function array_reverse;
  20. use function array_search;
  21. use function array_slice;
  22. use function array_values;
  23. use function count;
  24. use function current;
  25. use function end;
  26. use function in_array;
  27. use function key;
  28. use function next;
  29. use function reset;
  30. use function spl_object_hash;
  31. use function uasort;
  33. use const ARRAY_FILTER_USE_BOTH;
  35. /**
  36.  * An ArrayCollection is a Collection implementation that wraps a regular PHP array.
  37.  *
  38.  * Warning: Using (un-)serialize() on a collection is not a supported use-case
  39.  * and may break when we change the internals in the future. If you need to
  40.  * serialize a collection use {@link toArray()} and reconstruct the collection
  41.  * manually.
  42.  *
  43.  * @psalm-template TKey of array-key
  44.  * @psalm-template T
  45.  * @template-implements Collection<TKey,T>
  46.  * @template-implements Selectable<TKey,T>
  47.  * @psalm-consistent-constructor
  48.  */
  49. class ArrayCollection implements Collection, Selectable, Stringable
  50. {
  51.     /**
  52.      * An array containing the entries of this collection.
  53.      *
  54.      * @psalm-var array<TKey,T>
  55.      * @var mixed[]
  56.      */
  57.     private array $elements = [];
  59.     /**
  60.      * Initializes a new ArrayCollection.
  61.      *
  62.      * @psalm-param array<TKey,T> $elements
  63.      */
  64.     public function __construct(array $elements = [])
  65.     {
  66.         $this->elements = $elements;
  67.     }
  69.     /**
  70.      * {@inheritDoc}
  71.      */
  72.     public function toArray()
  73.     {
  74.         return $this->elements;
  75.     }
  77.     /**
  78.      * {@inheritDoc}
  79.      */
  80.     public function first()
  81.     {
  82.         return reset($this->elements);
  83.     }
  85.     /**
  86.      * Creates a new instance from the specified elements.
  87.      *
  88.      * This method is provided for derived classes to specify how a new
  89.      * instance should be created when constructor semantics have changed.
  90.      *
  91.      * @param array $elements Elements.
  92.      * @psalm-param array<K,V> $elements
  93.      *
  94.      * @return static
  95.      * @psalm-return static<K,V>
  96.      *
  97.      * @psalm-template K of array-key
  98.      * @psalm-template V
  99.      */
  100.     protected function createFrom(array $elements)
  101.     {
  102.         return new static($elements);
  103.     }
  105.     /**
  106.      * {@inheritDoc}
  107.      */
  108.     public function last()
  109.     {
  110.         return end($this->elements);
  111.     }
  113.     /**
  114.      * {@inheritDoc}
  115.      */
  116.     public function key()
  117.     {
  118.         return key($this->elements);
  119.     }
  121.     /**
  122.      * {@inheritDoc}
  123.      */
  124.     public function next()
  125.     {
  126.         return next($this->elements);
  127.     }
  129.     /**
  130.      * {@inheritDoc}
  131.      */
  132.     public function current()
  133.     {
  134.         return current($this->elements);
  135.     }
  137.     /**
  138.      * {@inheritDoc}
  139.      */
  140.     public function remove(string|int $key)
  141.     {
  142.         if (! isset($this->elements[$key]) && ! array_key_exists($key, $this->elements)) {
  143.             return null;
  144.         }
  146.         $removed = $this->elements[$key];
  147.         unset($this->elements[$key]);
  149.         return $removed;
  150.     }
  152.     /**
  153.      * {@inheritDoc}
  154.      */
  155.     public function removeElement(mixed $element)
  156.     {
  157.         $key = array_search($element, $this->elements, true);
  159.         if ($key === false) {
  160.             return false;
  161.         }
  163.         unset($this->elements[$key]);
  165.         return true;
  166.     }
  168.     /**
  169.      * Required by interface ArrayAccess.
  170.      *
  171.      * @param TKey $offset
  172.      *
  173.      * @return bool
  174.      */
  175.     #[ReturnTypeWillChange]
  176.     public function offsetExists(mixed $offset)
  177.     {
  178.         return $this->containsKey($offset);
  179.     }
  181.     /**
  182.      * Required by interface ArrayAccess.
  183.      *
  184.      * @param TKey $offset
  185.      *
  186.      * @return T|null
  187.      */
  188.     #[ReturnTypeWillChange]
  189.     public function offsetGet(mixed $offset)
  190.     {
  191.         return $this->get($offset);
  192.     }
  194.     /**
  195.      * Required by interface ArrayAccess.
  196.      *
  197.      * @param TKey|null $offset
  198.      * @param T         $value
  199.      *
  200.      * @return void
  201.      */
  202.     #[ReturnTypeWillChange]
  203.     public function offsetSet(mixed $offset, mixed $value)
  204.     {
  205.         if ($offset === null) {
  206.             $this->add($value);
  208.             return;
  209.         }
  211.         $this->set($offset, $value);
  212.     }
  214.     /**
  215.      * Required by interface ArrayAccess.
  216.      *
  217.      * @param TKey $offset
  218.      *
  219.      * @return void
  220.      */
  221.     #[ReturnTypeWillChange]
  222.     public function offsetUnset(mixed $offset)
  223.     {
  224.         $this->remove($offset);
  225.     }
  227.     /**
  228.      * {@inheritDoc}
  229.      */
  230.     public function containsKey(string|int $key)
  231.     {
  232.         return isset($this->elements[$key]) || array_key_exists($key, $this->elements);
  233.     }
  235.     /**
  236.      * {@inheritDoc}
  237.      */
  238.     public function contains(mixed $element)
  239.     {
  240.         return in_array($element, $this->elements, true);
  241.     }
  243.     /**
  244.      * {@inheritDoc}
  245.      */
  246.     public function exists(Closure $p)
  247.     {
  248.         foreach ($this->elements as $key => $element) {
  249.             if ($p($key, $element)) {
  250.                 return true;
  251.             }
  252.         }
  254.         return false;
  255.     }
  257.     /**
  258.      * {@inheritDoc}
  259.      *
  260.      * @psalm-param TMaybeContained $element
  261.      *
  262.      * @return int|string|false
  263.      * @psalm-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.      * @psalm-suppress InvalidPropertyAssignmentValue
  319.      *
  320.      * This breaks assumptions about the template type, but it would
  321.      * be a backwards-incompatible change to remove this method
  322.      */
  323.     public function add(mixed $element)
  324.     {
  325.         $this->elements[] = $element;
  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.     public function reduce(Closure $func, $initial = null)
  367.     {
  368.         return array_reduce($this->elements, $func, $initial);
  369.     }
  371.     /**
  372.      * {@inheritDoc}
  373.      *
  374.      * @psalm-param Closure(T, TKey):bool $p
  375.      *
  376.      * @return static
  377.      * @psalm-return static<TKey,T>
  378.      */
  379.     public function filter(Closure $p)
  380.     {
  381.         return $this->createFrom(array_filter($this->elements, $p, ARRAY_FILTER_USE_BOTH));
  382.     }
  384.     /**
  385.      * {@inheritDoc}
  386.      */
  387.     public function findFirst(Closure $p)
  388.     {
  389.         foreach ($this->elements as $key => $element) {
  390.             if ($p($key, $element)) {
  391.                 return $element;
  392.             }
  393.         }
  395.         return null;
  396.     }
  398.     /**
  399.      * {@inheritDoc}
  400.      */
  401.     public function forAll(Closure $p)
  402.     {
  403.         foreach ($this->elements as $key => $element) {
  404.             if (! $p($key, $element)) {
  405.                 return false;
  406.             }
  407.         }
  409.         return true;
  410.     }
  412.     /**
  413.      * {@inheritDoc}
  414.      */
  415.     public function partition(Closure $p)
  416.     {
  417.         $matches = $noMatches = [];
  419.         foreach ($this->elements as $key => $element) {
  420.             if ($p($key, $element)) {
  421.                 $matches[$key] = $element;
  422.             } else {
  423.                 $noMatches[$key] = $element;
  424.             }
  425.         }
  427.         return [$this->createFrom($matches), $this->createFrom($noMatches)];
  428.     }
  430.     /**
  431.      * Returns a string representation of this object.
  432.      * {@inheritDoc}
  433.      *
  434.      * @return string
  435.      */
  436.     #[ReturnTypeWillChange]
  437.     public function __toString()
  438.     {
  439.         return self::class . '@' . spl_object_hash($this);
  440.     }
  442.     /**
  443.      * {@inheritDoc}
  444.      */
  445.     public function clear()
  446.     {
  447.         $this->elements = [];
  448.     }
  450.     /**
  451.      * {@inheritDoc}
  452.      */
  453.     public function slice(int $offset, int|null $length = null)
  454.     {
  455.         return array_slice($this->elements, $offset, $length, true);
  456.     }
  458.     /** @psalm-return Collection<TKey, T>&Selectable<TKey,T> */
  459.     public function matching(Criteria $criteria)
  460.     {
  461.         $expr     = $criteria->getWhereExpression();
  462.         $filtered = $this->elements;
  464.         if ($expr) {
  465.             $visitor  = new ClosureExpressionVisitor();
  466.             $filter   = $visitor->dispatch($expr);
  467.             $filtered = array_filter($filtered, $filter);
  468.         }
  470.         $orderings = $criteria->orderings();
  472.         if ($orderings) {
  473.             $next = null;
  474.             foreach (array_reverse($orderings) as $field => $ordering) {
  475.                 $next = ClosureExpressionVisitor::sortByField($field, $ordering === Order::Descending ? -1 : 1, $next);
  476.             }
  478.             uasort($filtered, $next);
  479.         }
  481.         $offset = $criteria->getFirstResult();
  482.         $length = $criteria->getMaxResults();
  484.         if ($offset !== null && $offset > 0 || $length !== null && $length > 0) {
  485.             $filtered = array_slice($filtered, (int) $offset, $length, true);
  486.         }
  488.         return $this->createFrom($filtered);
  489.     }
  490. }