/*
invalidateAll(boolean)

@see com.ibm.wsspi.servlet.session.IBMSessionExt#invalidateAll(boolean)
340157
public void invalidateAll(boolean remote) throws SecurityException {

        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINER)) {
            String logString = "(" + remote + ") for app " + appName + " id " + getId();
            LoggingUtil.SESSION_LOGGER_CORE.entering(methodClassName, "invalidateAll", logString);
        }
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(invalidateAllPerm);
        }
        SessionContextRegistry.getInstance().invalidateAll(getId(), _sessCtx.getAppName(), this, remote, false); // false
                                                                                                                 // indicates
                                                                                                                 // request
                                                                                                                 // was
                                                                                                                 // not
                                                                                                                 // remotely
                                                                                                                 // initiated
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, "invalidateAll");
        }
    }
1305386
public void invalidate() throws IOException {
        if (roles!=null) {
            roles = null;
            timestamp = System.currentTimeMillis();
            user.save();
        }
    }
470772
public void clearAll() {
    final List<EncodedImage> old;
    synchronized (this) {
      old = new ArrayList<>(mMap.values());
      mMap.clear();
    }
    for (int i = 0; i < old.size(); i++) {
      EncodedImage encodedImage = old.get(i);
      if (encodedImage != null) {
        encodedImage.close();
      }
    }
  }
1021155
public void invalidate(String sessionId) {
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            StringBuffer sb = new StringBuffer("for app ").append(_sap.getAppName()).append(" id ").append(sessionId);
            LoggingUtil.SESSION_LOGGER_CORE.entering(methodClassName, methodNames[INVALIDATE], sb.toString());
        }
        ISession iSess = _coreHttpSessionManager.getISession(sessionId);

        if (iSess != null) {
            IStore iStore = _coreHttpSessionManager.getIStore();
            try {
                iStore.setThreadContext();
                synchronized (iSess) { // START PM47941
                    if (iSess.isValid()) {
                        iSess.invalidate();
                    }
                } // END PM47941
            } finally {
                iStore.unsetThreadContext();
            }
        }
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, methodNames[INVALIDATE]);
        }
    }
737959
public void resetAll(MemberId leader, Collection<MemberId> members) {
    MemberId oldLeader = this.leader;
    this.leader = leader;
    this.members = Lists.newLinkedList(members);
    selectors.forEach(s -> s.reset(leader, this.members));
    if (!Objects.equals(oldLeader, leader)) {
      leaderChangeListeners.forEach(l -> l.accept(leader));
    }
  }
1301663
protected static void invalidateSwitchPoints() {
            if (LOG_ENABLED) {
                 LOG.info("invalidating switch point");
            }
        	SwitchPoint old = switchPoint;
            switchPoint = new SwitchPoint();
            synchronized(IndyInterface.class) { SwitchPoint.invalidateAll(new SwitchPoint[]{old}); }
        }
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;
            }
        }
    }
800885
@Override
    public void deleteAll(final Collection<T> values) {
        if (values == null || values.size() == 0) {
            return;
        }

        // we need a List of values to partition
        final List<T> valuesList;
        if (values instanceof List) {
            valuesList = (List<T>) values;
        } else {
            valuesList = Lists.newArrayList(values);
        }

        // process values in groups of <partition size>
        for (final List<T> partition : Lists.partition(valuesList, config.getPartitionSize())) {
            doDeleteAllValues(partition);
            for (final T value : partition) {
                notifyDeleted(value);
            }
        }
    }
1280347
@Override
    public void clearAll() {
        synchronized (this) {
            if (isActive()) {
                deactivateAll();
            }
            activeStore.remove();
            for (Map.Entry<T, ObjectStore> entry : stores.entrySet()) {
                entry.getValue().clear();
            }
            stores.clear();
        }
    }
198875
@Override
    @Transactional(rollbackFor = Exception.class)
    public void removeAll(List pDatas) throws APPErrorException {
        for (int i = 0; i < pDatas.size(); i++) {
            remove(pDatas.get(i));
        }
    }
264984
public void removeAll()
    {
        if (m_gridList != null)
            m_gridList.removeAll();
        if (m_gridBuffer != null)
            m_gridBuffer.removeAll();
        if (m_gridNew != null)
            m_gridNew.removeAll();
        m_iEndOfFileIndex = UNKNOWN_POSITION;
        m_iPhysicalFilePosition = UNKNOWN_POSITION;
        m_iLogicalFilePosition = UNKNOWN_POSITION;
    }
915598
@CanIgnoreReturnValue
  @Override
  public Set<V> removeAll(@Nullable Object key) {
    return (Set<V>) super.removeAll(key);
  }
261006
public void invalidate() {
        synchronized (mMeasuredChildren) {
            Log.d(Log.SUBSYSTEM.LAYOUT, TAG, "invalidate all [%d]", mMeasuredChildren.size());
            mMeasuredChildren.clear();
        }
    }
33456
public synchronized void invalidate()
	{
		// Remove this cached wrapper from the appropriate cache
        if (invalidated != true){
			if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))  //306998.15
				logger.logp(Level.FINE, CLASS_NAME,"invalidate", "first invalidate");
			WebContainer.removeFromCache(cacheKeyStr);

			/* Avoid nulling things out so we can continue to handle requests in this wrapper
	                     * while the app is being destroyed
			cacheTarget = null;
			_servletPath = null;
			_pathInfo = null;
                        webapp = null;
			cacheKeyStr = null;
			*/
			invalidated = true;
		}
		else{
			if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))  //306998.15
				logger.logp(Level.FINE, CLASS_NAME,"invalidate", "additional invalidate");
		}
	}
1343357
public void invalidateAll(Predicate<? super C> predicate) {
        final Set<C> keys = cache.asMap().keySet().stream()
                .filter(predicate)
                .collect(Collectors.toSet());
        cache.invalidateAll(keys);
    }
335495
protected void common_invalidate(Object key) {
        ValidateUtility.objectNotNull(key, "key");
        cache.invalidateById(key, true);
    }
398774
public void invalidateAll(Iterable<P> principals) {
        final Set<P> principalSet = Sets.of(principals);
        final Set<ImmutablePair<P, String>> keys = cache.asMap().keySet().stream()
                .filter(cacheKey -> principalSet.contains(cacheKey.getLeft()))
                .collect(Collectors.toSet());
        cache.invalidateAll(keys);
    }