Add Tables.wrap method for lists of vanilla data

ctrueden · ctrueden · commit 82888002d1f2 · 2018-12-26T10:44:54.000-06:00
If you have a list, each element of the list can be treated as a row in
a table with a single column. This method enables that sort of wrapping.
diff --git a/pom.xml b/pom.xml
@@ -10,7 +10,7 @@
 	</parent>
 
 	<artifactId>scijava-table</artifactId>
-	<version>0.3.1-SNAPSHOT</version>
+	<version>0.4.0-SNAPSHOT</version>
 
 	<name>SciJava Table</name>
 	<description>Table structures for SciJava.</description>
diff --git a/src/main/java/org/scijava/table/Tables.java b/src/main/java/org/scijava/table/Tables.java
@@ -46,6 +46,84 @@ private Tables() {
 		// NB: Prevent instantiation of utility class.
 	}
 
+	/**
+	 * Creates a single-column table wrapping a list. Each element is one row of
+	 * the table.
+	 * 
+	 * @param data The data to wrap. Each list element is a row.
+	 * @param colHeader Header to use for the table's sole column. Pass null for
+	 *          no column header.
+	 * @param rowHeaders List of row header labels. Pass null for no row headers.
+	 * @param <T> The type of data in each cell of the table.
+	 * @return A {@link Table} object wrapping the data structure.
+	 */
+	public static <T> Table<Column<T>, T> wrap(final List<T> data,
+		final String colHeader, final List<String> rowHeaders)
+	{
+		return new ReadOnlyTable<T>() {
+
+			@Override
+			public int getRowCount() {
+				return data.size();
+			}
+
+			@Override
+			public String getRowHeader(final int row) {
+				if (rowHeaders == null || rowHeaders.size() < row) return null;
+				return rowHeaders.get(row);
+			}
+
+			@Override
+			public int size() {
+				return 1;
+			}
+
+			@Override
+			public Column<T> get(final int col) {
+				if (col != 0) //
+					throw new IllegalArgumentException("Column out of range: " + col);
+				class ColumnAccessor implements ReadOnlyColumn<T> {
+
+					private final Object tableData = data;
+
+					@Override
+					public String getHeader() {
+						return colHeader;
+					}
+
+					@Override
+					public int size() {
+						return data.size();
+					}
+
+					@Override
+					public Class<T> getType() {
+						// TODO: Consider whether this is terrible.
+						throw new UnsupportedOperationException();
+					}
+
+					@Override
+					public T get(final int index) {
+						return data.get(index);
+					}
+
+					@Override
+					public int hashCode() {
+						return getHeader().hashCode();
+					}
+
+					@Override
+					public boolean equals(final Object obj) {
+						if (!(obj instanceof ColumnAccessor)) return false;
+						final ColumnAccessor other = ((ColumnAccessor) obj);
+						return data == other.tableData;
+					}
+				}
+				return new ColumnAccessor();
+			}
+		};
+	}
+
 	/**
 	 * Creates a table wrapping a list of maps. Each map is one row of the table.
 	 * Map keys are column names; map values are cell data.
diff --git a/src/test/java/org/scijava/table/TablesTest.java b/src/test/java/org/scijava/table/TablesTest.java
@@ -47,7 +47,37 @@
 public class TablesTest {
 
 	@Test
-	public void testWrap() {
+	public void testWrapList() {
+		final List<?> names = //
+			Arrays.asList("Phoebe", "Jezebel", "Daphne", "Fiona");
+		final String colHeader = "Name";
+		final List<String> rowHeaders = Arrays.asList("A", "B", "C", "D");
+		final Table<?, ?> table = Tables.wrap(names, colHeader, rowHeaders);
+
+		// check table dimensions
+		assertEquals(1, table.size());
+		assertEquals(1, table.getColumnCount());
+		assertEquals(4, table.getRowCount());
+
+		// check row headers
+		for (int r = 0; r < rowHeaders.size(); r++)
+			assertEquals(rowHeaders.get(r), table.getRowHeader(r));
+
+		// check direct data access
+		for (int i = 0; i < names.size(); i++)
+			assertEquals(names.get(i), table.get(0, i));
+
+		// check first column
+		assertEquals("Name", table.getColumnHeader(0));
+		final Column<?> nameColumn = table.get("Name");
+		assertEquals(4, nameColumn.size());
+		for (int i = 0; i < names.size(); i++)
+			assertEquals(names.get(i), nameColumn.get(i));
+		assertEquals(nameColumn, table.get(0));
+	}
+
+	@Test
+	public void testWrapMaps() {
 		final List<Map<Object, Object>> towns = Arrays.asList( //
 			map("Town", "Shanghai", "Population", 24_256_800), //
 			map("Town", "Karachi", "Population", 23_500_000), //
