// HasMagic takes the passed TX and determines if it has the magic bytes
// associated with Ombuds. This method only looks for the leading bytes, it
// does not assert anything about the protocol buffers within.
330736
func HasMagic(tx *wire.MsgTx) bool {
	if len(tx.TxOut) == 0 {
		return false
	}
	inFirst := matchFirstOut(tx, Magic[:])

	inLast := matchLastOut(tx, Magic[:])
	return inFirst || inLast
}
288010
func (s *symbol) HasDocTag(tag string) bool {
	if s.tags == nil {
		s.tags = stringset.Set{}
		for _, word := range strings.Fields(s.Doc().RemarkBlock("DocTags").Body) {
			s.tags.Add(strings.ToLower(strings.Trim(word, ".,")))
		}
	}
	return s.tags.Has(strings.ToLower(tag))
}
1101825
func (db *GoLevelDB) Has(key []byte) bool {
	return db.Get(key) != nil
}
1017844
func (b *MemoryBookmarks) Has(name string) bool {
	_, ok := b.bookmarks[name]
	return ok
}
1080402
func (ps *PeerSet) Has(peerKey ID) bool {
	ps.mtx.Lock()
	_, ok := ps.lookup[peerKey]
	ps.mtx.Unlock()
	return ok
}
242719
func (t *Table) HasBinding(b string) bool {
	t.mu.RLock()
	defer t.mu.RUnlock()
	return t.mbs[b]
}
697991
func (p *Plugin) HasMemory(in *Msg, k string) bool {
	return len(p.GetMemory(in, k).Val) > 0
}
927174
func (pvtdata *TxPvtData) Has(ns string, coll string) bool {
	if pvtdata.WriteSet == nil {
		return false
	}
	for _, nsdata := range pvtdata.WriteSet.NsPvtRwset {
		if nsdata.Namespace == ns {
			for _, colldata := range nsdata.CollectionPvtRwset {
				if colldata.CollectionName == coll {
					return true
				}
			}
		}
	}
	return false
}
855964
func (ddb debugDB) Has(key []byte) (has bool) {
	defer func() {
		fmt.Printf("%v.Has(%v) %v\n", ddb.label,
			cmn.ColoredBytes(key, cmn.Cyan, cmn.Blue), has)
	}()
	return ddb.db.Has(key)
}
589378
func (smap *syncedMap) Has(key interface{}) bool {
	_, ok := smap.Get(key)
	return ok
}
504616
func (evt *Event) HasExpr() bool {
	_, ok := evt.Node.(*ast.Expr)
	return ok
}
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
}
553786
func (b *Buffer) Has(n int) bool {
	return len(b.data) >= n
}
211696
func (t *Mutable) Has(key []byte) bool {
	if node, _ := t.get(key); node != nil {
		return true
	}
	return false
}
1223525
func (mod Mod) Has(p string) bool {
	for _, v := range mod.All() {
		if filepath.Clean(p) == filepath.Clean(v) {
			return true
		}
	}
	return false
}
838886
func (tx *transaction) hasBlock(hash *chainhash.Hash) bool {
	// Return true if the block is pending to be written on commit since
	// it exists from the viewpoint of this transaction.
	if _, exists := tx.pendingBlocks[*hash]; exists {
		return true
	}

	return tx.hasKey(bucketizedKey(blockIdxBucketID, hash[:]))
}
149667
func (snap *dbCacheSnapshot) Has(key []byte) bool {
	// Check the cached entries first.
	if snap.pendingRemove.Has(key) {
		return false
	}
	if snap.pendingKeys.Has(key) {
		return true
	}

	// Consult the database.
	hasKey, _ := snap.dbSnapshot.Has(key, nil)
	return hasKey
}