Deletes an item from the cache

@param  string $sKey The cache key

@return boolean
772889
protected function unsetCache($sKey)
    {
        if (!static::$CACHING_ENABLED) {
            return false;
        } elseif (empty($sKey)) {
            return false;
        }

        $iCacheIndex = $this->getCache($sKey, false);
        if (is_null($iCacheIndex)) {
            return false;
        }

        unset($this->aCache[$iCacheIndex]);

        return true;
    }
1283898
public function clear($sKey)
    {
        if (empty($sKey) || empty($this->arStore) || !isset($this->arStore[$sKey])) {
            return;
        }

        unset($this->arStore[$sKey]);
    }
229080
public function delete($key){
        $this->connection->where('keyCache = :key', array('key' => $key));
        return $this->connection->delete($this->table);
    }
1103445
public function remove($sKey)
    {
        if ($this->contains($sKey)) {
            $mRes = $_SESSION[$sKey];
            unset($_SESSION[$sKey]);
            return $mRes;
        } else {
            return null;
        }
    }
354388
public function remove($key)
    {
        $this->initializeOnDemand();

        if ($this->has($key) && $this->cacheMapper->delete($key)) {
            unset($this->cache[$key]);
            return true;
        } else {
            return false;
        }
    }
1363203
public function delete($key) {
        $filename = $key.'.cache';
        $file = $this->file_path_for_key($key);
        if (@unlink($file)) {
            unset($this->keys[$filename]);
            return true;
        }

        return false;
    }
428666
public function save($sKey)
    {
        if (empty($sKey)) {
            return $this;
        }

        $sKey = static::class.'@'.$sKey;
        CollectionStore::instance()->save($sKey, $this);

        return $this->returnThis();
    }
309606
public final function deleteItem($key)
   {
       try {
           if (!$this->hasItem($key)
            || !$this->poolDeleteItem($this->pool[$key])) {
               return false;
           }
           unset($this->pool[$key]);
       } catch (InvalidArgumentException $e) {
           throw $e;
       }
       return true;
   }
607052
public function deleteHasCache($key)
    {
        if ($this->isCachable()) {
            return Yii::$app->cache->delete($key);
        }
        
        return false;
    }
77172
public function delete($key)
    {
        if (!$object = $this->tryGetObject($key)) {
            return false;
        }

        try {
            $object->delete();
        } catch (DeleteError $deleteError) {
            return false;
        }

        return true;
    }
76028
public function deleteValue($key)
    {
        $this->ssdbHandle->hdel($this->cache_keys_hash, $key);
        return $this->ssdbHandle->del($key);
    }
340158
public function delete($key)
    {
        if (true === array_key_exists($key, $this->cache)) {
            unset($this->cache[$key]);

            return true;
        }

        return false;
    }
311734
public function delete($key)
    {
        if ($this->redis->hDel($this->prefix, $key) > 0) {
            return true;
        }
        return false;
    }
1148035
public function IsReservedKey( $sKey )
	{
		$bRet	= false;

		if ( CLib::IsExistingString( $sKey, true ) )
		{
			$sKey	= strtolower( trim( $sKey ) );
			$bRet	= in_array( $sKey, self::ARR_RESERVED_KEYS );
		}

		return $bRet;
	}
1132672
public function delete($key)
    {

        $deleted = false;

        $catalog = \array_keys($this->getKeys());
        foreach ($catalog as $k) {

            if (substr($k, 0, strlen($key)) == $key) {

                $delete = $this->memcache->delete($this->namespace . $key);
                if ($delete) {
                    $this->catalogKeyDelete($k);
                    $deleted = true;
                }
            }
        }

        return $deleted;
    }
306821
protected function deleteValue($key)
    {
        $this->db->createCommand()
            ->delete($this->cacheTable, ['id' => $key])
            ->execute();

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