Deletes an object from the store based on its key.

@param key
the object key.
@return true if the delete operation succeeds.
@throws NullPointerException if <code>key</code> is null.
@throws Exception if this operation cannot be completed successfully.
420829
@Override
    public boolean delete(K key) throws Exception {
        if(key == null) {
            throw new NullPointerException("key");
        }
        
        return _store.delete(_keySerializer.serialize(key));
    }
913157
public void remove(String key) {
        int i = indexOfKey(key);
        if (i != NotFound)
            remove(i);
    }
380901
@Override
    public synchronized void remove(String key) {
        boolean deleted = getFileForKey(key).delete();
        removeEntry(key);
        if (!deleted) {
            VolleyLog.d("Could not delete cache entry for key=%s, filename=%s",
                    key, getFilenameForKey(key));
        }
    }
379139
public boolean delete(final T key) {
    try (Txn<T> txn = env.txnWrite()) {
      final boolean ret = delete(txn, key);
      txn.commit();
      return ret;
    }
  }
1277044
public static final void remove(String key) {
        Map<String, Object> ctx = CTX_HOLDER.get();
        if (ctx != null) {
            ctx.remove(key);
        }
    }
1299122
public final boolean remove(Object key) {
        java.util.Set subSet = getSubSet(key);
        synchronized (subSet) {
            return subSet.remove(key);
        } // synchronized (subSet).
    }
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--;
        }
    }
1268943
public boolean containsLostStorage(
      java.lang.String key) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    return internalGetLostStorage().getMap().containsKey(key);
  }
1308952
@Override
  public void evict(K key) {
    Object existed = store.getIfPresent(key);
    if (null != existed) store.invalidate(key);
  }
1201185
public Response delete(String bucket, String key) throws QiniuException {
        return rsPost(bucket, String.format("/delete/%s", encodedEntry(bucket, key)), null);
    }
1240464
@Override
    public V remove(final long key) {
        V x = firstGenerationQueue.remove(key);
        if (x != null) {
            fireListenersAboutDeletion(key, x);
        } else {
            x = secondGenerationQueue.remove(key);
            if (x != null) {
                fireListenersAboutDeletion(key, x);
            }
        }
        return x;
    }
413353
@Override
    public void delete(Key key) {
	// TODO check whether this needs to be checked!!
	if (!contains(key)) {
	    return;
	}

	// if both children of root are black, set root to red
	if (!isRed(root.getLeft()) && !isRed(root.getRight())) {
	    root.setColor(RED);
	}

	root = delete(root, key);
	if (!isEmpty()) {
	    root.setParent(null);
	    root.setColor(BLACK);
	}
	// assert check();
    }
1342594
@Override
  public V remove(Object key)
  {
    if (key == null) {
      V value = _nullValue;
      _nullValue = null;
      return value;
    }

    int hash = key.hashCode() & _mask;
    int count = _size + 1;

    V item = null;

    for (; count > 0; count--) {
      item = _values[hash];

      if (item == null)
        return null;

      if (_keys[hash].equals(key)) {
        _keys[hash] = null;
        _values[hash] = null;
        _size--;

        refillEntries(hash);
        break;
      }

      hash = (hash + 1) & _mask;
    }

    if (count < 0)
      throw new RuntimeException("internal cache error");

    return item;
  }
71134
public void deleteKey(HKey hk, String key) throws RegistryException {
		int rc = -1;
		try {
			rc = ReflectedMethods.deleteKey(hk.root(), hk.hex(), key);
		} catch (Exception e) {
			throw new RegistryException("Cannot delete key " + key, e);
		}
		if (rc != RC.SUCCESS) {
			throw new RegistryException("Cannot delete key " + key + ". Return code is " + rc);
		}
	}
718365
public synchronized boolean remove(String key) throws IOException {
		checkNotClosed();
		validateKey(key);
		Entry entry = lruEntries.get(key);
		if (entry == null || entry.currentEditor != null) {
			return false;
		}

		for (int i = 0; i < valueCount; i++) {
			File file = entry.getCleanFile(i);
			if (file.exists() && !file.delete()) {
				throw new IOException("failed to delete " + file);
			}
			size -= entry.lengths[i];
			fileCount--;
			entry.lengths[i] = 0;
		}

		redundantOpCount++;
		journalWriter.append(REMOVE + ' ' + key + '\n');
		lruEntries.remove(key);

		if (journalRebuildRequired()) {
			executorService.submit(cleanupCallable);
		}

		return true;
	}
331489
@Override
    public V remove(Object key) {
        CachedValue<K, V> entry = map.remove(key);
        if (entry != null) {
            onValueRemove(entry);
            if (!isValueExpired(entry)) {
                return (V) entry.getValue();
            }
        }
        return null;
    }
198761
public void delete(int key) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            if (mValues[i] != DELETED) {
                mValues[i] = DELETED;
                mGarbage = true;
            }
        }
    }