trigger a clear cache on all related articles.
516360
public function ClearCacheOnAllAffectedArticles()
    {
        $iStartOperation = time();
        $aArticleRestrictions = $this->GetMLTIdList('shop_article_mlt');
        foreach ($aArticleRestrictions as $sArticelId) {
            TCacheManager::PerformeTableChange('shop_article', $sArticelId);
        }

        $aCategoryRestrictons = $this->GetMLTIdList('shop_category_mlt');
        $databaseConnection = $this->getDatabaseConnection();
        if (count($aCategoryRestrictons) > 0) {
            $quotedCategoryRestrictions = implode(',', array_map(array($databaseConnection, 'quote'), $aCategoryRestrictons));
            $query = "SELECT `shop_article`.`id`
                    FROM `shop_article`
               LEFT JOIN `shop_article_shop_category_mlt` ON `shop_article`.`id` = `shop_article_shop_category_mlt`.`source_id`
                   WHERE `shop_article`.`shop_category_id` IN ($quotedCategoryRestrictions)
                      OR `shop_article_shop_category_mlt`.`target_id` IN ($quotedCategoryRestrictions)
                GROUP BY `shop_article`.`id`
                 ";
            $tRes = MySqlLegacySupport::getInstance()->query($query);
            while ($aRes = MySqlLegacySupport::getInstance()->fetch_assoc($tRes)) {
                TCacheManager::PerformeTableChange('shop_article', $aRes['id']);
            }
        }

        if (0 === count($aArticleRestrictions) && 0 === count($aCategoryRestrictons)) {
            TCacheManager::PerformeTableChange('shop_article', null);
        }

        $databaseConnection->update($this->table, array(
            'cache_clear_last_executed' => date('Y-m-d H:i:s', $iStartOperation),
        ), array(
            'id' => $this->id,
        ));
    }
1132467
final void clear() {
        while (!resolveCache.isEmpty()) {
            for (Iterator<Entry<String, Entries>> i = resolveCache.entrySet().iterator(); i.hasNext();) {
                Map.Entry<String, Entries> e = i.next();
                i.remove();

                e.getValue().clearAndCancel();
            }
        }
    }
493547
def Flush(self):
    """"""
    if self._dirty:
      self.Set(self.Schema.SIZE(self.size))
      if self.content_last is not None:
        self.Set(self.Schema.CONTENT_LAST, self.content_last)

    # Flushing the cache will write all chunks to the blob store.
    self.chunk_cache.Flush()
    super(AFF4ImageBase, self).Flush()
406005
def recent_articles(limit=10, exclude=None):
    """"""
    queryset = Article.objects.filter(published=True).order_by('-modified')
    if exclude:
        if hasattr(exclude, '__iter__'):
            queryset = queryset.exclude(pk__in=exclude)
        else:
            queryset = queryset.exclude(pk=exclude)
    return queryset
599976
public function clear()
    {
        $url = UrlHelper::buildUrl(Urls::URL_QUERY_CACHE, []);
        $this->getConnection()->delete($url);
    }
1354239
protected function _delete_all_cache() {
		$sidebars_widgets = wp_get_sidebars_widgets();
		$sidebars = array_keys( $sidebars_widgets );

		foreach ( $sidebars as $sidebar_id ) {
			if ( ! static::_is_caching_sidebar( $sidebar_id ) ) {
				continue;
			}

			delete_transient( static::get_transient_id( $sidebar_id ) );
		}
	}
262966
public function clear()
    {
        $files=@scandir($this->getCacheDir());
        foreach ($files as $file){
            if($file != "." && $file != ".."){
                $file=$this->getCacheDir().$file;
                @unlink($file);
            }
        }
    }
1367210
public function clear()
    {
        $this->metaTags = [];
        $this->linkTags = [];
        $this->css = [];
        $this->cssFiles = [];
        $this->js = [];
        $this->jsFiles = [];
        static::$constants = [];
        $this->placeholders = [];
    }
295478
protected function clearCaches()
    {
        $this->callSilent('clear-compiled');
        $this->callSilent('cache:clear');
        $this->callSilent('route:clear');
        $this->callSilent('config:clear');
        $this->callSilent('view:clear');
        Cache::flush();
    }
831991
public function clear()
	{
		if( $this->prefix ) {
			$this->object->flushByTag( $this->prefix . 'siteid' );
		} else {
			$this->object->flush();
		}
	}
1129170
def _cleanup(self):  # pragma: no cover
        
        need_to_delete = []  # can't delete from a dict while iterating
        with self.attr_lock:
            now_time = time()
            for path in self.cache:
                if now_time - self.attr[path][TIMESTAMP_KEY] >= MAX_CACHE_TIME:
                    need_to_delete.append(path)
            for path in need_to_delete:
                del self.attr[path]
                del self.cache[path]
734780
function clearCache() {
  cache_stopById.clear();
  cache_stopByName.clear();
  cache_stopByStatusId.clear();
  cache_stops.clear();
  cache_stopsByRoute.clear();
}
707245
private function clearAllCaches()
    {
        $this->clearCache(self::CACHE_KEY_CSS);
        $this->clearCache(self::CACHE_KEY_SELECTOR);
        $this->clearCache(self::CACHE_KEY_XPATH);
        $this->clearCache(self::CACHE_KEY_CSS_DECLARATIONS_BLOCK);
        $this->clearCache(self::CACHE_KEY_COMBINED_STYLES);
    }
1041774
def sync(self):
        """"""
        if self.writeback and self.cache:
            super(_TimeoutMixin, self).__delitem__(self._INDEX)
            super(_TimeoutMixin, self).sync()
            self.writeback = False
            super(_TimeoutMixin, self).__setitem__(self._INDEX, self._index)
            self.writeback = True
        if hasattr(self.dict, 'sync'):
            self.dict.sync()
90712
def reset_all(self):
        """"""

        self._LOG.debug("Marking all CMs as Good.")

        for key in self.list:
            self.mark_good(key)
523579
public void clearCache() {
        File cacheDir = getCacheDir();
        if (cacheDir.exists()) {
            File[] files = cacheDir.listFiles();
            if (files != null) {
                for (File child : files) {
                    deleteFilesRecursively(child);
                }
            }
        }
    }
65025
public function clearCache() {
        $files = glob($this->getConfig('cacheDir') . '/*', GLOB_MARK);
        foreach ($files as $file) {
            unlink($file);
        }
    }