// Has checks if a key is stored.
163786
func (d *Datastore) Has(k ds.Key) (bool, error) {
	o, ok := d.buffer[k]
	if ok {
		return !o.delete, nil
	}

	return d.child.Has(k)
}
34204
func (m ConcurrentMap) Has(key string) bool {
	// Get shard
	shard := m.GetShard(key)
	shard.RLock()
	// See if element is within shard.
	_, ok := shard.items[key]
	shard.RUnlock()
	return ok
}
1101825
func (db *GoLevelDB) Has(key []byte) bool {
	return db.Get(key) != nil
}
853388
func (t *LLRB) Has(key Item) bool {
	return t.Get(key) != nil
}
1317782
func (t *BTree) Has(key Item) bool {
	return t.Get(key) != nil
}
971693
func (d *Diskv) Has(key string) bool {
	pathKey := d.transform(key)
	d.mu.Lock()
	defer d.mu.Unlock()

	if _, ok := d.cache[key]; ok {
		return true
	}

	filename := d.completeFilename(pathKey)
	s, err := os.Stat(filename)
	if err != nil {
		return false
	}
	if s.IsDir() {
		return false
	}

	return true
}
1080402
func (ps *PeerSet) Has(peerKey ID) bool {
	ps.mtx.Lock()
	_, ok := ps.lookup[peerKey]
	ps.mtx.Unlock()
	return ok
}
28395
func (f *Flash) Has(key string) bool {
	if f.v == nil {
		return false
	}
	return len(f.v[key]) > 0
}
734383
func (db *Database) Has(key []byte) (bool, error) {
	db.lock.RLock()
	defer db.lock.RUnlock()

	if db.db == nil {
		return false, errMemorydbClosed
	}
	_, ok := db.db[string(key)]
	return ok, nil
}
804716
func (u *User) Has(key string) bool {
	u.RLock()
	defer u.RUnlock()

	_, ok := u.data[key]
	return ok
}
168824
func (s *Settings) Has(name string) bool {
	s.lock.Lock()
	defer s.lock.Unlock()
	_, ok := s.data[name]
	return ok
}
492336
func (n *NetStore) Has(ctx context.Context, ref Address) bool {
	return n.store.Has(ctx, ref)
}
1272036
func (params Params) Has(key string) bool {
	_, ok := params[key]
	return ok
}
109603
func (s *Schema_Set) Has(token string) bool {
	for _, tok := range s.Entry {
		if tok.Token == token {
			return true
		}
	}
	return false
}
1061774
func (dds *Delayed) Has(key ds.Key) (exists bool, err error) {
	dds.delay.Wait()
	return dds.ds.Has(key)
}
915194
func (c *EndpointCache) Has(endpointKey string) bool {
	endpoint, ok := c.get(endpointKey)
	_, found := endpoint.GetValidAddress()

	return ok && found
}
1253309
func (s Byte) Has(item byte) bool {
	_, contained := s[item]
	return contained
}