/** * Returns an immutable set of the distinct keys in this multimap, in the same order as they * appear in this multimap. */ @Override public ImmutableSet<K> keySet() { return map.keySet(); }
/** * Returns an immutable set of the valid column keys, including those that are associated with * null values only. * * @return immutable set of column keys */ @Override public ImmutableSet<C> columnKeySet() { return columnKeyToIndex.keySet(); }
/** * Returns an immutable set of the valid row keys, including those that are associated with null * values only. * * @return immutable set of row keys */ @Override public ImmutableSet<R> rowKeySet() { return rowKeyToIndex.keySet(); }
@Override public String toString() { return "Sets.combinations(" + index.keySet() + ", " + size + ")"; } };
@Override public String toString() { return "Ordering.explicit(" + rankMap.keySet() + ")"; }
@Override public Set<K> keySet() { return keyIndex.keySet(); }
@Override public List<String> create(String[] elements) { ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder(); for (int i = 0; i < elements.length; i++) { builder.put(elements[i], i); } return builder.build().keySet().asList(); } }
@Override public ImmutableSet<R> rowKeySet() { return rowMap().keySet(); }
@Override public ImmutableSet<C> columnKeySet() { return columnMap().keySet(); }
K getKey(int index) { return keyIndex.keySet().asList().get(index); }
@Override public V put(K key, V value) { Integer index = keyIndex.get(key); if (index == null) { throw new IllegalArgumentException( getKeyRole() + " " + key + " not in " + keyIndex.keySet()); } return setValue(index, value); }
@Override public boolean contains(@Nullable Object o) { if (o instanceof Set) { Set<?> s = (Set<?>) o; return s.size() == size && index.keySet().containsAll(s); } return false; }
K getKey(int index) { return keyToIndex().keySet().asList().get(index); }
@Override public boolean contains(@Nullable Object obj) { if (obj instanceof Set) { Set<?> set = (Set<?>) obj; return inputSet.keySet().containsAll(set); } return false; }
@Override public int hashCode() { /* * The sum of the sums of the hash codes in each subset is just the sum of * each input element's hash code times the number of sets that element * appears in. Each element appears in exactly half of the 2^n sets, so: */ return inputSet.keySet().hashCode() << (inputSet.size() - 1); }
@Override ImmutableSet<K> createKeySet() { return isFull() ? keyToIndex().keySet() : super.createKeySet(); }
@GwtIncompatible("assumptions about splitting") public void testKeySetSplittable() { ImmutableMap<Integer, Integer> map = ImmutableMap.<Integer, Integer>builder() .put(1, 1) .put(2, 2) .put(3, 3) .put(4, 4) .put(5, 5) .put(6, 6) .build(); assertNotNull(map.keySet().spliterator().trySplit()); }
public void testHashing() { for (String stringToTest : INPUTS) { for (String algorithmToTest : ALGORITHMS.keySet()) { assertMessageDigestHashing(HashTestUtils.ascii(stringToTest), algorithmToTest); } } }
@AndroidIncompatible // Android forbids null parent ClassLoader public void testClassPathEntries_emptyURLClassLoader_noParent() { assertThat(ClassPath.Scanner.getClassPathEntries(new URLClassLoader(new URL[0], null)).keySet()) .isEmpty(); }
public void testCopyOf() { Table<Character, Integer, String> table = TreeBasedTable.create(); validateTableCopies(table); table.put('b', 2, "foo"); validateTableCopies(table); table.put('b', 1, "bar"); table.put('a', 2, "baz"); validateTableCopies(table); // Even though rowKeySet, columnKeySet, and cellSet have the same // iteration ordering, row has an inconsistent ordering. assertThat(table.row('b').keySet()).containsExactly(1, 2).inOrder(); assertThat(ImmutableTable.copyOf(table).row('b').keySet()).containsExactly(2, 1).inOrder(); }