Assert that the session does not have a given key.

@param  string|array  $key
@return void
765563
public function assertSessionMissing($key)
    {
        if (is_array($key)) {
            foreach ($key as $k) {
                $this->assertSessionMissing($k);
            }
        } else {
            PHPUnit::assertFalse($this->app['session.store']->has($key), "Session has unexpected key: $key");
        }
    }
555121
public function isEmpty($key)
    {
        $this->setScope($key);
        $result = parent::isEmpty($key);
        /** @noinspection PhpInternalEntityUsedInspection */
        $this->key = null;

        return $result;
    }
1207867
public function has(string $key): bool
    {
        $this->assertRead();

        return \array_key_exists($key, $this->data);
    }
3899
public static function remove($key) {
        static::init();
        if (isset($_SESSION[self::$prepend . $key]))
            unset($_SESSION[self::$prepend . $key]);
    }
720766
public function has($key)
    {
        // For performance, we can use isset,
        // but it will not match if value == 0
        return isset($this->values[$key]) || array_key_exists($key, $this->values);
    }
1312252
public static function remove($key)
		{
			self::_cleanPrevious();

			if(self::is($key))
			{
				unset($_SESSION[self::$_sessionKey.$key]);
				return true;
			}
			else
			{
				return false;
			}
		}
1198222
protected function isPk($key)
    {
        $pk = $this->getPk();
        if (is_string($pk) && $pk == $key) {
            return true;
        } elseif (is_array($pk) && in_array($key, $pk)) {
            return true;
        }

        return false;
    }
619011
private static function keyExists($key)
    {
        $apiKeyCount = self::where('key', '=', $key)->limit(1)->count();

        if ($apiKeyCount > 0) return true;

        return false;
    }
798080
public function contains($key): bool
    {
        if ($this->cookieExists()) {
            $this->start();
        } elseif (!$this->sessionExists()) {
            return false;
        }
        return isset($_SESSION[$this->namespace][$key]);
    }
233023
public function has( $key = null )
	{
		$keys = is_array( $key ) ? $key : func_get_args();

		foreach ( $keys as $key )
		{
			if ( $this->first( $key ) === '' )
			{
				return false;
			}
		}

		return true;
	}
1005396
protected function has($key)
    {
        if (!is_array($key)) {
            return (array_key_exists($key, $this->item));
        }

        foreach ($key as $value) {
            if (!array_key_exists($value, $this->item)) {
                return false;
            }
        }

        return true;
    }
76553
public function __isset($key)
    {
        $getter = 'get' . str_replace('_', '', $key);

        return method_exists($this, $getter) && null !== $this->__get($key);
    }
459658
public function validateKey($key)
    {
        $length = strlen((string) $key);

        if (!$length) {
            $this->addError('key', 'Key cannot be empty');
            return false;
        }

        return true;
    }
231340
public function offsetUnset($key)
    {
        if ($this->offsetExists($key)) {
            $this->deleted[] = $this->items[$key];
        }
        parent::offsetUnset($key);
    }
1179507
public function offsetUnset($key)
    {
        $keys = $this->parseKey($key);
        $array = &$this->values;

        while (count($keys) > 1) {
            $key = array_shift($keys);

            if (!isset($array[$key]) || !is_array($array[$key])) {
                return;
            }

            $array =& $array[$key];
        }

        unset($array[array_shift($keys)]);
    }
128170
public static function destroy($key = '')
    {
        if (self::$_sessionStarted == true) {

            if (empty($key)) {
                session_unset();
                session_destroy();
            } else {
                self::setPrefix();
                unset($_SESSION[self::$_sessionPrefix . $key]);
            }
        }
    }
1347460
public function forget($key)
    {
        $this->load();

        if ($this->has($key)) {
            $this->dirt[$key] = ['type' => 'deleted'];
            Arr::forget($this->settings, $key);
        }
    }