@Override public Collection<V> values() { return original.values(); }
@Override Collection<V2> createValues() { return Collections2.transform(fromTable.values(), function); }
@Override public Collection<V> values() { synchronized (mutex) { return collection(delegate().values(), mutex); } }
@Override public Collection<V> values() { synchronized (mutex) { return collection(delegate().values(), mutex); } }
@Override public Collection<V> values() { return delegate().values(); }
@Override public Collection<V> values() { return delegate().values(); }
@Override public Collection<V> values() { assertTrue(Thread.holdsLock(mutex)); /* TODO: verify that the Collection is also synchronized? */ return delegate.values(); }
@Override protected Collection<String> create(String[] elements) { List<Integer> rowKeys = Lists.newArrayList(); for (int i = 0; i < elements.length; i++) { rowKeys.add(i); } Table<Integer, Character, String> table = ArrayTable.create(rowKeys, ImmutableList.of('a')); populateForValues(table, elements); return table.values(); } })
@Override protected Collection<String> create(String[] elements) { Table<Integer, Character, String> table = HashBasedTable.create(); for (int i = 0; i < elements.length; i++) { table.put(i, 'a', "x" + checkNotNull(elements[i])); } return Tables.transformValues(table, removeFirstCharacter).values(); } })
@Override protected Collection<String> create(String[] elements) { Table<Integer, Character, String> table = HashBasedTable.create(); table.put(1, 'a', "foo"); table.clear(); populateForValues(table, elements); return table.values(); } })
@Override protected Collection<String> create(String[] elements) { Table<Integer, Character, String> table = TreeBasedTable.create(); table.put(1, 'a', "foo"); table.clear(); populateForValues(table, elements); return table.values(); } })
public void testValuesToString_ordered() { table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c'); assertEquals("[a, null, c, b, null, null, null, null, null]", table.values().toString()); }
public void testValuesToString_ordered() { table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c'); assertEquals("[b, a, c]", table.values().toString()); }
@Override protected Collection<String> create(String[] elements) { Table<Integer, Character, String> table = HashBasedTable.create(); table.put(1, 'a', "foo"); table.clear(); populateForValues(table, elements); return Tables.unmodifiableTable(table).values(); } })
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(); }
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 testBuilder_orderRowsAndColumnsBy_putAll() { Table<Character, Integer, String> table = HashBasedTable.create(); table.put('b', 2, "foo"); table.put('b', 1, "bar"); table.put('a', 2, "baz"); ImmutableTable.Builder<Character, Integer, String> builder = ImmutableTable.builder(); Table<Character, Integer, String> copy = builder .orderRowsBy(Ordering.natural()) .orderColumnsBy(Ordering.natural()) .putAll(table) .build(); assertThat(copy.rowKeySet()).containsExactly('a', 'b').inOrder(); assertThat(copy.columnKeySet()).containsExactly(1, 2).inOrder(); assertThat(copy.values()).containsExactly("baz", "bar", "foo").inOrder(); assertThat(copy.row('b').keySet()).containsExactly(1, 2).inOrder(); }
public void testBuilder_orderRowsAndColumnsBy_dense() { ImmutableTable.Builder<Character, Integer, String> builder = ImmutableTable.builder(); builder.orderRowsBy(Ordering.natural()); builder.orderColumnsBy(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.columnKeySet()).containsExactly(1, 2, 3).inOrder(); assertThat(table.values()) .containsExactly("baz", "bar", "foo", "dog", "cat", "baz", "bar", "foo") .inOrder(); assertThat(table.row('c').keySet()).containsExactly(1, 2, 3).inOrder(); assertThat(table.column(1).keySet()).containsExactly('a', 'b', 'c').inOrder(); }
public void testBuilder_orderRowsAndColumnsBy_sparse() { ImmutableTable.Builder<Character, Integer, String> builder = ImmutableTable.builder(); builder.orderRowsBy(Ordering.natural()); builder.orderColumnsBy(Ordering.natural()); builder.put('x', 2, "foo"); builder.put('r', 1, "bar"); builder.put('c', 3, "baz"); builder.put('b', 7, "cat"); builder.put('e', 5, "dog"); builder.put('c', 0, "axe"); builder.put('e', 3, "tub"); builder.put('r', 4, "foo"); builder.put('x', 5, "bar"); Table<Character, Integer, String> table = builder.build(); assertThat(table.rowKeySet()).containsExactly('b', 'c', 'e', 'r', 'x').inOrder(); assertThat(table.columnKeySet()).containsExactly(0, 1, 2, 3, 4, 5, 7).inOrder(); assertThat(table.values()) .containsExactly("cat", "axe", "baz", "tub", "dog", "bar", "foo", "foo", "bar") .inOrder(); assertThat(table.row('c').keySet()).containsExactly(0, 3).inOrder(); assertThat(table.column(5).keySet()).containsExactly('e', 'x').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")); } }