Clear cache data
@param array $arTags
@param string $sKeys
501701
public static function clear($arTags, $sKeys = null)
    {
        $sCacheDriver = config('cache.default');
        if(!empty($arTags)) {
            if($sCacheDriver == 'redis') {
                if(!empty($sKeys)) {
                    Cache::tags($arTags)->forget($sKeys);
                } else {
                    Cache::tags($arTags)->flush();
                }
            } else {
                $sKeys = implode('_', $arTags).'_'.$sKeys;
                Cache::forget($sKeys);
            }
        }
    }
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();
    }
295335
public function clear () : void
    {
        $storage = $this->locator->get(AssetStorage::class);
        $cache = $this->locator->get(AssetsCache::class);

        $storage->removeAllStoredFiles();
        $cache->clear();
    }
654762
function clear() {
        var cache = caches[this.name];
        if (cache && cache.flush && !redisOffline) {
            cache.flush();
        }
    }
579255
public function flushKeysForTags($tags)
    {
        $tags = is_array($tags) ? $tags : func_get_args();

        $cache = $this->getCache();

        $store = $cache->getStore();

        if (! $store instanceof RedisStore) {
            // we can't cache forever in this case. we need sets.
            return;
        }

        $connection = $store->connection();

        foreach ($tags as $tag) {
            $segment = $this->getCacheSegmentKey($tag);

            $this->deleteCacheValues($store->getPrefix().$segment, $connection, $cache);

            $cache->forget($segment);
        }
    }
378686
public function clean(array $conditions): void
	{
		$this->cachedStorage->clean($conditions);
		$this->memoryStorage->clean($conditions);
	}
245896
@Override
	public void clear(final Class<?> clas) {
		this.logger.debug("@clear:".concat(clas.getName()));
		getCachableMap(clas).clear();
	}
990242
protected function clearDynamic(array &$data)
    {
        if (!$this->schema->dynamic) {
            $data = array_intersect_key($data, $this->schema->fields);
        }
    }
58162
public function flush($tags = null)
    {
        $tags = $this->getCacheTags($tags);

        $this->flushKeysForTags($tags);
    }
365303
def clear_association_cache
      self.class.associations[:has_many].each do |assoc|
        instance_variable_set(:"@_her_association_#{assoc[:name]}", nil)
        attributes.delete(assoc[:name].to_s)
      end
    end
687239
public static function clearGroupsAllCaches($caches = false, $groups = false) {
        $caches = self::_getCachesList($caches);
        foreach ($caches as $cache) {
            if (!$groups)//alls groups
                $cache->clearGroups();
            else {//groups list
                if (is_array($groups)) {
                    foreach ($groups as &$group)
                        $cache->clearGroup($group);
                } elseif (is_string($groups))
                    $cache->clearGroup($groups);
            }
        }
    }
465774
public function deleteMulti(array $keys): void
    {
        if ($this->enabled === false) {
            return;
        }

        foreach ($keys as $index) {
            if ($key = $this->cacheIndex[$index] ?? null) {
                unset($this->cacheIndex[$index]);
            } else {
                $key = $index;
            }

            unset($this->cache[$key], $this->cacheExpiryTime[$key], $this->cacheAccessCount[$key]);
        }
    }
1334643
public void clear(Collection keys) {
		synchronized (mirror) {
			synchronized (data) {
				Iterator i = keys.iterator();
				while (i.hasNext()) {
					Object key = i.next();
					data.remove(key);
					mirror.remove(key);
				}
			}
		}
	}
940787
public static function put($arTags, $sKeys, &$arValue, $iMinute)
    {
        $obDate = Carbon::now()->addMinute($iMinute);

        $sCacheDriver = config('cache.default');
        if(!empty($arTags)) {
            if($sCacheDriver == 'redis') {
                Cache::tags($arTags)->put($sKeys, $arValue, $obDate);
                return;
            } else {
                $sKeys = implode('_', $arTags).'_'.$sKeys;
            }
        }

        Cache::put($sKeys, $arValue, $obDate);
    }
704769
public function clearCache()
    {
        \App\Registry::$cache->remove('mmi-cms-navigation-');
        \App\Registry::$cache->remove('mmi-cms-navigation-' . \Mmi\App\FrontController::getInstance()->getRequest()->lang);
        \App\Registry::$cache->remove('mmi-cms-acl');
        return true;
    }
825827
public function clear($prefix = '', $skip_modules = false)
    {
        // Delete from database
        $settings_collection = new SettingEntityRepository();
        if ($prefix) {
            $settings_collection->setWherePrefix($prefix);
        }
        if ($skip_modules) {
            $settings_collection->setSkipModules();
        }

        $settings_collection->deleteObjectCollection();

        // Clear cache
        Cacher::getInstance()->getDefaultCacher()->delete(self::CACHE_KEY);

        return true;
    }
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()