/*
@see com.ibm.wsspi.session.ISession#invalidate()
484496
@Override
    public synchronized void invalidate() {

        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.entering(methodClassName, methodNames[INVALIDATE], appNameAndIdString);
        }
        if (invalInProgress) {
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, methodNames[INVALIDATE], "Invalidation in Progress");
            }
            return;
        }
        if (!_isValid) {
            throw new IllegalStateException();
        }
        invalInProgress = true;
        
        // PM03375: Remove duplicate call to sessionCacheDiscard for persistence case
        if (_smc.isUsingMemory()) {
            _storeCallback.sessionCacheDiscard(this);
        }
        _storeCallback.sessionInvalidated(this);
        _store.removeSession(_sessionId);

        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[INVALIDATE], "_removeAttrOnInvalidate = " + _removeAttrOnInvalidate );
            if(_attributes != null) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[INVALIDATE], "session _attributes.size() = " + _attributes.size() );
            }
        }        
        
        //CTS defect expects removal of session attributes
        if(_attributes != null && _removeAttrOnInvalidate) {
            
           Enumeration<String> attrKey =  _attributes.keys();
           while(attrKey.hasMoreElements()){
               
               String key = attrKey.nextElement();
               this.removeAttribute(key);
           }                    
           if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
               LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[INVALIDATE], "session attributes removed");
           }
        }

        setIsValid(false);

        invalInProgress = false;
        _attributes = null;
        _attributeNames.clear();
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, methodNames[INVALIDATE]);
        }
    }
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;
            }
        }
    }
603111
public void invalidateAll() {
		int N = width*height;
		for( int i = 0; i < N; i++ )
			data[i].x = Float.NaN;
	}
39446
def invalidate(self):
        """"""

        super(RedisTransport, self).invalidate()
        for server in self._servers:
            server['redis'].connection_pool.disconnect()
        return False
388705
public void registerInvalidations(String cacheName, Iterator invalidations) {

		InvalidationTableList invalidationTableList = getInvalidationTableList(cacheName);

		if (invalidationTableList != null) {
			try {
				invalidationTableList.readWriteLock.writeLock().lock();
				
				while (invalidations.hasNext()) {
					try {
						Object invalidation = invalidations.next();
						if (invalidation instanceof InvalidateByIdEvent) {
							InvalidateByIdEvent idEvent = (InvalidateByIdEvent) invalidation;

							Object id = idEvent.getId();
							InvalidateByIdEvent oldIdEvent = (InvalidateByIdEvent) invalidationTableList.presentIdSet.get(id);

							long timeStamp = idEvent.getTimeStamp();
							if ((oldIdEvent != null) && (oldIdEvent.getTimeStamp() >= timeStamp)) {
								continue;
							}
							invalidationTableList.presentIdSet.put(id, idEvent);
							continue;
						}
						InvalidateByTemplateEvent templateEvent = (InvalidateByTemplateEvent) invalidation;

						String template = templateEvent.getTemplate();

						InvalidateByTemplateEvent oldTemplateEvent = (InvalidateByTemplateEvent) invalidationTableList.presentTemplateSet.get(template);

						long timeStamp = templateEvent.getTimeStamp();
						if ((oldTemplateEvent != null) && (oldTemplateEvent.getTimeStamp() >= timeStamp)) {
							continue;
						}
						invalidationTableList.presentTemplateSet.put(template, templateEvent);
					} catch (Exception ex) {
						com.ibm.ws.ffdc.FFDCFilter.processException(ex, "com.ibm.ws.cache.InvalidationAuditDaemon.registerInvalidations", "126", this);
					}
				}
			} finally {
				invalidationTableList.readWriteLock.writeLock().unlock();
			}
		}
	}
674957
public void invalidate() {
        if (mInvalid.compareAndSet(false, true)) {
            for (InvalidatedCallback callback : mOnInvalidatedCallbacks) {
                callback.onInvalidated();
            }
        }
    }
1117921
public void invalidateAll(final String sessionId)
    {
        // tell all contexts that may have a session object with this id to
        // get rid of them
        Handler[] contexts = _server.getChildHandlersByClass(ContextHandler.class);
        for (int i = 0; contexts != null && i < contexts.length; i++)
        {
            SessionHandler sessionHandler = ((ContextHandler) contexts[i]).getChildHandlerByClass(SessionHandler.class);
            if (sessionHandler != null)
            {
                SessionManager manager = sessionHandler.getSessionManager();
                if (manager != null && manager instanceof KeyValueStoreSessionManager)
                {
                    ((KeyValueStoreSessionManager) manager).invalidateSession(sessionId);
                }
            }
        }
    }
895560
synchronized void removeSession(long sessionID) {

        LongKeyIntValueHashMap scsMap;
        long                   csid;
        Iterator               i;

        scsMap = (LongKeyIntValueHashMap) sessionUseMap.remove(sessionID);

        if (scsMap == null) {
            return;
        }

        i = scsMap.keySet().iterator();

        while (i.hasNext()) {
            csid = i.nextLong();

            int usecount = useMap.get(csid, 1) - 1;

            if (usecount == 0) {
                Statement cs = (Statement) csidMap.remove(csid);

                if (cs != null) {
                    int schemaid = cs.getSchemaName().hashCode();
                    LongValueHashMap sqlMap =
                        (LongValueHashMap) schemaMap.get(schemaid);
                    String sql = (String) sqlLookup.remove(csid);

                    sqlMap.remove(sql);
                }

                useMap.remove(csid);
            } else {
                useMap.put(csid, usecount);
            }
        }
    }
780542
public void invalidate(InternalIndex index) {
        String[] components = index.getComponents();
        if (components == null) {
            cache.remove(index.getName());
            return;
        }

        for (String component : components) {
            TypeConverter converter = cache.get(component);
            if (converter instanceof UnresolvedConverter) {
                cache.remove(component);
            }
        }
    }
1266466
public final void removeSession (final Session sessionReq) throws NoSuchSessionException {

        final Session session = sessions.get(sessionReq.getTargetName());

        if (session != null) {
            sessions.remove(sessionReq.getTargetName());
        } else {
            throw new NoSuchSessionException("Session " + sessionReq.getTargetName() + " not found!");
        }
    }
40847
public final void invalidateNearCache(Data key) {
        if (!mapContainer.hasInvalidationListener() || key == null) {
            return;
        }

        Invalidator invalidator = getNearCacheInvalidator();
        invalidator.invalidateKey(key, name, getCallerUuid());
    }
335495
protected void common_invalidate(Object key) {
        ValidateUtility.objectNotNull(key, "key");
        cache.invalidateById(key, true);
    }
1132545
@Override
    public synchronized void invalidate(String key, boolean fullExpire) {
        Entry entry = get(key);
        if (entry != null) {
            entry.softTtl = 0;
            if (fullExpire) {
                entry.ttl = 0;
            }
            put(key, entry);
        }

    }
284222
@DELETE
    @Path("/{token}")
    public void invalidateToken(@PathParam("token") String authToken)
            throws GuacamoleException {

        // Invalidate session, if it exists
        if (!authenticationService.destroyGuacamoleSession(authToken))
            throw new GuacamoleResourceNotFoundException("No such token.");

    }
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' );
        }
    }
875784
public void invalidate(P principal, String role) {
        cache.invalidate(ImmutablePair.of(principal, role));
    }
368452
private void invalidate(String message) {
        isValid = Boolean.FALSE;
        messages.append(message).append(' ');
    }