Memcached::getSetting() - Code Metrics - Logi-CE/fmup - Measure and Improve Code Quality continuously with Scrutinizer

Memcached::getSetting() A
last analyzed 2017-12-05 10:44 UTC

↳ Parent: Memcached

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	3
nc	2
nop	1
dl	0
loc	5
ccs	3
cts	3
cp	1
crap	2
rs	9.4285
c	0
b	0
f	0

<?php
namespace FMUP\Cache\Driver;

use FMUP\Cache\CacheInterface;
use FMUP\Cache\Exception;

/**
 * Class Memcached
 * This driver needs MEMCACHED installed on server to work properly
 * @package FMUP\Cache\Driver
 */
class Memcached implements CacheInterface
{
    const SETTINGS_MEMCACHED = 'SETTINGS_MEMCACHED';
    /**
     * @see http://php.net/manual/fr/memcached.expiration.php
     */
    const SETTINGS_TTL_IN_SECOND = 'SETTINGS_TTL_IN_SECOND';
    const SETTINGS_CACHE_PREFIX = 'SETTINGS_CACHE_PREFIX';

    private $isAvailable = null;
    private $memcachedInstance = null;
    private $settings = array();

    /**
     * Check whether memcached is available
     * @return bool
     */
    public function isAvailable()
    {
        if (is_null($this->isAvailable)) {
            $this->isAvailable = class_exists('\Memcached');
        }
        return $this->isAvailable;
    }

    /**
     * constructor of Memcached
     * @param array $settings
     */
    public function __construct($settings = array())
    {
        if (isset($settings[self::SETTINGS_MEMCACHED])) {
            $this->setMemcachedInstance($settings[self::SETTINGS_MEMCACHED]);
        }
        $this->settings = $settings;
    }

    /**
     * Get the memcached instance
     * @return \Memcached
     * @throws Exception
     */
    public function getMemcachedInstance()
    {
        if (!$this->memcachedInstance) {
            if (!$this->isAvailable()) {
                throw new Exception('Memcached is not available');
            }
            $this->memcachedInstance = $this->createMemcached();
        }
        return $this->memcachedInstance;
    }

    /**
     * @return \Memcached
     * @codeCoverageIgnore
     */
    protected function createMemcached()
    {
        return new \Memcached();
    }

    /**
     * Define a memcached instance
     * @param \Memcached $memcachedInstance
     * @return $this
     */
    public function setMemcachedInstance(\Memcached $memcachedInstance)
    {
        $this->memcachedInstance = $memcachedInstance;
        return $this;
    }

    /**
     * @param string $key
     * @return string
     */
    protected function getCacheKey($key)
    {
        $prefix = (string)$this->getSetting(self::SETTINGS_CACHE_PREFIX);
        return $prefix . $key;
    }


    /**
     * Check whether a key exists
     * @param string $key
     * @return bool
     * @throws Exception
     */
    public function has($key)
    {
        if (!$this->isAvailable()) {
            throw new Exception('Memcached is not available');
        }
        $key = $this->getCacheKey($key);
        $keys = array_flip($this->getMemcachedInstance()->getAllKeys());
        return isset($keys[$key]);
    }

    /**
     * @param string $key
     * @return mixed
     * @throws Exception
     */
    public function get($key)

    {
        if (!$this->isAvailable()) {
            throw new Exception('Memcached is not available');
        }
        $key = $this->getCacheKey($key);
        return $this->getMemcachedInstance()->get($key);
    }

    /**
     * Define a
     * @param string $key
     * @param mixed $value
     * @return $this
     * @throws Exception
     */
    public function set($key, $value)
    {
        if (!$this->isAvailable()) {
            throw new Exception('Memcached is not available');
        }
        $ttl = (int)$this->getSetting(self::SETTINGS_TTL_IN_SECOND);
        $key = $this->getCacheKey($key);
        if (!$this->getMemcachedInstance()->set($key, $value, $ttl)) {
            throw new Exception(
                'Error while inserting value in memcached : ' . $this->getMemcachedInstance()->getResultMessage(),
                $this->getMemcachedInstance()->getResultCode()
            );
        }
        return $this;
    }

    /**
     * Delete a value in memcache
     * @param string $key
     * @return $this
     * @throws Exception
     */
    public function remove($key)

    {
        if (!$this->isAvailable()) {
            throw new Exception('Memcached is not available');
        }
        $key = $this->getCacheKey($key);
        if (!$this->getMemcachedInstance()->delete($key)) {
            throw new Exception('Error while deleting key in memcached');
        }
        return $this;
    }

    /**
     * Define a setting
     * @param string $setting
     * @param mixed $value
     * @return $this
     */
    public function setSetting($setting, $value)
    {
        $this->settings[(string)$setting] = $value;
        return $this;
    }

    /**
     * Retrieve a defined setting
     * @param string $setting
     * @return mixed|null
     */
    public function getSetting($setting)
    {
        $setting = (string) $setting;
        return isset($this->settings[$setting]) ? $this->settings[$setting] : null;
    }
}


1			<?php
2			namespace FMUP\Cache\Driver;
3
4			use FMUP\Cache\CacheInterface;
5			use FMUP\Cache\Exception;
6
7			/**
8			* Class Memcached
9			* This driver needs MEMCACHED installed on server to work properly
10			* @package FMUP\Cache\Driver
11			*/
12			class Memcached implements CacheInterface
13			{
14			const SETTINGS_MEMCACHED = 'SETTINGS_MEMCACHED';
15			/**
16			* @see http://php.net/manual/fr/memcached.expiration.php
17			*/
18			const SETTINGS_TTL_IN_SECOND = 'SETTINGS_TTL_IN_SECOND';
19			const SETTINGS_CACHE_PREFIX = 'SETTINGS_CACHE_PREFIX';
20
21			private $isAvailable = null;
22			private $memcachedInstance = null;
23			private $settings = array();
24
25			/**
26			* Check whether memcached is available
27			* @return bool
28			*/
29	1		public function isAvailable()
30			{
31	1		if (is_null($this->isAvailable)) {
32	1		$this->isAvailable = class_exists('\Memcached');
33			}
34	1		return $this->isAvailable;
35			}
36
37			/**
38			* constructor of Memcached
39			* @param array $settings
40			*/
41	15		public function __construct($settings = array())
42			{
43	15		if (isset($settings[self::SETTINGS_MEMCACHED])) {
44	1		$this->setMemcachedInstance($settings[self::SETTINGS_MEMCACHED]);
45			}
46	15		$this->settings = $settings;
47	15		}
48
49			/**
50			* Get the memcached instance
51			* @return \Memcached
52			* @throws Exception
53			*/
54	5		public function getMemcachedInstance()
55			{
56	5		if (!$this->memcachedInstance) {
57	2		if (!$this->isAvailable()) {
58	1		throw new Exception('Memcached is not available');
59			}
60	1		$this->memcachedInstance = $this->createMemcached();
61			}
62	4		return $this->memcachedInstance;
63			}
64
65			/**
66			* @return \Memcached
67			* @codeCoverageIgnore
68			*/
69			protected function createMemcached()
70			{
71			return new \Memcached();
72			}
73
74			/**
75			* Define a memcached instance
76			* @param \Memcached $memcachedInstance
77			* @return $this
78			*/
79	3		public function setMemcachedInstance(\Memcached $memcachedInstance)
80			{
81	3		$this->memcachedInstance = $memcachedInstance;
82	3		return $this;
83			}
84
85			/**
86			* @param string $key
87			* @return string
88			*/
89	4		protected function getCacheKey($key)
90			{
91	4		$prefix = (string)$this->getSetting(self::SETTINGS_CACHE_PREFIX);
92	4		return $prefix . $key;
93			}
94
95
96			/**
97			* Check whether a key exists
98			* @param string $key
99			* @return bool
100			* @throws Exception
101			*/
102	2		public function has($key)
103			{
104	2		if (!$this->isAvailable()) {
105	1		throw new Exception('Memcached is not available');
106			}
107	1		$key = $this->getCacheKey($key);
108	1		$keys = array_flip($this->getMemcachedInstance()->getAllKeys());
109	1		return isset($keys[$key]);
110			}
111
112			/**
113			* @param string $key
114			* @return mixed
115			* @throws Exception
116			*/
117	2	View Code Duplication	public function get($key)
			0 ignored issues – show Duplication introduced 2017-08-25 13:37 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
118			{
119	2		if (!$this->isAvailable()) {
120	1		throw new Exception('Memcached is not available');
121			}
122	1		$key = $this->getCacheKey($key);
123	1		return $this->getMemcachedInstance()->get($key);
124			}
125
126			/**
127			* Define a
128			* @param string $key
129			* @param mixed $value
130			* @return $this
131			* @throws Exception
132			*/
133	3		public function set($key, $value)
134			{
135	3		if (!$this->isAvailable()) {
136	1		throw new Exception('Memcached is not available');
137			}
138	2		$ttl = (int)$this->getSetting(self::SETTINGS_TTL_IN_SECOND);
139	2		$key = $this->getCacheKey($key);
140	2		if (!$this->getMemcachedInstance()->set($key, $value, $ttl)) {
141	1		throw new Exception(
142	1		'Error while inserting value in memcached : ' . $this->getMemcachedInstance()->getResultMessage(),
143	1		$this->getMemcachedInstance()->getResultCode()
144			);
145			}
146	1		return $this;
147			}
148
149			/**
150			* Delete a value in memcache
151			* @param string $key
152			* @return $this
153			* @throws Exception
154			*/
155	3	View Code Duplication	public function remove($key)
			0 ignored issues – show Duplication introduced 2017-08-25 13:37 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
156			{
157	3		if (!$this->isAvailable()) {
158	1		throw new Exception('Memcached is not available');
159			}
160	2		$key = $this->getCacheKey($key);
161	2		if (!$this->getMemcachedInstance()->delete($key)) {
162	1		throw new Exception('Error while deleting key in memcached');
163			}
164	1		return $this;
165			}
166
167			/**
168			* Define a setting
169			* @param string $setting
170			* @param mixed $value
171			* @return $this
172			*/
173	1		public function setSetting($setting, $value)
174			{
175	1		$this->settings[(string)$setting] = $value;
176	1		return $this;
177			}
178
179			/**
180			* Retrieve a defined setting
181			* @param string $setting
182			* @return mixed\|null
183			*/
184	5		public function getSetting($setting)
185			{
186	5		$setting = (string) $setting;
187	5		return isset($this->settings[$setting]) ? $this->settings[$setting] : null;
188			}
189			}
190

Logi-CE / fmup

Memcached::getSetting() A last analyzed 2017-12-05 10:44 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Memcached::getSetting() A
last analyzed 2017-12-05 10:44 UTC