@Override public Set<R> rowKeySet() { return fromTable.rowKeySet(); }
@Override public Set<R> columnKeySet() { return original.rowKeySet(); }
@Override public Set<R> rowKeySet() { return delegate().rowKeySet(); }
@Override public Set<R> rowKeySet() { assertTrue(Thread.holdsLock(mutex)); return delegate.rowKeySet(); }
@Override public Set<R> rowKeySet() { synchronized (mutex) { return set(delegate().rowKeySet(), mutex); } }
private ArrayTable(Table<R, C, V> table) { this(table.rowKeySet(), table.columnKeySet()); putAll(table); }
@Override protected Set<String> create(String[] elements) { Table<String, Integer, Character> table = HashBasedTable.create(); populateForRowKeySet(table, elements); return table.rowKeySet(); } })
@Override protected Set<String> create(String[] elements) { Table<String, Integer, Character> table = ArrayTable.create(ImmutableList.copyOf(elements), ImmutableList.of(1, 2)); populateForRowKeySet(table, elements); return table.rowKeySet(); } })
public void testRowKeySetToString_ordered() { table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c'); assertEquals("[foo, bar, cat]", table.rowKeySet().toString()); }
public void testRowKeySetToString_ordered() { table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c'); assertEquals("[bar, foo]", table.rowKeySet().toString()); }
@Override protected Set<String> create(String[] elements) { Table<String, Integer, Character> table = HashBasedTable.create(); populateForRowKeySet(table, elements); return Tables.unmodifiableTable(table).rowKeySet(); } })
public void testCreateExplicitComparators() { table = TreeBasedTable.create(Collections.reverseOrder(), Ordering.usingToString()); table.put("foo", 3, 'a'); table.put("foo", 12, 'b'); table.put("bar", 5, 'c'); table.put("cat", 8, 'd'); assertThat(table.rowKeySet()).containsExactly("foo", "cat", "bar").inOrder(); assertThat(table.row("foo").keySet()).containsExactly(12, 3).inOrder(); }
public void testRowKeySetOrdering() { table = create("foo", 3, 'a', "bar", 1, 'b', "foo", 2, 'c'); assertThat(table.rowKeySet()).containsExactly("foo", "bar").inOrder(); }
public void testCreateCopyArrayTable() { Table<String, Integer, Character> original = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c'); Table<String, Integer, Character> copy = ArrayTable.create(original); assertEquals(original, copy); original.put("foo", 1, 'd'); assertEquals((Character) 'd', original.get("foo", 1)); assertEquals((Character) 'a', copy.get("foo", 1)); assertEquals(copy.rowKeySet(), original.rowKeySet()); assertEquals(copy.columnKeySet(), original.columnKeySet()); }
private static <R, C, V> void validateViewOrdering(Table<R, C, V> original, Table<R, C, V> copy) { assertThat(copy.cellSet()).containsExactlyElementsIn(original.cellSet()).inOrder(); assertThat(copy.rowKeySet()).containsExactlyElementsIn(original.rowKeySet()).inOrder(); assertThat(copy.values()).containsExactlyElementsIn(original.values()).inOrder(); }
private static <R, C, V> void validateReserialization(Table<R, C, V> original) { Table<R, C, V> copy = SerializableTester.reserializeAndAssert(original); assertThat(copy.cellSet()).containsExactlyElementsIn(original.cellSet()).inOrder(); assertThat(copy.rowKeySet()).containsExactlyElementsIn(original.rowKeySet()).inOrder(); assertThat(copy.columnKeySet()).containsExactlyElementsIn(original.columnKeySet()).inOrder(); }
public void testIterationOrder() { Table<String, String, String> table = HashBasedTable.create(); for (int i = 0; i < 5; i++) { table.put("r" + i, "c" + i, "v" + i); } assertThat(table.rowKeySet()).containsExactly("r0", "r1", "r2", "r3", "r4").inOrder(); assertThat(table.columnKeySet()).containsExactly("c0", "c1", "c2", "c3", "c4").inOrder(); assertThat(table.values()).containsExactly("v0", "v1", "v2", "v3", "v4").inOrder(); }
public void testCreateCopy() { TreeBasedTable<String, Integer, Character> original = TreeBasedTable.create(Collections.reverseOrder(), Ordering.usingToString()); original.put("foo", 3, 'a'); original.put("foo", 12, 'b'); original.put("bar", 5, 'c'); original.put("cat", 8, 'd'); table = TreeBasedTable.create(original); assertThat(table.rowKeySet()).containsExactly("foo", "cat", "bar").inOrder(); assertThat(table.row("foo").keySet()).containsExactly(12, 3).inOrder(); assertEquals(original, table); }
public void testBuilder_orderRowsBy_dense() { ImmutableTable.Builder<Character, Integer, String> builder = ImmutableTable.builder(); builder.orderRowsBy(Ordering.natural()); builder.put('c', 3, "foo"); builder.put('c', 2, "bar"); builder.put('c', 1, "baz"); builder.put('b', 3, "cat"); builder.put('b', 1, "dog"); builder.put('a', 3, "foo"); builder.put('a', 2, "bar"); builder.put('a', 1, "baz"); Table<Character, Integer, String> table = builder.build(); assertThat(table.rowKeySet()).containsExactly('a', 'b', 'c').inOrder(); assertThat(table.column(1).keySet()).containsExactly('a', 'b', 'c').inOrder(); }
public void testTransposedViews() { Table<Integer, String, Character> original = HashBasedTable.create(); Table<String, Integer, Character> transpose = Tables.transpose(original); original.put(1, "foo", 'a'); assertSame(original.columnKeySet(), transpose.rowKeySet()); assertSame(original.rowKeySet(), transpose.columnKeySet()); assertSame(original.columnMap(), transpose.rowMap()); assertSame(original.rowMap(), transpose.columnMap()); assertSame(original.values(), transpose.values()); assertEquals(original.row(1), transpose.column(1)); assertEquals(original.row(2), transpose.column(2)); assertEquals(original.column("foo"), transpose.row("foo")); assertEquals(original.column("bar"), transpose.row("bar")); } }