Get a key from cache

@param string $key
@return mixed|NULL
545614
public function get($key)
    {
        $filename = $this->cacheDir . DIRECTORY_SEPARATOR . $this->processKey($key);

        if (is_file($filename) && is_readable($filename)) {
            if (@filemtime($filename) < (time() - $this->ttl)) {
                return null;
            } else {
                return unserialize($this->safelyReadData($filename));
            }
        }

        return null;
    }
547685
public function get($key){
		if(DEBUG_MODE){
			BDebug::message('[Memcached]: Get key('.$key.')');
			}
		$mc=$this->getMemcached();
		if(empty($mc))return NULL;
		$this->queries_get_count++;
		return $mc->get($key);
		}
889070
public function get($key)
	{
		$value = xcache_get($this->prefix.$key);

		if (isset($value))
		{
			return $value;
		}
	}
221173
public function get($key)
    {
        if (!$this->isEnabled()) {
            return null;
        }

        if (xcache_isset($this->prefix() . $key)) {
            return unserialize(xcache_get($this->prefix() . $key));
        } else {
            return null;
        }
    }
472044
protected function retrieve($key)
    {
        if (!$this->has($key)) {
            return null;
        }

        $cache = file_get_contents($this->path . $key);

        // compare the timestamp to the current time when we read the file.
        if (time() >= substr($cache, 0, 10)) {
            $this->forget($key);
            return null;
        }

        return unserialize(substr($cache, 10));
    }
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;
    }
83343
public function get($key)
	{
		$hash = md5($key);
		$cacheFile = $this->getPath().'/'.$hash.'.cache';

		if (!is_file($cacheFile)) {
			return null;
		}
		return unserialize(file_get_contents($cacheFile));
	}
324833
public function get($key)
    {
        if (!$this->isEnabled()) {
            return null;
        }

        $value = $this->server->get($this->prefix . $key);

        return false === $value ? null : $value;
    }
1094684
public static function get($key)
    {
        return isset(self::$config[$key]) ? self::$config[$key] : null;
    }
168433
public function get($key){

		if(!is_null($this->args))
			if(in_array($key, array_keys($this->args)))
				return $this->args[$key];

		return null;
	}
519744
protected function retrieve($key)
    {
        if (($cache = wincache_ucache_get($this->key . $key)) !== false) {
            return $cache;
        }

        return null;
    }
1245248
protected function retrieve($key)
        {
            if (!File::exists($this->path . $key)) {
                return null;
            }

            // File based caches store have the expiration timestamp stored in
            // UNIX format prepended to their contents. We'll compare the
            // timestamp to the current time when we read the file.
            if (time() >= substr($cache = fgc($this->path . $key), 0, 10)) {
                return $this->forget($key);
            }

            return unserialize(substr($cache, 10));
        }
1073655
public function get(string $key)
    {
        if ($this->enabled === false) {
            return null;
        }

        $index = $this->cacheIndex[$key] ?? $key;
        if (!isset($this->cache[$index]) || $this->cacheExpiryTime[$index] < microtime(true)) {
            return null;
        }

        ++$this->cacheAccessCount[$index];

        return $this->cache[$index];
    }
1041359
public function getCacheManager($key)
    {
        return array_key_exists($key, $this->cacheManagers) ? $this->cacheManagers[$key] : null;
    }
503513
public function get($key)
    {
        if (isset($this->cache[$key])) {
            list($expires, $value) = $this->cache[$key];
            if (!$expires || ($expires >= microtime(true))) {
                return $value;
            }
            unset($this->cache[$key]);
        }
        return false;
    }
655638
protected function retrieve($key)
    {
        if (array_key_exists($key, $this->storage)) {
            return $this->storage[$key];
        }

        return null;
    }
870837
public function getFromCache($key)
  {
    $value = $this->memcache->get($this->buildMKey($key));
    if ($value) {
      return unserialize($value);
    }
    return null;
  }