Deregister a session.
168184
def _deregister(self, session):
        
        if session in self:
            self._sessions.pop(self._get_session_key(session), None)
122719
def cleanup(self):
        """"""
        for item in self.server_map:
            self.member_del(item, reconfig=False)
        self.server_map.clear()
278145
def OnDestroy(self, event):
        """"""
        # deregister observers
        if hasattr(self, 'cardmonitor'):
            self.cardmonitor.deleteObserver(self.cardtreecardobserver)
        if hasattr(self, 'readermonitor'):
            self.readermonitor.deleteObserver(self.readertreereaderobserver)
            self.cardmonitor.deleteObserver(self.readertreecardobserver)
        event.Skip()
994275
final void disassociateSession(final JmsJcaSessionImpl session) {

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, "disassociateSession", session);
        }

        _sessions.remove(session);

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, "disassociateSession");
        }

    }
1012986
def destroy_digidoc_session(self):
        

        # cleanup data too
        self.destroy_digidoc_session_data()

        try:
            session = self.request.session[self.DIGIDOC_SESSION_KEY]

            if session:
                try:
                    service = self.flat_service()
                    service.session_code = session
                    service.close_session()

                except DigiDocError:
                    pass

            del self.request.session[self.DIGIDOC_SESSION_KEY]

        except KeyError:
            pass
155905
def delete(method, hmc, uri, uri_parms, logon_required):
        """"""
        try:
            adapter = hmc.lookup_by_uri(uri)
        except KeyError:
            raise InvalidResourceError(method, uri)
        cpc = adapter.manager.parent
        assert cpc.dpm_enabled
        adapter.manager.remove(adapter.oid)
664795
public static void deregisterTx(Session tx) {
        if (tx == null) {
            return;
        }
        synchronized (allFields) {
            for (TransientField<?> f: allFields.keySet()) {
                //returns null if key does not exist.
                synchronized (f) {
                    if (f.txMap.containsKey(tx)) {
                        f.txMap.remove(tx).clear();
                    }
                }
            }
        }
    }
1318221
def _delete(self, *args, **kwargs):
        

        if 'timeout' not in kwargs:
            kwargs['timeout'] = self.timeout

        req = self.session.delete(*args, **kwargs)
        return req
625592
def close_session():
        
        for prop in LTI_PROPERTY_LIST:
            if session.get(prop, None):
                del session[prop]
        session[LTI_SESSION_KEY] = False
1231282
int removeSessionToSessions(Session session, Collection<Session> sessions) {
		if (sessions != null) {
			if (sessions.remove(session)) {
				return 1;
			}
		}
		return 0;
	}
477078
def deactivate():
    

    if hasattr(_mode, "current_state"):
        del _mode.current_state
    if hasattr(_mode, "schema"):
        del _mode.schema

    for k in connections:
        con = connections[k]
        if hasattr(con, 'reset_schema'):
            con.reset_schema()
445704
def deregister_all(self, *events):
        
        if events:
            for event in events:
                self._handler_dict[event] = []
        else:
            self._handler_dict = {}
47797
def del_key(cls, k):
        
        k = cls.__name__ + "__" + k
        session.pop(k)
251026
def clean_deleted_sessions(cls):
        """"""
        for federate_slo in cls.objects.all():
            if not SessionStore(session_key=federate_slo.session_key).get('authenticated'):
                federate_slo.delete()
144046
def clear(self, session):
        
        try:
            sess = self.sessions[session]
        except KeyError:
            return constants.StatusCode.error_invalid_object
        return sess.clear()
326348
public void destroySession() {
		if (entryPoint != null) {
			entryPoint.onSessionDestruction(this, session);
		}
		if (accessManager != null) {
			accessManager.destroyCurrentSession();
		}
		session = null;
	}
963611
def destroy(self):
		
		if self.session_type == 'bash':
			# TODO: does this work/handle already being logged out/logged in deep OK?
			self.logout()
		elif self.session_type == 'vagrant':
			# TODO: does this work/handle already being logged out/logged in deep OK?
			self.logout()