Checks whether the given key is a multi valued option

@param scheme the component name
@param key    the option key
@return <tt>true</tt> if the key is multi valued, <tt>false</tt> otherwise
498557
public static String getPrefix(CamelCatalog camelCatalog, String scheme, String key) {
        // use the camel catalog
        String json = camelCatalog.componentJSonSchema(scheme);
        if (json == null) {
            throw new IllegalArgumentException("Could not find catalog entry for component name: " + scheme);
        }

        List<Map<String, String>> data = JSonSchemaHelper.parseJsonSchema("properties", json, true);
        if (data != null) {
            for (Map<String, String> propertyMap : data) {
                String name = propertyMap.get("name");
                String prefix = propertyMap.get("prefix");
                if (key.equals(name)) {
                    return prefix;
                }
            }
        }
        return null;
    }
614296
public static boolean containsKey(String key, int length)
    {
        if (!trie.containsKey(key)) return false;
        return key.length() >= length;
    }
237081
@SuppressWarnings("unchecked")
  public boolean contains(final Object key) {
    // validate key
    if (key == null) {
      throw new IllegalArgumentException("Null element is not supported.");
    }
    // find element
    final int hashCode = ((T)key).hashCode();
    final int index = getIndex(hashCode);
    return containsElem(index, (T) key, hashCode);
  }
270142
public boolean exists(Object key) {
		for (Scope cur=this; cur!=null; cur=cur.parent) {
			if (cur.data != null && cur.data.containsKey(key)) {
				return true;
			}
		}
		return false;
	}
1138272
public static boolean hasScheme(String possibleUrl) {
        boolean result = false;
        for (int i = 0; i < possibleUrl.length(); i++) {
            char c = possibleUrl.charAt(i);
            if (c == ':') {
                if (i != 0) {
                    result = true;
                }
                break;
            }
            if (!scheme.get(c)) {
                break;
            }
        }
        return result;
    }
1173021
public void setScheme( String scheme )
    {
        _scheme = null;
        if ( scheme != null && scheme.length() > 0 )
        {
            _scheme = scheme;
        }
    }
827348
public boolean containsInputs(
      java.lang.String key) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    return internalGetInputs().getMap().containsKey(key);
  }
1190953
public boolean containsKey(Object key)
    {
        if (key==null)
            return _nullEntry!=null;
        return
            getEntry(key.toString(),0,key==null?0:key.toString().length())!=null;
    }
1289202
public final boolean hasTag(String key, Set<String> values) {
        return values.contains(getTag(key, ""));
    }
1035790
public boolean containsKey(Object key) {
        if( !cache.containsKey(key) ) {
            return false;
        }
        else {
            SoftReference<T> ref = cache.get(key);
            T ob = ref.get();
            
            if( ob == null ) {
                release(key);
                return false;
            }
            if( ob instanceof CachedItem ) {
                if( !((CachedItem)ob).isValidForCache() ) {
                    release(key);
                    return false;
                }
            }
            return true;
        }
    }
1315262
protected boolean matchesFilter(String key) {
		boolean rets = (null == filterList);
		if (!rets) {
			for (Iterator<String> it = filterList.iterator(); it.hasNext() && !rets;)
				rets = key.startsWith(it.next());
		}
		return rets;

	}
290668
@Override
    public boolean containsKey(Object key) {
        if (key instanceof String) {
            return has((String) key, this);
        } else if (key instanceof Number) {
            return has(((Number) key).intValue(), this);
        }
        return false;
    }
177338
@Override
    public boolean contains(AttributeKey<?> key) {

        if (this.internals.containsKey(key.name())) {
            return true;
        }

        return this.attributes.contains(key);

    }
903510
@SuppressWarnings("RedundantIfStatement")
  @RestrictTo(RestrictTo.Scope.LIBRARY)
  public boolean matches(String key, int depth) {
    if (isContainer(key)) {
      // This is an artificial layer we programatically create.
      return true;
    }
    if (depth >= keys.size()) {
      return false;
    }
    if (keys.get(depth).equals(key) ||
        keys.get(depth).equals("**") ||
        keys.get(depth).equals("*")) {
      return true;
    }
    return false;
  }
1236049
public boolean containsKey(String inputKey) {
        String key = Normalizer.normalize(inputKey, Normalizer.NORMALIZE_LOWER);
        List<String> list = this.values.get(key);
        boolean rc = (null == list) ? false : !list.isEmpty();
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "containsKey: key=" + inputKey + " rc=" + rc);
        }
        return rc;
    }
583490
@VisibleForTesting
  public boolean containsKey(K key) {
    Preconditions.checkNotNull(key, "key can not be null");
    return mCache.containsKey(key);
  }
911183
@Override
	public List<CPDefinitionOptionValueRel> findByKey(String key) {
		return findByKey(key, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
	}