Clear caches to force a reload.
327116
def reset(self):
        ""
        self._page_cache.clear()
        self._direct_lookup_cache.clear()
        self._page_offset = 0
        self.complete = self._catalog.page_size is None
672246
public function resetCache() {
		// only reset caches if cache link is present
		if (!empty($this->db_object->object->options['cache_link'])) {
			$tags = array_unique($this->cache_tags);
			sort($tags, SORT_STRING);
			$hash = sha1(serialize($tags));
			\Cache::$reset_caches[$this->db_object->object->options['cache_link']][$hash] = $tags;
		}
	}
750682
public function reset()
	{
		$this->meta = false;
		$this->file = false;
		$this->content = false;
		$this->changed = false;
		$this->ttl = 0;
		$this->cacheHash = null;
	}
687321
def reload(force=false)
      raise ArgumentError, 'Argument must be true or false.' unless [true, false].include?(force)
      if force || reload?
        flush_cache
        return true
      end
      false
    end
705351
def clear_cache(self):
        """"""
        for cmd in (self.cat_file_all, self.cat_file_header):
            if cmd:
                cmd.__del__()

        self.cat_file_all = None
        self.cat_file_header = None
        return self
1254707
protected static function reset_caches() {
        self::$cache_contextsbyid = array();
        self::$cache_contexts     = array();
        self::$cache_count        = 0;
        self::$cache_preloaded    = array();

        self::$systemcontext = null;
    }
1313009
function unload() {
    u.each(opts.sources, function(source) {
      if (source.src && source.src.unref) { source.src.unref(); }
      if (source.cache && source.cache.unref) { source.cache.unref(); }
    });
    u.each(opts.outputs, function(output) {
      if (output.output && output.output.cancel) { output.output.cancel(); }
    });
    if (generator.reload && generator.reload.cancel) { generator.reload.cancel(); }
    if (generator.clientSave && generator.clientSave.cancel) { generator.clientSave.cancel(); }
  }
1260621
def reset(self, force_flush_cache: bool = False) -> None:
        
        super(LDAPwrapper, self).reset()
        if len(self._transactions) == 0:
            raise RuntimeError("reset called outside a transaction.")
        self._transactions[-1] = []
528657
def invalidate_caches(cls):
        """"""
        for finder in sys.path_importer_cache.values():
            if hasattr(finder, 'invalidate_caches'):
                finder.invalidate_caches()
885798
def force_invalidate(self, cache_key):
    """"""
    try:
      if self.cacheable(cache_key):
        os.unlink(self._sha_file(cache_key))
    except OSError as e:
      if e.errno != errno.ENOENT:
        raise
271132
public function clearCache()
  {
    $files = glob($this->cachePath);
    foreach($files as $file) {
      if (is_file($file)) {
        unlink($file);
      }
    }
  }
596542
public void clearAllCaches() {
        logger.warn("beginning request to clear all caches");
        for (final String cacheName : this.cacheManager.getCacheNames()) {
            clearCache(cacheName);
        }
        logger.warn("completed request to clear all caches");
    }
1010019
def clear_caches():  # suppress(unused-function)
    """"""
    for _, reader in _spellchecker_cache.values():
        reader.close()

    _spellchecker_cache.clear()
    _valid_words_cache.clear()
    _user_dictionary_cache.clear()
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)
819370
public void clear() {
    mMap.forEach((key, value) -> {
      onCacheUpdate(key, value.mValue);
      onRemove(key);
    });
    mMap.clear();
  }
295784
def refresh_cache(self, if_want_update=False):
        """"""
        for thread in tuple(self._thread_cache.values()):
            if if_want_update:
                if not thread.want_update:
                    continue
            thread.update()
17479
def clear_cache(self):
        """"""
        self.raw_packet_cache = None
        for _, fval in six.iteritems(self.fields):
            if isinstance(fval, Packet):
                fval.clear_cache()
        self.payload.clear_cache()