Ob unter dem angegebenen Schluessel ein Wert im Cache gespeichert ist.

@param  string $key - Schluessel

@return bool
341854
public function isCached($key) {
        // Hier wird die eigentliche Arbeit gemacht. Die Methode prueft nicht nur, ob der Wert im Cache
        // existiert, sondern speichert ihn auch im lokalen ReferencePool. Folgende Abfragen muessen so
        // nicht ein weiteres Mal auf den Cache zugreifen, sondern koennen aus dem lokalen Pool bedient
        // werden.

        // ReferencePool abfragen
        if ($this->getReferencePool()->isCached($key)) {
            return true;
        }
        else {
            // Datei suchen und auslesen
            $file = $this->getFilePath($key);
            $data = $this->readFile($file);
            if (!$data)       // Cache-Miss
                return false;

            // Cache-Hit, $data Format: array(created, $expires, $value, $dependency)
            $created    = $data[0];
            $expires    = $data[1];
            $value      = $data[2];
            $dependency = $data[3];

            // expires pruefen
            if ($expires && $created+$expires < time()) {
                $this->drop($key);
                return false;
            }

            // Dependency pruefen
            if ($dependency) {
                $minValid = $dependency->getMinValidity();

                if ($minValid) {
                    if (time() > $created+$minValid) {
                        if (!$dependency->isValid()) {
                            $this->drop($key);
                            return false;
                        }
                        // created aktualisieren (Wert praktisch neu in den Cache schreiben)
                        return $this->set($key, $value, $expires, $dependency);
                    }
                }
                elseif (!$dependency->isValid()) {
                    $this->drop($key);
                    return false;
                }
            }

            // ok, Wert im ReferencePool speichern
            $this->getReferencePool()->set($key, $value, Cache::EXPIRES_NEVER, $dependency);
            return true;
        }
    }
1296614
public function rm(string $key): bool {
		return $this->driver->del($key) === 0 ? false : true;
	}
1157533
public function forget($key)
    {
        $key = Arr::wrap($key);
        $result = $this->whereIn('key', $key)->delete();
        $this->cacheForget($key);

        return $result;
    }
965554
public static function removeFromCache($key)
    {
        $fullKey = static::makeCacheKey($key);
        if (!Cache::forget($fullKey)) {
            return false;
        }

        static::removeKeys($key);

        return true;
    }
669642
public function exists(string $key): bool
    {
        $key = $this->getKey($key);

        return cache()->has($key);
    }
1076281
public function delete($key)
    {
        if (!$this->enabled)
            return true;

        $this->Logger->debug("Delete key: {$key}");
        return $this->db->queryExec("DELETE FROM cache WHERE key='" . $this->key($key). "'");
    }
454016
public function hasKey($key)
    {
        if (array_key_exists($key, $this->data)) {
            return true;
        }

        $entity = $this->getEntity();
        if ($entity->getRepository()->getCache()->tableHasField($entity->getTable(), $key)) {
            return true;
        }

        if ($entity->getRepository()->getCache()->tableHasField($entity->getTable() . '_i18n', $key)) {
            return true;
        }

        return false;
    }
170730
public static function has( $key )
	{
		$cache = self::instance();
		if ( $cache ) {
			return $cache->isExisting( $key );
		}
		return false;
	}
220977
public function containsKey($key)
    {
        if (!$this->enabled)
            return false;

        $has_key = array_key_exists($this->key($key), $this->cache);

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

        return $has_key;
    }
1362107
public function read(string $key)
    {
        $file = $this->cacheFile($key);

        if (is_file($file)) {
            // Cache exists
            $data = include $file;
            $expire = (int)$data['ttl'];
            if ($expire === 0 || time() < $expire) {
                return unserialize($data['data']);
            }
            unlink($file);
        }

        return false;
    }
1132672
public function delete($key)
    {

        $deleted = false;

        $catalog = \array_keys($this->getKeys());
        foreach ($catalog as $k) {

            if (substr($k, 0, strlen($key)) == $key) {

                $delete = $this->memcache->delete($this->namespace . $key);
                if ($delete) {
                    $this->catalogKeyDelete($k);
                    $deleted = true;
                }
            }
        }

        return $deleted;
    }
283670
public function clear(string $key = ''): bool {
		if ($key === '') {
			$this->recursiveDeleteDirectory($this->storageCachePath);
			return true;
		}
		$cacheDir = $this->storageCachePath . $key;
		$dirName  = dirname($cacheDir);
		$find     = str_replace($dirName . '/', '', $cacheDir);
		if (is_dir($dirName) && $dirArray = scandir($dirName)) {
			foreach ($dirArray as $k => $v) {
				if ($v !== '.' && $v !== '..') {
					if (is_dir($dirName . '/' . $v) && (strpos($v, $find) === 0)) {
						$this->recursiveDeleteDirectory($dirName . '/' . $v);
						rmdir($dirName . '/' . $v);
					}
					elseif (strpos($v, $find) === 0) {
						unlink($dirName . '/' . $v);
					}
				}
			}
		}
		return true;
	}
1363203
public function delete($key) {
        $filename = $key.'.cache';
        $file = $this->file_path_for_key($key);
        if (@unlink($file)) {
            unset($this->keys[$filename]);
            return true;
        }

        return false;
    }
940765
public function isCached($key)
    {
        if ($this->getCache() != false) {
            $cached = $this->getCache();

            return isset($cached[$key]['data']);
        }
    }
69348
public function has($key)
    {
        return $this->enabled && $this->filesystem->exists($this->cacheDir.$key);
    }
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;
    }
334315
public function exists($key)
    {
        try {
            return $this->redis->exists($key);
        } catch (\RedisException $e) {
            die("Error!: " . $e->getMessage() . "<br/>");
        }
    }