/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ApcCache.php |
@@ -0,0 +1,118 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* APC cache provider. |
* |
* @link www.doctrine-project.org |
* @deprecated since version 1.6, use ApcuCache instead |
* @since 2.0 |
* @author Benjamin Eberlei <kontakt@beberlei.de> |
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> |
* @author Jonathan Wage <jonwage@gmail.com> |
* @author Roman Borschel <roman@code-factory.org> |
* @author David Abdemoulaie <dave@hobodave.com> |
*/ |
class ApcCache extends CacheProvider |
{ |
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
return apc_fetch($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
return apc_exists($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
return apc_store($id, $data, $lifeTime); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
// apc_delete returns false if the id does not exist |
return apc_delete($id) || ! apc_exists($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
return apc_clear_cache() && apc_clear_cache('user'); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetchMultiple(array $keys) |
{ |
return apc_fetch($keys) ?: []; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSaveMultiple(array $keysAndValues, $lifetime = 0) |
{ |
$result = apc_store($keysAndValues, null, $lifetime); |
|
return empty($result); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
$info = apc_cache_info('', true); |
$sma = apc_sma_info(); |
|
// @TODO - Temporary fix @see https://github.com/krakjoe/apcu/pull/42 |
if (PHP_VERSION_ID >= 50500) { |
$info['num_hits'] = isset($info['num_hits']) ? $info['num_hits'] : $info['nhits']; |
$info['num_misses'] = isset($info['num_misses']) ? $info['num_misses'] : $info['nmisses']; |
$info['start_time'] = isset($info['start_time']) ? $info['start_time'] : $info['stime']; |
} |
|
return array( |
Cache::STATS_HITS => $info['num_hits'], |
Cache::STATS_MISSES => $info['num_misses'], |
Cache::STATS_UPTIME => $info['start_time'], |
Cache::STATS_MEMORY_USAGE => $info['mem_size'], |
Cache::STATS_MEMORY_AVAILABLE => $sma['avail_mem'], |
); |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ApcuCache.php |
@@ -0,0 +1,106 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* APCu cache provider. |
* |
* @link www.doctrine-project.org |
* @since 1.6 |
* @author Kévin Dunglas <dunglas@gmail.com> |
*/ |
class ApcuCache extends CacheProvider |
{ |
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
return apcu_fetch($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
return apcu_exists($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
return apcu_store($id, $data, $lifeTime); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
// apcu_delete returns false if the id does not exist |
return apcu_delete($id) || ! apcu_exists($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
return apcu_clear_cache(); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetchMultiple(array $keys) |
{ |
return apcu_fetch($keys) ?: []; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSaveMultiple(array $keysAndValues, $lifetime = 0) |
{ |
$result = apcu_store($keysAndValues, null, $lifetime); |
|
return empty($result); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
$info = apcu_cache_info(true); |
$sma = apcu_sma_info(); |
|
return array( |
Cache::STATS_HITS => $info['num_hits'], |
Cache::STATS_MISSES => $info['num_misses'], |
Cache::STATS_UPTIME => $info['start_time'], |
Cache::STATS_MEMORY_USAGE => $info['mem_size'], |
Cache::STATS_MEMORY_AVAILABLE => $sma['avail_mem'], |
); |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ArrayCache.php |
@@ -0,0 +1,142 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Array cache driver. |
* |
* @link www.doctrine-project.org |
* @since 2.0 |
* @author Benjamin Eberlei <kontakt@beberlei.de> |
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> |
* @author Jonathan Wage <jonwage@gmail.com> |
* @author Roman Borschel <roman@code-factory.org> |
* @author David Abdemoulaie <dave@hobodave.com> |
*/ |
class ArrayCache extends CacheProvider |
{ |
/** |
* @var array[] $data each element being a tuple of [$data, $expiration], where the expiration is int|bool |
*/ |
private $data = []; |
|
/** |
* @var int |
*/ |
private $hitsCount = 0; |
|
/** |
* @var int |
*/ |
private $missesCount = 0; |
|
/** |
* @var int |
*/ |
private $upTime; |
|
/** |
* {@inheritdoc} |
*/ |
public function __construct() |
{ |
$this->upTime = time(); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
if (! $this->doContains($id)) { |
$this->missesCount += 1; |
|
return false; |
} |
|
$this->hitsCount += 1; |
|
return $this->data[$id][0]; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
if (! isset($this->data[$id])) { |
return false; |
} |
|
$expiration = $this->data[$id][1]; |
|
if ($expiration && $expiration < time()) { |
$this->doDelete($id); |
|
return false; |
} |
|
return true; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
$this->data[$id] = [$data, $lifeTime ? time() + $lifeTime : false]; |
|
return true; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
unset($this->data[$id]); |
|
return true; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
$this->data = []; |
|
return true; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
return [ |
Cache::STATS_HITS => $this->hitsCount, |
Cache::STATS_MISSES => $this->missesCount, |
Cache::STATS_UPTIME => $this->upTime, |
Cache::STATS_MEMORY_USAGE => null, |
Cache::STATS_MEMORY_AVAILABLE => null, |
]; |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/Cache.php |
@@ -0,0 +1,116 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Interface for cache drivers. |
* |
* @link www.doctrine-project.org |
* @since 2.0 |
* @author Benjamin Eberlei <kontakt@beberlei.de> |
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> |
* @author Jonathan Wage <jonwage@gmail.com> |
* @author Roman Borschel <roman@code-factory.org> |
* @author Fabio B. Silva <fabio.bat.silva@gmail.com> |
* @author Kévin Dunglas <dunglas@gmail.com> |
*/ |
interface Cache |
{ |
const STATS_HITS = 'hits'; |
const STATS_MISSES = 'misses'; |
const STATS_UPTIME = 'uptime'; |
const STATS_MEMORY_USAGE = 'memory_usage'; |
const STATS_MEMORY_AVAILABLE = 'memory_available'; |
/** |
* Only for backward compatibility (may be removed in next major release) |
* |
* @deprecated |
*/ |
const STATS_MEMORY_AVAILIABLE = 'memory_available'; |
|
/** |
* Fetches an entry from the cache. |
* |
* @param string $id The id of the cache entry to fetch. |
* |
* @return mixed The cached data or FALSE, if no cache entry exists for the given id. |
*/ |
public function fetch($id); |
|
/** |
* Tests if an entry exists in the cache. |
* |
* @param string $id The cache id of the entry to check for. |
* |
* @return bool TRUE if a cache entry exists for the given cache id, FALSE otherwise. |
*/ |
public function contains($id); |
|
/** |
* Puts data into the cache. |
* |
* If a cache entry with the given id already exists, its data will be replaced. |
* |
* @param string $id The cache id. |
* @param mixed $data The cache entry/data. |
* @param int $lifeTime The lifetime in number of seconds for this cache entry. |
* If zero (the default), the entry never expires (although it may be deleted from the cache |
* to make place for other entries). |
* |
* @return bool TRUE if the entry was successfully stored in the cache, FALSE otherwise. |
*/ |
public function save($id, $data, $lifeTime = 0); |
|
/** |
* Deletes a cache entry. |
* |
* @param string $id The cache id. |
* |
* @return bool TRUE if the cache entry was successfully deleted, FALSE otherwise. |
* Deleting a non-existing entry is considered successful. |
*/ |
public function delete($id); |
|
/** |
* Retrieves cached information from the data store. |
* |
* The server's statistics array has the following values: |
* |
* - <b>hits</b> |
* Number of keys that have been requested and found present. |
* |
* - <b>misses</b> |
* Number of items that have been requested and not found. |
* |
* - <b>uptime</b> |
* Time that the server is running. |
* |
* - <b>memory_usage</b> |
* Memory used by this server to store items. |
* |
* - <b>memory_available</b> |
* Memory allowed to use for storage. |
* |
* @since 2.2 |
* |
* @return array|null An associative array with server's statistics if available, NULL otherwise. |
*/ |
public function getStats(); |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/CacheProvider.php |
@@ -0,0 +1,312 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Base class for cache provider implementations. |
* |
* @since 2.2 |
* @author Benjamin Eberlei <kontakt@beberlei.de> |
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> |
* @author Jonathan Wage <jonwage@gmail.com> |
* @author Roman Borschel <roman@code-factory.org> |
* @author Fabio B. Silva <fabio.bat.silva@gmail.com> |
*/ |
abstract class CacheProvider implements Cache, FlushableCache, ClearableCache, MultiGetCache, MultiPutCache |
{ |
const DOCTRINE_NAMESPACE_CACHEKEY = 'DoctrineNamespaceCacheKey[%s]'; |
|
/** |
* The namespace to prefix all cache ids with. |
* |
* @var string |
*/ |
private $namespace = ''; |
|
/** |
* The namespace version. |
* |
* @var integer|null |
*/ |
private $namespaceVersion; |
|
/** |
* Sets the namespace to prefix all cache ids with. |
* |
* @param string $namespace |
* |
* @return void |
*/ |
public function setNamespace($namespace) |
{ |
$this->namespace = (string) $namespace; |
$this->namespaceVersion = null; |
} |
|
/** |
* Retrieves the namespace that prefixes all cache ids. |
* |
* @return string |
*/ |
public function getNamespace() |
{ |
return $this->namespace; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function fetch($id) |
{ |
return $this->doFetch($this->getNamespacedId($id)); |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function fetchMultiple(array $keys) |
{ |
if (empty($keys)) { |
return array(); |
} |
|
// note: the array_combine() is in place to keep an association between our $keys and the $namespacedKeys |
$namespacedKeys = array_combine($keys, array_map(array($this, 'getNamespacedId'), $keys)); |
$items = $this->doFetchMultiple($namespacedKeys); |
$foundItems = array(); |
|
// no internal array function supports this sort of mapping: needs to be iterative |
// this filters and combines keys in one pass |
foreach ($namespacedKeys as $requestedKey => $namespacedKey) { |
if (isset($items[$namespacedKey]) || array_key_exists($namespacedKey, $items)) { |
$foundItems[$requestedKey] = $items[$namespacedKey]; |
} |
} |
|
return $foundItems; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function saveMultiple(array $keysAndValues, $lifetime = 0) |
{ |
$namespacedKeysAndValues = array(); |
foreach ($keysAndValues as $key => $value) { |
$namespacedKeysAndValues[$this->getNamespacedId($key)] = $value; |
} |
|
return $this->doSaveMultiple($namespacedKeysAndValues, $lifetime); |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function contains($id) |
{ |
return $this->doContains($this->getNamespacedId($id)); |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function save($id, $data, $lifeTime = 0) |
{ |
return $this->doSave($this->getNamespacedId($id), $data, $lifeTime); |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function delete($id) |
{ |
return $this->doDelete($this->getNamespacedId($id)); |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function getStats() |
{ |
return $this->doGetStats(); |
} |
|
/** |
* {@inheritDoc} |
*/ |
public function flushAll() |
{ |
return $this->doFlush(); |
} |
|
/** |
* {@inheritDoc} |
*/ |
public function deleteAll() |
{ |
$namespaceCacheKey = $this->getNamespaceCacheKey(); |
$namespaceVersion = $this->getNamespaceVersion() + 1; |
|
if ($this->doSave($namespaceCacheKey, $namespaceVersion)) { |
$this->namespaceVersion = $namespaceVersion; |
|
return true; |
} |
|
return false; |
} |
|
/** |
* Prefixes the passed id with the configured namespace value. |
* |
* @param string $id The id to namespace. |
* |
* @return string The namespaced id. |
*/ |
private function getNamespacedId($id) |
{ |
$namespaceVersion = $this->getNamespaceVersion(); |
|
return sprintf('%s[%s][%s]', $this->namespace, $id, $namespaceVersion); |
} |
|
/** |
* Returns the namespace cache key. |
* |
* @return string |
*/ |
private function getNamespaceCacheKey() |
{ |
return sprintf(self::DOCTRINE_NAMESPACE_CACHEKEY, $this->namespace); |
} |
|
/** |
* Returns the namespace version. |
* |
* @return integer |
*/ |
private function getNamespaceVersion() |
{ |
if (null !== $this->namespaceVersion) { |
return $this->namespaceVersion; |
} |
|
$namespaceCacheKey = $this->getNamespaceCacheKey(); |
$this->namespaceVersion = $this->doFetch($namespaceCacheKey) ?: 1; |
|
return $this->namespaceVersion; |
} |
|
/** |
* Default implementation of doFetchMultiple. Each driver that supports multi-get should owerwrite it. |
* |
* @param array $keys Array of keys to retrieve from cache |
* @return array Array of values retrieved for the given keys. |
*/ |
protected function doFetchMultiple(array $keys) |
{ |
$returnValues = array(); |
|
foreach ($keys as $key) { |
if (false !== ($item = $this->doFetch($key)) || $this->doContains($key)) { |
$returnValues[$key] = $item; |
} |
} |
|
return $returnValues; |
} |
|
/** |
* Fetches an entry from the cache. |
* |
* @param string $id The id of the cache entry to fetch. |
* |
* @return mixed|false The cached data or FALSE, if no cache entry exists for the given id. |
*/ |
abstract protected function doFetch($id); |
|
/** |
* Tests if an entry exists in the cache. |
* |
* @param string $id The cache id of the entry to check for. |
* |
* @return bool TRUE if a cache entry exists for the given cache id, FALSE otherwise. |
*/ |
abstract protected function doContains($id); |
|
/** |
* Default implementation of doSaveMultiple. Each driver that supports multi-put should override it. |
* |
* @param array $keysAndValues Array of keys and values to save in cache |
* @param int $lifetime The lifetime. If != 0, sets a specific lifetime for these |
* cache entries (0 => infinite lifeTime). |
* |
* @return bool TRUE if the operation was successful, FALSE if it wasn't. |
*/ |
protected function doSaveMultiple(array $keysAndValues, $lifetime = 0) |
{ |
$success = true; |
|
foreach ($keysAndValues as $key => $value) { |
if (!$this->doSave($key, $value, $lifetime)) { |
$success = false; |
} |
} |
|
return $success; |
} |
|
/** |
* Puts data into the cache. |
* |
* @param string $id The cache id. |
* @param string $data The cache entry/data. |
* @param int $lifeTime The lifetime. If != 0, sets a specific lifetime for this |
* cache entry (0 => infinite lifeTime). |
* |
* @return bool TRUE if the entry was successfully stored in the cache, FALSE otherwise. |
*/ |
abstract protected function doSave($id, $data, $lifeTime = 0); |
|
/** |
* Deletes a cache entry. |
* |
* @param string $id The cache id. |
* |
* @return bool TRUE if the cache entry was successfully deleted, FALSE otherwise. |
*/ |
abstract protected function doDelete($id); |
|
/** |
* Flushes all cache entries. |
* |
* @return bool TRUE if the cache entries were successfully flushed, FALSE otherwise. |
*/ |
abstract protected function doFlush(); |
|
/** |
* Retrieves cached information from the data store. |
* |
* @since 2.2 |
* |
* @return array|null An associative array with server's statistics if available, NULL otherwise. |
*/ |
abstract protected function doGetStats(); |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ChainCache.php |
@@ -0,0 +1,147 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Cache provider that allows to easily chain multiple cache providers |
* |
* @author Michaël Gallego <mic.gallego@gmail.com> |
*/ |
class ChainCache extends CacheProvider |
{ |
/** |
* @var CacheProvider[] |
*/ |
private $cacheProviders = array(); |
|
/** |
* Constructor |
* |
* @param CacheProvider[] $cacheProviders |
*/ |
public function __construct($cacheProviders = array()) |
{ |
$this->cacheProviders = $cacheProviders; |
} |
|
/** |
* {@inheritDoc} |
*/ |
public function setNamespace($namespace) |
{ |
parent::setNamespace($namespace); |
|
foreach ($this->cacheProviders as $cacheProvider) { |
$cacheProvider->setNamespace($namespace); |
} |
} |
|
/** |
* {@inheritDoc} |
*/ |
protected function doFetch($id) |
{ |
foreach ($this->cacheProviders as $key => $cacheProvider) { |
if ($cacheProvider->doContains($id)) { |
$value = $cacheProvider->doFetch($id); |
|
// We populate all the previous cache layers (that are assumed to be faster) |
for ($subKey = $key - 1 ; $subKey >= 0 ; $subKey--) { |
$this->cacheProviders[$subKey]->doSave($id, $value); |
} |
|
return $value; |
} |
} |
|
return false; |
} |
|
/** |
* {@inheritDoc} |
*/ |
protected function doContains($id) |
{ |
foreach ($this->cacheProviders as $cacheProvider) { |
if ($cacheProvider->doContains($id)) { |
return true; |
} |
} |
|
return false; |
} |
|
/** |
* {@inheritDoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
$stored = true; |
|
foreach ($this->cacheProviders as $cacheProvider) { |
$stored = $cacheProvider->doSave($id, $data, $lifeTime) && $stored; |
} |
|
return $stored; |
} |
|
/** |
* {@inheritDoc} |
*/ |
protected function doDelete($id) |
{ |
$deleted = true; |
|
foreach ($this->cacheProviders as $cacheProvider) { |
$deleted = $cacheProvider->doDelete($id) && $deleted; |
} |
|
return $deleted; |
} |
|
/** |
* {@inheritDoc} |
*/ |
protected function doFlush() |
{ |
$flushed = true; |
|
foreach ($this->cacheProviders as $cacheProvider) { |
$flushed = $cacheProvider->doFlush() && $flushed; |
} |
|
return $flushed; |
} |
|
/** |
* {@inheritDoc} |
*/ |
protected function doGetStats() |
{ |
// We return all the stats from all adapters |
$stats = array(); |
|
foreach ($this->cacheProviders as $cacheProvider) { |
$stats[] = $cacheProvider->doGetStats(); |
} |
|
return $stats; |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ClearableCache.php |
@@ -0,0 +1,40 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Interface for cache that can be flushed. |
* |
* Intended to be used for partial clearing of a cache namespace. For a more |
* global "flushing", see {@see FlushableCache}. |
* |
* @link www.doctrine-project.org |
* @since 1.4 |
* @author Adirelle <adirelle@gmail.com> |
*/ |
interface ClearableCache |
{ |
/** |
* Deletes all cache entries in the current cache namespace. |
* |
* @return bool TRUE if the cache entries were successfully deleted, FALSE otherwise. |
*/ |
public function deleteAll(); |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/CouchbaseCache.php |
@@ -0,0 +1,121 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
use \Couchbase; |
|
/** |
* Couchbase cache provider. |
* |
* @link www.doctrine-project.org |
* @since 2.4 |
* @author Michael Nitschinger <michael@nitschinger.at> |
*/ |
class CouchbaseCache extends CacheProvider |
{ |
/** |
* @var Couchbase|null |
*/ |
private $couchbase; |
|
/** |
* Sets the Couchbase instance to use. |
* |
* @param Couchbase $couchbase |
* |
* @return void |
*/ |
public function setCouchbase(Couchbase $couchbase) |
{ |
$this->couchbase = $couchbase; |
} |
|
/** |
* Gets the Couchbase instance used by the cache. |
* |
* @return Couchbase|null |
*/ |
public function getCouchbase() |
{ |
return $this->couchbase; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
return $this->couchbase->get($id) ?: false; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
return (null !== $this->couchbase->get($id)); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
if ($lifeTime > 30 * 24 * 3600) { |
$lifeTime = time() + $lifeTime; |
} |
return $this->couchbase->set($id, $data, (int) $lifeTime); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
return $this->couchbase->delete($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
return $this->couchbase->flush(); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
$stats = $this->couchbase->getStats(); |
$servers = $this->couchbase->getServers(); |
$server = explode(":", $servers[0]); |
$key = $server[0] . ":" . "11210"; |
$stats = $stats[$key]; |
return array( |
Cache::STATS_HITS => $stats['get_hits'], |
Cache::STATS_MISSES => $stats['get_misses'], |
Cache::STATS_UPTIME => $stats['uptime'], |
Cache::STATS_MEMORY_USAGE => $stats['bytes'], |
Cache::STATS_MEMORY_AVAILABLE => $stats['limit_maxbytes'], |
); |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FileCache.php |
@@ -0,0 +1,286 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Base file cache driver. |
* |
* @since 2.3 |
* @author Fabio B. Silva <fabio.bat.silva@gmail.com> |
* @author Tobias Schultze <http://tobion.de> |
*/ |
abstract class FileCache extends CacheProvider |
{ |
/** |
* The cache directory. |
* |
* @var string |
*/ |
protected $directory; |
|
/** |
* The cache file extension. |
* |
* @var string |
*/ |
private $extension; |
|
/** |
* @var int |
*/ |
private $umask; |
|
/** |
* @var int |
*/ |
private $directoryStringLength; |
|
/** |
* @var int |
*/ |
private $extensionStringLength; |
|
/** |
* @var bool |
*/ |
private $isRunningOnWindows; |
|
/** |
* Constructor. |
* |
* @param string $directory The cache directory. |
* @param string $extension The cache file extension. |
* |
* @throws \InvalidArgumentException |
*/ |
public function __construct($directory, $extension = '', $umask = 0002) |
{ |
// YES, this needs to be *before* createPathIfNeeded() |
if ( ! is_int($umask)) { |
throw new \InvalidArgumentException(sprintf( |
'The umask parameter is required to be integer, was: %s', |
gettype($umask) |
)); |
} |
$this->umask = $umask; |
|
if ( ! $this->createPathIfNeeded($directory)) { |
throw new \InvalidArgumentException(sprintf( |
'The directory "%s" does not exist and could not be created.', |
$directory |
)); |
} |
|
if ( ! is_writable($directory)) { |
throw new \InvalidArgumentException(sprintf( |
'The directory "%s" is not writable.', |
$directory |
)); |
} |
|
// YES, this needs to be *after* createPathIfNeeded() |
$this->directory = realpath($directory); |
$this->extension = (string) $extension; |
|
$this->directoryStringLength = strlen($this->directory); |
$this->extensionStringLength = strlen($this->extension); |
$this->isRunningOnWindows = defined('PHP_WINDOWS_VERSION_BUILD'); |
} |
|
/** |
* Gets the cache directory. |
* |
* @return string |
*/ |
public function getDirectory() |
{ |
return $this->directory; |
} |
|
/** |
* Gets the cache file extension. |
* |
* @return string |
*/ |
public function getExtension() |
{ |
return $this->extension; |
} |
|
/** |
* @param string $id |
* |
* @return string |
*/ |
protected function getFilename($id) |
{ |
$hash = hash('sha256', $id); |
|
// This ensures that the filename is unique and that there are no invalid chars in it. |
if ( |
'' === $id |
|| ((strlen($id) * 2 + $this->extensionStringLength) > 255) |
|| ($this->isRunningOnWindows && ($this->directoryStringLength + 4 + strlen($id) * 2 + $this->extensionStringLength) > 258) |
) { |
// Most filesystems have a limit of 255 chars for each path component. On Windows the the whole path is limited |
// to 260 chars (including terminating null char). Using long UNC ("\\?\" prefix) does not work with the PHP API. |
// And there is a bug in PHP (https://bugs.php.net/bug.php?id=70943) with path lengths of 259. |
// So if the id in hex representation would surpass the limit, we use the hash instead. The prefix prevents |
// collisions between the hash and bin2hex. |
$filename = '_' . $hash; |
} else { |
$filename = bin2hex($id); |
} |
|
return $this->directory |
. DIRECTORY_SEPARATOR |
. substr($hash, 0, 2) |
. DIRECTORY_SEPARATOR |
. $filename |
. $this->extension; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
$filename = $this->getFilename($id); |
|
return @unlink($filename) || ! file_exists($filename); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
foreach ($this->getIterator() as $name => $file) { |
if ($file->isDir()) { |
// Remove the intermediate directories which have been created to balance the tree. It only takes effect |
// if the directory is empty. If several caches share the same directory but with different file extensions, |
// the other ones are not removed. |
@rmdir($name); |
} elseif ($this->isFilenameEndingWithExtension($name)) { |
// If an extension is set, only remove files which end with the given extension. |
// If no extension is set, we have no other choice than removing everything. |
@unlink($name); |
} |
} |
|
return true; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
$usage = 0; |
foreach ($this->getIterator() as $name => $file) { |
if (! $file->isDir() && $this->isFilenameEndingWithExtension($name)) { |
$usage += $file->getSize(); |
} |
} |
|
$free = disk_free_space($this->directory); |
|
return array( |
Cache::STATS_HITS => null, |
Cache::STATS_MISSES => null, |
Cache::STATS_UPTIME => null, |
Cache::STATS_MEMORY_USAGE => $usage, |
Cache::STATS_MEMORY_AVAILABLE => $free, |
); |
} |
|
/** |
* Create path if needed. |
* |
* @param string $path |
* @return bool TRUE on success or if path already exists, FALSE if path cannot be created. |
*/ |
private function createPathIfNeeded($path) |
{ |
if ( ! is_dir($path)) { |
if (false === @mkdir($path, 0777 & (~$this->umask), true) && !is_dir($path)) { |
return false; |
} |
} |
|
return true; |
} |
|
/** |
* Writes a string content to file in an atomic way. |
* |
* @param string $filename Path to the file where to write the data. |
* @param string $content The content to write |
* |
* @return bool TRUE on success, FALSE if path cannot be created, if path is not writable or an any other error. |
*/ |
protected function writeFile($filename, $content) |
{ |
$filepath = pathinfo($filename, PATHINFO_DIRNAME); |
|
if ( ! $this->createPathIfNeeded($filepath)) { |
return false; |
} |
|
if ( ! is_writable($filepath)) { |
return false; |
} |
|
$tmpFile = tempnam($filepath, 'swap'); |
@chmod($tmpFile, 0666 & (~$this->umask)); |
|
if (file_put_contents($tmpFile, $content) !== false) { |
if (@rename($tmpFile, $filename)) { |
return true; |
} |
|
@unlink($tmpFile); |
} |
|
return false; |
} |
|
/** |
* @return \Iterator |
*/ |
private function getIterator() |
{ |
return new \RecursiveIteratorIterator( |
new \RecursiveDirectoryIterator($this->directory, \FilesystemIterator::SKIP_DOTS), |
\RecursiveIteratorIterator::CHILD_FIRST |
); |
} |
|
/** |
* @param string $name The filename |
* |
* @return bool |
*/ |
private function isFilenameEndingWithExtension($name) |
{ |
return '' === $this->extension |
|| strrpos($name, $this->extension) === (strlen($name) - $this->extensionStringLength); |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FilesystemCache.php |
@@ -0,0 +1,111 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Filesystem cache driver. |
* |
* @since 2.3 |
* @author Fabio B. Silva <fabio.bat.silva@gmail.com> |
*/ |
class FilesystemCache extends FileCache |
{ |
const EXTENSION = '.doctrinecache.data'; |
|
/** |
* {@inheritdoc} |
*/ |
public function __construct($directory, $extension = self::EXTENSION, $umask = 0002) |
{ |
parent::__construct($directory, $extension, $umask); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
$data = ''; |
$lifetime = -1; |
$filename = $this->getFilename($id); |
|
if ( ! is_file($filename)) { |
return false; |
} |
|
$resource = fopen($filename, "r"); |
|
if (false !== ($line = fgets($resource))) { |
$lifetime = (int) $line; |
} |
|
if ($lifetime !== 0 && $lifetime < time()) { |
fclose($resource); |
|
return false; |
} |
|
while (false !== ($line = fgets($resource))) { |
$data .= $line; |
} |
|
fclose($resource); |
|
return unserialize($data); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
$lifetime = -1; |
$filename = $this->getFilename($id); |
|
if ( ! is_file($filename)) { |
return false; |
} |
|
$resource = fopen($filename, "r"); |
|
if (false !== ($line = fgets($resource))) { |
$lifetime = (int) $line; |
} |
|
fclose($resource); |
|
return $lifetime === 0 || $lifetime > time(); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
if ($lifeTime > 0) { |
$lifeTime = time() + $lifeTime; |
} |
|
$data = serialize($data); |
$filename = $this->getFilename($id); |
|
return $this->writeFile($filename, $lifeTime . PHP_EOL . $data); |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FlushableCache.php |
@@ -0,0 +1,37 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Interface for cache that can be flushed. |
* |
* @link www.doctrine-project.org |
* @since 1.4 |
* @author Adirelle <adirelle@gmail.com> |
*/ |
interface FlushableCache |
{ |
/** |
* Flushes all cache entries, globally. |
* |
* @return bool TRUE if the cache entries were successfully flushed, FALSE otherwise. |
*/ |
public function flushAll(); |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MemcacheCache.php |
@@ -0,0 +1,126 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
use \Memcache; |
|
/** |
* Memcache cache provider. |
* |
* @link www.doctrine-project.org |
* @since 2.0 |
* @author Benjamin Eberlei <kontakt@beberlei.de> |
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> |
* @author Jonathan Wage <jonwage@gmail.com> |
* @author Roman Borschel <roman@code-factory.org> |
* @author David Abdemoulaie <dave@hobodave.com> |
*/ |
class MemcacheCache extends CacheProvider |
{ |
/** |
* @var Memcache|null |
*/ |
private $memcache; |
|
/** |
* Sets the memcache instance to use. |
* |
* @param Memcache $memcache |
* |
* @return void |
*/ |
public function setMemcache(Memcache $memcache) |
{ |
$this->memcache = $memcache; |
} |
|
/** |
* Gets the memcache instance used by the cache. |
* |
* @return Memcache|null |
*/ |
public function getMemcache() |
{ |
return $this->memcache; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
return $this->memcache->get($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
$flags = null; |
$this->memcache->get($id, $flags); |
|
//if memcache has changed the value of "flags", it means the value exists |
return ($flags !== null); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
if ($lifeTime > 30 * 24 * 3600) { |
$lifeTime = time() + $lifeTime; |
} |
return $this->memcache->set($id, $data, 0, (int) $lifeTime); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
// Memcache::delete() returns false if entry does not exist |
return $this->memcache->delete($id) || ! $this->doContains($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
return $this->memcache->flush(); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
$stats = $this->memcache->getStats(); |
return array( |
Cache::STATS_HITS => $stats['get_hits'], |
Cache::STATS_MISSES => $stats['get_misses'], |
Cache::STATS_UPTIME => $stats['uptime'], |
Cache::STATS_MEMORY_USAGE => $stats['bytes'], |
Cache::STATS_MEMORY_AVAILABLE => $stats['limit_maxbytes'], |
); |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MemcachedCache.php |
@@ -0,0 +1,146 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
use \Memcached; |
|
/** |
* Memcached cache provider. |
* |
* @link www.doctrine-project.org |
* @since 2.2 |
* @author Benjamin Eberlei <kontakt@beberlei.de> |
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> |
* @author Jonathan Wage <jonwage@gmail.com> |
* @author Roman Borschel <roman@code-factory.org> |
* @author David Abdemoulaie <dave@hobodave.com> |
*/ |
class MemcachedCache extends CacheProvider |
{ |
/** |
* @var Memcached|null |
*/ |
private $memcached; |
|
/** |
* Sets the memcache instance to use. |
* |
* @param Memcached $memcached |
* |
* @return void |
*/ |
public function setMemcached(Memcached $memcached) |
{ |
$this->memcached = $memcached; |
} |
|
/** |
* Gets the memcached instance used by the cache. |
* |
* @return Memcached|null |
*/ |
public function getMemcached() |
{ |
return $this->memcached; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
return $this->memcached->get($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetchMultiple(array $keys) |
{ |
return $this->memcached->getMulti($keys) ?: []; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSaveMultiple(array $keysAndValues, $lifetime = 0) |
{ |
if ($lifetime > 30 * 24 * 3600) { |
$lifetime = time() + $lifetime; |
} |
|
return $this->memcached->setMulti($keysAndValues, $lifetime); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
return false !== $this->memcached->get($id) |
|| $this->memcached->getResultCode() !== Memcached::RES_NOTFOUND; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
if ($lifeTime > 30 * 24 * 3600) { |
$lifeTime = time() + $lifeTime; |
} |
return $this->memcached->set($id, $data, (int) $lifeTime); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
return $this->memcached->delete($id) |
|| $this->memcached->getResultCode() === Memcached::RES_NOTFOUND; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
return $this->memcached->flush(); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
$stats = $this->memcached->getStats(); |
$servers = $this->memcached->getServerList(); |
$key = $servers[0]['host'] . ':' . $servers[0]['port']; |
$stats = $stats[$key]; |
return array( |
Cache::STATS_HITS => $stats['get_hits'], |
Cache::STATS_MISSES => $stats['get_misses'], |
Cache::STATS_UPTIME => $stats['uptime'], |
Cache::STATS_MEMORY_USAGE => $stats['bytes'], |
Cache::STATS_MEMORY_AVAILABLE => $stats['limit_maxbytes'], |
); |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MongoDBCache.php |
@@ -0,0 +1,197 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
use MongoBinData; |
use MongoCollection; |
use MongoCursorException; |
use MongoDate; |
|
/** |
* MongoDB cache provider. |
* |
* @since 1.1 |
* @author Jeremy Mikola <jmikola@gmail.com> |
*/ |
class MongoDBCache extends CacheProvider |
{ |
/** |
* The data field will store the serialized PHP value. |
*/ |
const DATA_FIELD = 'd'; |
|
/** |
* The expiration field will store a MongoDate value indicating when the |
* cache entry should expire. |
* |
* With MongoDB 2.2+, entries can be automatically deleted by MongoDB by |
* indexing this field with the "expireAfterSeconds" option equal to zero. |
* This will direct MongoDB to regularly query for and delete any entries |
* whose date is older than the current time. Entries without a date value |
* in this field will be ignored. |
* |
* The cache provider will also check dates on its own, in case expired |
* entries are fetched before MongoDB's TTLMonitor pass can expire them. |
* |
* @see http://docs.mongodb.org/manual/tutorial/expire-data/ |
*/ |
const EXPIRATION_FIELD = 'e'; |
|
/** |
* @var MongoCollection |
*/ |
private $collection; |
|
/** |
* Constructor. |
* |
* This provider will default to the write concern and read preference |
* options set on the MongoCollection instance (or inherited from MongoDB or |
* MongoClient). Using an unacknowledged write concern (< 1) may make the |
* return values of delete() and save() unreliable. Reading from secondaries |
* may make contain() and fetch() unreliable. |
* |
* @see http://www.php.net/manual/en/mongo.readpreferences.php |
* @see http://www.php.net/manual/en/mongo.writeconcerns.php |
* @param MongoCollection $collection |
*/ |
public function __construct(MongoCollection $collection) |
{ |
$this->collection = $collection; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
$document = $this->collection->findOne(array('_id' => $id), array(self::DATA_FIELD, self::EXPIRATION_FIELD)); |
|
if ($document === null) { |
return false; |
} |
|
if ($this->isExpired($document)) { |
$this->doDelete($id); |
return false; |
} |
|
return unserialize($document[self::DATA_FIELD]->bin); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
$document = $this->collection->findOne(array('_id' => $id), array(self::EXPIRATION_FIELD)); |
|
if ($document === null) { |
return false; |
} |
|
if ($this->isExpired($document)) { |
$this->doDelete($id); |
return false; |
} |
|
return true; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
try { |
$result = $this->collection->update( |
array('_id' => $id), |
array('$set' => array( |
self::EXPIRATION_FIELD => ($lifeTime > 0 ? new MongoDate(time() + $lifeTime) : null), |
self::DATA_FIELD => new MongoBinData(serialize($data), MongoBinData::BYTE_ARRAY), |
)), |
array('upsert' => true, 'multiple' => false) |
); |
} catch (MongoCursorException $e) { |
return false; |
} |
|
return isset($result['ok']) ? $result['ok'] == 1 : true; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
$result = $this->collection->remove(array('_id' => $id)); |
|
return isset($result['ok']) ? $result['ok'] == 1 : true; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
// Use remove() in lieu of drop() to maintain any collection indexes |
$result = $this->collection->remove(); |
|
return isset($result['ok']) ? $result['ok'] == 1 : true; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
$serverStatus = $this->collection->db->command(array( |
'serverStatus' => 1, |
'locks' => 0, |
'metrics' => 0, |
'recordStats' => 0, |
'repl' => 0, |
)); |
|
$collStats = $this->collection->db->command(array('collStats' => 1)); |
|
return array( |
Cache::STATS_HITS => null, |
Cache::STATS_MISSES => null, |
Cache::STATS_UPTIME => (isset($serverStatus['uptime']) ? (int) $serverStatus['uptime'] : null), |
Cache::STATS_MEMORY_USAGE => (isset($collStats['size']) ? (int) $collStats['size'] : null), |
Cache::STATS_MEMORY_AVAILABLE => null, |
); |
} |
|
/** |
* Check if the document is expired. |
* |
* @param array $document |
* |
* @return bool |
*/ |
private function isExpired(array $document) |
{ |
return isset($document[self::EXPIRATION_FIELD]) && |
$document[self::EXPIRATION_FIELD] instanceof MongoDate && |
$document[self::EXPIRATION_FIELD]->sec < time(); |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MultiGetCache.php |
@@ -0,0 +1,39 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Interface for cache drivers that allows to get many items at once. |
* |
* @link www.doctrine-project.org |
* @since 1.4 |
* @author Asmir Mustafic <goetas@gmail.com> |
*/ |
interface MultiGetCache |
{ |
/** |
* Returns an associative array of values for keys is found in cache. |
* |
* @param string[] $keys Array of keys to retrieve from cache |
* @return mixed[] Array of retrieved values, indexed by the specified keys. |
* Values that couldn't be retrieved are not contained in this array. |
*/ |
function fetchMultiple(array $keys); |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MultiPutCache.php |
@@ -0,0 +1,41 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Interface for cache drivers that allows to put many items at once. |
* |
* @link www.doctrine-project.org |
* @since 1.6 |
* @author Daniel Gorgan <danut007ro@gmail.com> |
*/ |
interface MultiPutCache |
{ |
/** |
* Returns a boolean value indicating if the operation succeeded. |
* |
* @param array $keysAndValues Array of keys and values to save in cache |
* @param int $lifetime The lifetime. If != 0, sets a specific lifetime for these |
* cache entries (0 => infinite lifeTime). |
* |
* @return bool TRUE if the operation was successful, FALSE if it wasn't. |
*/ |
function saveMultiple(array $keysAndValues, $lifetime = 0); |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/PhpFileCache.php |
@@ -0,0 +1,120 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Php file cache driver. |
* |
* @since 2.3 |
* @author Fabio B. Silva <fabio.bat.silva@gmail.com> |
*/ |
class PhpFileCache extends FileCache |
{ |
const EXTENSION = '.doctrinecache.php'; |
|
/** |
* {@inheritdoc} |
*/ |
public function __construct($directory, $extension = self::EXTENSION, $umask = 0002) |
{ |
parent::__construct($directory, $extension, $umask); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
$value = $this->includeFileForId($id); |
|
if (! $value) { |
return false; |
} |
|
if ($value['lifetime'] !== 0 && $value['lifetime'] < time()) { |
return false; |
} |
|
return $value['data']; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
$value = $this->includeFileForId($id); |
|
if (! $value) { |
return false; |
} |
|
return $value['lifetime'] === 0 || $value['lifetime'] > time(); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
if ($lifeTime > 0) { |
$lifeTime = time() + $lifeTime; |
} |
|
if (is_object($data) && ! method_exists($data, '__set_state')) { |
throw new \InvalidArgumentException( |
"Invalid argument given, PhpFileCache only allows objects that implement __set_state() " . |
"and fully support var_export(). You can use the FilesystemCache to save arbitrary object " . |
"graphs using serialize()/deserialize()." |
); |
} |
|
$filename = $this->getFilename($id); |
|
$value = array( |
'lifetime' => $lifeTime, |
'data' => $data |
); |
|
$value = var_export($value, true); |
$code = sprintf('<?php return %s;', $value); |
|
return $this->writeFile($filename, $code); |
} |
|
/** |
* @param string $id |
* |
* @return array|false |
*/ |
private function includeFileForId($id) |
{ |
$fileName = $this->getFilename($id); |
|
// note: error suppression is still faster than `file_exists`, `is_file` and `is_readable` |
$value = @include $fileName; |
|
if (! isset($value['lifetime'])) { |
return false; |
} |
|
return $value; |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/PredisCache.php |
@@ -0,0 +1,136 @@ |
<?php |
|
namespace Doctrine\Common\Cache; |
|
use Predis\ClientInterface; |
|
/** |
* Predis cache provider. |
* |
* @author othillo <othillo@othillo.nl> |
*/ |
class PredisCache extends CacheProvider |
{ |
/** |
* @var ClientInterface |
*/ |
private $client; |
|
/** |
* @param ClientInterface $client |
* |
* @return void |
*/ |
public function __construct(ClientInterface $client) |
{ |
$this->client = $client; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
$result = $this->client->get($id); |
if (null === $result) { |
return false; |
} |
|
return unserialize($result); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetchMultiple(array $keys) |
{ |
$fetchedItems = call_user_func_array(array($this->client, 'mget'), $keys); |
|
return array_map('unserialize', array_filter(array_combine($keys, $fetchedItems))); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSaveMultiple(array $keysAndValues, $lifetime = 0) |
{ |
if ($lifetime) { |
$success = true; |
|
// Keys have lifetime, use SETEX for each of them |
foreach ($keysAndValues as $key => $value) { |
$response = $this->client->setex($key, $lifetime, serialize($value)); |
|
if ((string) $response != 'OK') { |
$success = false; |
} |
} |
|
return $success; |
} |
|
// No lifetime, use MSET |
$response = $this->client->mset(array_map(function ($value) { |
return serialize($value); |
}, $keysAndValues)); |
|
return (string) $response == 'OK'; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
return (bool) $this->client->exists($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
$data = serialize($data); |
if ($lifeTime > 0) { |
$response = $this->client->setex($id, $lifeTime, $data); |
} else { |
$response = $this->client->set($id, $data); |
} |
|
return $response === true || $response == 'OK'; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
return $this->client->del($id) >= 0; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
$response = $this->client->flushdb(); |
|
return $response === true || $response == 'OK'; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
$info = $this->client->info(); |
|
return array( |
Cache::STATS_HITS => $info['Stats']['keyspace_hits'], |
Cache::STATS_MISSES => $info['Stats']['keyspace_misses'], |
Cache::STATS_UPTIME => $info['Server']['uptime_in_seconds'], |
Cache::STATS_MEMORY_USAGE => $info['Memory']['used_memory'], |
Cache::STATS_MEMORY_AVAILABLE => false |
); |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/RedisCache.php |
@@ -0,0 +1,180 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
use Redis; |
|
/** |
* Redis cache provider. |
* |
* @link www.doctrine-project.org |
* @since 2.2 |
* @author Osman Ungur <osmanungur@gmail.com> |
*/ |
class RedisCache extends CacheProvider |
{ |
/** |
* @var Redis|null |
*/ |
private $redis; |
|
/** |
* Sets the redis instance to use. |
* |
* @param Redis $redis |
* |
* @return void |
*/ |
public function setRedis(Redis $redis) |
{ |
$redis->setOption(Redis::OPT_SERIALIZER, $this->getSerializerValue()); |
$this->redis = $redis; |
} |
|
/** |
* Gets the redis instance used by the cache. |
* |
* @return Redis|null |
*/ |
public function getRedis() |
{ |
return $this->redis; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
return $this->redis->get($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetchMultiple(array $keys) |
{ |
$fetchedItems = array_combine($keys, $this->redis->mget($keys)); |
|
// Redis mget returns false for keys that do not exist. So we need to filter those out unless it's the real data. |
$foundItems = array(); |
|
foreach ($fetchedItems as $key => $value) { |
if (false !== $value || $this->redis->exists($key)) { |
$foundItems[$key] = $value; |
} |
} |
|
return $foundItems; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSaveMultiple(array $keysAndValues, $lifetime = 0) |
{ |
if ($lifetime) { |
$success = true; |
|
// Keys have lifetime, use SETEX for each of them |
foreach ($keysAndValues as $key => $value) { |
if (!$this->redis->setex($key, $lifetime, $value)) { |
$success = false; |
} |
} |
|
return $success; |
} |
|
// No lifetime, use MSET |
return (bool) $this->redis->mset($keysAndValues); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
return $this->redis->exists($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
if ($lifeTime > 0) { |
return $this->redis->setex($id, $lifeTime, $data); |
} |
|
return $this->redis->set($id, $data); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
return $this->redis->delete($id) >= 0; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
return $this->redis->flushDB(); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
$info = $this->redis->info(); |
return array( |
Cache::STATS_HITS => $info['keyspace_hits'], |
Cache::STATS_MISSES => $info['keyspace_misses'], |
Cache::STATS_UPTIME => $info['uptime_in_seconds'], |
Cache::STATS_MEMORY_USAGE => $info['used_memory'], |
Cache::STATS_MEMORY_AVAILABLE => false |
); |
} |
|
/** |
* Returns the serializer constant to use. If Redis is compiled with |
* igbinary support, that is used. Otherwise the default PHP serializer is |
* used. |
* |
* @return integer One of the Redis::SERIALIZER_* constants |
*/ |
protected function getSerializerValue() |
{ |
if (defined('HHVM_VERSION')) { |
return Redis::SERIALIZER_PHP; |
} |
|
if (defined('Redis::SERIALIZER_IGBINARY') && extension_loaded('igbinary')) { |
return Redis::SERIALIZER_IGBINARY; |
} |
|
return Redis::SERIALIZER_PHP; |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/RiakCache.php |
@@ -0,0 +1,250 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
use Riak\Bucket; |
use Riak\Connection; |
use Riak\Input; |
use Riak\Exception; |
use Riak\Object; |
|
/** |
* Riak cache provider. |
* |
* @link www.doctrine-project.org |
* @since 1.1 |
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> |
*/ |
class RiakCache extends CacheProvider |
{ |
const EXPIRES_HEADER = 'X-Riak-Meta-Expires'; |
|
/** |
* @var \Riak\Bucket |
*/ |
private $bucket; |
|
/** |
* Sets the riak bucket instance to use. |
* |
* @param \Riak\Bucket $bucket |
*/ |
public function __construct(Bucket $bucket) |
{ |
$this->bucket = $bucket; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
try { |
$response = $this->bucket->get($id); |
|
// No objects found |
if ( ! $response->hasObject()) { |
return false; |
} |
|
// Check for attempted siblings |
$object = ($response->hasSiblings()) |
? $this->resolveConflict($id, $response->getVClock(), $response->getObjectList()) |
: $response->getFirstObject(); |
|
// Check for expired object |
if ($this->isExpired($object)) { |
$this->bucket->delete($object); |
|
return false; |
} |
|
return unserialize($object->getContent()); |
} catch (Exception\RiakException $e) { |
// Covers: |
// - Riak\ConnectionException |
// - Riak\CommunicationException |
// - Riak\UnexpectedResponseException |
// - Riak\NotFoundException |
} |
|
return false; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
try { |
// We only need the HEAD, not the entire object |
$input = new Input\GetInput(); |
|
$input->setReturnHead(true); |
|
$response = $this->bucket->get($id, $input); |
|
// No objects found |
if ( ! $response->hasObject()) { |
return false; |
} |
|
$object = $response->getFirstObject(); |
|
// Check for expired object |
if ($this->isExpired($object)) { |
$this->bucket->delete($object); |
|
return false; |
} |
|
return true; |
} catch (Exception\RiakException $e) { |
// Do nothing |
} |
|
return false; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
try { |
$object = new Object($id); |
|
$object->setContent(serialize($data)); |
|
if ($lifeTime > 0) { |
$object->addMetadata(self::EXPIRES_HEADER, (string) (time() + $lifeTime)); |
} |
|
$this->bucket->put($object); |
|
return true; |
} catch (Exception\RiakException $e) { |
// Do nothing |
} |
|
return false; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
try { |
$this->bucket->delete($id); |
|
return true; |
} catch (Exception\BadArgumentsException $e) { |
// Key did not exist on cluster already |
} catch (Exception\RiakException $e) { |
// Covers: |
// - Riak\Exception\ConnectionException |
// - Riak\Exception\CommunicationException |
// - Riak\Exception\UnexpectedResponseException |
} |
|
return false; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
try { |
$keyList = $this->bucket->getKeyList(); |
|
foreach ($keyList as $key) { |
$this->bucket->delete($key); |
} |
|
return true; |
} catch (Exception\RiakException $e) { |
// Do nothing |
} |
|
return false; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
// Only exposed through HTTP stats API, not Protocol Buffers API |
return null; |
} |
|
/** |
* Check if a given Riak Object have expired. |
* |
* @param \Riak\Object $object |
* |
* @return bool |
*/ |
private function isExpired(Object $object) |
{ |
$metadataMap = $object->getMetadataMap(); |
|
return isset($metadataMap[self::EXPIRES_HEADER]) |
&& $metadataMap[self::EXPIRES_HEADER] < time(); |
} |
|
/** |
* On-read conflict resolution. Applied approach here is last write wins. |
* Specific needs may override this method to apply alternate conflict resolutions. |
* |
* {@internal Riak does not attempt to resolve a write conflict, and store |
* it as sibling of conflicted one. By following this approach, it is up to |
* the next read to resolve the conflict. When this happens, your fetched |
* object will have a list of siblings (read as a list of objects). |
* In our specific case, we do not care about the intermediate ones since |
* they are all the same read from storage, and we do apply a last sibling |
* (last write) wins logic. |
* If by any means our resolution generates another conflict, it'll up to |
* next read to properly solve it.} |
* |
* @param string $id |
* @param string $vClock |
* @param array $objectList |
* |
* @return \Riak\Object |
*/ |
protected function resolveConflict($id, $vClock, array $objectList) |
{ |
// Our approach here is last-write wins |
$winner = $objectList[count($objectList)]; |
|
$putInput = new Input\PutInput(); |
$putInput->setVClock($vClock); |
|
$mergedObject = new Object($id); |
$mergedObject->setContent($winner->getContent()); |
|
$this->bucket->put($mergedObject, $putInput); |
|
return $mergedObject; |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/SQLite3Cache.php |
@@ -0,0 +1,220 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
use SQLite3; |
use SQLite3Result; |
|
/** |
* SQLite3 cache provider. |
* |
* @since 1.4 |
* @author Jake Bell <jake@theunraveler.com> |
*/ |
class SQLite3Cache extends CacheProvider |
{ |
/** |
* The ID field will store the cache key. |
*/ |
const ID_FIELD = 'k'; |
|
/** |
* The data field will store the serialized PHP value. |
*/ |
const DATA_FIELD = 'd'; |
|
/** |
* The expiration field will store a date value indicating when the |
* cache entry should expire. |
*/ |
const EXPIRATION_FIELD = 'e'; |
|
/** |
* @var SQLite3 |
*/ |
private $sqlite; |
|
/** |
* @var string |
*/ |
private $table; |
|
/** |
* Constructor. |
* |
* Calling the constructor will ensure that the database file and table |
* exist and will create both if they don't. |
* |
* @param SQLite3 $sqlite |
* @param string $table |
*/ |
public function __construct(SQLite3 $sqlite, $table) |
{ |
$this->sqlite = $sqlite; |
$this->table = (string) $table; |
|
list($id, $data, $exp) = $this->getFields(); |
|
return $this->sqlite->exec(sprintf( |
'CREATE TABLE IF NOT EXISTS %s(%s TEXT PRIMARY KEY NOT NULL, %s BLOB, %s INTEGER)', |
$table, |
$id, |
$data, |
$exp |
)); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
if ($item = $this->findById($id)) { |
return unserialize($item[self::DATA_FIELD]); |
} |
|
return false; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
return null !== $this->findById($id, false); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
$statement = $this->sqlite->prepare(sprintf( |
'INSERT OR REPLACE INTO %s (%s) VALUES (:id, :data, :expire)', |
$this->table, |
implode(',', $this->getFields()) |
)); |
|
$statement->bindValue(':id', $id); |
$statement->bindValue(':data', serialize($data), SQLITE3_BLOB); |
$statement->bindValue(':expire', $lifeTime > 0 ? time() + $lifeTime : null); |
|
return $statement->execute() instanceof SQLite3Result; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
list($idField) = $this->getFields(); |
|
$statement = $this->sqlite->prepare(sprintf( |
'DELETE FROM %s WHERE %s = :id', |
$this->table, |
$idField |
)); |
|
$statement->bindValue(':id', $id); |
|
return $statement->execute() instanceof SQLite3Result; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
return $this->sqlite->exec(sprintf('DELETE FROM %s', $this->table)); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
// no-op. |
} |
|
/** |
* Find a single row by ID. |
* |
* @param mixed $id |
* @param bool $includeData |
* |
* @return array|null |
*/ |
private function findById($id, $includeData = true) |
{ |
list($idField) = $fields = $this->getFields(); |
|
if (!$includeData) { |
$key = array_search(static::DATA_FIELD, $fields); |
unset($fields[$key]); |
} |
|
$statement = $this->sqlite->prepare(sprintf( |
'SELECT %s FROM %s WHERE %s = :id LIMIT 1', |
implode(',', $fields), |
$this->table, |
$idField |
)); |
|
$statement->bindValue(':id', $id, SQLITE3_TEXT); |
|
$item = $statement->execute()->fetchArray(SQLITE3_ASSOC); |
|
if ($item === false) { |
return null; |
} |
|
if ($this->isExpired($item)) { |
$this->doDelete($id); |
|
return null; |
} |
|
return $item; |
} |
|
/** |
* Gets an array of the fields in our table. |
* |
* @return array |
*/ |
private function getFields() |
{ |
return array(static::ID_FIELD, static::DATA_FIELD, static::EXPIRATION_FIELD); |
} |
|
/** |
* Check if the item is expired. |
* |
* @param array $item |
* |
* @return bool |
*/ |
private function isExpired(array $item) |
{ |
return isset($item[static::EXPIRATION_FIELD]) && |
$item[self::EXPIRATION_FIELD] !== null && |
$item[self::EXPIRATION_FIELD] < time(); |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/VoidCache.php |
@@ -0,0 +1,78 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Void cache driver. The cache could be of use in tests where you don`t need to cache anything. |
* |
* @link www.doctrine-project.org |
* @since 1.5 |
* @author Kotlyar Maksim <kotlyar.maksim@gmail.com> |
*/ |
class VoidCache extends CacheProvider |
{ |
/** |
* {@inheritDoc} |
*/ |
protected function doFetch($id) |
{ |
return false; |
} |
|
/** |
* {@inheritDoc} |
*/ |
protected function doContains($id) |
{ |
return false; |
} |
|
/** |
* {@inheritDoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
return true; |
} |
|
/** |
* {@inheritDoc} |
*/ |
protected function doDelete($id) |
{ |
return true; |
} |
|
/** |
* {@inheritDoc} |
*/ |
protected function doFlush() |
{ |
return true; |
} |
|
/** |
* {@inheritDoc} |
*/ |
protected function doGetStats() |
{ |
return; |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/WinCacheCache.php |
@@ -0,0 +1,109 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* WinCache cache provider. |
* |
* @link www.doctrine-project.org |
* @since 2.2 |
* @author Benjamin Eberlei <kontakt@beberlei.de> |
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> |
* @author Jonathan Wage <jonwage@gmail.com> |
* @author Roman Borschel <roman@code-factory.org> |
* @author David Abdemoulaie <dave@hobodave.com> |
*/ |
class WinCacheCache extends CacheProvider |
{ |
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
return wincache_ucache_get($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
return wincache_ucache_exists($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
return wincache_ucache_set($id, $data, $lifeTime); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
return wincache_ucache_delete($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
return wincache_ucache_clear(); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFetchMultiple(array $keys) |
{ |
return wincache_ucache_get($keys); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSaveMultiple(array $keysAndValues, $lifetime = 0) |
{ |
$result = wincache_ucache_set($keysAndValues, null, $lifetime); |
|
return empty($result); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
$info = wincache_ucache_info(); |
$meminfo = wincache_ucache_meminfo(); |
|
return array( |
Cache::STATS_HITS => $info['total_hit_count'], |
Cache::STATS_MISSES => $info['total_miss_count'], |
Cache::STATS_UPTIME => $info['total_cache_uptime'], |
Cache::STATS_MEMORY_USAGE => $meminfo['memory_total'], |
Cache::STATS_MEMORY_AVAILABLE => $meminfo['memory_free'], |
); |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/XcacheCache.php |
@@ -0,0 +1,112 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Xcache cache driver. |
* |
* @link www.doctrine-project.org |
* @since 2.0 |
* @author Benjamin Eberlei <kontakt@beberlei.de> |
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> |
* @author Jonathan Wage <jonwage@gmail.com> |
* @author Roman Borschel <roman@code-factory.org> |
* @author David Abdemoulaie <dave@hobodave.com> |
*/ |
class XcacheCache extends CacheProvider |
{ |
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
return $this->doContains($id) ? unserialize(xcache_get($id)) : false; |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
return xcache_isset($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
return xcache_set($id, serialize($data), (int) $lifeTime); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
return xcache_unset($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
$this->checkAuthorization(); |
|
xcache_clear_cache(XC_TYPE_VAR); |
|
return true; |
} |
|
/** |
* Checks that xcache.admin.enable_auth is Off. |
* |
* @return void |
* |
* @throws \BadMethodCallException When xcache.admin.enable_auth is On. |
*/ |
protected function checkAuthorization() |
{ |
if (ini_get('xcache.admin.enable_auth')) { |
throw new \BadMethodCallException( |
'To use all features of \Doctrine\Common\Cache\XcacheCache, ' |
. 'you must set "xcache.admin.enable_auth" to "Off" in your php.ini.' |
); |
} |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
$this->checkAuthorization(); |
|
$info = xcache_info(XC_TYPE_VAR, 0); |
return array( |
Cache::STATS_HITS => $info['hits'], |
Cache::STATS_MISSES => $info['misses'], |
Cache::STATS_UPTIME => null, |
Cache::STATS_MEMORY_USAGE => $info['size'], |
Cache::STATS_MEMORY_AVAILABLE => $info['avail'], |
); |
} |
} |
/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ZendDataCache.php |
@@ -0,0 +1,83 @@ |
<?php |
/* |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
* |
* This software consists of voluntary contributions made by many individuals |
* and is licensed under the MIT license. For more information, see |
* <http://www.doctrine-project.org>. |
*/ |
|
namespace Doctrine\Common\Cache; |
|
/** |
* Zend Data Cache cache driver. |
* |
* @link www.doctrine-project.org |
* @since 2.0 |
* @author Ralph Schindler <ralph.schindler@zend.com> |
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> |
*/ |
class ZendDataCache extends CacheProvider |
{ |
/** |
* {@inheritdoc} |
*/ |
protected function doFetch($id) |
{ |
return zend_shm_cache_fetch($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doContains($id) |
{ |
return (false !== zend_shm_cache_fetch($id)); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doSave($id, $data, $lifeTime = 0) |
{ |
return zend_shm_cache_store($id, $data, $lifeTime); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doDelete($id) |
{ |
return zend_shm_cache_delete($id); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doFlush() |
{ |
$namespace = $this->getNamespace(); |
if (empty($namespace)) { |
return zend_shm_cache_clear(); |
} |
return zend_shm_cache_clear($namespace); |
} |
|
/** |
* {@inheritdoc} |
*/ |
protected function doGetStats() |
{ |
return null; |
} |
} |