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.      * @param array $elements
  63.      * @psalm-param array<TKey,T> $elements
  64.      */
  65.     public function __construct(array $elements = [])
  66.     {
  67.         $this->elements = $elements;
  68.     }
  70.     /**
  71.      * {@inheritDoc}
  72.      */
  73.     public function toArray()
  74.     {
  75.         return $this->elements;
  76.     }
  78.     /**
  79.      * {@inheritDoc}
  80.      */
  81.     public function first()
  82.     {
  83.         return reset($this->elements);
  84.     }
  86.     /**
  87.      * Creates a new instance from the specified elements.
  88.      *
  89.      * This method is provided for derived classes to specify how a new
  90.      * instance should be created when constructor semantics have changed.
  91.      *
  92.      * @param array $elements Elements.
  93.      * @psalm-param array<K,V> $elements
  94.      *
  95.      * @return static
  96.      * @psalm-return static<K,V>
  97.      *
  98.      * @psalm-template K of array-key
  99.      * @psalm-template V
  100.      */
  101.     protected function createFrom(array $elements)
  102.     {
  103.         return new static($elements);
  104.     }
  106.     /**
  107.      * {@inheritDoc}
  108.      */
  109.     public function last()
  110.     {
  111.         return end($this->elements);
  112.     }
  114.     /**
  115.      * {@inheritDoc}
  116.      */
  117.     public function key()
  118.     {
  119.         return key($this->elements);
  120.     }
  122.     /**
  123.      * {@inheritDoc}
  124.      */
  125.     public function next()
  126.     {
  127.         return next($this->elements);
  128.     }
  130.     /**
  131.      * {@inheritDoc}
  132.      */
  133.     public function current()
  134.     {
  135.         return current($this->elements);
  136.     }
  138.     /**
  139.      * {@inheritDoc}
  140.      */
  141.     public function remove(string|int $key)
  142.     {
  143.         if (! isset($this->elements[$key]) && ! array_key_exists($key, $this->elements)) {
  144.             return null;
  145.         }
  147.         $removed = $this->elements[$key];
  148.         unset($this->elements[$key]);
  150.         return $removed;
  151.     }
  153.     /**
  154.      * {@inheritDoc}
  155.      */
  156.     public function removeElement(mixed $element)
  157.     {
  158.         $key = array_search($element, $this->elements, true);
  160.         if ($key === false) {
  161.             return false;
  162.         }
  164.         unset($this->elements[$key]);
  166.         return true;
  167.     }
  169.     /**
  170.      * Required by interface ArrayAccess.
  171.      *
  172.      * @param TKey $offset
  173.      *
  174.      * @return bool
  175.      */
  176.     #[ReturnTypeWillChange]
  177.     public function offsetExists(mixed $offset)
  178.     {
  179.         return $this->containsKey($offset);
  180.     }
  182.     /**
  183.      * Required by interface ArrayAccess.
  184.      *
  185.      * @param TKey $offset
  186.      *
  187.      * @return T|null
  188.      */
  189.     #[ReturnTypeWillChange]
  190.     public function offsetGet(mixed $offset)
  191.     {
  192.         return $this->get($offset);
  193.     }
  195.     /**
  196.      * Required by interface ArrayAccess.
  197.      *
  198.      * @param TKey|null $offset
  199.      * @param T         $value
  200.      *
  201.      * @return void
  202.      */
  203.     #[ReturnTypeWillChange]
  204.     public function offsetSet(mixed $offset, mixed $value)
  205.     {
  206.         if ($offset === null) {
  207.             $this->add($value);
  209.             return;
  210.         }
  212.         $this->set($offset, $value);
  213.     }
  215.     /**
  216.      * Required by interface ArrayAccess.
  217.      *
  218.      * @param TKey $offset
  219.      *
  220.      * @return void
  221.      */
  222.     #[ReturnTypeWillChange]
  223.     public function offsetUnset(mixed $offset)
  224.     {
  225.         $this->remove($offset);
  226.     }
  228.     /**
  229.      * {@inheritDoc}
  230.      */
  231.     public function containsKey(string|int $key)
  232.     {
  233.         return isset($this->elements[$key]) || array_key_exists($key, $this->elements);
  234.     }
  236.     /**
  237.      * {@inheritDoc}
  238.      */
  239.     public function contains(mixed $element)
  240.     {
  241.         return in_array($element, $this->elements, true);
  242.     }
  244.     /**
  245.      * {@inheritDoc}
  246.      */
  247.     public function exists(Closure $p)
  248.     {
  249.         foreach ($this->elements as $key => $element) {
  250.             if ($p($key, $element)) {
  251.                 return true;
  252.             }
  253.         }
  255.         return false;
  256.     }
  258.     /**
  259.      * {@inheritDoc}
  260.      *
  261.      * @psalm-param TMaybeContained $element
  262.      *
  263.      * @return int|string|false
  264.      * @psalm-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.      * @psalm-suppress InvalidPropertyAssignmentValue
  320.      *
  321.      * This breaks assumptions about the template type, but it would
  322.      * be a backwards-incompatible change to remove this method
  323.      */
  324.     public function add(mixed $element)
  325.     {
  326.         $this->elements[] = $element;
  327.     }
  329.     /**
  330.      * {@inheritDoc}
  331.      */
  332.     public function isEmpty()
  333.     {
  334.         return empty($this->elements);
  335.     }
  337.     /**
  338.      * {@inheritDoc}
  339.      *
  340.      * @return Traversable<int|string, mixed>
  341.      * @psalm-return Traversable<TKey, T>
  342.      */
  343.     #[ReturnTypeWillChange]
  344.     public function getIterator()
  345.     {
  346.         return new ArrayIterator($this->elements);
  347.     }
  349.     /**
  350.      * {@inheritDoc}
  351.      *
  352.      * @psalm-param Closure(T):U $func
  353.      *
  354.      * @return static
  355.      * @psalm-return static<TKey, U>
  356.      *
  357.      * @psalm-template U
  358.      */
  359.     public function map(Closure $func)
  360.     {
  361.         return $this->createFrom(array_map($func, $this->elements));
  362.     }
  364.     /**
  365.      * {@inheritDoc}
  366.      */
  367.     public function reduce(Closure $func, $initial = null)
  368.     {
  369.         return array_reduce($this->elements, $func, $initial);
  370.     }
  372.     /**
  373.      * {@inheritDoc}
  374.      *
  375.      * @return static
  376.      * @psalm-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.         foreach ($this->elements as $key => $element) {
  389.             if ($p($key, $element)) {
  390.                 return $element;
  391.             }
  392.         }
  394.         return null;
  395.     }
  397.     /**
  398.      * {@inheritDoc}
  399.      */
  400.     public function forAll(Closure $p)
  401.     {
  402.         foreach ($this->elements as $key => $element) {
  403.             if (! $p($key, $element)) {
  404.                 return false;
  405.             }
  406.         }
  408.         return true;
  409.     }
  411.     /**
  412.      * {@inheritDoc}
  413.      */
  414.     public function partition(Closure $p)
  415.     {
  416.         $matches = $noMatches = [];
  418.         foreach ($this->elements as $key => $element) {
  419.             if ($p($key, $element)) {
  420.                 $matches[$key] = $element;
  421.             } else {
  422.                 $noMatches[$key] = $element;
  423.             }
  424.         }
  426.         return [$this->createFrom($matches), $this->createFrom($noMatches)];
  427.     }
  429.     /**
  430.      * Returns a string representation of this object.
  431.      * {@inheritDoc}
  432.      *
  433.      * @return string
  434.      */
  435.     #[ReturnTypeWillChange]
  436.     public function __toString()
  437.     {
  438.         return self::class . '@' . spl_object_hash($this);
  439.     }
  441.     /**
  442.      * {@inheritDoc}
  443.      */
  444.     public function clear()
  445.     {
  446.         $this->elements = [];
  447.     }
  449.     /**
  450.      * {@inheritDoc}
  451.      */
  452.     public function slice(int $offset, int|null $length = null)
  453.     {
  454.         return array_slice($this->elements, $offset, $length, true);
  455.     }
  457.     /** @psalm-return Collection<TKey, T>&Selectable<TKey,T> */
  458.     public function matching(Criteria $criteria)
  459.     {
  460.         $expr     = $criteria->getWhereExpression();
  461.         $filtered = $this->elements;
  463.         if ($expr) {
  464.             $visitor  = new ClosureExpressionVisitor();
  465.             $filter   = $visitor->dispatch($expr);
  466.             $filtered = array_filter($filtered, $filter);
  467.         }
  469.         $orderings = $criteria->getOrderings();
  471.         if ($orderings) {
  472.             $next = null;
  473.             foreach (array_reverse($orderings) as $field => $ordering) {
  474.                 $next = ClosureExpressionVisitor::sortByField($field, $ordering === Criteria::DESC ? -1 : 1, $next);
  475.             }
  477.             uasort($filtered, $next);
  478.         }
  480.         $offset = $criteria->getFirstResult();
  481.         $length = $criteria->getMaxResults();
  483.         if ($offset || $length) {
  484.             $filtered = array_slice($filtered, (int) $offset, $length, true);
  485.         }
  487.         return $this->createFrom($filtered);
  488.     }
  489. }