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

  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.      * tag v6.6.0 Return type will be natively typed to `static`
  129.      *
  130.      * @return static
  131.      */
  132.     #[\ReturnTypeWillChange]
  133.     public function filterInstance(string $class)
  134.     {
  135.         return $this->filter(static function ($item) use ($class) {
  136.             return $item instanceof $class;
  137.         });
  138.     }
  140.     /**
  141.      * tag v6.6.0 Return type will be natively typed to `static`
  142.      *
  143.      * @return static
  144.      */
  145.     #[\ReturnTypeWillChange]
  146.     public function filter(\Closure $closure)
  147.     {
  148.         return $this->createNew(array_filter($this->elements, $closure));
  149.     }
  151.     /**
  152.      * tag v6.6.0 Return type will be natively typed to `static`
  153.      *
  154.      * @return static
  155.      */
  156.     #[\ReturnTypeWillChange]
  157.     public function slice(int $offset, ?int $length = null)
  158.     {
  159.         return $this->createNew(\array_slice($this->elements, $offset, $length, true));
  160.     }
  162.     /**
  163.      * @return array<TElement>
  164.      */
  165.     public function getElements(): array
  166.     {
  167.         return $this->elements;
  168.     }
  170.     /**
  171.      * @return list<TElement>
  172.      */
  173.     public function jsonSerialize(): array
  174.     {
  175.         return array_values($this->elements);
  176.     }
  178.     /**
  179.      * return ($this->elements is non-empty-array ? TElement : null) does not work as return type for now.
  180.      * Possible with PHPStan 1.9.0 see https://github.com/phpstan/phpstan/issues/7110
  181.      */
  182.     public function first()
  183.     {
  184.         return array_values($this->elements)[0] ?? null;
  185.     }
  187.     /**
  188.      * @return TElement|null
  189.      */
  190.     public function getAt(int $position)
  191.     {
  192.         return array_values($this->elements)[$position] ?? null;
  193.     }
  195.     /**
  196.      * return ($this->elements is non-empty-array ? TElement : null) does not work as return type for now.
  197.      * Possible with PHPStan 1.9.0 see https://github.com/phpstan/phpstan/issues/7110
  198.      */
  199.     public function last()
  200.     {
  201.         return array_values($this->elements)[\count($this->elements) - 1] ?? null;
  202.     }
  204.     /**
  205.      * @param array-key $key
  206.      */
  207.     public function remove($key): void
  208.     {
  209.         unset($this->elements[$key]);
  210.     }
  212.     /**
  213.      * @return \Generator<TElement>
  214.      */
  215.     public function getIterator(): \Traversable
  216.     {
  217.         yield from $this->elements;
  218.     }
  220.     /**
  221.      * @return class-string<TElement>|null
  222.      */
  223.     protected function getExpectedClass(): ?string
  224.     {
  225.         return null;
  226.     }
  228.     /**
  229.      * @param iterable<TElement> $elements
  230.      *
  231.      * tag v6.6.0 Return type will be natively typed to `static`
  232.      *
  233.      * @return static
  234.      */
  235.     #[\ReturnTypeWillChange]
  236.     protected function createNew(iterable $elements = [])
  237.     {
  238.         return new static($elements);
  239.     }
  241.     /**
  242.      * @param TElement $element
  243.      */
  244.     protected function validateType($element): void
  245.     {
  246.         $expectedClass = $this->getExpectedClass();
  247.         if ($expectedClass === null) {
  248.             return;
  249.         }
  251.         if (!$element instanceof $expectedClass) {
  252.             $elementClass = \get_class($element);
  254.             throw new \InvalidArgumentException(
  255.                 sprintf('Expected collection element of type %s got %s', $expectedClass, $elementClass)
  256.             );
  257.         }
  258.     }
  259. }