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

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