Delete the cache entry for a given key.

@param key
@throws VictimsException
509300
public void delete(String key) throws VictimsException {
        key = hash(key);
        try {
            FileUtils.forceDelete(FileUtils.getFile(location, key));
        } catch (IOException e) {
            throw new VictimsException(String.format(
                    "Could not delete the cached entry from disk: %s", key), e);
        }
    }
60181
public final void deleteWithNoReply(final String key, final int time)
      throws InterruptedException, MemcachedException {
    try {
      this.delete0(key, time, 0, true, this.opTimeout);
    } catch (TimeoutException e) {
      throw new MemcachedException(e);
    }
  }
547204
public void removeTarget(Object key) throws MatchingException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc,
                  "removeTarget",
                  new Object[]{key});
    // Remove from the HashMap, with synch, there may be other accessors
    synchronized(_targets)
    {
      Target targ = (Target) _targets.get(key);
      if (targ == null)
        throw new MatchingException();
      for (int i = 0; i < targ.targets.length; i++)
        _matchSpace.removeTarget(targ.expr[i], targ.targets[i]);

      // Now remove the Target from the cache
      _targets.remove(key);

      // Remove from the Monitor state, with synch, there may be other accessors
      if(targ.targets.length > 0) // Defect 417084, check targets is non-empty
      {
        if(targ.targets[0] instanceof MonitoredConsumer)
          _consumerMonitoring.removeConsumer((MonitoredConsumer)targ.targets[0]);
      }
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "removeTarget");
  }
84311
void removeEntry(NodeId nodeId) throws Exception {
		this.entryCache.remove(nodeId);
		this.entries.remove(nodeId);
	}
405202
public void add(String key, Collection<String> cves)
            throws VictimsException {
        key = hash(key);

        if (exists(key)) {
            delete(key);
        }

        String result = "";
        if (cves != null) {
            result = StringUtils.join(cves, ",");
        }

        try {
            FileOutputStream fos = new FileOutputStream(FileUtils.getFile(
                    location, key));
            try {
                fos.write(result.getBytes());
            } finally {
                fos.close();
            }
        } catch (IOException e) {
            throw new VictimsException(String.format(
                    "Could not add disk entry for key: %s", key), e);
        }

    }
632492
public void delete(int key) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            System.arraycopy(mKeys, i + 1, mKeys, i, mSize - (i + 1));
            System.arraycopy(mValues, i + 1, mValues, i, mSize - (i + 1));
            mSize--;
        }
    }
772277
public function forget(string $key)
    {
        $cacheKey = $this->cacheKeys[$key] ?? null;
        if (!empty($cacheKey)) {
            Cache::forget($cacheKey);
        }
    }
737251
public void remove(Object key) {
		for (Scope cur=this; cur!=null; cur=cur.parent) {
			if (cur.data != null && cur.data.containsKey(key)) {
				cur.data.remove(key);
				return ;
			}
		}
	}
713806
public void purge() throws VictimsException {
        try {
            File cache = new File(location);
            if (cache.exists()) {
                FileUtils.deleteDirectory(cache);
            }
            create(cache);
        } catch (IOException e) {
            throw new VictimsException("Could not purge on disk cache.", e);
        }
    }
281582
public void delete(final K key) throws DataAccessException {
        jdbcTemplate.execute(new ConnectionCallback<Object>() {
            @Override
            public Object doInConnection(Connection connection) throws SQLException, DataAccessException {
                crud.delete(connection, key);
                return null;
            }
        });
    }
595098
public void deleteObject(String key) throws QiniuException {
    com.qiniu.http.Response response = mBucketManager.delete(mBucketName, key);
    response.close();
  }
18004
@VisibleForTesting
    void removeAllCacheEntries() {
        List<CacheEntry> entries;
        synchronized (this.cacheEntries) {
            entries = new ArrayList<>(this.cacheEntries.values());
            this.cacheEntries.clear();
        }

        removeFromCache(entries);
        if (entries.size() > 0) {
            log.debug("{}: Cleared all cache entries ({}).", this.traceObjectId, entries.size());
        }
    }
1239828
public synchronized void remove(final String key) {
		try {
			list.remove(key);
		} catch (Exception e) {
			log.log(Level.SEVERE, "remove", e);
		}
		super.remove(key);
	}
313686
public Task<Void> remove(final CacheKey key) {
    Preconditions.checkNotNull(key);
    mStagingArea.remove(key);
    try {
      return Task.call(
          new Callable<Void>() {
            @Override
            public Void call() throws Exception {
              try {
                if (FrescoSystrace.isTracing()) {
                  FrescoSystrace.beginSection("BufferedDiskCache#remove");
                }
                mStagingArea.remove(key);
                mFileCache.remove(key);
              } finally {
                if (FrescoSystrace.isTracing()) {
                  FrescoSystrace.endSection();
                }
              }
              return null;
            }
          },
          mWriteExecutor);
    } catch (Exception exception) {
      // Log failure
      // TODO: 3697790
      FLog.w(TAG, exception, "Failed to schedule disk-cache remove for %s", key.getUriString());
      return Task.forError(exception);
    }
  }
1264470
public void removeKey(String key) {
        if (key != null && !key.isEmpty()) {
            for (int i=0; i<map.size(); i++) {
                KeyValue kv = map.get(i);
                if (key.equals(kv.getKey())) {
                    map.remove(i);
                    return;
                }
            }
        }
    }
1263869
static void removeFromCache(String key) {
        HashMap<String, MPApiResponse> mapCache = getMapCache();
        mapCache.remove(key);
    }
1290309
@Override
	public void remove(final Object key, final Class<?> clas) {
		this.logger.debug("@remove :".concat(key.toString()).concat(" with class : ".concat(clas.getName())));
		getCachableMap(clas).remove(key);
	}