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

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\Struct;
  5. abstract class Collection extends Struct implements \IteratorAggregate, \Countable
  6. {
  7.     /**
  8.      * @var array
  9.      */
  10.     protected $elements = [];
  12.     public function __construct(iterable $elements = [])
  13.     {
  14.         foreach ($elements as $key => $element) {
  15.             $this->set($key, $element);
  16.         }
  17.     }
  19.     public function add($element): void
  20.     {
  21.         $this->validateType($element);
  23.         $this->elements[] = $element;
  24.     }
  26.     public function set($key, $element): void
  27.     {
  28.         $this->validateType($element);
  30.         if ($key === null) {
  31.             $this->elements[] = $element;
  32.         } else {
  33.             $this->elements[$key] = $element;
  34.         }
  35.     }
  37.     /**
  38.      * @param mixed|null $key
  39.      *
  40.      * @return mixed|null
  41.      */
  42.     public function get($key)
  43.     {
  44.         if ($this->has($key)) {
  45.             return $this->elements[$key];
  46.         }
  48.         return null;
  49.     }
  51.     public function clear(): void
  52.     {
  53.         $this->elements = [];
  54.     }
  56.     public function count(): int
  57.     {
  58.         return \count($this->elements);
  59.     }
  61.     public function getKeys(): array
  62.     {
  63.         return array_keys($this->elements);
  64.     }
  66.     public function has($key): bool
  67.     {
  68.         return \array_key_exists($key, $this->elements);
  69.     }
  71.     public function map(\Closure $closure): array
  72.     {
  73.         return array_map($closure, $this->elements);
  74.     }
  76.     public function reduce(\Closure $closure, $initial = null)
  77.     {
  78.         return array_reduce($this->elements, $closure, $initial);
  79.     }
  81.     public function fmap(\Closure $closure): array
  82.     {
  83.         return array_filter($this->map($closure));
  84.     }
  86.     public function sort(\Closure $closure): void
  87.     {
  88.         uasort($this->elements, $closure);
  89.     }
  91.     /**
  92.      * @return static
  93.      */
  94.     public function filterInstance(string $class)
  95.     {
  96.         return $this->filter(static function ($item) use ($class) {
  97.             return $item instanceof $class;
  98.         });
  99.     }
  101.     /**
  102.      * @return static
  103.      */
  104.     public function filter(\Closure $closure)
  105.     {
  106.         return $this->createNew(array_filter($this->elements, $closure));
  107.     }
  109.     /**
  110.      * @return static
  111.      */
  112.     public function slice(int $offset, ?int $length = null)
  113.     {
  114.         return $this->createNew(\array_slice($this->elements, $offset, $length, true));
  115.     }
  117.     public function getElements(): array
  118.     {
  119.         return $this->elements;
  120.     }
  122.     public function jsonSerialize(): array
  123.     {
  124.         return array_values($this->elements);
  125.     }
  127.     public function first()
  128.     {
  129.         return array_values($this->elements)[0] ?? null;
  130.     }
  132.     public function getAt(int $position)
  133.     {
  134.         return array_values($this->elements)[$position] ?? null;
  135.     }
  137.     public function last()
  138.     {
  139.         return array_values($this->elements)[\count($this->elements) - 1] ?? null;
  140.     }
  142.     /**
  143.      * @param int|string $key
  144.      */
  145.     public function remove($key): void
  146.     {
  147.         unset($this->elements[$key]);
  148.     }
  150.     /**
  151.      * @deprecated tag:v6.5.0 - reason:return-type-change - Return type will be changed to \Traversable
  152.      */
  153.     #[\ReturnTypeWillChange]
  154.     public function getIterator(): \Generator/* :\Traversable */
  155.     {
  156.         yield from $this->elements;
  157.     }
  159.     protected function getExpectedClass(): ?string
  160.     {
  161.         return null;
  162.     }
  164.     /**
  165.      * @return static
  166.      */
  167.     protected function createNew(iterable $elements = [])
  168.     {
  169.         return new static($elements);
  170.     }
  172.     protected function validateType($element): void
  173.     {
  174.         $expectedClass = $this->getExpectedClass();
  175.         if ($expectedClass === null) {
  176.             return;
  177.         }
  179.         if (!$element instanceof $expectedClass) {
  180.             $elementClass = \get_class($element);
  182.             throw new \InvalidArgumentException(
  183.                 sprintf('Expected collection element of type %s got %s', $expectedClass, $elementClass)
  184.             );
  185.         }
  186.     }
  187. }