Retrieve an entry from the MemcacheCache.

@param string $name
@param boolean &$error
@return mixed
@see Cache::get()
@see Memcache::get()
323691
public function get($name, &$error = false){

		// If disabled, return nothing so that this cache is overwritten

		if(!$this->_enabled){

			return null;
		}

		$name = $this->_prependPrefix($name);

		error_clear_last();

		$value = @$this->_Memcache->get($name);

		// Attempt to separate "real" errors from missing cache entries

		$last_error = error_get_last();

		if($value === false && $last_error !== null && $last_error['type'] === E_WARNING){

			$error = true;

			return null;
		}

		if($value === false){

			$value = null;
		}

		return $value;
	}
1833
final public function &__get($name)
    {
        $value = $this->data[$name];

        //Apply accessor
        $this->applyModifier($name, $value, 'get');

        return $value;
    }
1279983
public function get($name, &$error = false){

		// If disabled, return nothing so that this cache is overwritten

		if(!$this->_enabled){

			return null;
		}

		try{

			$file = $this->_getFileName($name);
		}
		catch(CacheException $e){

			$error = true;

			return null;
		}

		if(time() > @filemtime($this->_cache_path . $file)){

			return null;
		}

		$contents = @file_get_contents($this->_cache_path . $file);

		if($contents !== false){

			error_clear_last();

			$value = @unserialize($contents);

			// Attempt to separate serialised "false" from unserialisation errors

			$last_error = error_get_last();

			if($value === false && $last_error !== null && $last_error['type'] === E_WARNING){

				$error = true;

				return null;
			}

			return $value;
		}

		return null;
	}
965505
public function getFor($name)
    {
        if (isset($this->cache[$name])) {
            return $this->cache[$name];
        }

        $handlers = $this->getHandlers(self::KEY_ALWAYS_LOADED);
        if ($name !== self::KEY_ALWAYS_LOADED) {
            $handlers = array_merge($handlers, $this->getHandlers($name));
        }

        $logger = new Logger($name, $handlers);
        ErrorHandler::register($logger);
        $this->cache[$name] = $logger;

        return $logger;
    }
855811
public static function get($key) {
		$memcached = self::connect();
		$var = $memcached->get($key);
		if ($var === false) {
			throw new \Exception('Object not in cache');
		} else {
			return $var;
		}
	}
459061
public static function get($name)
    {
        if (self::existe($name)) {
            return $_COOKIE[$name];
        }

        exception(CookieKeyNotFoundException::class, $name);
    }
184322
public function get($name = ''){
            if(false === $var = xcache_get($name)){
                xcache_set($name, $var = parent::get($name));
            }

            return $var;
        }
941542
public static function get($name, $value = NULL)
    {
        return isset($_GET[$name]) ? $_GET[$name] : $value;
    }
502693
public static function getCache($name)
    {
        if (is_callable(self::$cache_callable['get'])) {
            return call_user_func_array(self::$cache_callable['get'], func_get_args());
        }
        $file = self::_getCacheName($name);
        if (file_exists($file) && ($content = file_get_contents($file))) {
            $data = unserialize($content);
            if (isset($data['expired']) && (intval($data['expired']) === 0 || intval($data['expired']) >= time())) {
                return $data['value'];
            }
            self::delCache($name);
        }
        return null;
    }
1165681
public function get($name = false) {
        N('cache_read',1);
        $id = shmop_open($this->handler, 'c', 0600, 0);
        if ($id !== false) {
            $ret = unserialize(shmop_read($id, 0, shmop_size($id)));
            shmop_close($id);

            if ($name === false) {
                return $ret;
            }
            $name   =   $this->options['prefix'].$name;
            if(isset($ret[$name])) {
                $content   =  $ret[$name];
                if(C('DATA_CACHE_COMPRESS') && function_exists('gzcompress')) {
                    //启用数据压缩
                    $content   =   gzuncompress($content);
                }
                return $content;
            }else {
                return null;
            }
        }else {
            return false;
        }
    }
288136
public static function get($name, $closure = false)
    {

        if (!is_string($name)) {
            throw new \Exception('Cache key must be a string.');
        }

        // First check php-memory cache
        if (isset(self::$cache[$name])) {
            // Cache hit!
            self::$cacheHit = true;
            return self::$cache[$name];
        }

        if (self::$config['memcached']['enabled']) {
            // Connect if not connected
            self::memcachedConnect();

            // Check if in memcached
            $val = self::$memcached->get($name);

            if (self::$memcached->getResultCode() == \Memcached::RES_SUCCESS) {
                // Cache hit!
                self::$cacheHit = true;

                // Set php-memory cache
                self::$cache[$name] = $val;
                return $val;
            }
        }

        self::$cacheHit = false;

        // If no other way to get value, return
        if (!is_callable($closure)) {
            return null;
        }

        // Call given closure to get value
        $val = $closure();

        // Nothing returned, no need to store it
        if (is_null($val)) {
            return null;
        }

        // Store closure-returned value in cache
        self::set($name, $val);

        return $val;
    }
528355
public function get($name) {
         $this->open();
         $name  =   $this->options['prefix'].$name;
         $s     =   'F' . pack('N', strlen($name)) . $name;
         fwrite($this->handler, $s);

         for ($data = ''; !feof($this->handler);) {
             $data .= fread($this->handler, 4096);
         }
        N('cache_read',1);
         $this->close();
         return $data === '' ? '' : unserialize($data);
     }
1116147
public static function delCache($name)
    {
        if (is_callable(self::$cache_callable['del'])) {
            return call_user_func_array(self::$cache_callable['del'], func_get_args());
        }
        $file = self::_getCacheName($name);
        return file_exists($file) ? unlink($file) : true;
    }
513126
public function get($name)
    {
        $file = $this->cacheFileNameGenaretor($name);
        $file = $this->inPath($file);

        $content = $this->getFileSystem()->read($file);
        $parsed = $this->parseContent($content);

        if (count($parsed) === 2) {
            list($time, $content) = $parsed;

            if ($this->checkTime($time)) {
                return $content;
            }else{
                $this->delete($file);
            }
        }

        return false;
    }
1184263
public function stickyGet($name)
    {
        if (isset($_GET[$name])) {
            $this->sticky_get_arguments[$name] = $_GET[$name];

            return $_GET[$name];
        }
    }
623816
public function get($name) {
		if (isset($_COOKIE[$name]))
			return $this->decrypt( $_COOKIE[$name] );
		else
			return NULL;
	}
642657
public static function get($name)
    {
        if (isset(self::$_cached_settings[$name])) {
            return self::$_cached_settings[$name];
        }
        return NULL;
    }