Forcibly clear all _SESSION variables and destroys the session

@param string $guid The GUID of this user
502767
public static function ClearAuthentication($guid = "CURRENT_USER")
	{
		self::Init();
		self::$user = null;
		unset($_SESSION[$guid]);
		
		self::UnsetAllSessionVars();
		
		@session_destroy();
	}
152907
public function remove($key): void
    {
        foreach ((array) $key as $key) {
            unset($_SESSION[$this->name][$key]);
        }
    }
637074
public function removeFromCalendar($calendar_guid) {
		$calendar = get_entity($calendar_guid);
		if ($calendar instanceof Calendar) {
			$calendar->removeEvent($this);
			return true;
		}

		return false;
	}
589234
public function destroy($sessionId): bool
    {
        $sql = 'DELETE FROM sessions WHERE id = :id';
        $params = ['id' => $sessionId];
        $this->db->delete($sql, $params);

        return true;
    }
1309190
@DELETE
    @Path("/guid/{guid}")
    @Consumes(Servlets.JSON_MEDIA_TYPE)
    @Produces(Servlets.JSON_MEDIA_TYPE)
    public void deleteById(@PathParam("guid") String guid) throws AtlasBaseException {
        AtlasPerfTracer perf = null;

        try {
            if (AtlasPerfTracer.isPerfTraceEnabled(PERF_LOG)) {
                perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "RelationshipREST.deleteById(" + guid + ")");
            }

            relationshipStore.deleteById(guid);
        } finally {
            AtlasPerfTracer.log(perf);
        }
    }
1306471
public function destroy($sessionId) {
        try {
            $this->_tableRestProxy->deleteEntity($this->_sessionContainer, $this->_sessionContainerParition, $sessionId);
            return TRUE;
        } catch (ServiceException $e) {
            return FALSE;
        }
    }
1238800
public function destroy($session_id)
	{
		if (!xcache_isset($this->key($session_id)))
		{
			return true;
		}

		return xcache_unset($this->key($session_id));
	}
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]);
            }
        }
    }
802318
public function delete($key)
    {
        $this->initSession();
        $key_name = $this->getSessionKeyName($key);
        unset($_SESSION[$key_name]);
    }
1186377
public static function unsetInvalidGUIDs($guids)
    {
        foreach ($guids as $key => $guid)
        {
            if (!preg_match(self::GUID_REGEX, $guid)){
                unset($guids[$key]);
            }
        }
        return $guids;
    }
572115
public function resetID()
    {
        if (session_status() === PHP_SESSION_ACTIVE)
        {
            $this->set('session_mgmt', 'destroyed', time());
            $auth = $this->get('authentication');
            if ($auth)
                unset($this['authentication']);

            $new_session_id = self::create_new_id();
            $this->set('session_mgmt', 'new_session_id', $new_session_id);
            session_commit();
            
            ini_set('session.use_strict_mode', 0);
            session_id($new_session_id);

            session_start();
            ini_set('session.use_strict_mode', 1);
            $this->session_id = session_id();
            $this->values = &$_SESSION;
            $this->session_cookie->setValue($new_session_id);

            // Force destroyed to be empty 
            $this->set('session_mgmt', 'destroyed', null);

            if ($auth)
                $this['authentication'] = $auth;

            // Store the start time of the new session
            $this->set('session_mgmt', 'start_time', time());
        }
    }
530130
public function destroy($sessionId)
    {
        if ($this->_lock) {
            $query = $this->newQuery()
                ->where('id', $sessionId);
            if (!$query->delete()) {
                return $this->_fail();
            }
        }
        if ($this->close() === $this->_success) {
            $this->_cookie_destroy();
            return $this->_success;
        }

        return $this->_fail();
    }
181628
public function deleteUserForced($uid)
    {
        $return['error'] = true;

        $query = "DELETE FROM {$this->config->table_users} WHERE id = :uid";
        $query_prepared = $this->dbh->prepare($query);

        if (!$query_prepared->execute(['uid' => $uid])) {
            $return['message'] = $this->__lang("system_error") . " #05";

            return $return;
        }

        $query = "DELETE FROM {$this->config->table_sessions} WHERE uid = :uid";
        $query_prepared = $this->dbh->prepare($query);

        if (!$query_prepared->execute(['uid' => $uid])) {
            $return['message'] = $this->__lang("system_error") . " #06";

            return $return;
        }

        $query = "DELETE FROM {$this->config->table_requests} WHERE uid = :uid";
        $query_prepared = $this->dbh->prepare($query);

        if (!$query_prepared->execute(['uid' => $uid])) {
            $return['message'] = $this->__lang("system_error") . " #07";

            return $return;
        }

        $return['error'] = false;
        $return['message'] = $this->__lang("account_deleted");

        return $return;
    }
487850
public function __tearup($sessionId = null)
    {
        $configuration = self::getRegistry()->getConfiguration()->session;

        $this
            ->logger(self::getRegistry()->getLogging())
            ->id($sessionId)
            ->clientIp($_SERVER['REMOTE_ADDR'])
            ->userAgent($_SERVER['HTTP_USER_AGENT'])
            ->domain($_SERVER['SERVER_NAME'])
            ->flagStatus('httpOnly', true)
            ->flagStatus('ssl', true);

        if (true === $configuration->autoinit) {
            $this
                ->init($configuration)
                ->start();
        }
    }
346129
function destroy($id) {
		Cache::instance()->clear($id.'.@');
		setcookie(session_name(),'',strtotime('-1 year'));
		unset($_COOKIE[session_name()]);
		header_remove('Set-Cookie');
		return TRUE;
	}
661329
public function destroy($sessionId)
    {
        $this->_memcache->delete(Kwf_Cache_Simple::getUniquePrefix().'sess-'.$sessionId);
        $this->_memcache->delete(Kwf_Cache_Simple::getUniquePrefix().'sess-db-'.$sessionId);
        Kwf_Registry::get('db')->query("DELETE FROM kwf_sessions WHERE sessionId=?", $sessionId); 
        return true;
    }
686155
public function destroy()
    {
        // Erase the id on the client side
        if ($this->cookieBag->has($this->getName())) {
            $this->cookieBag->remove($this->getName());
        }

        // Erase on the server side
        return session_destroy();
    }