// Remove deletes a ChainLink from the cache.
504618
func (c *LinkCache) Remove(id LinkID) {
	c.Lock()
	defer c.Unlock()
	var linkID linkIDFixed
	copy(linkID[:], id)
	elt, ok := c.cache[linkID]
	if ok {
		c.accessOrder.Remove(elt)
	}
	delete(c.cache, linkID)
}
356016
func (r *ChainResource) Delete(context smolder.APIContext, request *restful.Request, response *restful.Response) {
	resp := ChainResponse{}
	resp.Init(context)

	id := request.PathParameter("chain-id")

	found := false
	chains := []bees.Chain{}
	for _, v := range bees.GetChains() {
		if v.Name == id {
			found = true
		} else {
			chains = append(chains, v)
		}
	}

	if found {
		bees.SetChains(chains)
		resp.Send(response)
	} else {
		r.NotFound(request, response)
	}
}
1274877
func (rl *List) Remove() error {
	conn := rl.pool.Get(rl.dbindex)
	_, err := conn.Do("DEL", rl.id)
	return err
}
29799
func (k *Store) Remove(key string) {
	k.mu.Lock()
	defer k.mu.Unlock()

	delete(k.db, key)
	k.logChange(removeOperation, key, nil)
}
287194
func (c *Cache) Delete(key string) {
	c.Client.Delete(cacheKey(key))
}
8565
func (t *txLookup) Remove(hash common.Hash) {
	t.lock.Lock()
	defer t.lock.Unlock()

	delete(t.all, hash)
}
590263
func (c *Cache) Remove(itmID string) {
	c.Lock()
	c.remove(itmID)
	c.Unlock()
}
629766
func (c *Client) Remove(name string) error {
	return delete(c, name, false)
}
1322295
func (pool *Pool) Remove(addr string) {
	pool.mutex.Lock()
	defer pool.mutex.Unlock()
	delete(pool.Clients, addr)
}
575936
func (c *Cache) Delete(key Key) {
	logger.Debugf("%s - Deleting cache key", key.String())
	value, ok := c.m.Load(key.String())
	if ok {
		c.close(key.String(), value.(future))
		c.m.Delete(key.String())
	}
}
471665
func (l *LFUNoTS) Delete(key string) error {
	res, err := l.cache.Get(key)
	if err != nil && err != ErrNotFound {
		return err
	}

	// we dont need to delete if already doesn't exist
	if err == ErrNotFound {
		return nil
	}

	ci := res.(*cacheItem)

	l.remove(ci, ci.freqElement)
	l.currentSize--
	return l.cache.Delete(key)
}
533050
func (q *poolEntryQueue) remove(entry *poolEntry) {
	if q.queue[entry.queueIdx] == entry {
		delete(q.queue, entry.queueIdx)
	}
}
189395
func (s *Set) Remove(item interface{}) {
	s.lock.Lock()
	defer s.lock.Unlock()
	delete(s.items, item)
}
264913
func (m *Model) Remove() {
	for _, dir := range m.dirs {
		_ = os.RemoveAll(dir)
	}
}
980267
func (c *Cache) Remove(key uint32) {
	shard := key & (shardSize - 1)
	c.shards[shard].Remove(key)
}
1318737
func (m *txSortedMap) Remove(nonce uint64) bool {
	// Short circuit if no transaction is present
	_, ok := m.items[nonce]
	if !ok {
		return false
	}
	// Otherwise delete the transaction and fix the heap index
	for i := 0; i < m.index.Len(); i++ {
		if (*m.index)[i] == nonce {
			heap.Remove(m.index, i)
			break
		}
	}
	delete(m.items, nonce)
	m.cache = nil

	return true
}
938142
func (c *ReasonCache) Remove(uid types.UID, name string) {
	c.lock.Lock()
	defer c.lock.Unlock()
	c.cache.Remove(c.composeKey(uid, name))
}