Retrieve an item from the cache storage.

@param string $key

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

        return null;
    }
1014666
protected function getItem($key)
    {
        $cache_file = $this->path($key);
        if (!file_exists($cache_file) || !is_readable($cache_file)) {
            return false;
        }

        $cache_data = file_get_contents($cache_file);
        if (empty($cache_data)) {
            return false;
        }
        $cache_data = json_decode($cache_data, true);
        if ($cache_data) {
            $check_expire = $this->checkExpire($cache_data);
            if ($check_expire === false) {
                $this->delete($key);
                return false;
            }
        }

        return $cache_data;
    }
1350821
public function get($key)
    {
        $prefixed = $this->prefix.$key;

        $cache = $this->table()->where('key', '=', $prefixed)->first();

        // If we have a cache record we will check the expiration time against current
        // time on the system and see if the record has expired. If it has, we will
        // remove the records from the database table so it isn't returned again.
        if (is_null($cache)) {
            return;
        }

        $cache = is_array($cache) ? (object) $cache : $cache;

        // If this cache expiration date is past the current time, we will remove this
        // item from the cache. Then we will return a null value since the cache is
        // expired. We will use "Carbon" to make this comparison with the column.
        if (Carbon::now()->getTimestamp() >= $cache->expiration) {
            $this->forget($key);

            return;
        }

        return unserialize($cache->value);
    }
714637
public function get(string $key): ?\BearFramework\App\CacheItem
    {
        $driver = $this->getDriver();
        $item = null;
        $value = $driver->get($key);
        if ($value !== null) {
            $item = $this->make($key, $value);
        }
        if ($this->hasEventListeners('itemGet')) {
            $this->dispatchEvent('itemGet', new \BearFramework\App\Cache\ItemGetEventDetails($key, $item === null ? null : clone($item)));
        }
        if ($this->hasEventListeners('itemRequest')) {
            $this->dispatchEvent('itemRequest', new \BearFramework\App\Cache\ItemRequestEventDetails($key));
        }
        return $item;
    }
745407
public function retrieve($key)
    {
        $key = (string)$key;
        if ($cache = $this->loadCache()) {
            if (isset($cache[$key])) {
                if (!$this->isExpired($cache[$key]['time'], $cache[$key]['expire'])) {
                    return unserialize($cache[$key]['data']);
                }
            }
        }
        return null;
    }
887561
public function get($key) {
        if (isset($this->store[$key])) {
            if ($this->ttl == 0) {
                $value = $this->store[$key][0];
                if ($this->maxsize !== false) {
                    // Make sure the element is now in the end of array.
                    $this->set($key, $value);
                }
                return $value;
            } else if ($this->store[$key][1] >= (cache::now() - $this->ttl)) {
                return $this->store[$key][0];
            } else {
                // Element is present but has expired.
                $this->check_ttl();
            }
        }
        return false;
    }
458821
public static function get($key)
    {
        if (!self::$instance) return null;

        return self::$instance->cache->get($key);
    }
29661
public function GetCache($key)
    {
		return (array_key_exists($key, $this->_cache) ? $this->_cache[$key] : null);
	}
712758
public function getFromCache($key)
  {
    $file = $this->cachePath . $this->getEncodedKey($key);
    if (file_exists($file)) {
      return unserialize(file_get_contents($file));
    }
    return null;
  }
714838
public function get($key)
    {
        if (array_key_exists($key, $this->store)) {
            return $this->store[$key];
        }
        return null;
    }
1127057
public function get($key)
    {
        $file=$this->getCacheDir().$key;
        if(file_exists($file)){
            $content=file_get_contents($file);
            $content=unserialize($content);
            return $content;
        }
        return null;
    }
295139
protected function getCache($key) {
        $cached = ArrayHelper::getValue($this->cachedData, $key);
        if (!isset($cached)) {
            $cacheData = $this->resolveCacheComponent()->get($this->cacheKeyName);
            $cached = $this->cachedData[$key] = ArrayHelper::getValue($cacheData, $key);
        }
        return $cached;
    }
190290
public function get($key)
    {
        $items = Arr::get($this->items, $key);

        return $this->firstOrAll($items);
    }
261462
protected function get($key)
    {
        $this->checkForNonEmptyKey($key);
        if (!$this->settingsHaveBeenRetrieved) {
            $this->retrieveSettings();
        }
        if (!isset($this->cachedSettings[$key])) {
            return null;
        }

        return $this->cachedSettings[$key];
    }
1173845
public static function get($storage, $key)
    {
        $keys	= explode('.', $key);

        foreach($keys as $key)
            $storage	= &$storage[$key];

        return $storage;
    }
297813
public function get(string $key)
    {
        $key = $this->hashKey($key);
        if (\array_key_exists($key, $this->cache)) {
            $this->hits++;
            return $this->cache[$key];
        }
        $this->misses++;
        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];
    }