Checks if the specified bank contains the specified key.
507410
def contains(bank, key):
    '''
    
    '''
    _init_client()
    etcd_key = '{0}/{1}/{2}'.format(path_prefix, bank, key)
    try:
        r = client.read(etcd_key)
        # return True for keys, not dirs
        return r.dir is False
    except etcd.EtcdKeyNotFound:
        return False
    except Exception as exc:
        raise SaltCacheError(
            'There was an error getting the key, {0}: {1}'.format(
                etcd_key, exc
            )
        )
725429
public boolean containsKey(Object key) {
        Entry tab[] = mTable;

        if (key != null) {
            int hash = key.hashCode();
            int index = (hash & 0x7FFFFFFF) % tab.length;
            for (Entry e = tab[index], prev = null; e != null; e = e.mNext) {
                if (e.getValue() == null) {
                    // Clean up after a cleared Reference.
                    mModCount++;
                    if (prev != null) {
                        prev.mNext = e.mNext;
                    }
                    else {
                        tab[index] = e.mNext;
                    }
                    mCount--;
                }
                else if (e.mHash == hash && key.equals(e.mKey)) {
                    return true;
                }
                else {
                    prev = e;
                }
            }
        }
        else {
            for (Entry e = tab[0], prev = null; e != null; e = e.mNext) {
                if (e.getValue() == null) {
                    // Clean up after a cleared Reference.
                    mModCount++;
                    if (prev != null) {
                        prev.mNext = e.mNext;
                    }
                    else {
                        tab[0] = e.mNext;
                    }
                    mCount--;
                }
                else if (e.mKey == null) {
                    return true;
                }
                else {
                    prev = e;
                }
            }
        }

        return false;
    }
662639
public boolean containsKey(Object key) {
        if (key == null) {
            return false;
        }

        Entry tab[] = mTable;
        int hash = System.identityHashCode(key);
        int index = (hash & 0x7FFFFFFF) % tab.length;

        for (Entry e = tab[index], prev = null; e != null; e = e.mNext) {
            Object entryKey = e.getKey();

            if (entryKey == null) {
                // Clean up after a cleared Reference.
                mModCount++;
                if (prev != null) {
                    prev.mNext = e.mNext;
                }
                else {
                    tab[index] = e.mNext;
                }
                mCount--;
            }
            else if (e.mHash == hash && key == entryKey) {
                return true;
            }
            else {
                prev = e;
            }
        }

        return false;
    }
402453
public boolean containsKey(int key) {
        Entry tab[] = table;

        int index = (key & 0x7FFFFFFF) % tab.length;
        for (Entry e = tab[index]; e != null; e = e.next) {
            if (e.key == key) {
                return true;
            }
        }
        
        return false;
    }
227084
public boolean containsKey(String key) {

        if (key == null) {
            throw new NullPointerException("Missing resource key.");
        }

        PropertyBundle p = this;

        do {
            String value = p.key2values.get(key);
            if (value != null) {
                return true;
            }
        } while ((p = p.parent) != null);

        return false;

    }
94360
@Override
    public boolean containsKey(Object key) {
        if (key == null) {
            return false;
        }
        Map<String, GroovyRunner> map = getMap();
        readLock.lock();
        try {
            return map.containsKey(key);
        } finally {
            readLock.unlock();
        }
    }
1272944
public static boolean containsKey(final String _key)
    {
        final Cache<String, BundleInterface> cache = InfinispanCache.get()
                        .<String, BundleInterface>getIgnReCache(BundleMaker.CACHE4BUNDLE);
        return cache.containsKey(_key);
    }
1078660
def has_key?(key, opts={})
      key = normalize_key(key) if opts.fetch(:normalize, true)
      @source.has_key?(key)
    end
896652
@Override
    public boolean contains(@NonNull String key) {
        if (key == null) { throw new IllegalArgumentException("key cannot be null."); }

        synchronized (lock) {
            return !getMValue(internalDict, key).isEmpty();
        }
    }
1335367
def _has(self, key, exact=0):
        """"""
        if not exact:
            key = self.getfullkey(key,new=1)
        return key in self.data
460647
public boolean containsKey(String name)
    {
        FieldInfo info=getFieldInfo(name);
        return getField(info,true)!=null;
    }
748569
def contains_entry(self, key, value):
        
        check_not_none(key, "key can't be None")
        check_not_none(value, "value can't be None")
        key_data = self._to_data(key)
        value_data = self._to_data(value)
        return self._encode_invoke_on_key(multi_map_contains_entry_codec, key_data, key=key_data,
                                          value=value_data, thread_id=thread_id())
1005484
def has_key(self, key):
        
        self.is_a(Mapping)
        self.contains(key)
        return KeyInspector(self._subject[key])
655370
def check_key(self, key: str) -> bool:
        
        keys = self.get_keys()
        return key in keys
457211
def contains(self, key, counter_id):
        
        with self._lock:
            return counter_id in self._metadata[key]
48497
def ContainsKey(self, public_key):
        
        return self.ContainsKeyHash(Crypto.ToScriptHash(public_key.encode_point(True), unhex=True))
201078
def contains(self, key):
    '''
    '''
    self.logger.info('%s: contains %s' % (self, key))
    return super(LoggingDatastore, self).contains(key)