Removes all keys and values in the L2 and L1 caches
320118
@ManagedOperation
    public void clear() {
        Set<K> keys=new HashSet<>(l2_cache.getInternalMap().keySet());
        mcastClear(keys, false);
    }
218121
def clear(self) -> None:
        

        LOGGER.debug('SchemaCache.clear >>>')

        self._schema_key2schema = {}
        self._seq_no2schema_key = {}

        LOGGER.debug('SchemaCache.clear <<<')
516487
private void clearCachedEncodings() {

        cachedEncodedString = null;
        cachedPartialEncodedString = null;

        for (int i = 0; i < cachedEncoding.length; i++)
            cachedEncoding[i] = null;
    }
52376
def clear_cache():
        """"""
        del Cache._keys
        for k in list(Cache._cache.keys()):
            it = Cache._cache.pop(k)
            del it
        del Cache._cache
        Cache._keys = []
        Cache._cache = {}
        gc.collect()
869009
private void cleanupLists(PrefixKey key) {
    // Remove expired list entries. Keep track of the last list removed.
    NavigableMap<PrefixKey, CacheValue<Object>> head = prefixMap.headMap(key, true).descendingMap();
    Iterator<Entry<PrefixKey, CacheValue<Object>>> headItr = head.entrySet().iterator();
    Entry<PrefixKey, CacheValue<Object>> last = null;

    while (headItr.hasNext()) {
      Entry<PrefixKey, CacheValue<Object>> entry = headItr.next();
      if (isExpired(entry.getValue()) && key.isParent(entry.getKey())) {
        last = entry;
        headItr.remove();
      }
    }

    // If a list was removed, check its contained items for expiration.
    if (last != null) {
      SortedMap<PrefixKey, CacheValue<GoogleCloudStorageItemInfo>> prefix =
          getPrefixSubMap(itemMap, last.getKey());
      prefix.entrySet().removeIf(entry -> isExpired(entry.getValue()));
    }
  }
1192979
def clear(self):
        
        for f in [x['content'] for x in self.metadata.values()]:
            os.remove(f)

        self.metadata = {}
        self._flush()
1274379
def clean_cache(cached, **kwargs):
    "  "

    if isinstance(cached, basestring):
        cached = _str_to_model(cached)

    cache_key = generate_cache_key(cached, **kwargs)
    cache.delete(cache_key)
216566
def invalidate_all(self):
        
        for fname in os.listdir(self.cache_path):
            if fname.startswith(self.func.__name__ + "."):
                os.remove(os.path.join(self.cache_path, fname))
45671
def clean(self, *args, **kwargs):
        """"""
        for key in list(self.store.keys()):
            self.unset(key)
1082965
public void clearMemoryCaches() {
    Predicate<CacheKey> allPredicate =
        new Predicate<CacheKey>() {
          @Override
          public boolean apply(CacheKey key) {
            return true;
          }
        };
    mBitmapMemoryCache.removeAll(allPredicate);
    mEncodedMemoryCache.removeAll(allPredicate);
  }
1189532
def clear_cache_fields(self):
        ''''''
        for field in self._meta.scalarfields:
            if field.as_cache:
                setattr(self, field.name, None)
61045
public function clear(): void
    {
        $list = $this->dataRepository->getList()
                ->filterBy('key', $this->keyPrefix, 'startWith');
        foreach ($list as $item) {
            $this->dataRepository->delete($item->key);
        };
    }
894952
public void clear()
  {
    for (int i = 0; i < values.length; i++) {
      keys[i] = DEAD_KEY;
      flags[i] = 0;
      values[i] = null;
    }
    size = 0;
  }
1047049
public static synchronized void clear() {
        for (final Map.Entry<String, Cache> entry : CACHES.entrySet()) {
            final Cache cache = entry.getValue();
            cache.clear();
            LOGGER.log(Level.TRACE, "Cleared cache [name={0}]", entry.getKey());
        }
    }
350450
def clean_cache(self, section=None):
        """"""
        self.remove_all_locks()
        if section is not None and "/" in section:
            raise ValueError("invalid section '{0}'".format(section))
        if section is not None:
            path = os.path.join(self._full_base, section)
        else:
            path = self._full_base
        if not os.path.exists(path):
            return
        shutil.rmtree(path)
615794
public static function _clear()
    {
        if (self::getBackend() == 'memcache') {
            if (!Kwf_Config::getValue('cacheSimpleNamespace')) {
                //increment namespace
                $mc = Kwf_Cache_Simple::getMemcache();
                if ($mc->get(Kwf_Cache_Simple::$uniquePrefix.'cache_namespace')) {
                    $mc->increment(Kwf_Cache_Simple::$uniquePrefix.'cache_namespace');
                }
            } else {
                $mc = Kwf_Cache_Simple::getMemcache();
                $mc->flush();
            }
        } else if (self::getBackend() == 'redis') {
            $prefixLength = strlen(self::getRedis()->_prefix(''));
            $it = null;
            while ($keys = self::getRedis()->scan($it, self::getRedis()->_prefix('simple:*'))) {
                foreach ($keys as $k=>$i) {
                    $keys[$k] = substr($i, $prefixLength);
                }
                self::getRedis()->delete($keys);
            }
        } else if (self::getBackend() == 'file') {
            foreach(glob('cache/simple/*') as $i) {
                unlink($i);
            }
        } else if (self::getBackend() == 'apc' || self::getBackend() == 'apcu') {
            //those are cleared using their own clear-cache type
        } else {
            if (!isset(self::$_zendCache)) self::getZendCache();
            $r = self::$_zendCache->clean(Zend_Cache::CLEANING_MODE_ALL);
        }
    }
819370
public void clear() {
    mMap.forEach((key, value) -> {
      onCacheUpdate(key, value.mValue);
      onRemove(key);
    });
    mMap.clear();
  }