Invalidate the RouteMap caches
503603
public function invalidateCache()
    {
        $cache = Craft::$app->getCache();
        TagDependency::invalidate($cache, self::ROUTEMAP_CACHE_TAG);
        Craft::info(
            'Route Map cache cleared',
            __METHOD__
        );
    }
398774
public void invalidateAll(Iterable<P> principals) {
        final Set<P> principalSet = Sets.of(principals);
        final Set<ImmutablePair<P, String>> keys = cache.asMap().keySet().stream()
                .filter(cacheKey -> principalSet.contains(cacheKey.getLeft()))
                .collect(Collectors.toSet());
        cache.invalidateAll(keys);
    }
1315688
public function invalidateCache()
    {
        if ($this->cache) {
            $cacheId = $this->_getCacheId();
            $this->cache->remove($cacheId);
        }
        return $this;
    }
465199
def invalidate_cache_after_error(f):
    
    @wraps(f)
    def wrapper(self, *args, **kwds):
        try:
            return f(self, *args, **kwds)
        except Exception:
            self.clear_cluster_nodes_cache()
            raise
    return wrapper
1078624
protected void reset() {
        for (RouteMap.Entry<String, RouteAsImpl> e = this.route.head(), end = this.route.tail(); (e = e.getNext()) != end;) {
            String key = e.getKey();
            RouteAsImpl routeAs = e.getValue();
            routeAs.setM3uaManagement(this.m3uaManagement);
            routeAs.reset();

            As[] asList = routeAs.getAsArray();

            try {
                String[] keys = key.split(KEY_SEPARATOR);
                int dpc = Integer.parseInt(keys[0]);
                for (count = 0; count < asList.length; count++) {
                    AsImpl asImpl = (AsImpl) asList[count];
                    if (asImpl != null) {
                        this.addAsToDPC(dpc, asImpl);
                    }
                }
            } catch (Exception ex) {
                logger.error(String.format("Error while adding key=%s to As list=%s", key, Arrays.toString(asList)));
            }
        }
    }
1343357
public void invalidateAll(Predicate<? super C> predicate) {
        final Set<C> keys = cache.asMap().keySet().stream()
                .filter(predicate)
                .collect(Collectors.toSet());
        cache.invalidateAll(keys);
    }
576042
@Delete
    public Maybe<Boolean> invalidateCaches() {
        return Flowable.fromIterable(cacheManager.getCacheNames())
                .map(cacheManager::getCache)
                .flatMap(c ->
                        Publishers.fromCompletableFuture(() -> c.async().invalidateAll())
                ).reduce((aBoolean, aBoolean2) -> aBoolean && aBoolean2);
    }
628555
static public function flushRoutesCache()
    {
        $cachePath = Config::getCommon('router.cache_file');
        if (FileHelper::delete($cachePath)) {
            return ErrorInfo::success('flush routes cache success');
        } else {
            return ErrorInfo::error('flush routes cache fail, please check config[router.cache_file]');
        }
    }
1026684
def invalidate(self, key):
        """"""
        if key not in self.data:
            return
        del self.data[key]

        # Find all components that used it and invalidate their results
        for cname in self.components:
            if key in self.depends[cname]:
                for downstream_key in self.provides[cname]:
                    self.invalidate(downstream_key)
1302251
protected function flushCache(array $invalidates): void
    {
        if (\count($invalidates) > 0) {
            if ($this->cache instanceof AdapterInterface && null !== $this->context) {
                $this->cache->clearByPrefixes($invalidates);
            } elseif (null !== $this->cache) {
                $this->cache->clear();
            }

            if ($this->sim instanceof CacheSecurityIdentityManagerInterface) {
                $this->sim->invalidateCache();
            }
        }
    }
767206
protected void clearCaches(CmsEvent event) {

        // synchronization of this method is not required as the individual maps are all synchronized maps anyway,
        // and setExportnames() is doing it's own synchronization

        // flush all caches
        m_cacheOnlineLinks.clear();
        m_cacheExportUris.clear();
        m_cacheSecureLinks.clear();
        m_cacheExportLinks.clear();
        m_exportnameResources = null;
        if (LOG.isDebugEnabled()) {
            LOG.debug(Messages.get().getBundle().key(Messages.LOG_FLUSHED_CACHES_1, new Integer(event.getType())));
        }
    }
1200183
public void invalidate(TemplateClass parent) {
        if (mode().isProd()) return;
        Set<TemplateClass> children = extendMap.get(parent);
        if (null == children) return;
        for (TemplateClass child : children) {
            invalidate(child);
            child.reset();
        }
    }
1272313
def invalidate(self, *raw_args, **raw_kwargs):
        
        args = self.prepare_args(*raw_args)
        kwargs = self.prepare_kwargs(**raw_kwargs)
        key = self.key(*args, **kwargs)
        item = self.cache.get(key)
        if item is not None:
            expiry, data = item
            self.store(key, self.timeout(*args, **kwargs), data)
            self.async_refresh(*args, **kwargs)
266574
void invalidateToStringCache() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "invalidateToStringCache");

        // Invalidate the toString cache.
        cachedToString = null;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "invalidateToStringCache");
    }
96295
function clearCache() {
  require('./AboutTable.js').clearCache();
  require('./CalendarTable.js').clearCache();
  require('./HolidayTable.js').clearCache();
  require('./LineGraphTable.js').clearCache();
  require('./LinksTable.js').clearCache();
  require('./RouteGraphTable.js').clearCache();
  require('./RoutesTable.js').clearCache();
  require('./StopsTable.js').clearCache();
  require('./StopTimesTable.js').clearCache();
  require('./TripsTable.js').clearCache();
}
1169557
function reset(route) {

		// Resolve module location from given path
		const filename = _require.resolve(route);

		// Load it into memory
		_require(filename);

		// Remove all children from memory, recursively
		shidu(filename);

		// Remove module from memory as well
		delete _require.cache[filename];

		// Return exports value
		return _require(filename);
	}
622504
public function invalidateBrowserCache() {
        $this->response->headers->set('Cache-Control','nocache, no-store, max-age=0, must-revalidate');
        $this->response->headers->set('Pragma','no-cache');
        $this->response->headers->set('Expires','Fri, 01 Jan 1970 00:00:00 GMT');
    }