Checks whether there's a key in namespaced query

@param string $ns Namespace (Group)
@param string $key
@return boolean
976659
public function hasQueryNs($ns, $key)
    {
        $data = $this->getQuery($ns);

        // If there's no such key, then $data isn't an array, so just make sure
        if (is_array($data)) {
            return array_key_exists($key, $data);
        } else {
            // If $data isn't an array, then there's no such key
            return false;
        }
    }
1207867
public function has(string $key): bool
    {
        $this->assertRead();

        return \array_key_exists($key, $this->data);
    }
569703
function getPrefixFromNamespace($ns)
    {
        foreach ($this->namespaces as $p => $n) {
            if ($ns == $n || $ns == $p) {
                $this->usedNamespaces[$p] = $n;

                return $p;
            }
        }

        return FALSE;
    }
1174934
protected function getNamespaceKey(array $namespaces, $key)
	{
		if(empty($namespaces)) { 
			return $key;
		}

		$component = '';
		$parts = array();
		foreach($namespaces as $namespace) {
			$component.= $this->delimiter.$namespace;
			$parts[] = $this->getVersionNumber(substr($component, 1));
		}
		
		// generate the full key which will be passed to the low level cache functions
		$newKey = implode($this->delimiter, $parts).$this->delimiter;
		$newKey.= substr($component, 1).$this->delimiter;
		$newKey.= $key;
		
		return $newKey;
	}
397443
public function hasConfigurationKey($key)
    {
        $result = true;
        $configuration = $this->getConfiguration();

        $pathParts = explode(self::DELIMITER, $key);
        foreach ($pathParts as $pathPart) {
            if (array_key_exists(ucfirst($pathPart), $configuration) === false) {
                $result = false;
                break;
            } else {
                $configuration = $configuration[ucfirst($pathPart)];
            }
        }

        return $result;
    }
852379
public function has(string $key): bool
    {
        $slug = $this->splitKey($key);

        if (is_string($slug)) {
            return isset($this[$slug]);
        }

        $collection = $this->all();

        foreach ($this->splitKey($key) as $search) {
            if (!isset($collection[$search])) {
                return false;
            }

            $collection = $collection[$search];
        }

        return true;
    }
16434
public function keyExists($key)
    {
        $exists = true;
        try {
            $this->get($key);
        } catch (Exception $e) {
            $exists = false;
        }
        return $exists;
    }
503096
public function delete($key, $namespace)
    {
        // Get internal key
        $key = $this->calculateUuid($key);

        // Assume the process will fail
        $result = true;

        // First of all - remove element from namespace ...
        $this->purgeRuntimeCache($key, $namespace);

        // Get file
        $filename = $this->getFilenameByKeyAndNamespace($key, $namespace);

        // Check if file exists
        if (file_exists($filename) === true) {
            $result = unlink($filename);

            // clear php's file cache
            $this->clear();
        }

        // return the result
        return $result;
    }
204401
protected function isAllowedKey($key): bool
    {
        return empty($this->allowedKeys) || \in_array($key, $this->allowedKeys, true);
    }
1239417
public function has($key)
    {
        if (!$this->isEnabled()) {
            return false;
        }

        return (false !== apc_fetch($this->prefix() . $key));
    }
784907
public function clearFrom($namespace, $key = null)
    {
        $oldNamespace = $this->namespace;
        $this->setNamespace($namespace);
        $this->clear($key);
        $this->setNamespace($oldNamespace);
    }
148906
public function has($key)
    {
        $result = array_key_exists($key, $this->data);
        if (!$result && $this->isDotNotation($key)) {
            $result = true;
            $keys = explode('.', $key);
            $data = $this->data;

            foreach ($keys as $key) {
                if (!is_array($data) || !array_key_exists($key, $data)) {
                    $result = false;
                    break;
                }

                $data = $data[$key];
            }
        }

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

        $has_key = (eaccelerator_get($this->key($key)) !== null);

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

        return $has_key;
    }
281349
public function read($key, $namespace)
    {
        // Get internal used key
        $key = $this->calculateUuid($key);

        // Try to retrieve data from runtime cache ...
        $dataset = $this->getFromRuntimeCache($key, $namespace);

        // Check for result from runtime cache
        if ($dataset === false) {

            // get filename
            $filename = $this->getFilenameByKeyAndNamespace($key, $namespace);

            // if file does not exist -> then there is nothing to read
            if (!file_exists($filename)) {
                return false;
            }

            // Read (no lock = change possible from another process!)
            $dataset = $this->readFile($filename, false);
        }

        return $dataset;
    }
566699
public function hasKey(string $key): bool
    {
        return $key && strpos($key, '@@') === false && file_exists($this->getPathFromKey($key));
    }
1225151
public function has($key)
    {
        if (!$this->isEnabled()) {
            return false;
        }

        return (null !== eaccelerator_get($this->prefix() . $key));
    }
551349
public function has(?string $key) : bool
    {
        return $key === null ? false : isset($this->themes[$key]);
    }