// Delete removes a key-value pair from the BiMap for a given key. Returns if the key doesn't exist
498296
func (b *BiMap) Delete(k interface{}) {
	b.s.RLock()
	if b.immutable {
		panic("Cannot modify immutable map")
	}
	b.s.RUnlock()

	if !b.Exists(k) {
		return
	}
	val, _ := b.Get(k)
	b.s.Lock()
	defer b.s.Unlock()
	delete(b.forward, k)
	delete(b.inverse, val)
}
988067
func (t *Tree) Delete(key string) error {
	keys, err := parseKey(key)
	if err != nil {
		return err
	}
	return t.DeletePath(keys)
}
832374
func (tx *txn) Delete(key string) keyval.BytesTxn {
	tx.ops = append(tx.ops, &api.KVTxnOp{
		Verb: api.KVDelete,
		Key:  key,
	})
	return tx
}
1209591
func (vs *ValueMap) Delete(k Value) {
	if vs == nil {
		return
	}
	vs.hashMap.Delete(k)
}
587745
func (c *Client) Delete(key string) error {
	return c.deleteRecurse(key, false)
}
12551
func (c *InMemoryCache) Delete(_ context.Context, key Key) bool {
	if _, found := c.items.Load(key.String()); found {
		c.items.Delete(key.String())
		return true
	}
	return false
}
1152588
func (k *KeyValueStringSlice) Delete(key string) {
	for i := 0; i < len(k.Keys); i++ {
		if k.Keys[i] == key {
			k.Keys = k.deleteIndex(i, k.Keys)
			k.Values = k.deleteIndex(i, k.Values)
		}
	}
}
355006
func (d *Datastore) Delete(k ds.Key) error {
	d.buffer[k] = op{delete: true}
	if len(d.buffer) > d.maxBufferEntries {
		return d.Flush()
	}
	return nil
}
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)
	})
}
970938
func (m *CouchDBBackend) Delete(ctx context.Context, key string) error {
	m.permitPool.Acquire()
	defer m.permitPool.Release()

	return m.DeleteInternal(ctx, key)
}
1078436
func (c *LedisCacher) Delete(key string) (err error) {
	if _, err = c.c.Del([]byte(key)); err != nil {
		return err
	}
	_, err = c.c.HDel(defaultHSetName, []byte(key))
	return err
}
459882
func (kv *KV) Delete(key []byte) error {
	return kv.db.Update(func(txn *badger.Txn) error {
		return txn.Delete(key)
	})
}
52230
func (om *OrdMap) Delete(key interface{}) {
	rkey := ty.AssertType(key, om.ktype)

	// Avoid doing work if we don't need to.
	if !om.exists(rkey) {
		return
	}

	keysLen := om.keys.Len()
	for i := 0; i < keysLen; i++ {
		if key == om.keys.Index(i).Interface() {
			// om.keys = append(om.keys[:i], om.keys[i+1:]...)
			om.keys = reflect.AppendSlice(
				om.keys.Slice(0, i), om.keys.Slice(i+1, keysLen))
			break
		}
	}

	// Setting a key to a zero reflect.Value deletes the key from the map.
	om.m.SetMapIndex(rkey, reflect.Value{})
}
1173943
func (m *dirsMap) Delete(key string) {
	m.data.Delete(m.normalizeKey(key))
}
434434
func (c *BigCache) Delete(key string) error {
	hashedKey := c.hash.Sum64(key)
	shard := c.getShard(hashedKey)
	return shard.del(key, hashedKey)
}
89637
func (b *DynamoDBBackend) Delete(ctx context.Context, key []byte) error {
	if len(key) == 0 {
		return trace.BadParameter("missing parameter key")
	}
	if _, err := b.getKey(ctx, key); err != nil {
		return err
	}
	return b.deleteKey(ctx, key)
}