Returns a state that was previously saved

@param *string $key the state name

@return mixed
9794
public function loadState(string $name)
    {
        $state = $this->resolve($name);

        if (is_callable($state)) {
            if ($state instanceof Closure) {
                $state = $state->bindTo($this, get_class($this));
            }

            $state = call_user_func($state, $this);
        }

        return $state;
    }
8942
protected function getHistory($key = null)
    {
        return (true === isset($this->history[$key])) ? $this->history[$key] : null;
    }
685828
public function getExpiry($key)
    {
        $key = $this->getPrefix().$key;
        if (!$this->isInCache($key)) {
            return false;
        }

        return $this->fetchExpirationFromCache($key);
    }
281408
public function get(string $key)
    {
        if (!isset($this->data[$key])) {
            return null;
        }

        $struct = $this->data[$key];

        if ($struct->ttl !== null) {
            $expire = \time() + $struct->ttl;
            if ($struct->expire < $expire) {
                $struct->expire = $expire;
                $this->queue->insert([$key, $struct->expire], -$struct->expire);
            }
        }

        return $struct->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);
    }
41867
public static function get($key)
    {
        $path = Cache::path($key);

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

        return null;
    }
514477
public static function  get($key)
	{
		//check if this key exists 
		$exists = (isset($_SESSION[$key])) ? true : false;

		//return check status if false
		if ( ! $exists)  return $exists;

		//return the session data if found
		else return $_SESSION[$key];

	}
44150
public function getByKey($key)
    {
        $storage = $this->getStorage();

        return isset($storage[$key]) ? $storage[$key] : null;
    }
419574
public function getCached($key)
    {
        if ($image = $this->imageResolver->resolveFromCache($key)) {
            return $this->render($image);
        }

        return $this->notFound();
    }
945849
public function isOpen($key)
    {
        return isset($this->states[$key]) and $this->states[$key]->isOpen();
    }
574607
public function get(string $key)
    {
        if (isset($this->inMemoryCache[$key])) {
            return $this->inMemoryCache[$key];
        }

        return $this->inMemoryCache[$key] = $this->laravelCache->get($key, null);
    }
994571
public function get($key)
    {
        if ($this->willRemove($key)) {
            return null;
        }
        if (true === $this->willChange($key)) {
            return $this->getCurrent($key);
        }
        return $this->getOriginal($key);
    }
1120058
public function expiration($key)
	{
		if (isset($this->data[static::EXPIRE_DATA_KEY][$key]))
		{
			$expiration = array(
				$this->data[static::EXPIRE_DATA_KEY][$key][0] == EXPIRE_ON_REQUEST ? 'EXPIRE_ON_REQUEST' : 'EXPIRE_ON_GET',
				$this->data[static::EXPIRE_DATA_KEY][$key][1] == static::EXPIRE_STATE_NEW ? 'STATE_NEW' : ($this->data[static::EXPIRE_DATA_KEY][$key][1] == static::EXPIRE_STATE_LOADED ? 'STATE_LOADED' : 'STATE_EXPIRED'),
			);
			return $expiration;
		}

		return false;
	}
945123
public function previous($key = null)
    {
        if (is_null($key)) {
            return $this->oldAttributes;
        }

        return $this->oldAttributes[$key];
    }
709476
public function &offsetGet($key)
    {
        $ret = null;

        if (!$this->offsetExists($key)) {
            return $ret;
        }

        $ret =& $this->storage[$key];

        return $ret;
    }
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));
        }
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;
    }