Retrieve data from memcache

@param string $key
972285
public function get($key)
    {
        if (!$this->requireProvider("Getting key " . $key)) return false;

        return $this->cacheProvider->get($key);
    }
985882
public function remove($key)
    {
        if (!$this->hasConnection()) {
            // @codeCoverageIgnoreStart
            return false;
            // @codeCoverageIgnoreEnd
        }

        try {
            return $this->memcache->delete($key);
        // @codeCoverageIgnoreStart
        } catch (\Exception $e) {
        }

        return false;
        // @codeCoverageIgnoreEnd
    }
1188442
public function get($key)
    {
        if (empty($this->memcache)) {
            return false;
        }

        $key = $this->processKey($key);

        $data = $this->memcache->get($key);

        return $data;
    }
869400
public function remove($key){
        return ($this->memcache) ? $this->memcache->remove($this->prefix . '_' . $key) : false;
    }
788658
public function get($key)
    {
        $value = $this->memcached->get($key);

        return is_array($value) ? $value[0] : $value;
    }
1272823
protected function set($key, $data, $expire) {
		$this->memcache->set($key, $data, null, $expire);
	}
845354
public function get($key = null)
    {
        if (isset ($this->cacheListing [$key])) {
            $val = apc_fetch($key, $success);

            return $success ? $val : $success;
        }

        return false;
    }
1000012
public function remove($key)
	{
		$this->connect();

		$this->driver->delete($key);

		$rc = $this->driver->getResultCode();

		if ($rc !== \Memcached::RES_SUCCESS)
		{
			return false;
		}

		return true;
	}
41867
public static function get($key)
    {
        $path = Cache::path($key);

        if (file_exists($path)) {
            return file_get_contents($path);
        }

        return null;
    }
705896
public function delete($key)
    {
        self::validateKey($key);

        $this->queriesCount++;

        return $this->memcache->delete($key);
    }
832127
protected function load($key) {
        try {
            return $this->memcached->get($key);
        } catch (\Exception $e) {
            throw new StorageException("Failed to load memcached key: $key", 1, $e);
        }
    }
645042
public function get($key, $default = null)
    {
        is_array($key)
            ? self::validateKeys($key)
            : self::validateKey($key);

        $this->queriesCount++;

        return ($tmp = $this->memcache->get($key)) === false
            ? false
            : unserialize($tmp);
    }
379585
private function loadFromCache($key)
    {
        $encoded = (string) $this
            ->cache
            ->fetch($key);

        try {
            return is_string($encoded)
                ? $this
                    ->encoder
                    ->decode($encoded)
                : null;
        } catch (Exception $e) {
            // Silent pass
        }

        return null;
    }
1345319
protected function get($key)
    {
        $this->checkForNonEmptyKey($key);
        if (!$this->requestDataHasBeenRetrieved) {
            $this->retrieveRequestData();
        }
        if (!isset($this->cachedRequestData[$key])) {
            return null;
        }

        return $this->cachedRequestData[$key];
    }
224985
private function __connect(Memento\Key $key = null)
    {
        if (!is_null($this->groupKey)) {
            $connectKey = $this->groupKey;
        } else {
            $connectKey = $key;
        }

        $config = $this->getServer($connectKey, $this->config);

        $host = null;
        if (isset($config['host'])) {
            $host = $config['host'];
        } elseif (isset($config[0]) && is_string($config[0])) {
            $host = $config[0];
        }

        $port = self::DEFAULT_PORT;
        if (isset($config['port'])) {
            $port = $config['port'];
        } elseif (isset($config[1]) && is_numeric($config[1])) {
            $port = $config[1];
        }

        if (empty($host)) {
            throw new \Exception("Invalid memcache configuration");
        }

        // instantiate to the memcache connection
        $this->memcache = new \Memcache();

        return $this->memcache->connect($host, $port);
    }
233038
public function get($key)
    {
        $data = [];
        $data = $this->memcached()->get($key);

        return ($this->memcached()->getResultCode() == 0) ? $data : null;
    }
708113
public function get($key)
    {
        $key = $this->salted($key, $this->suffix);

        $cached = $this->cache->get($key);
        $code = $this->cache->getResultCode();

        if ($code === Memcached::RES_SUCCESS) {
            return $cached;

        } elseif ($code !== Memcached::RES_NOTFOUND) {
            $this->sendAlert('get', $key, $code);
        }

        return null;
    }