Gets the keys contained in the bundle.

@return the keys. At least one key is returned as empty bundle
was rejected.
351656
public Set<String> keys() {
        Set<String> list = new LinkedHashSet<>();
        Enumeration<String> keys = bundle.getKeys();
        while (keys.hasMoreElements()) {
            list.add(keys.nextElement());
        }
        return list;
    }
624232
@Override
  public List<String> listKeys() {
    lock.readLock().lock();
    try {
      List<String> keyList = new ArrayList<>(items.size());
      for (Map.Entry<String, Deque<MutablePair<DeltaType, Object>>> entry : items.entrySet()) {
        keyList.add(entry.getKey());
      }
      return keyList;
    } finally {
      lock.readLock().unlock();
    }
  }
364143
public Set<Integer> intKeySet() {
        return data.keySet().stream()
                .map(Any2::getLeft)
                .flatMap(opt -> opt.map(Stream::of).orElseGet(Stream::empty))
                .collect(Collectors.toSet());
    }
354875
public Iterable<FallbackKey> fallbackKeys() {
		return (fallbackKeys == EMPTY) ? Collections.emptyList() : Arrays.asList(fallbackKeys);
	}
1121815
@SuppressWarnings("deprecation") // The String ctor is deprecated, but fast.
  public Set<String> keys() {
    if (isEmpty()) {
      return Collections.emptySet();
    }
    Set<String> ks = new HashSet<>(size);
    for (int i = 0; i < size; i++) {
      ks.add(new String(name(i), 0 /* hibyte */));
    }
    // immutable in case we decide to change the implementation later.
    return Collections.unmodifiableSet(ks);
  }
275075
public List<K> getKeys() {
        synchronized ( _map ) {
            return new java.util.ArrayList<K>( _map.keySet() );
        }
    }
676357
public java.util.List<String> getBundleIds() {
        if (bundleIds == null) {
            bundleIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return bundleIds;
    }
564979
public Set<Property> getPropertyKeys() {
        return nodeProperties != null ? nodeProperties.keySet() : Collections.<Property>emptySet();
    }
561597
int[] getKeys()
    {
        Set<Integer> keySet = map.keySet();
        int keys[] = new int[keySet.size()];
        int index = 0;
        for (Integer key : keySet)
        {
            keys[index] = key;
            index++;
        }
        return keys;
    }
938151
@Nullable
    @ThriftField(value = 4, requiredness = OPTIONAL)
    public List<Set<String>> getIndexableKeys()
    {
        return indexableKeys;
    }
1313729
@Override
    public Set<String> getKeys() {
        Map<String, String> map = inheritableThreadLocal.get();
        if (map != null) {
            return map.keySet();
        } else {
            return null;
        }
    }
940539
private static boolean containsKey(ResourceBundle bundle, String key) {
        for (Enumeration<String> en = bundle.getKeys(); en.hasMoreElements(); ) {
            if (en.nextElement().equals(key)) {
                return true;
            }
        }
        return false;
    }
1158326
public Iterator<K> keys()
  {
    KeyIterator<K,V> iter = new KeyIterator<K,V>(this);

    iter.init(this);

    return iter;
  }
1012822
Map<String, WSKeyStore> getKeyStores() {
        Map<String, WSKeyStore> ret = new HashMap<String, WSKeyStore>(keystoreIdMap);
        ret.putAll(keystorePidMap);
        return ret;
    }
1135620
public Set<String> getNewElementKeys() {

        Set<String> result = new HashSet<String>();
        for (CmsContainerConfiguration configuration : m_parentConfigurations) {
            result.addAll(configuration.getNewElements().keySet());
        }
        return result;
    }
424443
@Override
  public List<String> listKeys() {
    lock.lock();
    try {
      List<String> keys = new ArrayList<>(this.items.size());
      for (Map.Entry<String, ApiType> entry : this.items.entrySet()) {
        keys.add(entry.getKey());
      }
      return keys;
    } finally {
      lock.unlock();
    }
  }
240756
public Set<String> keySet() {

        PropertyBundle p = this;
        Set<String> keys = new HashSet<>(p.key2values.keySet());

        while ((p = p.parent) != null) {
            keys.addAll(p.key2values.keySet());
        }

        return Collections.unmodifiableSet(keys);

    }