MapperMap.php

<?php
 
declare(strict_types=1);
namespace Commercetools\Base;
 
use stdClass;
 
abstract class MapperMap implements CMap
{
    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();
    }
 
    final public static function of($data = null)
    {
        if (is_array($data)) {
            return self::fromArray($data);
        }
        return self::fromStdClass($data);
    }
 
    public function toArray(): ?array
    {
        return $this->data;
    }
 
    #[\ReturnTypeWillChange]
    public function jsonSerialize(): ?array
    {
        return $this->data;
    }
 
    final public static function fromStdClass(stdClass $data = null)
    {
        $t = (array)$data;
        return new static($t);
    }
 
    final public static function fromArray(array $data)
    {
        return new static($data);
    }
 
    protected function index($data): void
    {
    }
 
    final protected function get(string $key)
    {
        if (isset($this->data[$key])) {
            return $this->data[$key];
        }
        return null;
    }
 
    final protected function set($data, string $key): void
    {
        $this->data[$key] = $data;
    }
 
    public function put(string $key, $value)
    {
        return $this->store($key, $value);
    }
 
    final protected function store(string $key, $value)
    {
        $this->set($value, $key);
        $this->iterator = $this->getIterator();
 
        return $this;
    }
 
    public function at(string $key)
    {
        return $this->mapper()($key);
    }
 
    public function with(string $key, callable $callable = null)
    {
        $data = $this->at($key);
        if (is_null($callable)) {
            return $data;
        }
 
        return $callable($data);
    }
 
    abstract protected function mapper();
 
    final protected function addToIndex(string $field, string $key, string $indexKey): void
    {
        $this->indexes[$field][$key] = $indexKey;
    }
 
    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 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->store($offset, $value);
    }
 
    public function offsetUnset($offset)
    {
        if ($this->offsetExists($offset)) {
            unset($this->data[$offset]);
            $this->iterator = $this->getIterator();
        }
    }
}