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

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\Struct;
  5. /**
  6.  * @template TElement
  7.  */
  8. abstract class Collection extends Struct implements \IteratorAggregate, \Countable
  9. {
  10.     /**
  11.      * @var array<TElement>
  12.      */
  13.     protected $elements = [];
  15.     /**
  16.      * @param array<TElement> $elements
  17.      */
  18.     public function __construct(iterable $elements = [])
  19.     {
  20.         foreach ($elements as $key => $element) {
  21.             $this->set($key, $element);
  22.         }
  23.     }
  25.     /**
  26.      * @param TElement $element
  27.      */
  28.     public function add($element): void
  29.     {
  30.         $this->validateType($element);
  32.         $this->elements[] = $element;
  33.     }
  35.     /**
  36.      * @param TElement $element
  37.      */
  38.     public function set($key, $element): void
  39.     {
  40.         $this->validateType($element);
  42.         if ($key === null) {
  43.             $this->elements[] = $element;
  44.         } else {
  45.             $this->elements[$key] = $element;
  46.         }
  47.     }
  49.     /**
  50.      * @param mixed|null $key
  51.      *
  52.      * @return TElement|null
  53.      */
  54.     public function get($key)
  55.     {
  56.         if ($this->has($key)) {
  57.             return $this->elements[$key];
  58.         }
  60.         return null;
  61.     }
  63.     public function clear(): void
  64.     {
  65.         $this->elements = [];
  66.     }
  68.     public function count(): int
  69.     {
  70.         return \count($this->elements);
  71.     }
  73.     public function getKeys(): array
  74.     {
  75.         return array_keys($this->elements);
  76.     }
  78.     public function has($key): bool
  79.     {
  80.         return \array_key_exists($key, $this->elements);
  81.     }
  83.     public function map(\Closure $closure): array
  84.     {
  85.         return array_map($closure, $this->elements);
  86.     }
  88.     public function reduce(\Closure $closure, $initial = null)
  89.     {
  90.         return array_reduce($this->elements, $closure, $initial);
  91.     }
  93.     public function fmap(\Closure $closure): array
  94.     {
  95.         return array_filter($this->map($closure));
  96.     }
  98.     public function sort(\Closure $closure): void
  99.     {
  100.         uasort($this->elements, $closure);
  101.     }
  103.     /**
  104.      * @return static
  105.      */
  106.     public function filterInstance(string $class)
  107.     {
  108.         return $this->filter(static function ($item) use ($class) {
  109.             return $item instanceof $class;
  110.         });
  111.     }
  113.     /**
  114.      * @return static
  115.      */
  116.     public function filter(\Closure $closure)
  117.     {
  118.         return $this->createNew(array_filter($this->elements, $closure));
  119.     }
  121.     /**
  122.      * @return static
  123.      */
  124.     public function slice(int $offset, ?int $length = null)
  125.     {
  126.         return $this->createNew(\array_slice($this->elements, $offset, $length, true));
  127.     }
  129.     /**
  130.      * @return array<TElement>
  131.      */
  132.     public function getElements(): array
  133.     {
  134.         return $this->elements;
  135.     }
  137.     /**
  138.      * @return list<TElement>
  139.      */
  140.     public function jsonSerialize(): array
  141.     {
  142.         return array_values($this->elements);
  143.     }
  145.     /**
  146.      * @return ($this->elements is non-empty-array ? TElement : null)
  147.      */
  148.     public function first()
  149.     {
  150.         return array_values($this->elements)[0] ?? null;
  151.     }
  153.     /**
  154.      * @return TElement|null
  155.      */
  156.     public function getAt(int $position)
  157.     {
  158.         return array_values($this->elements)[$position] ?? null;
  159.     }
  161.     /**
  162.      * @return ($this->elements is non-empty-array ? TElement : null)
  163.      */
  164.     public function last()
  165.     {
  166.         return array_values($this->elements)[\count($this->elements) - 1] ?? null;
  167.     }
  169.     /**
  170.      * @param int|string $key
  171.      */
  172.     public function remove($key): void
  173.     {
  174.         unset($this->elements[$key]);
  175.     }
  177.     /**
  178.      * @deprecated tag:v6.5.0 - reason:return-type-change - Return type will be changed to \Traversable
  179.      *
  180.      * @return \Generator<TElement>
  181.      */
  182.     #[\ReturnTypeWillChange]
  183.     public function getIterator(): \Generator/* :\Traversable */
  184.     {
  185.         yield from $this->elements;
  186.     }
  188.     /**
  189.      * @return class-string<TElement>|null
  190.      */
  191.     protected function getExpectedClass(): ?string
  192.     {
  193.         return null;
  194.     }
  196.     /**
  197.      * @return static
  198.      */
  199.     protected function createNew(iterable $elements = [])
  200.     {
  201.         return new static($elements);
  202.     }
  204.     protected function validateType($element): void
  205.     {
  206.         $expectedClass = $this->getExpectedClass();
  207.         if ($expectedClass === null) {
  208.             return;
  209.         }
  211.         if (!$element instanceof $expectedClass) {
  212.             $elementClass = \get_class($element);
  214.             throw new \InvalidArgumentException(
  215.                 sprintf('Expected collection element of type %s got %s', $expectedClass, $elementClass)
  216.             );
  217.         }
  218.     }
  219. }