MapperScalarSequence.php

<?php
 
declare(strict_types=1);
namespace Commercetools\Base;
 
use stdClass;
 
abstract class MapperScalarSequence implements CSequence
{
    private $data;
    private $indexes = [];
    private $iterator;
 
    final public function __construct(array $data = null)
    {
        if (!is_null($data)) {
            $this->index($data);
        }
        $this->data = $data;
        $this->iterator = $this->getIterator();
    }
 
    public function toArray(): ?array
    {
        return $this->data;
    }
 
    #[\ReturnTypeWillChange]
    public function jsonSerialize(): ?array
    {
        return $this->data;
    }
 
    final public static function fromArray(array $data)
    {
        return new static($data);
    }
 
    protected function index($data): void
    {
    }
 
    final protected function get(?int $index)
    {
        if (isset($this->data[$index])) {
            return $this->data[$index];
        }
        return null;
    }
 
    final protected function set($data, ?int $index): void
    {
        if (is_null($index)) {
            $this->data[] = $data;
        } else {
            $this->data[$index] = $data;
        }
    }
 
    public function add($value)
    {
        return $this->store($value);
    }
 
    final protected function store($value)
    {
        $this->set($value, null);
        $this->iterator = $this->getIterator();
 
        return $this;
    }
 
    public function at(int $index)
    {
        return $this->mapper()($index);
    }
 
    abstract protected function mapper();
 
    final protected function addToIndex(string $field, string $key, int $index): void
    {
        $this->indexes[$field][$key] = $index;
    }
 
    final protected function valueByKey(string $field, string $key)
    {
        return isset($this->indexes[$field][$key]) ? $this->at($this->indexes[$field][$key]) : null;
    }
 
    public function getIterator(): MapperIterator
    {
        $keys = !is_null($this->data) ? array_keys($this->data) : [];
        $keyIterator = new \ArrayIterator(array_combine($keys, $keys));
        $iterator = new MapperIterator(
            $keyIterator,
            $this->mapper()
        );
        $iterator->rewind();
 
        return $iterator;
    }
 
    public function current()
    {
        return $this->iterator->current();
    }
 
    public function end()
    {
        if ($this->data == null) {
            return null;
        }
        $arrayKeys = array_keys($this->data);
        $lastKey = array_pop($arrayKeys);
 
        return $this->at($lastKey);
    }
 
    public function next()
    {
        $this->iterator->next();
    }
 
    public function key()
    {
        return $this->iterator->key();
    }
 
    public function valid()
    {
        return $this->iterator->valid();
    }
 
    public function rewind()
    {
        $this->iterator->rewind();
    }
 
    public function offsetExists($offset)
    {
        return !is_null($this->data) && array_key_exists($offset, $this->data);
    }
 
    public function offsetGet($offset)
    {
        return $this->at($offset);
    }
 
    public function offsetSet($offset, $value)
    {
        $this->set($value, $offset);
        $this->iterator = $this->getIterator();
    }
 
    public function offsetUnset($offset)
    {
        if ($this->offsetExists($offset)) {
            unset($this->data[$offset]);
            $this->iterator = $this->getIterator();
        }
    }
 
    final public static function of()
    {
        return new static();
    }
}