/*
(non-Javadoc)

@see
net.jawr.web.resource.bundle.generator.AbstractCachedGenerator#resetCache
()
960434
@Override
	protected void resetCache() {
		super.resetCache();
		cacheProperties.put(JAWR_SERVLET_MAPPING, config.getServletMapping());
		String binaryServletMapping = getBinaryServletMapping();
		if (binaryServletMapping != null) {
			cacheProperties.put(JAWR_BINARY_SERVLET_MAPPING, binaryServletMapping);
		} else {
			cacheProperties.remove(JAWR_BINARY_SERVLET_MAPPING);
		}
		cacheProperties.put(JawrConfig.JAWR_CSS_CLASSPATH_HANDLE_IMAGE,
				Boolean.toString(config.isCssClasspathImageHandledByClasspathCss()));
		cacheProperties.put(JawrConfig.JAWR_BINARY_HASH_ALGORITHM, config.getBinaryHashAlgorithm());
	}
246711
public static function resetCache()
    {
        if (Cache::has('combiner.index')) {
            $index = (array) @unserialize(@base64_decode(Cache::get('combiner.index'))) ?: [];

            foreach ($index as $cacheKey) {
                Cache::forget($cacheKey);
            }

            Cache::forget('combiner.index');
        }

        CacheHelper::instance()->clearCombiner();
    }
627061
public final void useCache(final boolean useCache) {
        synchronized (cache) {
            this.useCache = useCache;
            logger.logDebug(getClass(), useCache ? "Enabled" : "Disabled" + " caching");

            if (!useCache) {
                clearCache();
            }
        }
    }
273001
public static function resetCache()
    {
        self::$activeThemeCache = false;
        self::$editThemeCache = false;

        Cache::forget(self::ACTIVE_KEY);
        Cache::forget(self::EDIT_KEY);
    }
262783
function reset()
    {
        $this->result = null;
        $this->filter = null;
        $this->cache  = null;
    }
766755
@Override
	public void clearCache() {
		entityCache.clearCache(CPAttachmentFileEntryImpl.class);

		finderCache.clearCache(FINDER_CLASS_NAME_ENTITY);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
	}
536818
public synchronized void reset() {
        final String methodName = "reset()";
        this.currentDataGB = 1;
        if (this.currentDependencyIdGB > 0) {
            this.currentDependencyIdGB = 1;
        }
        if (this.currentTemplateGB > 0) {
            this.currentTemplateGB = 1;
        }
        if (this.diskCacheSizeInGBLimit > 0) {
            this.diskCacheSizeInBytesLimit = (diskCacheSizeInGBLimit - this.currentDependencyIdGB - this.currentTemplateGB) * GB_SIZE;
            this.diskCacheSizeInBytesHighLimit = (this.diskCacheSizeInBytesLimit * (long)this.highThreshold) / 100l;
            this.diskCacheSizeInBytesLowLimit  = (this.diskCacheSizeInBytesLimit * (long)this.lowThreshold ) / 100l;
            traceDebug(methodName, "cacheName=" + this.cacheName + " diskCacheSizeInBytesLimit=" + this.diskCacheSizeInBytesLimit + " diskCacheSizeInBytesHighLimit=" + this.diskCacheSizeInBytesHighLimit + " diskCacheSizeInBytesLowLimit=" + this.diskCacheSizeInBytesLowLimit  + " currentDataGB=" + this.currentDataGB + " currentDependencyIdGB=" + this.currentDependencyIdGB + " currentTemplateGB=" + this.currentTemplateGB);
        }
    }
248219
public void clearCache(CacheInvocationContext<CacheRemove> context) {
        HystrixCacheKeyGenerator defaultCacheKeyGenerator = HystrixCacheKeyGenerator.getInstance();
        String cacheName = context.getCacheAnnotation().commandKey();
        HystrixGeneratedCacheKey hystrixGeneratedCacheKey =
                defaultCacheKeyGenerator.generateCacheKey(context);
        String key = hystrixGeneratedCacheKey.getCacheKey();
        HystrixRequestCache.getInstance(HystrixCommandKey.Factory.asKey(cacheName),
                HystrixConcurrencyStrategyDefault.getInstance()).clear(key);
    }
651208
public void
setCache(Cache cache) {
	if (cache == null) {
		this.cache = new Cache(dclass);
		this.temporary_cache = true;
	} else {
		this.cache = cache;
		this.temporary_cache = false;
	}
}
1082965
public void clearMemoryCaches() {
    Predicate<CacheKey> allPredicate =
        new Predicate<CacheKey>() {
          @Override
          public boolean apply(CacheKey key) {
            return true;
          }
        };
    mBitmapMemoryCache.removeAll(allPredicate);
    mEncodedMemoryCache.removeAll(allPredicate);
  }
752934
@Override
	public void clearCache() {
		entityCache.clearCache(CPDefinitionLocalizationImpl.class);

		finderCache.clearCache(FINDER_CLASS_NAME_ENTITY);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
	}
436717
@Override
	public void cacheResult(List<CPInstance> cpInstances) {
		for (CPInstance cpInstance : cpInstances) {
			if (entityCache.getResult(
						CPInstanceModelImpl.ENTITY_CACHE_ENABLED,
						CPInstanceImpl.class, cpInstance.getPrimaryKey()) == null) {
				cacheResult(cpInstance);
			}
			else {
				cpInstance.resetOriginalValues();
			}
		}
	}
409774
private synchronized void clearCaches() {
        fileListMap.clear();
        includeNonPatterns.clear();
        excludeNonPatterns.clear();
        includePatterns = null;
        excludePatterns = null;
        areNonPatternSetsReady = false;
    }
1357125
public void clearCache()
  {
    // skip the clear on restart
    if (_lifecycle.isStopping()) {
      return;
    }

    if (log.isLoggable(Level.FINER)) {
      log.finest("clearCache");
    }

    // the invocation cache must be cleared first because the old
    // filter chain entries must not point to the cache's
    // soon-to-be-invalid entries
    getInvocationManager().clearCache();

    /*
    if (_httpCache != null) {
      _httpCache.clear();
    }
    */
  }
717517
public void cacheCleared(DCache cache) {
        final String methodName = "cacheCleared()";
        ExpirationMetaData expirationMetaData = (ExpirationMetaData)cacheInstancesTable.get(cache);
        if (expirationMetaData == null) {
            return;
        }
        synchronized (expirationMetaData) {
            if (!expirationMetaData.expirationTable.isEmpty()) {
                Enumeration e = expirationMetaData.expirationTable.elements();
                while (e.hasMoreElements()) {
                    InvalidationTask it = (InvalidationTask)e.nextElement();
                    it.reset();
                    taskPool.add(it);
                }
                expirationMetaData.expirationTable.clear();
                expirationMetaData.timeLimitHeap.clear();
                if (tc.isDebugEnabled()){
                	Tr.debug(tc, methodName + cache.getCacheName() + " expirationTable=" + expirationMetaData.expirationTable.size());
                }
            }
        }
    }
545446
@Override
	public void cacheResult(List<CommerceWarehouse> commerceWarehouses) {
		for (CommerceWarehouse commerceWarehouse : commerceWarehouses) {
			if (entityCache.getResult(
						CommerceWarehouseModelImpl.ENTITY_CACHE_ENABLED,
						CommerceWarehouseImpl.class,
						commerceWarehouse.getPrimaryKey()) == null) {
				cacheResult(commerceWarehouse);
			}
			else {
				commerceWarehouse.resetOriginalValues();
			}
		}
	}
729067
function resetCache()
    {
        if ( $this->CacheFile && file_exists( $this->CacheFile ) )
            unlink( $this->CacheFile );
        if ( $this->PlacementCacheFile && file_exists( $this->PlacementCacheFile ) )
            unlink( $this->PlacementCacheFile );
    }