returns if the key is a readonly key

@param key key to check
@return is readonly
499423
private boolean isReadOnlyKey(Collection.Key key) {

	return (key.equals(KeyConstants._java) || key.equals(KeyConstants._separator) || key.equals(KeyConstants._os) || key.equals(KeyConstants._coldfusion)
		|| key.equals(KeyConstants._lucee));
    }
395107
public boolean getBoolean(String key) {
    String value = getString(key);
    return StringUtils.isNotEmpty(value) && Boolean.parseBoolean(value);
  }
545820
@Override
    public boolean getBoolean(@NonNull String key) {
        if (key == null) { throw new IllegalArgumentException("key cannot be null."); }

        synchronized (lock) {
            final Object obj = getMValue(internalDict, key).asNative(internalDict);
            return CBLConverter.asBoolean(obj);
        }
    }
433485
@Override
    public boolean containsKey(Object key) {
        if (key == null) {
            throw new NullPointerException();
        }
        
        CachedValue<K, V> entry = map.get(key);
        if (entry == null) {
            return false;
        }
        if (isValueExpired(entry)) {
            if (map.remove(key, entry)) {
                onValueRemove(entry);
                return false;
            }
            return containsKey(key);
        }
        return true;
    }
985377
public boolean containsKey(Object key)
    {
        purge();
        Entry entry = getEntry(key);
        if (entry == null) return false;
        return entry.getValue() != null;
    }
1299122
public final boolean remove(Object key) {
        java.util.Set subSet = getSubSet(key);
        synchronized (subSet) {
            return subSet.remove(key);
        } // synchronized (subSet).
    }
357814
@CheckForSigned
  private int _getReadIndex (final int key)
  {
    int idx = MapHelper.phiMix (key) & m_nMask;
    if (m_aKeys[idx] == key)
    {
      // we check FREE prior to this call
      return idx;
    }
    if (m_aKeys[idx] == FREE_KEY)
    {
      // end of chain already
      return -1;
    }
    final int startIdx = idx;
    while ((idx = _getNextIndex (idx)) != startIdx)
    {
      if (m_aKeys[idx] == FREE_KEY)
        return -1;
      if (m_aKeys[idx] == key)
        return idx;
    }
    return -1;
  }
234577
private boolean filteredKey(@NonNull CoreConfiguration config, @NonNull String key) {
        for (String regex : config.excludeMatchingSharedPreferencesKeys()) {
            if (key.matches(regex)) {
                return true;
            }
        }
        return false;
    }
882391
public boolean removeKey(long key) {
	int i = indexOfKey(key);
	if (i<0) return false; // key not contained

	this.state[i]=REMOVED;
	this.values[i]=0; // delta
	this.distinct--;

	if (this.distinct < this.lowWaterMark) {
		int newCapacity = chooseShrinkCapacity(this.distinct,this.minLoadFactor, this.maxLoadFactor);
		rehash(newCapacity);
	}
	
	return true;	
}
950098
public boolean containsKey(final long key) {
        int index = longHash(key, mask);
        while (null != values[index]) {
            if (key == keys[index]) {
                return true;
            }
            index = ++index & mask;
        }
        return false;
    }
741528
public Boolean isReadonlyCell() {
        return Boolean.valueOf(getStateHelper().eval(PropertyKeys.readonlyCell, Boolean.FALSE).toString());
    }
382867
@Override
    public final boolean has(final String key) {
        String result = this.obj.optString(key, null);
        return result != null;
    }
522261
private void setReadOnly(Boolean flag) {
        this.readOnly = flag;
        setProperty(Constants.SSLPROP_KEY_STORE_READ_ONLY, flag.toString());
    }
1164335
public void hasLastKey(@NullableDecl Object key) {
    if (actualAsNavigableMap().isEmpty()) {
      failWithActual("expected to have last key", key);
      return;
    }

    if (!Objects.equal(actualAsNavigableMap().lastKey(), key)) {
      if (actualAsNavigableMap().containsKey(key)) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s has last key <%s>. "
                        + "It does contain this key, but the last key is <%s>",
                    actualAsString(), key, actualAsNavigableMap().lastKey())));
        return;
      }
      failWithoutActual(
          simpleFact(
              lenientFormat(
                  "Not true that %s has last key <%s>. "
                      + "It does not contain this key, and the last key is <%s>",
                  actualAsString(), key, actualAsNavigableMap().lastKey())));
    }
  }
208927
boolean isEnvKeyInteresting(final String key) {
    final List<String> disallowedKeys = Arrays.asList("windir", "SystemDrive", "CommonProgramFiles", "ComSpec", "SystemRoot", "Path", "ProgramFiles");

    if (key == null || key.length() == 0)
      return false;
    // No all-uppercase keys
    if (key.toUpperCase().equals(key))
      return false;
    // No keys in the list
    if (disallowedKeys.contains(key))
      return false;

    return true;
  }
958575
public boolean containsKey(Key<?> key) {
    for (int i = 0; i < size; i++) {
      if (bytesEqual(key.asciiName(), name(i))) {
        return true;
      }
    }
    return false;
  }
1104109
def key?(key)
      # First, check if item is already cached in memory
      return true if @cache.key?(key)
      # Otherwise, it might be cached on disk
      # but we should not consider the disk cache if it is disabled
      return false unless disk_cache_enabled?

      path = path_to(hash(key))
      File.file?(path) && File.readable?(path)
    end