Maslosoft\EmbeDi\StaticStorage

Complexity

Total Complexity

30

Size/Duplication

Total Lines	203
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	29	6
A	getAll()	0	4	1
A	setAll()	0	4	1
A	removeAll()	0	4	1
A	destroy()	0	4	1
A	__get()	0	4	1
A	__set()	0	4	1
A	__unset()	0	4	1
A	__isset()	0	4	1
A	count()	0	4	1
A	current()	0	4	1
A	key()	0	4	1
A	next()	0	4	1
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	rewind()	0	4	1
A	serialize()	0	4	1
A	unserialize()	0	4	1
A	valid()	0	4	1
A	_propertize()	0	16	4

<?php

/**
 * This software package is licensed under `AGPL, Commercial` license[s].
 *
 * @package maslosoft/embedi
 * @license AGPL, Commercial
 *
 * @copyright Copyright (c) Peter Maselkowski <pmaselkowski@gmail.com>
 *
 */

namespace Maslosoft\EmbeDi;

use ArrayAccess;
use Countable;
use Iterator;
use Maslosoft\EmbeDi\Interfaces\MassAssignedInterface;
use ReflectionObject;
use ReflectionProperty;
use Serializable;

/**
 * Static Storage class
 * This stores variables in static var, depending on owner and instance id
 *
 * @author Piotr Maselkowski <pmaselkowski at gmail.com>
 */
class StaticStorage implements Countable, Iterator, Serializable, ArrayAccess, MassAssignedInterface
{

	/**
	 * Namespace, current container class name
	 * @var string
	 */
	private $ns = '';

	/**
	 * Owner Id
	 * @var string
	 */
	private $ownerId = '';

	/**
	 * Instance id
	 * @var string
	 */
	private $instanceId = '';

	/**
	 * Preset ID
	 * @var string
	 */
	private $presetId = '';

	/**
	 * Key for storage
	 * @var string
	 */
	private $key = '';

	/**
	 * Stored values
	 * @var mixed[][]
	 */
	public static $values = [];

	/**
	 *
	 * @param object|string $owner
	 * @param string $instanceId
	 */
	public function __construct($owner, $instanceId, $presetId = null)
	{
		$this->ns = get_class($this);
		$this->ownerId = is_object($owner) ? get_class($owner) : $owner;
		$this->instanceId = $instanceId;
		$this->presetId = $presetId;
		if (!empty($presetId))
		{
			$this->key = $this->instanceId . '.' . $this->presetId;
		}
		else
		{
			$this->key = $this->instanceId;
		}
		// Gracefully init - this is required for subsequent constructor calls
		if (!array_key_exists($this->ns, self::$values))
		{
			self::$values[$this->ns] = [];
		}
		if (!array_key_exists($this->ownerId, self::$values[$this->ns]))
		{
			self::$values[$this->ns][$this->ownerId] = [];
		}
		if (!array_key_exists($this->key, self::$values[$this->ns][$this->ownerId]))
		{
			self::$values[$this->ns][$this->ownerId][$this->key] = [];
		}
		$this->_propertize();
	}

	public function getAll()
	{
		return self::$values[$this->ns][$this->ownerId][$this->key];
	}

	public function setAll($values)
	{
		return self::$values[$this->ns][$this->ownerId][$this->key] = $values;
	}

	public function removeAll()
	{
		self::$values[$this->ns][$this->ownerId][$this->key] = [];
	}

	/**
	 * Destroy all data in all containers
	 */
	public function destroy()
	{
		self::$values = [];
	}

	public function &__get($name)
	{
		return self::$values[$this->ns][$this->ownerId][$this->key][$name];
	}

	public function __set($name, $value)
	{
		self::$values[$this->ns][$this->ownerId][$this->key][$name] = $value;
	}

	public function __unset($name)
	{
		unset(self::$values[$this->ns][$this->ownerId][$this->key][$name]);
	}

	public function __isset($name)
	{
		return isset(self::$values[$this->ns][$this->ownerId][$this->key][$name]);
	}

// <editor-fold defaultstate="collapsed" desc="Interfaces implementation">

	public function count($mode = 'COUNT_NORMAL')
	{
		return count(self::$values[$this->ns][$this->ownerId][$this->instanceId]);
	}

	public function current()
	{
		return current(self::$values[$this->ns][$this->ownerId][$this->instanceId]);
	}

	public function key()
	{
		return key(self::$values[$this->ns][$this->ownerId][$this->instanceId]);
	}

	public function next()
	{
		return next(self::$values[$this->ns][$this->ownerId][$this->instanceId]);
	}

	public function offsetExists($offset)
	{
		return array_key_exists($offset, self::$values[$this->ns][$this->ownerId][$this->instanceId]);
	}

	public function offsetGet($offset)
	{
		return self::$values[$this->ns][$this->ownerId][$this->instanceId][$offset];
	}

	public function offsetSet($offset, $value)
	{
		self::$values[$this->ns][$this->ownerId][$this->instanceId][$offset] = $value;
	}

	public function offsetUnset($offset)
	{
		unset(self::$values[$this->ns][$this->ownerId][$this->instanceId][$offset]);
	}

	public function rewind()
	{
		reset(self::$values[$this->ns][$this->ownerId][$this->instanceId]);
	}

	public function serialize()
	{
		return serialize(self::$values[$this->ns][$this->ownerId][$this->instanceId]);
	}

	public function unserialize($serialized)
	{
		return self::$values[$this->ns][$this->ownerId][$this->instanceId] = unserialize($serialized);
	}

	public function valid()
	{
		return $this->offsetExists($this->key());
	}

// </editor-fold>

	/**
	 * This unsets class fields and turns them into storage-aware properties
	 * @return void
	 */
	private function _propertize()
	{
		foreach ((new ReflectionObject($this))->getProperties(ReflectionProperty::IS_PUBLIC) as $property)
		{
			// http://stackoverflow.com/a/15784768/133408
			if (!$property->isStatic())
			{
				$name = $property->name;
				if (!array_key_exists($name, self::$values[$this->ns][$this->ownerId][$this->key]))
				{
					$this->__set($name, $this->$name);
				}
				unset($this->$name);
			}
		}
	}

}