PhpDbaCache\Cache

Complexity

Total Complexity

33

Size/Duplication

Total Lines	266
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	22	6
A	__destruct()	0	4	1
A	put()	0	14	3
A	forever()	0	4	1
A	get()	0	16	4
A	getStorage()	0	4	1
A	fetch()	0	14	3
A	delete()	0	12	3
A	has()	0	4	1
A	closeDba()	0	7	2
A	getDba()	0	4	1
A	getIds()	0	13	3
A	getMetaData()	0	13	2
A	erasable()	0	6	2

<?php

namespace PhpDbaCache;

/**
 * CacheDba - This class provides the functionality required to store
 * and retrieve PHP objects, strings, integers or arrays.
 * It uses the database (dbm-style) abstraction layer for persistence.
 * Even instances of SimpleXMLElement can be stored. You don't have
 * to matter about the size of the cache-file. It depends on the free
 * space of your disk.
 */

/**
 * Cache Dba
 *
 * @category PhpDbaCache
 */
class Cache
{
    /**
     * @var resource
     */
    protected $dba;

    /**
     * @var string
     */
    protected $handler;

    /**
     * @var string
     */
    protected $storage;

    /**
     * @param string  $file    the cache-file.
     *
     * @param string  $handler the dba handler.
     *
     * You have to install one of this handlers before use.
     *
     * cdb      = Tiny Constant Database - for reading.
     * cdb_make = Tiny Constant Database - for writing.
     * db4      = Oracle Berkeley DB 4   - for reading and writing.
     * qdbm     = Quick Database Manager - for reading and writing.
     * gdbm     = GNU Database Manager   - for reading and writing.
     * inifile  = Ini File               - for reading and writing.
     * flatfile = default dba extension  - for reading and writing.
     *
     * Use "flatfile" only when you cannot install one, of the libraries
     * required by the other handlers, and when you cannot use bundled cdb handler.
     *
     * @param string  $mode    For read/write access, database creation if it doesn't currently exist.
     *
     * r  = for read access
     * w  = for read/write access to an already existing database
     * c  = for read/write access and database creation if it doesn't currently exist
     * n  = for create, truncate and read/write access
     *
     * When you are absolutely sure that you do not require database locking you can use "-" as suffix.
     *
     * @param boolean $persistently
     *
     * @throws \RuntimeException If no DBA extension or handler installed.
     */
    public function __construct($file, $handler = 'flatfile', $mode = 'c', $persistently = true)
    {
        if (!extension_loaded('dba')) {
            throw new \RuntimeException('missing ext/dba');
        }

        if (!function_exists('dba_handlers') || !in_array($handler, dba_handlers(false))) {
            throw new \RuntimeException("dba-handler '{$handler}' not supported");
        }

        $this->dba = (true === $persistently)
            ? @dba_popen($file, $mode, $handler)
            : @dba_open($file, $mode, $handler);

        if ($this->dba === false) {
            $err = error_get_last();
            throw new \RuntimeException($err['message']);
        }

        $this->storage = $file;
        $this->handler = $handler;
    }

    /**
     * Closes an open dba resource
     *
     * @return void
     */
    public function __destruct()
    {
        $this->closeDba();
    }

    /**
     * @param string   $key
     * @param mixed    $value
     * @param int|bool $ltime Lifetime in seconds otherwise cache forever.
     *
     * @return bool
     */
    public function put($key, $value, $ltime = false)
    {
        try {
            $value = Pack::wrap($value, $ltime);
        } catch (\RuntimeException $ret) {
            return false;
        }

        if (true === $this->has($key)) {
            return dba_replace($key, $value, $this->dba);
        }

        return dba_insert($key, $value, $this->dba);
    }

    /**
     * @param string $key
     * @param mixed  $value
     *
     * @return bool
     */
    public function forever($key, $value)
    {
        return $this->put($key, $value, false);
    }

    /**
     * @param string $key
     *
     * @return bool|object
     */
    public function get($key)
    {
        $res = $this->fetch($key);

        if (false === $res) {
            return false;
        }

        if (false === $res->ltime || (microtime(true) - $res->mtime) < $res->ltime) {
            return $res->object;
        }

        $this->delete($key);

        return false;
    }

    /**
     * @return string
     */
    public function getStorage()
    {
        return $this->storage;
    }

    /**
     * @param string $key
     *
     * @return Capsule|boolean
     */
    public function fetch($key)
    {
        $fetched = dba_fetch($key, $this->dba);

        if (false === $fetched) {
            return false;
        }

        try {
            return Pack::unwrap($fetched);
        } catch (\RuntimeException $ret) {
            return false;
        }
    }

    /**
     * @param string $key
     *
     * @return boolean
     */
    public function delete($key)
    {
        if (false === is_resource($this->dba)) {
            return false;
        }

        if ($this->erasable()) {
            return dba_delete($key, $this->dba);
        }

        return true;
    }

    /**
     * @param string $key
     *
     * @return boolean
     */
    public function has($key)
    {
        return dba_exists($key, $this->dba);
    }

    /**
     * Close the handler.
     */
    public function closeDba()
    {
        if ($this->dba) {
            dba_close($this->dba);
            $this->dba = null;
        }
    }

    /**
     * @return resource
     */
    public function getDba()
    {
        return $this->dba;
    }

    /**
     * @return \ArrayObject of stored cache ids (string).
     */
    public function getIds()
    {
        $ids = new \ArrayObject();
        $dba = $this->getDba();
        $key = dba_firstkey($dba);

        while ($key !== false && $key !== null) {
            $ids->offsetSet(null, $key);
            $key = dba_nextkey($dba);
        }

        return $ids;
    }

    /**
     * Return an array of metadata for the given cache id.
     *
     * - expire = the expire timestamp
     * - mtime = timestamp of last modification time
     *
     * @param string $key cache id
     *
     * @return array|boolean
     */
    public function getMetaData($key)
    {
        $res = $this->fetch($key);

        if ($res instanceof Capsule) {
            return array(
                'expire' => $res->mtime + $res->ltime,
                'mtime'  => $res->mtime,
            );
        }

        return false;
    }

    /**
     * Ensures if a single cache-item can be deleted.
     *
     * @param null|string $handler
     *
     * @return bool
     */
    public function erasable($handler = null)
    {
        $handler = (!$handler) ? $this->handler : $handler;

        return in_array($handler, array('inifile', 'gdbm', 'qdbm', 'db4'), true);
    }
}