*
This method is used to clear the Java KeyStores held within the WSKeyStores
in the KeyStoreMap based on the files
*
181794
public void clearJavaKeyStoresFromKeyStoreMap(Collection<File> modifiedFiles) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "clearJavaKeyStoresFromKeyStoreMap ", new Object[] { modifiedFiles });

        String filePath = null;
        String comparePath = null;
        for (File modifiedKeystoreFile : modifiedFiles) {
            try {
                filePath = modifiedKeystoreFile.getCanonicalPath();
                comparePath = filePath.replace('\\', '/');
            } catch (IOException e) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    Tr.debug(tc, "Exception comparing file path.");
                continue;
            }

            findKeyStoreInMapAndClear(comparePath);
        }
    }
572937
private void removeKeys(List<Integer> keysToRemove, SparseArrayCompat<ViewHolder> headers) {
        for (Integer key : keysToRemove) {
            headers.remove(key);
        }
    }
221192
private void clearAllHeaders() {
        final boolean bTrace = TraceComponent.isAnyTracingEnabled();
        if (bTrace && tc.isEntryEnabled()) {
            Tr.entry(tc, "clearAllHeaders()");
        }

        HeaderElement elem = this.hdrSequence;
        while (null != elem) {
            final HeaderElement next = elem.nextSequence;
            final HeaderKeys key = elem.getKey();
            final int ord = key.getOrdinal();
            if (storage.containsKey(ord)) {
                // first instance being removed
                if (key.useFilters()) {
                    filterRemove(key, null);
                }
                storage.remove(ord);
            }
            elem.destroy();
            elem = next;
        }
        this.hdrSequence = null;
        this.lastHdrInSequence = null;
        this.numberOfHeaders = 0;
        if (bTrace && tc.isEntryEnabled()) {
            Tr.exit(tc, "clearAllHeaders()");
        }
    }
1047243
public void releaseAllKeys ()
    {
        long now = System.currentTimeMillis();
        Iterator<KeyInfo> iter = _keys.elements();
        while (iter.hasNext()) {
            iter.next().release(now);
        }
    }
745528
static void removeOldKeys(Map<String, String> map, String... keys) {
        if (CommonUtils.isEmpty(map)) {
            return;
        }
        for (String key : keys) {
            map.remove(key);
        }
    }
851779
@Override
    public boolean removeStoredCredentials() {
        if (!deleteTokens())
            return false;
        IDToken = null;
        refreshToken = null;
        haveSessionCookie = false;
        authURL = null;
        return true;
    }
24910
public void clearKeyStoreFromMap(String keyStoreName) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "clearKeyStoreFromMap: " + keyStoreName);
        synchronized (keyStoreMap) {
            keyStoreMap.remove(keyStoreName);
        }
    }
15146
private void removeExistingKeys(Collection<Data> keys) {
        if (keys == null || keys.isEmpty()) {
            return;
        }
        Storage storage = recordStore.getStorage();
        keys.removeIf(storage::containsKey);
    }
1155715
def _clear(self):
        
        self.root = RootGroup()
        self.groups = []
        self.entries = []
        self.readonly = False
        self.header = None
        self.password = None
        self.keyfile = None
        self.filepath = None
811933
public static void removeEntryFromSSLContextMap(String keyStorePath) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "removeEntryFromSSLContextMap: " + new Object[] { keyStorePath });

        List<SSLConfig> removeList = new ArrayList<SSLConfig>();

        for (Entry<SSLConfig, SSLContext> entry : sslContextCacheJAVAX.entrySet()) {
            SSLConfig cachedConfig = entry.getKey();

            if (cachedConfig != null) {
                String ksPropValue = cachedConfig.getProperty(Constants.SSLPROP_KEY_STORE, null);
                boolean ksFileBased = Boolean.parseBoolean(cachedConfig.getProperty(Constants.SSLPROP_KEY_STORE_FILE_BASED));
                String tsPropValue = cachedConfig.getProperty(Constants.SSLPROP_TRUST_STORE, null);
                boolean tsFileBased = Boolean.parseBoolean(cachedConfig.getProperty(Constants.SSLPROP_TRUST_STORE_FILE_BASED));

                if ((ksPropValue != null && keyStorePath.equals(WSKeyStore.getCannonicalPath(ksPropValue, ksFileBased))) ||
                    (tsPropValue != null && keyStorePath.equals(WSKeyStore.getCannonicalPath(tsPropValue, tsFileBased)))) {
                    removeList.add(cachedConfig);
                }
            }
        }
        if (!removeList.isEmpty()) {
            for (SSLConfig removeEntry : removeList) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    Tr.debug(tc, "removing from sslContext cache: " + removeEntry.toString());

                sslContextCacheJAVAX.remove(removeEntry);
            }
        }
    }
747576
public function cleanup(): void
    {
        foreach ($this->getStore() as $key => $value)
        {
            $this->remove($key);
        }
    }
258502
public synchronized void clear() {
		_layerCache.clear();
		_moduleCache.clear();
		_gzipCache.clear();
		for (IGenericCache cache : _namedCaches.values()) {
			cache.clear();
		}
	}
681091
public void findKeyStoreInMapAndClear(String keyStorePath) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "findKeyStoreInMapAndClear ", new Object[] { keyStorePath });

        for (Entry<String, WSKeyStore> entry : keyStoreMap.entrySet()) {
            WSKeyStore ws = entry.getValue();
            if (WSKeyStore.getCannonicalPath(ws.getLocation(), ws.getFileBased()).equals(keyStorePath)) {
                ws.clearJavaKeyStore();
            }
        }
    }
276913
public KeyValueStoreUpdate clearAll(String... segments) {
		actions.add(new Deletion("/" + String.join("/", segments)));
		return this;
	}
279177
public void clear() {
        while (tail != head) {
            hpackHeaderFields[tail++] = null;
            if (tail == hpackHeaderFields.length) {
                tail = 0;
            }
        }
        head = 0;
        tail = 0;
        size = 0;
    }
730244
@Override
  public void removeAllFailure(Iterable<? extends K> keys, StoreAccessException e) {
    cleanup(keys, e);
  }
1122632
public function clear()
    {
        if ($this->storageAdapter->has($this->key)) {
            $this->storageAdapter->remove($this->key);
        }
    }