Micro\Cache\MemcachedCache

Complexity

Total Complexity

28

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

11 Methods

Rating	Name	Duplication	Size	Complexity
C	__construct()	0	40	11
A	check()	0	4	3
A	__destruct()	0	6	2
A	get()	0	6	2
A	set()	0	15	3
A	delete()	0	4	1
A	clean()	0	4	1
A	info()	0	4	1
A	getMeta()	0	11	2
A	increment()	0	4	1
A	decrement()	0	4	1

<?php /** MicroMemcachedCache */

namespace Micro\Cache;

use Micro\Base\Exception;

/**
 * Class MemcachedCache
 *
 * @author Oleg Lunegov <testuser@mail.linpax.org>
 * @link https://github.com/lugnsk/micro
 * @copyright Copyright &copy; 2013 Oleg Lunegov
 * @license /LICENSE
 * @package Micro
 * @subpackage Cache
 * @version 1.0
 * @since 1.0
 */
class MemcachedCache extends BaseCache
{
    /** @var \Memcache|\Memcached $driver driver memcache(d) */
    protected $driver;

    /**
     * Constructor
     *
     * @access public
     *
     * @param array $config config array
     *
     * @result void
     * @throws Exception
     */
    public function __construct(array $config = [])
    {
        parent::__construct($config);

        if (empty($config['type']) || !$this->check()) {
            throw new Exception('Memcache(d) not installed or not select type');
        }

        switch (strtolower($config['type'])) {
            case 'memcached':
                $this->driver = new \Memcached;
                break;

            case 'memcache':
                $this->driver = new \Memcache;
                break;

            default:
                throw new Exception('Selected type not valid in the driver');
        }

        if (!empty($config['servers'])) {
            $this->driver->addServers($config['servers']);

The method addServers does only exist in Memcached, but not in Memcache.

        } elseif ($config['server']) {
            $conf = $config['server'];
            $server = [
                'hostname' => (!empty($conf['hostname']) ? $conf['hostname'] : '127.0.0.1'),
                'port' => (!empty($conf['port']) ? $conf['port'] : 11211),
                'weight' => (!empty($conf['weight']) ? $conf['weight'] : 1)
            ];

            if (get_class($this->driver) === 'Memcached') {
                $this->driver->addServer($server['hostname'], $server['port'], $server['weight']);
            } else {
                $this->driver->addServer($server['hostname'], $server['port'], true, $server['weight']);
            }
        } else {
            throw new Exception('Server(s) not configured');
        }
    }

    /**
     * @inheritdoc
     */
    public function check()
    {
        return (!extension_loaded('memcached') && !extension_loaded('memcache')) ?: true;
    }

    /**
     * Destructor
     *
     * @access public
     * @result void
     */
    public function __destruct()
    {
        if ($this->driver) {
            $this->driver->close();

The method close does only exist in Memcache, but not in Memcached.

        }
    }

    /**
     * @inheritdoc
     */
    public function get($name)
    {
        $data = $this->driver->get($name);

        return is_array($data) ? $data[0] : $data;
    }

    /**
     * @inheritdoc
     */
    public function set($name, $value, $duration = 0)
    {
        switch (get_class($this->driver)) {
            case 'Memcached':
                return $this->driver->set($name, $value, $duration);
                break;

break is not strictly necessary here and could be removed.

            case 'Memcache':
                return $this->driver->set($name, $value, 0, $duration);
                break;

break is not strictly necessary here and could be removed.

            default:
                return false;
        }
    }

    /**
     * @inheritdoc
     */
    public function delete($name)
    {
        return $this->driver->delete($name);
    }

    /**
     * @inheritdoc
     */
    public function clean()
    {
        return $this->driver->flush();
    }

    /**
     * @inheritdoc
     */
    public function info()
    {
        return $this->driver->getStats();
    }

    /**
     * @inheritdoc
     */
    public function getMeta($id)
    {
        $stored = $this->driver->get($id);
        if (count($stored) !== 3) {
            return false;
        }

        list($data, $time, $ttl) = $stored;

        return ['expire' => $time + $ttl, 'mtime' => $time, 'data' => $data];
    }

    /**
     * @inheritdoc
     */
    public function increment($name, $offset = 1)
    {
        return $this->driver->increment($name, $offset);
    }

    /**
     * @inheritdoc
     */
    public function decrement($name, $offset = 1)
    {
        return $this->driver->decrement($name, $offset);
    }
}