vendor/shopware/core/Framework/Struct/Collection.php line 120

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\Struct;
  5. use Shopware\Core\Framework\Log\Package;
  7. /**
  8.  * @template TElement
  9.  * @implements \IteratorAggregate<array-key, TElement>
  10.  */
  11. #[Package('core')]
  12. abstract class Collection extends Struct implements \IteratorAggregate, \Countable
  13. {
  14.     /**
  15.      * @var array<array-key, TElement>
  16.      */
  17.     protected $elements = [];
  19.     /**
  20.      * @param array<TElement> $elements
  21.      */
  22.     public function __construct(iterable $elements = [])
  23.     {
  24.         foreach ($elements as $key => $element) {
  25.             $this->set($key, $element);
  26.         }
  27.     }
  29.     /**
  30.      * @param TElement $element
  31.      */
  32.     public function add($element): void
  33.     {
  34.         $this->validateType($element);
  36.         $this->elements[] = $element;
  37.     }
  39.     /**
  40.      * @param array-key|null $key
  41.      * @param TElement $element
  42.      */
  43.     public function set($key, $element): void
  44.     {
  45.         $this->validateType($element);
  47.         if ($key === null) {
  48.             $this->elements[] = $element;
  49.         } else {
  50.             $this->elements[$key] = $element;
  51.         }
  52.     }
  54.     /**
  55.      * @param array-key $key
  56.      *
  57.      * @return TElement|null
  58.      */
  59.     public function get($key)
  60.     {
  61.         if ($this->has($key)) {
  62.             return $this->elements[$key];
  63.         }
  65.         return null;
  66.     }
  68.     public function clear(): void
  69.     {
  70.         $this->elements = [];
  71.     }
  73.     public function count(): int
  74.     {
  75.         return \count($this->elements);
  76.     }
  78.     /**
  79.      * @return list<array-key>
  80.      */
  81.     public function getKeys(): array
  82.     {
  83.         return array_keys($this->elements);
  84.     }
  86.     /**
  87.      * @param array-key $key
  88.      */
  89.     public function has($key): bool
  90.     {
  91.         return \array_key_exists($key, $this->elements);
  92.     }
  94.     /**
  95.      * @return list<mixed>
  96.      */
  97.     public function map(\Closure $closure): array
  98.     {
  99.         return array_map($closure, $this->elements);
  100.     }
  102.     /**
  103.      * @param  mixed|null        $initial
  104.      *
  105.      * @return mixed|null
  106.      */
  107.     public function reduce(\Closure $closure, $initial = null)
  108.     {
  109.         return array_reduce($this->elements, $closure, $initial);
  110.     }
  112.     /**
  113.      * @return array<array-key, mixed>
  114.      */
  115.     public function fmap(\Closure $closure): array
  116.     {
  117.         return array_filter($this->map($closure));
  118.     }
  120.     public function sort(\Closure $closure): void
  121.     {
  122.         uasort($this->elements, $closure);
  123.     }
  125.     /**
  126.      * @param class-string $class
  127.      *
  128.      * @return static
  129.      */
  130.     public function filterInstance(string $class)
  131.     {
  132.         return $this->filter(static function ($item) use ($class) {
  133.             return $item instanceof $class;
  134.         });
  135.     }
  137.     /**
  138.      * @return static
  139.      */
  140.     public function filter(\Closure $closure)
  141.     {
  142.         return $this->createNew(array_filter($this->elements, $closure));
  143.     }
  145.     /**
  146.      * @return static
  147.      */
  148.     public function slice(int $offset, ?int $length = null)
  149.     {
  150.         return $this->createNew(\array_slice($this->elements, $offset, $length, true));
  151.     }
  153.     /**
  154.      * @return array<TElement>
  155.      */
  156.     public function getElements(): array
  157.     {
  158.         return $this->elements;
  159.     }
  161.     /**
  162.      * @return list<TElement>
  163.      */
  164.     public function jsonSerialize(): array
  165.     {
  166.         return array_values($this->elements);
  167.     }
  169.     /**
  170.      * return ($this->elements is non-empty-array ? TElement : null) does not work as return type for now.
  171.      * Possible with PHPStan 1.9.0 see https://github.com/phpstan/phpstan/issues/7110
  172.      */
  173.     public function first()
  174.     {
  175.         return array_values($this->elements)[0] ?? null;
  176.     }
  178.     /**
  179.      * @return TElement|null
  180.      */
  181.     public function getAt(int $position)
  182.     {
  183.         return array_values($this->elements)[$position] ?? null;
  184.     }
  186.     /**
  187.      * return ($this->elements is non-empty-array ? TElement : null) does not work as return type for now.
  188.      * Possible with PHPStan 1.9.0 see https://github.com/phpstan/phpstan/issues/7110
  189.      */
  190.     public function last()
  191.     {
  192.         return array_values($this->elements)[\count($this->elements) - 1] ?? null;
  193.     }
  195.     /**
  196.      * @param array-key $key
  197.      */
  198.     public function remove($key): void
  199.     {
  200.         unset($this->elements[$key]);
  201.     }
  203.     /**
  204.      * @deprecated tag:v6.5.0 - reason:return-type-change - Return type will be changed to \Traversable
  205.      *
  206.      * @return \Generator<TElement>
  207.      */
  208.     #[\ReturnTypeWillChange]
  209.     public function getIterator(): \Generator/* :\Traversable */
  210.     {
  211.         yield from $this->elements;
  212.     }
  214.     /**
  215.      * @return class-string<TElement>|null
  216.      */
  217.     protected function getExpectedClass(): ?string
  218.     {
  219.         return null;
  220.     }
  222.     /**
  223.      * @param iterable<TElement> $elements
  224.      *
  225.      * @return static
  226.      */
  227.     protected function createNew(iterable $elements = [])
  228.     {
  229.         return new static($elements);
  230.     }
  232.     /**
  233.      * @param TElement $element
  234.      */
  235.     protected function validateType($element): void
  236.     {
  237.         $expectedClass = $this->getExpectedClass();
  238.         if ($expectedClass === null) {
  239.             return;
  240.         }
  242.         if (!$element instanceof $expectedClass) {
  243.             $elementClass = \get_class($element);
  245.             throw new \InvalidArgumentException(
  246.                 sprintf('Expected collection element of type %s got %s', $expectedClass, $elementClass)
  247.             );
  248.         }
  249.     }
  250. }