Purge cached entries.  If the cache is an array it will purge all entries matching the
supplied key (or sub keys)

@param $cacheKey
510907
public function purgeCachedFiles($cacheKey) {
        // Get directory and filename
        list($directory, $filename) = $this->getDirectoryAndFilenameFromKey($cacheKey);

        // Remove the directory
        passthru("rm -rf " . $directory . "/" . $filename);

    }
585798
public function purge($key) {
		if ($this->log) {
			if ($this->log instanceof LoggerInterface) {
				$this->log->info("Purging key '{key}' from file cache.", array('key'=>$key));
			} else {
				$this->log->trace("Purging key '$key' from file cache.");
			}
		}
		$filename = $this->getFileName($key);
		if (file_exists($filename)) {
			unlink($filename);
		}
	}
575887
public function delete($key)
    {
        $cache_file = $this->path($key);
        if (file_exists($cache_file)) {
            $unlink_result = unlink($cache_file);
            if ($unlink_result === false) return false;
        }

        return true;
    }
621161
public function clear($commandKey, $cacheKey)
    {
        if ($this->exists($commandKey, $cacheKey)) {
            unset($this->cachedResults[$commandKey][$cacheKey]);
        }
    }
681481
public function forget($key)
    {
        $this->fire('forgetting', $key, [$key]);

        $generatedKey = $this->getKey($key);

        $this->repository->forget($generatedKey);

        if ($this->isCacheEnabled()) {
            $this->cache->forget($generatedKey);
        }

        $this->fire('forget', $key, [$key]);

        $this->context(null);
    }
425619
public function find($cacheKey)
    {
        $key = array_search($cacheKey, $this->cachedKeys);

        if ($key != false and ! $this->cache->has($key))
        {
            unset($this->cachedKeys[$key]);
            $this->storeCachedKeys();

            return false;
        }

        return $key ? $this->cache->get($key) : false;
    }
482831
protected function pruneCache($cache)
    {
        if (count($this->cache[$cache]) == $this->maxCacheSize) {
            $this->cache[$cache] = array_slice($this->cache[$cache], $this->maxCacheSize * 0.2);
        }
    }
913826
public function clear(CacheKey $key) {
		if (isset ( $this->elements [$key->getModule()] [$key->getProperty()] )) {
			unset ( $this->elements [$key->getModule()] [$key->getProperty()] );
			$this->changed = true;
		}
	}
952813
public function purge($key) {
		if ($this->log != null) {
			if ($this->log instanceof LoggerInterface) {
				$this->log->info("Purging key '{key}' from no-cache. Nothing to purge.", array('key'=>$key));
			} else {
				$this->log->trace("Purging key '$key' from no-cache. Nothing to purge.");
			}
		}
	}
1374363
function clear($key) {
		// Normalize array literal
		$cache=Cache::instance();
		$parts=$this->cut($key);
		if ($key=='CACHE')
			// Clear cache contents
			$cache->reset();
		elseif (preg_match('/^(GET|POST|COOKIE)\b(.+)/',$key,$expr)) {
			$this->clear('REQUEST'.$expr[2]);
			if ($expr[1]=='COOKIE') {
				$parts=$this->cut($key);
				$jar=$this->hive['JAR'];
				unset($jar['lifetime']);
				$jar['expire']=0;
				call_user_func_array('setcookie',
					array_merge([$parts[1],NULL],$jar));
				unset($_COOKIE[$parts[1]]);
			}
		}
		elseif ($parts[0]=='SESSION') {
			if (!headers_sent() && session_status()!=PHP_SESSION_ACTIVE)
				session_start();
			if (empty($parts[1])) {
				// End session
				session_unset();
				session_destroy();
				$this->clear('COOKIE.'.session_name());
			}
			$this->sync('SESSION');
		}
		if (!isset($parts[1]) && array_key_exists($parts[0],$this->init))
			// Reset global to default value
			$this->hive[$parts[0]]=$this->init[$parts[0]];
		else {
			eval('unset('.$this->compile('@this->hive.'.$key).');');
			if ($parts[0]=='SESSION') {
				session_commit();
				session_start();
			}
			if ($cache->exists($hash=$this->hash($key).'.var'))
				// Remove from cache
				$cache->clear($hash);
		}
	}
106596
public function removeCacheControlDirective(string $key)
    {
        unset($this->cacheControl[$key]);
        $this->owner->getHeaders()->set('Cache-Control', $this->getCacheControlHeader());
    }
873607
public function remove($key) {
        X::logger()->trace("CCache remove $key");
        $file = $this->key2file($key);
        if (is_file($file)) {
            unlink($file);
            return true;
        }
        return false;
    }
820925
public function remove($key)
    {
        $keyGen = $this->generateKey($key);
        $this->cache->remove($keyGen);
        @unlink($this->getFilePath($keyGen));
    }
1282553
public function forget($key)
    {
        $contents = $this->getContents();
        Arr::forget($contents, $key);

        $this->saveContents($contents);
    }
294730
public static function expires($cacheloc, $cachekey)
    {
        $cacheloc = "cache_" . $cacheloc;
        if ( isset($_SESSION[$cacheloc]) ) {
            $cache_row = $_SESSION[$cacheloc];
            if ( time() >= $cache_row[2] ) { 
                unset($_SESSION[$cacheloc]);
                return false;
            }
            if ( $cache_row[0] != $cachekey ) return false;
            if ( $cache_row[0] === false ) return false;
            return $cache_row[2] - time();
        }
        return false;
    }
1295908
public function delete($key)
    {
        $query = sprintf('DELETE FROM `%s` WHERE `key` = :key', $this->table);
        $stmt = $this->pdo->prepare($query);

        return $stmt->execute(array(
            ':'.ConstProviderInterface::CACHE_PARAM_KEY => $key,
        ));
    }
1166543
public function purge($key) {
		
		if ($this->useFallback) {
			if ($this->log) {
				$this->log->trace("Purging key '$key' from file cache.");
			}
			$filename = $this->getFileName($key);
			unlink($filename);
			return;
		}
	
		if ($this->log) {
			$this->log->trace("Purging key '$key' from APC cache.");
		}
	
		apc_delete($key);
	}