Clear the resource bundle cache.
Subsequent resolve calls will lead to reloading of the properties files.
962216
public void clearCache() {
		logger.debug("Clearing entire resource bundle cache");
			this.cachedProperties.clear();
			this.cachedMergedProperties.clear();
		this.cachedFilenames.clear();
		this.cachedResources.clear();
	}
819370
public void clear() {
    mMap.forEach((key, value) -> {
      onCacheUpdate(key, value.mValue);
      onRemove(key);
    });
    mMap.clear();
  }
65025
public function clearCache() {
        $files = glob($this->getConfig('cacheDir') . '/*', GLOB_MARK);
        foreach ($files as $file) {
            unlink($file);
        }
    }
1188047
private void clear() {
		availableSlots.clear();
		allocatedSlots.clear();
		pendingRequests.clear();
		waitingForResourceManager.clear();
		registeredTaskManagers.clear();
	}
806687
def clear(self):
        
        self._lock.acquire()
        try:
            self._cache = []
            self._updated = False
        finally:
            self._lock.release()
258502
public synchronized void clear() {
		_layerCache.clear();
		_moduleCache.clear();
		_gzipCache.clear();
		for (IGenericCache cache : _namedCaches.values()) {
			cache.clear();
		}
	}
523579
public void clearCache() {
        File cacheDir = getCacheDir();
        if (cacheDir.exists()) {
            File[] files = cacheDir.listFiles();
            if (files != null) {
                for (File child : files) {
                    deleteFilesRecursively(child);
                }
            }
        }
    }
861321
public void dispose() {
        if (_cacheFile != null && _dirty) {
            PrintStream out = null;
            try {
                File parent = _cacheFile.getParentFile();
                if (parent.isDirectory() || parent.mkdirs()) {
                    out = new PrintStream(_cacheFile);
                    for (List<Resource> bundleInfoList : _cacheBySymbolicName.values()) {
                        for (Resource bundleInfo : bundleInfoList) {
                            out.println(bundleInfo);
                        }
                    }
                }
            } catch (IOException e) {
            } finally {
                Utils.tryToClose(out);
            }
        }
        _bundleLocations.clear();
        _cacheBySymbolicName.clear();
    }
582673
public final void clearCache() {
        if (unusedViews != null) {
            unusedViews.clear();
            unusedViews = null;
        }

        logger.logDebug(getClass(), "Removed all unused views from cache");
    }
937362
@Override
	public void clearCache(
		CPDefinitionVirtualSetting cpDefinitionVirtualSetting) {
		entityCache.removeResult(CPDefinitionVirtualSettingModelImpl.ENTITY_CACHE_ENABLED,
			CPDefinitionVirtualSettingImpl.class,
			cpDefinitionVirtualSetting.getPrimaryKey());

		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);

		clearUniqueFindersCache((CPDefinitionVirtualSettingModelImpl)cpDefinitionVirtualSetting,
			true);
	}
1297476
public void clear() {
        sourceWaterMarkMap.clear();
        flush();
        if (fileOriginal != null && fileOriginal.exists()) {
            fileOriginal.delete();
        }
    }
207962
public void clearResourceSet(final ResourceSet resourceSet) {
    final boolean wasDeliver = resourceSet.eDeliver();
    try {
      resourceSet.eSetDeliver(false);
      resourceSet.getResources().clear();
    } finally {
      resourceSet.eSetDeliver(wasDeliver);
    }
  }
528060
public static function clear()
    {
        $path = root().'resources/controllers/*.php';

        $files = File::glob($path);
        //
        foreach ($files as $file) {
            File::delete($file);
        }
        //
        return true;
    }
127284
@Override
	public void clearCached(ICacheManager mgr) {
		Map<String, CacheEntry> moduleBuilds;
		synchronized (this) {
			moduleBuilds = _moduleBuilds;
			_moduleBuilds = null;
		}
		if (moduleBuilds != null) {
			for (Map.Entry<String, CacheEntry> entry : moduleBuilds.entrySet()) {
				entry.getValue().delete(mgr);
			}
			moduleBuilds.clear();
		}
	}
873829
protected void clearCaches() {
        DescriptorFactory.clearInstance();
        ObjectTypeFactory.clearInstance();
        TypeQualifierApplications.clearInstance();
        TypeQualifierAnnotation.clearInstance();
        TypeQualifierValue.clearInstance();
        // Make sure the codebases on the classpath are closed
        AnalysisContext.removeCurrentAnalysisContext();
        Global.removeAnalysisCacheForCurrentThread();
        IO.close(classPath);
    }
270722
@Override
	public void clearCache() {
		entityCache.clearCache(CProductImpl.class);

		finderCache.clearCache(FINDER_CLASS_NAME_ENTITY);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
	}
416223
def clear(self) -> None:
        
        if self._cache_directory is not None:
            # Safety - if there isn't a cache directory file, this probably isn't a valid cache
            assert os.path.exists(self._cache_directory_index), "Attempt to clear a non-existent cache"
            self._load()            # Shouldn't have any impact but...
            for e in self._cache.values():
                if os.path.exists(e.loc):
                    os.remove(e.loc)
            self._cache.clear()
            self._update()
        self._cache = {}