Clear the cache

@return void
356960
public function forget()
    {
        foreach ($this->cachedKeys as $key => $signature)
        {
            if ($this->cache->isExisting($key))
            {
                $this->cache->delete($key);
            }
        }

        $this->cachedKeys = [];
        $this->storeCachedKeys();
    }
370232
public function clear()
    {
        echo $path  = $this->getFilePath();
        $files = glob($path . '*' . $this->fileExtension);

        foreach ($files as $file)
        {
            // if cache file expire, delete cache file
            if ( time() > filemtime($file) )
            {
                @unlink($file);
            }
        }
    }
819370
public void clear() {
    mMap.forEach((key, value) -> {
      onCacheUpdate(key, value.mValue);
      onRemove(key);
    });
    mMap.clear();
  }
724032
public function clearCacheBackend()
    {
        if (class_exists('\OxidEsales\EshopEnterprise\Core\Cache\Generic\Cache')) {
            $oCache = oxNew(\OxidEsales\Eshop\Core\Cache\Generic\Cache::class);
            $oCache->flush();
        }
    }
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);
    }
1036706
public function clearAssetCache()
    {
        foreach ($this->cachedFiles as $hash => $fileData) {
            if (!$this->fileBackend->isWritable($fileData['file'])) {
                continue;
            }
        
            $this->fileBackend->deleteFile($fileData['file']);
        }
        
        $this->cachedFiles = array();
        $this->saveAssetsCache();
    }
806986
public function cache_clear() {
		$cache = WP_CLI::get_cache();

		if ( ! $cache->is_enabled() ) {
			WP_CLI::error( 'Cache directory does not exist.' );
		}

		$cache->clear();

		WP_CLI::success( 'Cache cleared.' );
	}
880856
public function clear()
    {
        $prefix = $this->getDriver()->buildKey([$this->getPoolName(), '*']);

        return (bool)$this->getDriver()->deletePrefix($prefix);
    }
733687
public function clear(): bool
    {
        //TODO: check the need to call
        clearstatcache();
        
        $dh = @opendir($this->cacheDir);
        if (false === $dh) {
            return false;
        }
        
        while (false !== ($entry = readdir($dh))) {
            $file = $this->cacheDir . '/' . $entry;
            if (is_file($file) && 0 !== strpos($entry, '.')) { //exclude .htaccess
                unlink($file);
            }
        }
        
        closedir($dh);
        
        return true;
    }
1352261
def clear(self):
        
        self.log(u"Clearing cache...")
        for file_handler, file_info in self.cache.values():
            self.log([u"  Removing file '%s'", file_info])
            gf.delete_file(file_handler, file_info)
        self._initialize_cache()
        self.log(u"Clearing cache... done")
1351834
public function clear()
    {
        $this->settings = array();
        $this->save($this->path, $this->filename);
        $this->load($this->path, $this->filename);
    }
203162
public function clear()
    {
        try {
            $this->db->from($this->table)->delete();
        } catch (PDOException $e) {
            return false;
        }

        return true;
    }
99594
public function clearCacheAction()
    {
        /* @var $cache FlushableCache */
        $cache = $this->serviceLocator->get('DiCache');

        if ($cache instanceof FlushableCache) {
            $cache->flushAll();
        }

        echo "PHP DI definitions cache was cleared." . PHP_EOL . PHP_EOL;
    }
990962
public function clear()
    {
        foreach(FileUtil::enumAll($this->savePath) as $fileName)
        {
            if(is_file($fileName))
            {
                unlink($fileName);
            }
            else if(is_dir($fileName))
            {
                rmdir($fileName);
            }
        }
    }
714484
public function clearCache()
    {
        $cachePath = $this->cachePath();

        if (!file_exists($cachePath)) {
            return;
        }

        $dir = new RecursiveDirectoryIterator($cachePath, RecursiveDirectoryIterator::SKIP_DOTS);
        $files = new RecursiveIteratorIterator($dir, RecursiveIteratorIterator::CHILD_FIRST);

        foreach($files as $file) {
            $path = $file->getRealPath();
            $file->isDir() ? rmdir($path) : unlink($path);
        }
        rmdir($cachePath);
    }
295335
public function clear () : void
    {
        $storage = $this->locator->get(AssetStorage::class);
        $cache = $this->locator->get(AssetsCache::class);

        $storage->removeAllStoredFiles();
        $cache->clear();
    }
870074
protected function _clearCacheGroup()
    {
        $cacheGroups = (array) $this->getConfig('groups');
        foreach ($cacheGroups as $group) {
            Cache::clearGroup($group, $this->getConfig('config'));
        }
    }