Invalidates the given session.
No more heartbeats will be sent for the given session.
322570
public final void invalidateSession(RaftGroupId groupId, long id) {
        SessionState session = sessions.get(groupId);
        if (session != null && session.id == id) {
            sessions.remove(groupId, session);
        }
    }
1048711
public function invalidate()
	{
		// Only invalidate if this tag is valid to prevent infinite loops
		if (!$this->invalid)
		{
			$this->invalid = true;
			foreach ($this->cascade as $tag)
			{
				$tag->invalidate();
			}
		}
	}
444746
def invalidate(self):
        
        # Never schedule a second redraw, when a previous one has not yet been
        # executed. (This should protect against other threads calling
        # 'invalidate' many times, resulting in 100% CPU.)
        if self._invalidated:
            return
        else:
            self._invalidated = True

        # Trigger event.
        self.on_invalidate.fire()

        if self.eventloop is not None:
            def redraw():
                self._invalidated = False
                self._redraw()

            # Call redraw in the eventloop (thread safe).
            # Usually with the high priority, in order to make the application
            # feel responsive, but this can be tuned by changing the value of
            # `max_render_postpone_time`.
            if self.max_render_postpone_time:
                _max_postpone_until = time.time() + self.max_render_postpone_time
            else:
                _max_postpone_until = None

            self.eventloop.call_from_executor(
                redraw, _max_postpone_until=_max_postpone_until)
1267301
def invalidate(self):
        
        if hasattr(self, '_avail_backups'):
            del self._avail_backups
        if hasattr(self, '_ips'):
            del self._ips

        Base.invalidate(self)
807143
protected void callInvalidateFromInternalInvalidate() {
        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, "callInvalidateFromInternalInvalidate", "calling this.invalidate( false )");
        }
        invalidate(false);
    }
995724
public void destroySession() {
    	JsonObject session = get("session");
        if (session == null) {
            return;
        }

        String sessionId = session.getString("id");
        // remove from the context
        put("session", null);

        if (sessionId == null) {
            return;
        }

        store.destroy(sessionId, new Handler<Object>() {
            @Override
            public void handle(Object error) {
                if (error != null) {
                    // TODO: better handling of errors
                    System.err.println(error);
                }
            }
        });
    }
1308364
private void invalidateAllMemorySessions() {

        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.entering(methodClassName, methodNames[INVALIDATE_ALL_MEMORY_SESSIONS], appNameForLogging);
        }

        Set s = _sessions.keySet();
        if (s != null) {
            for (Iterator it = s.iterator(); it.hasNext();) {
                MemorySession ms = (MemorySession) _sessions.get(it.next());
                ms.internalInvalidate(false);
            }
        }
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, methodNames[INVALIDATE_ALL_MEMORY_SESSIONS]);
        }
    }
1322795
public void invalidate() {
        if (transitionLength <= 0f) {
            currentColor.set(targetColor);
            redNeedsUpdate = greenNeedsUpdate = blueNeedsUpdate = alphaNeedsUpdate = false;
            transitionInProgress = false;
        } else {
            redNeedsUpdate = initialColor.r != targetColor.r;
            greenNeedsUpdate = initialColor.g != targetColor.g;
            blueNeedsUpdate = initialColor.b != targetColor.b;
            alphaNeedsUpdate = initialColor.a != targetColor.a;

            updateTransitionStatus();
            if (transitionInProgress) {
                initialRedIsGreater = initialColor.r >= targetColor.r;
                initialGreenIsGreater = initialColor.g >= targetColor.g;
                initialBlueIsGreater = initialColor.b >= targetColor.b;
                initialAlphaIsGreater = initialColor.a >= targetColor.a;
            }
        }
    }
1272313
def invalidate(self, *raw_args, **raw_kwargs):
        
        args = self.prepare_args(*raw_args)
        kwargs = self.prepare_kwargs(**raw_kwargs)
        key = self.key(*args, **kwargs)
        item = self.cache.get(key)
        if item is not None:
            expiry, data = item
            self.store(key, self.timeout(*args, **kwargs), data)
            self.async_refresh(*args, **kwargs)
1306741
def invalidate(self):
        
        for key in [k for k in type(self).properties.keys()
                if not type(self).properties[k].identifier]:
            self._set(key, None)

        self._set('_populated', False)
315913
def invalidate(self):
        """"""
        with self._mesh_generator_lock:
            self._mesh_generator_pending = None
            self._mesh_generator = None
        self._dispatch_changed_callbacks()
677716
def revoke_session(self, sid='', token=''):
        
        if not sid:
            if token:
                sid = self.handler.sid(token)
            else:
                raise ValueError('Need one of "sid" or "token"')

        for typ in ['access_token', 'refresh_token', 'code']:
            try:
                self.revoke_token(self[sid][typ], typ)
            except KeyError:  # If no such token has been issued
                pass

        self.update(sid, revoked=True)
819767
public static void invalidate() throws IOException {
        final SharedOpenFilesCache obsolete;
        synchronized (syncObject) {
            obsolete = theCache;
            theCache = null;
        }
        if (obsolete != null) {
            obsolete.clear();
        }
    }
326348
public void destroySession() {
		if (entryPoint != null) {
			entryPoint.onSessionDestruction(this, session);
		}
		if (accessManager != null) {
			accessManager.destroyCurrentSession();
		}
		session = null;
	}
56773
def invalidate(self, key):
        ''''''
        path = self.path(self.xform_key(key))
        try:
            LOG.debug('invalidate %s (%s)', key, path)
            path.unlink()
        except OSError:
            pass
83326
def detach_session(self):
        """"""
        if self._session is not None:
            self._session.unsubscribe(self)
            self._session = None
274137
public function destroy()
    {
        if ( NULL !== $this->sessionID )
        {
            session_write_close();
        }
        elseif ( NULL === $this->sessionID && $this->strict )
        {
            throw new InvalidSessionException( 'There is no session to close' );
        }
    }