CacheMemcache

Complexity

Total Complexity

28

Size/Duplication

Total Lines	225
Duplicated Lines	16.89 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getInstance()	0	8	2
B	CacheMemcache()	0	25	5
A	isSupport()	0	19	4
A	getKey()	0	4	1
A	put()	0	15	3
B	isValid()	19	19	5
B	get()	19	19	5
A	delete()	0	5	1
A	_delete()	0	4	1
A	truncate()	0	4	1

<?php
/* Copyright (C) NAVER <http://www.navercorp.com> */

/**
 * Cache class for memcache
 *
 * @author NAVER (developer@xpressengine.com)
 */
class CacheMemcache extends CacheBase
{
	/**
	 * instance of Memcahe
	 * @var Memcahe
	 */
	var $Memcache;
	var $SelectedExtension;

	/**
	 * Get instance of CacheMemcache
	 *
	 * @param string $url url of memcache
	 * @return CacheMemcache instance of CacheMemcache
	 */
	function getInstance($url)
	{
		if(!$GLOBALS['__CacheMemcache__'])
		{
			$GLOBALS['__CacheMemcache__'] = new CacheMemcache($url);
		}
		return $GLOBALS['__CacheMemcache__'];
	}

	/**
	 * Construct
	 *
	 * Do not use this directly. You can use getInstance() instead.
	 * @param string $url url of memcache
	 * @return void
	 */
	function CacheMemcache($url)

Please use __construct() instead of a PHP4-style constructor that is named after the class.

	{
		//$config['url'] = array('memcache://localhost:11211');
		$config['url'] = is_array($url) ? $url : array($url);

$config was never initialized. Although not strictly required by PHP, it is generally a good practice to add $config = array(); before regardless.

		if(class_exists('Memcached'))
		{
			$this->Memcache = new Memcached;

It seems like new \Memcached() of type object<Memcached> is incompatible with the declared type object<Memcahe> of property $Memcache.

			$this->SelectedExtension = 'Memcached';
		}
		elseif(class_exists('Memcache'))
		{
			$this->Memcache = new Memcache;

It seems like new \Memcache() of type object<Memcache> is incompatible with the declared type object<Memcahe> of property $Memcache.

			$this->SelectedExtension = 'Memcache';
		}
		else
		{
			return false;
		}

		foreach($config['url'] as $url)
		{
			$info = parse_url($url);
			$this->Memcache->addServer($info['host'], $info['port']);
		}
	}

	/**
	 * Return whether support or not support cache
	 *
	 * @return bool Return true on support or false on not support
	 */
	function isSupport()
	{
		if(isset($GLOBALS['XE_MEMCACHE_SUPPORT']))
		{
			return $GLOBALS['XE_MEMCACHE_SUPPORT'];
		}
		if($this->SelectedExtension === 'Memcached')
		{
			return $GLOBALS['XE_MEMCACHE_SUPPORT'] = $this->Memcache->set('xe', 'xe', 1); 
		}
		elseif($this->SelectedExtension === 'Memcache')
		{
			return $GLOBALS['XE_MEMCACHE_SUPPORT'] = $this->Memcache->set('xe', 'xe', MEMCACHE_COMPRESSED, 1); 
		}
		else
		{
			return $GLOBALS['XE_MEMCACHE_SUPPORT'] = false;
		}
	}

	/**
	 * Get unique key of given key by path of XE
	 *
	 * @param string $key Cache key
	 * @return string Return unique key
	 */
	function getKey($key)
	{
		return md5(_XE_PATH_ . $key);
	}

	/**
	 * Store data at the server
	 *
	 * CacheMemcache::put() stores an item $buff with $key on the memcached server.
	 * Parameter $valid_time is expiration time in seconds. If it's 0, the item never expires
	 * (but memcached server doesn't guarantee this item to be stored all the time, it could be delete from the cache to make place for other items).
	 *
	 * Remember that resource variables (i.e. file and connection descriptors) cannot be stored in the cache,
	 * because they can not be adequately represented in serialized state.
	 *
	 * @param string $key The key that will be associated with the item.
	 * @param mixed $buff The variable to store. Strings and integers are stored as is, other types are stored serialized.
	 * @param int $valid_time 	Expiration time of the item.
	 * 							You can also use Unix timestamp or a number of seconds starting from current time, but in the latter case the number of seconds may not exceed 2592000 (30 days).
	 * 							If it's equal to zero, use the default valid time CacheMemcache::valid_time.
	 * @return bool Returns true on success or false on failure.
	 */
	function put($key, $buff, $valid_time = 0)
	{
		if($valid_time == 0)
		{
			$valid_time = $this->valid_time;
		}
		if($this->SelectedExtension === 'Memcached')
		{
			return $this->Memcache->set($this->getKey($key), array($_SERVER['REQUEST_TIME'], $buff), $valid_time);
		}
		else
		{
			return $this->Memcache->set($this->getKey($key), array($_SERVER['REQUEST_TIME'], $buff), MEMCACHE_COMPRESSED, $valid_time);
		}
	}

	/**
	 * Return whether cache is valid or invalid
	 *
	 * @param string $key Cache key
	 * @param int $modified_time 	Unix time of data modified.
	 * 								If stored time is older then modified time, the data is invalid.
	 * @return bool Return true on valid or false on invalid.
	 */
	function isValid($key, $modified_time = 0)

This method seems to be duplicated in your project.

	{
		$_key = $this->getKey($key);

		$obj = $this->Memcache->get($_key);
		if(!$obj || !is_array($obj))
		{
			return false;
		}
		unset($obj[1]);

		if($modified_time > 0 && $modified_time > $obj[0])
		{
			$this->_delete($_key);
			return false;
		}

		return true;
	}

	/**
	 * Retrieve item from the server
	 *
	 * CacheMemcache::get() returns previously stored data if an item with such $key exists on the server at this moment.
	 *
	 * @param string $key The key to fetch
	 * @param int $modified_time 	Unix time of data modified.
	 * 								If stored time is older then modified time, return false.
	 * @return false|mixed Return false on failure or older then modified time. Return the string associated with the $key on success.
	 */
	function get($key, $modified_time = 0)

This method seems to be duplicated in your project.

	{
		$_key = $this->getKey($key);
		$obj = $this->Memcache->get($_key);
		if(!$obj || !is_array($obj))
		{
			return false;
		}

		if($modified_time > 0 && $modified_time > $obj[0])
		{
			$this->_delete($_key);
			return false;
		}

		unset($obj[0]);

		return $obj[1];
	}

	/**
	 * Delete item from the server
	 *
	 * CacheMemcache::delete() deletes an item with tey $key.
	 *
	 * @param string $key The key associated with the item to delete.
	 * @return void
	 */
	function delete($key)
	{
		$_key = $this->getKey($key);
		$this->_delete($_key);
	}

	/**
	 * Delete item from the server(private)
	 *
	 * @see CacheMemcache::delete()
	 * @param string $_key The key associated with the item to delete.
	 * @return void
	 */
	function _delete($_key)
	{
		$this->Memcache->delete($_key);
	}

	/**
	 * Flush all existing items at the server
	 *
	 * CacheMemcache::truncate() immediately invalidates all existing items.
	 * CacheMemcache::truncate() doesn't actually free any resources, it only marks all the items as expired,
	 * so occupied memory will be overwitten by new items.
	 *
	 * @return bool Returns true on success or false on failure.
	 */
	function truncate()
	{
		return $this->Memcache->flush();
	}

}
/* End of file CacheMemcache.class.php */
/* Location: ./classes/cache/CacheMemcache.class.php */