Method to get a storage entry value from a key.

@param   string $key The storage entry identifier.

@return  CacheItemInterface

@throws \Exception
@since   2.0
768924
public function getItem($key)
    {
        if (!$this->exists($key)) {
            return new CacheItem($key);
        }

        $data = $this->read($this->fetchStreamUri($key));

        $item = new CacheItem($key);

        if ($this->denyAccess) {
            $data = substr($data, strlen($this->options['deny_code']));
        }

        $item->set($data);

        return $item;
    }
583036
protected function getCacheItem(/*# string */ $key)/*# : CacheItemExtendedInterface */
    {
        // validate key first
        $this->validateKey($key);

        // try local cache
        if ($this->use_item_cache) {
            if (!isset($this->item_cache[$key[0]][$key])) {
                $this->item_cache[$key[0]][$key] = $this->createCacheItem($key);
            }
            return $this->item_cache[$key[0]][$key];
        } else {
            return $this->createCacheItem($key);
        }
    }
29661
public function GetCache($key)
    {
		return (array_key_exists($key, $this->_cache) ? $this->_cache[$key] : null);
	}
636594
public function get($key)
    {
        $key       = (string)$key;
        $this->hit = false;

        $inMemoryValue = InMemoryAdapter::getInstance()->get($key);
        if (InMemoryAdapter::getInstance()->isHit()) {
            $this->hit = true;
            return $inMemoryValue;
        }

        $fileKey = $this->getFilenameFromCacheKey($key);

        if (true === \file_exists($fileKey)) {
            $value = $this->restoreDataStructure(\file_get_contents($fileKey));
            if ($value['expires'] >= (new DateTime())) {
                $this->hit = true;
                InMemoryAdapter::getInstance()->set($key, $value['value'], 0);
                return $value['value'];
            }
            $this->removeCacheFile($fileKey);
            $this->deleteChain($key);
        }

        return (null !== $this->nextAdapter) ? $this->nextAdapter->get($key) : null;
    }
564552
public function get($key)
    {
        $k = $this->hash($key);
        if (!isset($this->cache[$k])) {
            return null;
        }
        $item = $this->cache[$k];
        if (isset($item->expire)) {
            if (microtime(true) >= $item->expire) {
                unset($this->cache[$k]);
                return null;
            }
        }
        return $item;
    }
93468
public function getItem($key)
    {
        if (!$this->getOptions()->getEnabled()) {
            return null;
        }

        $this->normalizeKey($key);

        $result = null;
        try {
            $result = $this->internalGetItem($key);
        } catch (\Exception $e) {
        }

        return $result;
    }
1205783
public static function get($key)
    {
        $item = self::getCacheService()->user()->getItem(self::key($key));
        if ($item->isHit()) {
            return $item->get();
        }
        return null;
    }
985341
public static function get($key) {
		$memory = self::fetch();
		if (isset($memory->$key)) {
			return $memory->$key;
		} else {
			throw new \Exception('Object not in cache');
		}
	}
94621
public function get($key)
	{
	    $value = static::getRaw($key);
        
	    //\Wslim\Ioc::logger('cache')->debug(sprintf('get: %s %s', $key, print_r($this, true)));
	    
		$value = $this->decodeValue($value);
		
		return $value;
	}
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;
    }
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;
    }
57626
public function getItem($key)
    {
        if (!$this->isValidEntryIdentifier($key)) {
            throw new InvalidArgumentException('"' . $key . '" is not a valid cache entry identifier.', 1514738649629);
        }

        $rawResult = $this->backend->get($key);
        if ($rawResult === false) {
            return new CacheItem($key, false);
        }

        $value = unserialize($rawResult);
        return new CacheItem($key, true, $value);
    }
1004348
public function get($key)
    {
        $this->hit = false;

        $inMemoryValue = InMemoryAdapter::getInstance()->get($key);

        if (InMemoryAdapter::getInstance()->isHit()) {
            $this->hit = true;
            return $inMemoryValue;
        }

        $value = $this->memcached->get($key);

        if ($value) {
            $this->hit = true;
            InMemoryAdapter::getInstance()->set($key, $value, 0);
            return $value;
        }

        return (null !== $this->nextAdapter) ? $this->nextAdapter->get($key) : null;
    }
870837
public function getFromCache($key)
  {
    $value = $this->memcache->get($this->buildMKey($key));
    if ($value) {
      return unserialize($value);
    }
    return null;
  }
222418
public function fetch($key)
    {
        try {
            $cache = unserialize(wp_cache_get($key, $this->group));
            if ($cache instanceof CacheEntry) {
                return $cache;
            }
        } catch (\Exception $ignored) {
            // Don't fail if we can't load it
        }

        return null;
    }
941976
public function getMenuItem($key)
    {
        list($menu, $item) = explode('.', $key);

        $menu = $this->menu_collection->get($menu);

        if (is_null($menu)) {
            throw new \Exception('Menu can not be found.');
        }

        $item = $menu->get($item);

        if (is_null($item)) {
            throw new \Exception('Item can not be found.');
        }

        return $item;
    }
535971
private function getCache($key)
    {
        $cache = $this->client->getItem($key);
        if ($cache->isHit()) {
            return $cache->get();
        }

        return null;
    }