Spiral\ORM\EntityCache

Complexity

Total Complexity

17

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	2
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	isEnabled()	0	4	1
A	configureCache()	0	4	1
A	configure()	0	11	3
B	remember()	0	12	5
A	forget()	0	8	2
A	has()	0	4	1
A	get()	0	8	2
A	flushCache()	0	4	1
A	__destruct()	0	4	1

<?php
/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */
namespace Spiral\ORM;

use Spiral\Core\Component;
use Spiral\Models\IdentifiedInterface;
use Spiral\ORM\Exceptions\CacheException;

/**
 * Entity cache support. Used to share same model instance across it's child or related objects.
 *
 * @todo Interface is needed
 */
class EntityCache extends Component
{
    /**
     * Indication that entity cache is enabled.
     *
     * @var bool
     */
    private $enabled = true;

    /**
     * Maximum entity cache size. Null is unlimited.
     *
     * @var int|null
     */
    private $cacheSize = null;

    /**
     * In cases when ORM cache is enabled every constructed instance will be stored here, cache used
     * mainly to ensure the same instance of object, even if was accessed from different spots.
     * Cache usage increases memory consumption and does not decreases amount of queries being made.
     *
     * @var RecordEntity[]
     */
    private $cache = [];

    /**
     * Check if entity cache enabled.
     *
     * @return bool
     */
    public function isEnabled()
    {
        return $this->enabled;
    }

    /**
     * Enable or disable entity cache. Disabling cache will not flush it's values.
     *
     * @deprecated see configure
     * @param bool     $enabled
     * @param int|null $maxSize Null = unlimited.
     * @return $this
     */
    public function configureCache($enabled, $maxSize = null)
    {
        return $this->configure($enabled, $maxSize);
    }

    /**
     * Enable or disable entity cache. Disabling cache will not flush it's values.
     *
     * @param bool     $enabled
     * @param int|null $maxSize Null = unlimited.
     * @return $this
     */
    public function configure($enabled, $maxSize = null)
    {
        $this->enabled = (bool)$enabled;
        if (!is_null($maxSize) && !is_int($maxSize)) {
            throw new \InvalidArgumentException("Cache size value has to be null or integer.");
        }

        $this->cacheSize = $maxSize;

        return $this;
    }

    /**
     * Add Record to entity cache (only if cache enabled). Primary key is required for caching.
     *
     * @param IdentifiedInterface $entity
     * @param bool                $ignoreLimit Cache overflow will be ignored.
     * @return IdentifiedInterface
     * @throws CacheException
     */
    public function remember(IdentifiedInterface $entity, $ignoreLimit = true)
    {
        if (empty($entity->primaryKey()) || !$this->enabled) {
            return $entity;
        }

        if (!$ignoreLimit && count($this->cache) > $this->cacheSize) {
            throw new CacheException("Entity cache size exceeded.");
        }

        return $this->cache[get_class($entity) . '.' . $entity->primaryKey()] = $entity;
    }

    /**
     * Remove Record record from entity cache. Primary key is required for caching.
     *
     * @param IdentifiedInterface $entity
     */
    public function forget(IdentifiedInterface $entity)
    {
        if (empty($entity->primaryKey())) {
            return;
        }

        unset($this->cache[get_class($entity) . '.' . $entity->primaryKey()]);
    }

    /**
     * Check if desired entity was already cached.
     *
     * @param string $class
     * @param mixed  $primaryKey
     * @return bool
     */
    public function has($class, $primaryKey)
    {
        return isset($this->cache[$class . '.' . $primaryKey]);
    }

    /**
     * Fetch entity from cache.
     *
     * @param string $class
     * @param mixed  $primaryKey
     * @return null|IdentifiedInterface
     */
    public function get($class, $primaryKey)
    {
        if (empty($this->cache[$class . '.' . $primaryKey])) {
            return null;
        }

        return $this->cache[$class . '.' . $primaryKey];
    }

    /**
     * Flush content of entity cache.
     */
    public function flushCache()
    {
        $this->cache = [];
    }

    /**
     * Destructing.
     */
    public function __destruct()
    {
        $this->flushCache();
    }
}