Returns an {@link Iterable} of all keys or {@code null}
if a map loader is not configured for this map.
{@inheritDoc}
182019
@Override
    public Iterable<Object> loadAllKeys() {
        if (isMapLoader()) {
            Iterable<Object> allKeys;
            try {
                allKeys = mapLoader.loadAllKeys();
            } catch (AbstractMethodError e) {
                // Invoke reflectively to preserve backwards binary compatibility. Removable in v4.x
                allKeys = ReflectionHelper.invokeMethod(mapLoader, "loadAllKeys");
            }
            return allKeys;
        }
        return null;
    }
220521
public static Map mapKeys(Mapper mapper, Map map) {
        return mapKeys(mapper, map, false);
    }
1158326
public Iterator<K> keys()
  {
    KeyIterator<K,V> iter = new KeyIterator<K,V>(this);

    iter.init(this);

    return iter;
  }
938151
@Nullable
    @ThriftField(value = 4, requiredness = OPTIONAL)
    public List<Set<String>> getIndexableKeys()
    {
        return indexableKeys;
    }
900927
@Override
    @SuppressWarnings("unchecked")
    /**
     * override to support ordering of returned keys.
     */
    public Iterator<String> getKeys() {

        final Iterator tempKeysIter = super.getKeys();
        final List<String> keys = sortKeys(tempKeysIter);

        return keys.iterator();
    }
417297
@NullSafe
  @Override
  public Iterator<VALUE> iterator() {
    return Collections.unmodifiableMap(this.map).values().iterator();
  }
894362
@Nullable
  public <T> Iterable<T> getAll(final Key<T> key) {
    for (int i = 0; i < size; i++) {
      if (bytesEqual(key.asciiName(), name(i))) {
        return new IterableAt<>(key, i);
      }
    }
    return null;
  }
900352
public final List<String> getKeyList() {
        final List<String> keys = new ArrayList<>();
        final Iterator<String> it = keyIterator();
        while (it.hasNext()) {
            keys.add(it.next());
        }
        return keys;
    }
919167
@Override
  public Map<K, V> getAllFailure(Iterable<? extends K> keys, StoreAccessException e) {
    cleanup(keys, e);

    HashMap<K, V> result = keys instanceof Collection<?> ? new HashMap<>(((Collection<? extends K>) keys).size()) : new HashMap<>();
    for (K key : keys) {
      result.put(key, null);
    }
    return result;
  }
659466
public java.util.List<KeyListEntry> getKeys() {
        if (keys == null) {
            keys = new com.amazonaws.internal.SdkInternalList<KeyListEntry>();
        }
        return keys;
    }
399023
public static Collection map(Mapper mapper, Collection c, boolean allowNull) {
        return map(mapper, c.iterator(), allowNull);
    }
266478
@Override
    public <T> Flowable<T> get(@Nonnull ResultSetMapper<? extends T> mapper) {
        Preconditions.checkNotNull(mapper, "mapper cannot be null");
        return update.startWithDependency(Update.<T>createReturnGeneratedKeys(update.connections,
                update.parameterGroupsToFlowable(), update.sql, mapper, true));

    }
1313729
@Override
    public Set<String> getKeys() {
        Map<String, String> map = inheritableThreadLocal.get();
        if (map != null) {
            return map.keySet();
        } else {
            return null;
        }
    }
556359
@Override
	public Iterable<Map.Entry<K, V>> entries() {
		return Collections.unmodifiableSet(state.entrySet());
	}
535034
@Override
  @NullSafe
  public Map<KEY, VALUE> toMap() {
    return Collections.unmodifiableMap(nullSafeMap(getMap()));
  }
1356752
public Iterable<RowKey> getKeys() {
		if ( currentState.isEmpty() ) {
			if ( cleared ) {
				// if the association has been cleared and the currentState is empty, we consider that there are no rows.
				return Collections.emptyList();
			}
			else {
				// otherwise, the snapshot rows are the current ones
				return snapshot.getRowKeys();
			}
		}
		else {
			// It may be a bit too large in case of removals, but that's fine for now
			Set<RowKey> keys = CollectionHelper.newLinkedHashSet( cleared ? currentState.size() : snapshot.size() + currentState.size() );

			if ( !cleared ) {
				// we add the snapshot RowKeys only if the association has not been cleared
				for ( RowKey rowKey : snapshot.getRowKeys() ) {
					keys.add( rowKey );
				}
			}

			for ( Map.Entry<RowKey,AssociationOperation> op : currentState.entrySet() ) {
				switch ( op.getValue().getType() ) {
					case PUT:
						keys.add( op.getKey() );
						break;
					case REMOVE:
						keys.remove( op.getKey() );
						break;
				}
			}

			return keys;
		}
	}
347439
@SuppressWarnings("unchecked")
    public <K> K[] getKeys(Map<K, ?> map) {
        K[] result = null;
        Set<K> keySet = map.keySet();
        if (keySet.size() > 0) {
            result = (K[]) keySet.toArray(new Object[keySet.size()]);
        }
        
        return result;
    }