// ExistsNative behaves as Exists with the difference it
// will always invoke `iptables` binary.
762326
func ExistsNative(table Table, chain string, rule ...string) bool {
	return exists(true, table, chain, rule...)
}
896138
func (json *JSON) Exists(name string) bool {
	return json.fetch(name).Exists()
}
1340093
func (pm *PolicyMap) Exists(id uint32, dport uint16, proto u8proto.U8proto, trafficDirection trafficdirection.TrafficDirection) bool {
	key := newKey(id, dport, proto, trafficDirection)
	_, err := pm.Lookup(&key)
	return err == nil
}
705824
func (h *Handle) Exists() bool {
	h.Lock()
	defer h.Unlock()
	return h.dbExists
}
387495
func (m *mruNonceMap) Exists(nonce uint64) bool {
	m.mtx.Lock()
	_, exists := m.nonceMap[nonce]
	m.mtx.Unlock()

	return exists
}
729827
func (ns *Namespace) Exists(name string) bool {
	_, found := ns.deps.Tmpl.Lookup(name)
	return found

}
291743
func (h *PortRuleHTTP) Exists(rules L7Rules) bool {
	for _, existingRule := range rules.HTTP {
		if h.Equal(existingRule) {
			return true
		}
	}

	return false
}
170816
func (ipt *IPTables) existsForOldIptables(table, chain string, rulespec []string) (bool, error) {
	rs := strings.Join(append([]string{"-A", chain}, rulespec...), " ")
	args := []string{"-t", table, "-S"}
	var stdout bytes.Buffer
	err := ipt.runWithOutput(args, &stdout)
	if err != nil {
		return false, err
	}
	return strings.Contains(stdout.String(), rs), nil
}
1310656
func (f *FilterOp) Exists(field string) *FilterOp {
	f.ExistsProp = &propertyPathMarker{Field: field}
	return f
}
913560
func Exists(args ...string) bool {
	if _, err := Raw(append([]string{"-C"}, args...)...); err != nil {
		return false
	}
	return true
}
337826
func (c *ZkConn) Exists(ctx context.Context, path string) (exists bool, stat *zk.Stat, err error) {
	err = c.withRetry(ctx, func(conn *zk.Conn) error {
		exists, stat, err = conn.Exists(path)
		return err
	})
	return
}
1299468
func (om *OrdMap) Exists(key interface{}) bool {
	rkey := ty.AssertType(key, om.ktype)
	return om.exists(rkey)
}
443233
func (m *memory) Exist(ctx context.Context, t *triple.Triple) (bool, error) {
	suuid := UUIDToByteString(t.UUID())
	m.rwmu.RLock()
	defer m.rwmu.RUnlock()
	_, ok := m.idx[suuid]
	return ok, nil
}
967458
func Exists(ctx context.Context, clt client.ImageAPIClient, image string) (bool, error) {
	_, err := InspectImage(ctx, clt, image)
	if err != nil {
		if client.IsErrNotFound(err) {
			return false, nil
		}
		return false, err
	}
	return true, nil
}
320979
func (b *BiMap) Exists(k interface{}) bool {
	b.s.RLock()
	defer b.s.RUnlock()
	_, ok := b.forward[k]
	return ok
}
1004113
func (d *Driver) Exists(id string) bool {
	_, err := os.Stat(d.block(id))
	return err == nil
}
997928
func Exists(path string, fs afero.Fs) (bool, error) {
	return afero.Exists(fs, path)
}