{@inheritDoc}
@see \Psr\Cache\CacheItemPoolInterface::clear()
167508
public final function clear()
   {
       foreach ($this->pool as $value) {
           if (!$this->poolDeleteItem($value)) {
               return false;
           }
       }
       return true;
   }
539569
public void clear() {

        if (m_originalItems != null) {
            m_originalItems.clear();
        }
        m_filteredItems = null;
        synchronized (this) {
            if (m_visibleItems != null) {
                m_visibleItems.clear();
            }
        }
        setSearchFilter("");
        m_sortedColumn = null;
    }
1313923
static function clearStateLimitations( $cacheItem )
    {
        $cachePath = eZSys::cacheDirectory();

        $fileHandler = eZClusterFileHandler::instance();
        $fileHandler->fileDelete( $cachePath, 'statelimitations_' );
        ezpEvent::getInstance()->notify( 'content/state/cache/all' );
    }
867497
protected function clearCache()
    {
        $oldCacheDirName = "{$this->cacheDir}_old";
        $this->fs->rename($this->cacheDir, $oldCacheDirName);
        $this->fs->remove($oldCacheDirName);
    }
1333939
final public function clearCollection()
    {
        $reset = [
            &$this->collection,
            &$this->collectionRaw,
        ];

        foreach ($reset as &$property) {
            $property = [];
        }
    }
1064683
public function clear()
    {
        $keys = array_keys($this->values);
        foreach ($keys as $key)
            unset($this->values[$key]);
        return $this;
    }
1240856
public function clear()
    {
        foreach ($this->objectsRepository as $repository) {
            if ($repository instanceof Repository) {
                $repository->clear();
            }
        }
        parent::clear();
        $this->objectsRepository = [];
    }
58541
public function clear()
    {
        $directory = new \RecursiveIteratorIterator(
            new \RecursiveDirectoryIterator($this->path),
            \RecursiveIteratorIterator::SELF_FIRST
        );

        $cacheIterator = new \RegexIterator($directory, '/^.+\.cache/i', \RecursiveRegexIterator::GET_MATCH);

        $isCleared = false;

        foreach ($cacheIterator as $cacheFiles) {
            foreach ($cacheFiles as $cacheFile) {
                if (false === ($isCleared = unlink($cacheFile))) {
                    return $isCleared;
                    break;
                }
            }
        }

        return $isCleared;
    }
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;
    }
81563
public function clear($key)
    {
        $this->cache->forget($key);

        $this->cache->forget($key .':lockout');
    }
966932
public function clear($cacheDir)
    {
        $fs = new Filesystem();
        $proxyCacheDir = $cacheDir.'/kitpages_proxy';
        if ($fs->exists($proxyCacheDir)) {
            die('here');
            $fs->remove($proxyCacheDir);
        }
    }
24145
public function clear()
    {
        foreach ($this->items as $item) {
            $this->deleted[] = $item;
        }

        $this->items = [];
    }
207221
protected static function _clear($menu)
    {
        if (array_key_exists($menu, self::$_items)) {
            self::$_items[$menu] = [];
        } else {
            throw new \UnexpectedValueException('Invalid menu: ' . $menu);
        }
    }
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);
            }
        }
    }
165867
@Override
    public void clear() {
        List<BaseComponent> items = getChildren();
        
        for (int i = items.size() - 1; i >= 0; i--) {
            if (items.get(i) != customItem) {
                items.get(i).destroy();
            }
        }
    }
214304
public function clearCacheFiles()
    {
        if (false === $this->cache) {
            return;
        }

        foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($this->cache), RecursiveIteratorIterator::LEAVES_ONLY) as $file) {
            if ($file->isFile()) {
                @unlink($file->getPathname());
            }
        }
    }
810267
public function clear() {
        $this->nested = [];
        $this->getter = null;
        $this->setter = null;
        return $this;
    }