Get cache

@access  public
@param   string  $key    Cache key
@return  mixed
189031
public function get($key) {
        if ($this->exists($key)) {
            $key = $this->_encrypt($key);
            $contents = file_get_contents($this->_storage_path . $key);
            
            if (base64_decode($contents, true)) {
                $data = unserialize(base64_decode($contents, true));
            
                return isset($data['data']) ? $data['data'] : '';
            }
        }
        
        return null;
    }
576336
public function get($key)
	{
		$value = xcache_get($this->id($key));

		if (isset($value))
		{
			return $value;
		}
	}
31545
public function get($key){
		$mc=$this->getMemcache();
		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;
		}
	}
518754
public function get($key) {
        $filename = $this->generateFileLocation($key);
        if (file_exists($filename) && is_readable($filename)) {
            $cache = unserialize(file_get_contents($filename));
            if ($cache['expires'] > time()) {
                return $cache['content'];
            } else {
                unlink($filename);
            }
        }
        return null;
    }
722738
private function getSchemaCache($key)
    {
        if (isset($this->model_schema_cache[$key])) {
            return $this->model_schema_cache[$key];
        }

        return false;
    }
192559
protected function getData($key)
    {
        return $this->getCacheItem(self::CACHE_DATA, $key, function () {
            $result = $this->getContext()->invokeApiGet('POP', [
                'domain' => $this->getDomainName(),
                'action' => 'full_list',
            ]);
            return \GuzzleHttp\Psr7\parse_query($result[$this->getPrefix()]);
        });
    }
391906
public function get($key)
	{
		$path = $this->path($key);

		// If the file doesn't exists, we obviously can't return the cache so we will
		// just return null. Otherwise, we'll get the contents of the file and get
		// the expiration UNIX timestamps from the start of the file's contents.
		if ( ! $this->files->exists($path))
		{
			return null;
		}

		try
		{
			$expire = substr($contents = $this->files->get($path), 0, 10);
		}
		catch (\Exception $e)
		{
			return null;
		}

		// If the current time is greater than expiration timestamps we will delete
		// the file and return null. This helps clean up the old files and keeps
		// this directory much cleaner for us as old files aren't hanging out.
		if (time() >= $expire)
		{
			return $this->forget($key);
		}

		return unserialize(substr($contents, 10));
	}
751984
public function get(string $key)
    {
        $result = null;
        if (isset($this->configuration[$key])) {
            $result = (string)$this->configuration[$key];
        } elseif (isset($GLOBALS['TSFE']->config['config']['tx_staticfilecache.'][$key])) {
            $result = (string)$GLOBALS['TSFE']->config['config']['tx_staticfilecache.'][$key];
        }

        return $result;
    }
845354
public function get($key = null)
    {
        if (isset ($this->cacheListing [$key])) {
            $val = apc_fetch($key, $success);

            return $success ? $val : $success;
        }

        return false;
    }
712758
public function getFromCache($key)
  {
    $file = $this->cachePath . $this->getEncodedKey($key);
    if (file_exists($file)) {
      return unserialize(file_get_contents($file));
    }
    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);
		}
1188442
public function get($key)
    {
        if (empty($this->memcache)) {
            return false;
        }

        $key = $this->processKey($key);

        $data = $this->memcache->get($key);

        return $data;
    }
567001
public function get($key) {
		$data = CacheFactory::getCache()->get($key);
		if ($data && isset($data['__fsm'])) {
			$modelName = empty($data['__fsm']['m']) ? '' : 'App\\Model\\'.ucfirst($data['__fsm']['m']);
			$isArray = intval($data['__fsm']['a']);
			if ($isArray == 1) {
				$ma = new ModelArray();
				foreach ($data['data'] as $item) {
					$model = new $modelName();
					$model->fromArray($item);
					$ma[] = $model;
				}
				$data = $ma;
			} else {
				$model = new $modelName();
				$data = $model->fromArray($data['data']);
			}
		}
		return $data;
	}
1126788
protected function get_cache($key)
    {
        // no session data in cache (read() returns false)
        if (!$this->key) {
            $cache = null;
        }
        // use internal data for fast requests (up to 0.5 sec.)
        else if ($key == $this->key && (!$this->vars || microtime(true) - $this->start < 0.5)) {
            $cache = $this->vars;
        }
        else { // else read data again
            $cache = $this->read($key);
        }

        return $cache;
    }
733707
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 ) )
		{
			if ( is_array( $cache ) )
				$cache = (object) $cache;

			if ( time() >= $cache->expiration )
			{
				$this->forget( $key );

				return null;
			}

			return $this->encrypter->decrypt( $cache->value );
		}

		return null;
	}
41867
public static function get($key)
    {
        $path = Cache::path($key);

        if (file_exists($path)) {
            return file_get_contents($path);
        }

        return null;
    }