This will wipe out the entire cache's keys....

@return  boolean  The result of the clear operation.

@since   1.0
329418
public function clear()
	{
		$filePath = $this->options['file.path'];
		$this->checkFilePath($filePath);

		$iterator = new \RegexIterator(
			new \RecursiveIteratorIterator(
				new \RecursiveDirectoryIterator($filePath)
			),
			'/\.data$/i'
		);

		/* @var  \RecursiveDirectoryIterator  $file */
		foreach ($iterator as $file)
		{
			if ($file->isFile())
			{
				@unlink($file->getRealPath());
			}
		}

		return true;
	}
1305714
public function clear()
    {
        foreach ($this->filesystem()->listContents() as $file) {
            $this->filesystem()->delete($file['path']);
        }

        return true;
    }
984211
public function clear()
    {
        $result = false;
        if (false !== $files = @scandir($this->cachedir)) {
            foreach ($files as $file) {
                $file = $this->cachedir.DIRECTORY_SEPARATOR.$file;
                if (false === is_dir($file)) {
                    if (false === @unlink($file)) {
                        $this->log('warning', sprintf('Enable to remove cache file `%s`.', $file));
                    } else {
                        $result = true;
                    }
                }
            }
        }

        if (true === $result) {
            $this->log('debug', sprintf('File system cache cleared in `%s`.', $this->cachedir));
        }

        return $result;
    }
1056936
public function clear()
    {
        $keys = eaccelerator_list_keys();
        if (is_array($keys)) {
            foreach ($keys as $info) {
                // eaccelerator bug (Http://eaccelerator.net/ticket/287)
                if (0 === strpos($info['name'], ':')) {
                    $key = substr($info['name'], 1);
                } else {
                    $key = $info['name'];
                }

                if (!eaccelerator_rm($key)) {
                    return false;
                }
            }
        }

        return true;
    }
287357
public function removeAll()
    {
        $this->instance->unlock();
        $result = $this->instance->removeAll();
        $this->instance->lock();
        return $result;
    }
1187704
protected function clearAllObjectsFromCacheCluster()
    {
        $nodes = $this->cache->_masters();

        foreach ($nodes as $node) {
            if (!$this->cache->flushDB($node)) {
                return false;
            }
        }

        return true;
    }
523370
public function expireAll()
    {
        if (!$this->enabled)
            return true;

        $this->Logger->debug('Expire all keys');

        $apcMethod = $this->apcFuncPrefix.'_clear_cache';
        $apcMethod();

        return $apcMethod('user');
    }
1133355
public function clearCache()
    {
        $objects = scandir($this->getCachePath());
        $dir = $this->getCachePath();
        foreach ($objects as $object) {
            if ($object != "." && $object != "..") {
                if (is_dir($dir.$object)) {
                    self::rrmdir($dir.$object);
                } elseif ($object !== 'cache_config') {
                    unlink($dir.$object);
                }
            }
        }

        return $this;
    }
671638
public function clean() : void
    {
        foreach ($this->retrieveAllKeys() as $k) {
            $this->remove((string)$k);
        }
    }
437069
public function clearAll()
    {
        $path  = $this->getFilePath();
        $files = glob($path . '*' . $this->fileExtension);

        foreach ($files as $file)
        {
            @unlink($file);
        }

        static::$keys = [];
    }
1038246
public function clear() {
		if ( ! $this->enabled ) {
			return false;
		}

		$finder = $this->get_finder();

		foreach ( $finder as $file ) {
			unlink( $file->getRealPath() );
		}

		return true;
	}
62629
public function forget()
    {
        foreach ($this->cachedKeys as $key => $signature)
        {
            if ($this->cache->has($key))
            {
                $this->cache->forget($key);
            }
        }

        $this->cachedKeys = [];
        $this->storeCachedKeys();
    }
97043
public static function clear()
    {
        $isClearAll = true;
        if ($_COOKIE) {
            foreach ($_COOKIE as $key => $value) {
                $result = self::delete($key);
                if (!$result) {
                    $isClearAll = false;
                }
            }
        }
        return $isClearAll;
    }
824727
public function removeAll()
    {
        $aRes = array();
        foreach ($this->getKeys() as $sKey) {
            $aRes[$sKey] = $this->remove($sKey);
        }
        return $aRes;
    }
1235958
public function clear()
	{
		foreach( $GLOBALS[$this->poolKey] as $key => $value )
			unset( $GLOBALS[$this->poolKey][$key] );
	}
858639
public function clear()
	{
		$cvars = get_class_vars(__CLASS__);

		$this->_updatedkeys = array();

		foreach ($cvars as $key => $value)
		{
			if ($key{0} != '_')
			{
				unset($this->$key);

				$this->$key = null;
			}
		}

		$this->_updatedkeys = array();
	}
753856
public function clear()
    {
        $max = xcache_count(XC_TYPE_VAR);
        for ($index = 0; $index < $max; $index++) {
            if (!xcache_clear_cache(XC_TYPE_VAR, $index)) {
                return false;
            }
        }

        return true;
    }