Update #0 - First Release

sources/main/java/com/google/common/collect/SparseImmutableTable.java

@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2009 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.common.collect;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import javax.annotation.concurrent.Immutable;
+
+import com.google.common.annotations.GwtCompatible;
+
+/**
+ * A {@code RegularImmutableTable} optimized for sparse data.
+ */
+@GwtCompatible
+@Immutable
+final class SparseImmutableTable<R, C, V> extends RegularImmutableTable<R, C, V> {
+
+	private final ImmutableMap<R, Map<C, V>> rowMap;
+	private final ImmutableMap<C, Map<R, V>> columnMap;
+	private final int[] iterationOrderRow;
+	private final int[] iterationOrderColumn;
+
+	SparseImmutableTable(ImmutableList<Cell<R, C, V>> cellList, ImmutableSet<R> rowSpace, ImmutableSet<C> columnSpace) {
+		Map<R, Integer> rowIndex = Maps.newHashMap();
+		Map<R, Map<C, V>> rows = Maps.newLinkedHashMap();
+		for (R row : rowSpace) {
+			rowIndex.put(row, rows.size());
+			rows.put(row, new LinkedHashMap<C, V>());
+		}
+		Map<C, Map<R, V>> columns = Maps.newLinkedHashMap();
+		for (C col : columnSpace) {
+			columns.put(col, new LinkedHashMap<R, V>());
+		}
+		int[] iterationOrderRow = new int[cellList.size()];
+		int[] iterationOrderColumn = new int[cellList.size()];
+		for (int i = 0; i < cellList.size(); i++) {
+			Cell<R, C, V> cell = cellList.get(i);
+			R rowKey = cell.getRowKey();
+			C columnKey = cell.getColumnKey();
+			V value = cell.getValue();
+
+			iterationOrderRow[i] = rowIndex.get(rowKey);
+			Map<C, V> thisRow = rows.get(rowKey);
+			iterationOrderColumn[i] = thisRow.size();
+			V oldValue = thisRow.put(columnKey, value);
+			if (oldValue != null) {
+				throw new IllegalArgumentException(
+						"Duplicate value for row=" + rowKey + ", column=" + columnKey + ": " + value + ", " + oldValue);
+			}
+			columns.get(columnKey).put(rowKey, value);
+		}
+		this.iterationOrderRow = iterationOrderRow;
+		this.iterationOrderColumn = iterationOrderColumn;
+		ImmutableMap.Builder<R, Map<C, V>> rowBuilder = ImmutableMap.builder();
+		for (Map.Entry<R, Map<C, V>> row : rows.entrySet()) {
+			rowBuilder.put(row.getKey(), ImmutableMap.copyOf(row.getValue()));
+		}
+		this.rowMap = rowBuilder.build();
+
+		ImmutableMap.Builder<C, Map<R, V>> columnBuilder = ImmutableMap.builder();
+		for (Map.Entry<C, Map<R, V>> col : columns.entrySet()) {
+			columnBuilder.put(col.getKey(), ImmutableMap.copyOf(col.getValue()));
+		}
+		this.columnMap = columnBuilder.build();
+	}
+
+	@Override
+	public ImmutableMap<C, Map<R, V>> columnMap() {
+		return columnMap;
+	}
+
+	@Override
+	public ImmutableMap<R, Map<C, V>> rowMap() {
+		return rowMap;
+	}
+
+	@Override
+	public int size() {
+		return iterationOrderRow.length;
+	}
+
+	@Override
+	Cell<R, C, V> getCell(int index) {
+		int rowIndex = iterationOrderRow[index];
+		Map.Entry<R, Map<C, V>> rowEntry = rowMap.entrySet().asList().get(rowIndex);
+		ImmutableMap<C, V> row = (ImmutableMap<C, V>) rowEntry.getValue();
+		int columnIndex = iterationOrderColumn[index];
+		Map.Entry<C, V> colEntry = row.entrySet().asList().get(columnIndex);
+		return cellOf(rowEntry.getKey(), colEntry.getKey(), colEntry.getValue());
+	}
+
+	@Override
+	V getValue(int index) {
+		int rowIndex = iterationOrderRow[index];
+		ImmutableMap<C, V> row = (ImmutableMap<C, V>) rowMap.values().asList().get(rowIndex);
+		int columnIndex = iterationOrderColumn[index];
+		return row.values().asList().get(columnIndex);
+	}
+}