Return data for given cache key.

@param string $cacheKey

@return bool
437985
public function retrieve($cacheKey)
    {
        if ($this->has($cacheKey)) {
            return $this->cache()->get($cacheKey);
        }

        return false;
    }
29661
public function GetCache($key)
    {
		return (array_key_exists($key, $this->_cache) ? $this->_cache[$key] : null);
	}
278039
public function getItem($key)
    {
        $cacheFile = __cache_path().md5($key);
        if (file_exists($cacheFile)) {
            $fileHandling = new FileHandling();
            $data = $fileHandling->open($cacheFile, 'readOnly')->read($cacheFile);
            $data = json_decode($data, true);
            if ($data['ttl'] === 0 || (time() - $data['start'] <= $data['ttl'])) {
                $value = $data['value'];
            } else {
                $this->deleteItem($key);
            }
        }

        return (isset($value)) ? $value : false;
    }
1039255
protected function getData($key)
    {
        $cacheKey = $this->key($key);
        return array_key_exists($cacheKey, $this->cache)?$this->cache[$this->key($key)]:false;
    }
1188442
public function get($key)
    {
        if (empty($this->memcache)) {
            return false;
        }

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

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

        return $data;
    }
612381
public static function get($key)
    {
        if (!$cache = self::getInstance()) {
            return false;
        }

        $key = self::prepare($key);

        try {
            if ($cache->hasItem($key)) {
                $item = $cache->getItem($key);
                if ($item->isHit()) {
                    return $item->get();
                }
            }
        } catch (InvalidArgumentException $e) {
            // something going wrong
            Logger::error($e->getMessage());
        }

        return false;
    }
474090
public function getFromCache($key)
    {
        $fileName = $this->getCacheFilePath($key);
        $value = null;
        if (is_readable($fileName)) {
            $value = file_get_contents($fileName);
            if ($value == serialize(false)) {
                return false;
            }

            $value = unserialize($value);
            if ($value === false) {
                $value = null;
            }
        }

        return $value;
    }
1346148
public function getItem($key): CacheItem
    {
        if (isset($this->data[$key])) {
            return $this->data[$key];
        }

        $cacheItem = new CacheItem($key);

        if ($this->has($key)) {
            $cacheItem->set($this->get($key));
        }

        $this->data[$key] = $cacheItem;

        return $cacheItem;
    }
349924
public function read($key)
    {
        if (!isset($this->cacheDirectory)) {
            return;
        }

        $this->loadCacheMetaData();

        return unserialize(file_get_contents($this->cacheDirectory . '/' . $key));
    }
1126788
protected function get_cache($key)
    {
        // no session data in cache (read() returns false)
        if (!$this->key) {
            $cache = null;
        }
        // use internal data for fast requests (up to 0.5 sec.)
        else if ($key == $this->key && (!$this->vars || microtime(true) - $this->start < 0.5)) {
            $cache = $this->vars;
        }
        else { // else read data again
            $cache = $this->read($key);
        }

        return $cache;
    }
930580
public function exists($commandKey, $cacheKey)
    {
        return array_key_exists($commandKey, $this->cachedResults)
            && array_key_exists($cacheKey, $this->cachedResults[$commandKey]);
    }
1264418
private function getDirectoryAndFilenameFromKey($cacheKey) {

        if (!is_array($cacheKey)) {
            $cacheKey = array($cacheKey);
        }

        $filename = array_pop($cacheKey);
        $dir = $this->cacheBaseDir . "/" . join("/", $cacheKey);


        // Return dir and filename
        return array($dir, $filename);

    }
743996
public function containsKey($key)
    {
        if (!$this->enabled)
            return false;

        $has_key = false;

        $fetchMethod = $this->apcFuncPrefix.'_fetch';
        $fetchMethod($this->key($key), $has_key);

        // $this->Logger->debug("Cache contains {$key}? " . (($has_key) ? 'TRUE' : 'FALSE'));

        return $has_key;
    }
307495
public function get($key)
    {
        $this->checkForKey($key);

        return $this->cache->get($this->path.$key);
    }
1341635
private function cacheGet(Route $route, string $cacheKey)
    {
        if ($route->getOption(AbstractRoute::OPTIONS_CACHE)) {
            if ($data = self::cache(self::class)->get($cacheKey)) {
                foreach ($data['headers'] as $name => $header) {
                    self::response()->addHeader($name, $header);
                }

                return $data['output'];
            } else {
                return false;
            }
        }

        return false;
    }
6763
private function getCachePath($cacheKey)
    {
        $folder = $this->cacheDir . substr($cacheKey, 0, 2) . DIRECTORY_SEPARATOR . substr($cacheKey, 2,
                2) . DIRECTORY_SEPARATOR . substr($cacheKey, 4, 2) . DIRECTORY_SEPARATOR;
        if (!is_dir($folder)) {
            mkdir($folder, 0755, true);
        }

        return $folder . $cacheKey;
    }
786575
public function get($key)
    {
        $context = $this->_context;

        if ($context->cache !== null && array_key_exists($key, $context->cache)) {
            return $context->cache[$key];
        } elseif ($this->_enabled) {
            if ($this->_is_cli) {
                if (($r = apcu_fetch($this->_prefix ? ($this->_prefix . $key) : $key)) === false) {
                    return false;
                }
                return time() <= $r[0] ? $r[1] : false;
            } else {
                return apcu_fetch($this->_prefix ? ($this->_prefix . $key) : $key);
            }
        } else {
            return false;
        }
    }