// Delete a secondary key.
// The semantics are the same as for LayeredCache.Delete
339940
func (s *SecondaryCache) Delete(secondary string) bool {
	item := s.bucket.delete(secondary)
	if item != nil {
		s.pCache.deletables <- item
		return true
	}
	return false
}
819445
func (c *Cache) Delete(key string) {
	c.db.Delete([]byte(key), nil)
}
896059
func (r *MemoryTTL) Delete(key string) error {
	r.Lock()
	defer r.Unlock()

	r.delete(key)
	return nil
}
1114978
func (ds *RemoteCache) Delete(key string) error {
	return ds.client.Delete(key)
}
635387
func (c *Cacher) Delete(key string, recursive bool) []string {
	c.mu.Lock()
	defer c.mu.Unlock()
	var keys []string

	if recursive {
		for k := range c.data {
			if strings.HasPrefix(k, key) {
				delete(c.data, k)
				keys = append(keys, k)
			}
		}
	} else {
		if _, ok := c.data[key]; ok {
			delete(c.data, key)
			keys = append(keys, key)
		}
	}
	return keys
}
648141
func (db *DB) Delete(key []byte, wo *opt.WriteOptions) error {
	return db.putRec(keyTypeDel, key, nil, wo)
}
725430
func (i *InmemBackend) Delete(ctx context.Context, key string) error {
	i.permitPool.Acquire()
	defer i.permitPool.Release()

	i.Lock()
	defer i.Unlock()

	return i.DeleteInternal(ctx, key)
}
956872
func (md *MDCacheStandard) Delete(tlf tlf.ID, rev kbfsmd.Revision,
	bid kbfsmd.BranchID) {
	md.lock.Lock()
	defer md.lock.Unlock()
	key := mdCacheKey{tlf, rev, bid}
	md.lru.Remove(key)
}
1005393
func (e *Err) Delete(key string) {
	if e.data != nil {
		delete(e.data, key)
	}
}
1121638
func (c *Cache) Delete(host string) {
	c.Lock()
	defer c.Unlock()
	delete(c.Clients, host)
}
1207780
func (c *FileCacher) Delete(key string) error {
	return os.Remove(c.filepath(key))
}
604548
func (mem *Memcache) Delete(key string) error {
	return mem.conn.Delete(key)
}
814065
func (kv *KV) Delete(key []byte) error {
	return kv.db.Update(func(tx *bolt.Tx) error {
		return tx.Bucket(kv.table).Delete(key)
	})
}
330977
func (m *dbConn) Delete(key driver.Value) (int, error) {
	txn := m.db.Txn(true)
	err := txn.Delete(m.md.tbl.Name, key)
	if err != nil {
		txn.Abort()
		u.Warnf("could not delete: %v  err=%v", key, err)
		return 0, err
	}
	txn.Commit()
	return 1, nil
}
491008
func (c *Cache) Delete(key string) bool {
	item := c.bucket(key).delete(key)
	if item != nil {
		c.deletables <- item
		return true
	}
	return false
}
767534
func (c *Cache) Delete(_ context.Context, key dataloader.Key) bool {
	if c.ARCCache.Contains(key) {
		c.ARCCache.Remove(key)
		return true
	}
	return false
}
416724
func (s *storeImpl) Delete(key string) {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	delete(s.objects, key)
}