EaglerForge/sources/main/java/com/google/common/collect/TreeBasedTable.java

/*
 * Copyright (C) 2008 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 static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;

import java.io.Serializable;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;

import javax.annotation.Nullable;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Function;
import com.google.common.base.Supplier;

/**
 * Implementation of {@code Table} whose row keys and column keys are ordered by
 * their natural ordering or by supplied comparators. When constructing a
 * {@code TreeBasedTable}, you may provide comparators for the row keys and the
 * column keys, or you may use natural ordering for both.
 *
 * <p>
 * The {@link #rowKeySet} method returns a {@link SortedSet} and the
 * {@link #rowMap} method returns a {@link SortedMap}, instead of the
 * {@link Set} and {@link Map} specified by the {@link Table} interface.
 *
 * <p>
 * The views returned by {@link #column}, {@link #columnKeySet()}, and
 * {@link #columnMap()} have iterators that don't support {@code remove()}.
 * Otherwise, all optional operations are supported. Null row keys, columns
 * keys, and values are not supported.
 *
 * <p>
 * Lookups by row key are often faster than lookups by column key, because the
 * data is stored in a {@code Map<R, Map<C, V>>}. A method call like {@code
 * column(columnKey).get(rowKey)} still runs quickly, since the row key is
 * provided. However, {@code column(columnKey).size()} takes longer, since an
 * iteration across all row keys occurs.
 *
 * <p>
 * Because a {@code TreeBasedTable} has unique sorted values for a given row,
 * both {@code row(rowKey)} and {@code rowMap().get(rowKey)} are
 * {@link SortedMap} instances, instead of the {@link Map} specified in the
 * {@link Table} interface.
 *
 * <p>
 * Note that this implementation is not synchronized. If multiple threads access
 * this table concurrently and one of the threads modifies the table, it must be
 * synchronized externally.
 *
 * <p>
 * See the Guava User Guide article on <a href=
 * "http://code.google.com/p/guava-libraries/wiki/NewCollectionTypesExplained#Table">
 * {@code Table}</a>.
 *
 * @author Jared Levy
 * @author Louis Wasserman
 * @since 7.0
 */
@GwtCompatible(serializable = true)
@Beta
public class TreeBasedTable<R, C, V> extends StandardRowSortedTable<R, C, V> {
	private final Comparator<? super C> columnComparator;

	private static class Factory<C, V> implements Supplier<TreeMap<C, V>>, Serializable {
		final Comparator<? super C> comparator;

		Factory(Comparator<? super C> comparator) {
			this.comparator = comparator;
		}

		@Override
		public TreeMap<C, V> get() {
			return new TreeMap<C, V>(comparator);
		}

		private static final long serialVersionUID = 0;
	}

	/**
	 * Creates an empty {@code TreeBasedTable} that uses the natural orderings of
	 * both row and column keys.
	 *
	 * <p>
	 * The method signature specifies {@code R extends Comparable} with a raw
	 * {@link Comparable}, instead of {@code R extends Comparable<? super R>}, and
	 * the same for {@code C}. That's necessary to support classes defined without
	 * generics.
	 */
	public static <R extends Comparable, C extends Comparable, V> TreeBasedTable<R, C, V> create() {
		return new TreeBasedTable<R, C, V>(Ordering.natural(), Ordering.natural());
	}

	/**
	 * Creates an empty {@code TreeBasedTable} that is ordered by the specified
	 * comparators.
	 *
	 * @param rowComparator    the comparator that orders the row keys
	 * @param columnComparator the comparator that orders the column keys
	 */
	public static <R, C, V> TreeBasedTable<R, C, V> create(Comparator<? super R> rowComparator,
			Comparator<? super C> columnComparator) {
		checkNotNull(rowComparator);
		checkNotNull(columnComparator);
		return new TreeBasedTable<R, C, V>(rowComparator, columnComparator);
	}

	/**
	 * Creates a {@code TreeBasedTable} with the same mappings and sort order as the
	 * specified {@code TreeBasedTable}.
	 */
	public static <R, C, V> TreeBasedTable<R, C, V> create(TreeBasedTable<R, C, ? extends V> table) {
		TreeBasedTable<R, C, V> result = new TreeBasedTable<R, C, V>(table.rowComparator(), table.columnComparator());
		result.putAll(table);
		return result;
	}

	TreeBasedTable(Comparator<? super R> rowComparator, Comparator<? super C> columnComparator) {
		super(new TreeMap<R, Map<C, V>>(rowComparator), new Factory<C, V>(columnComparator));
		this.columnComparator = columnComparator;
	}

	// TODO(jlevy): Move to StandardRowSortedTable?

	/**
	 * Returns the comparator that orders the rows. With natural ordering,
	 * {@link Ordering#natural()} is returned.
	 */
	public Comparator<? super R> rowComparator() {
		return rowKeySet().comparator();
	}

	/**
	 * Returns the comparator that orders the columns. With natural ordering,
	 * {@link Ordering#natural()} is returned.
	 */
	public Comparator<? super C> columnComparator() {
		return columnComparator;
	}

	// TODO(user): make column return a SortedMap

	/**
	 * {@inheritDoc}
	 *
	 * <p>
	 * Because a {@code TreeBasedTable} has unique sorted values for a given row,
	 * this method returns a {@link SortedMap}, instead of the {@link Map} specified
	 * in the {@link Table} interface.
	 * 
	 * @since 10.0
	 *        (<a href="http://code.google.com/p/guava-libraries/wiki/Compatibility"
	 *        >mostly source-compatible</a> since 7.0)
	 */
	@Override
	public SortedMap<C, V> row(R rowKey) {
		return new TreeRow(rowKey);
	}

	private class TreeRow extends Row implements SortedMap<C, V> {
		@Nullable
		final C lowerBound;
		@Nullable
		final C upperBound;

		TreeRow(R rowKey) {
			this(rowKey, null, null);
		}

		TreeRow(R rowKey, @Nullable C lowerBound, @Nullable C upperBound) {
			super(rowKey);
			this.lowerBound = lowerBound;
			this.upperBound = upperBound;
			checkArgument(lowerBound == null || upperBound == null || compare(lowerBound, upperBound) <= 0);
		}

		@Override
		public SortedSet<C> keySet() {
			return new Maps.SortedKeySet<C, V>(this);
		}

		@Override
		public Comparator<? super C> comparator() {
			return columnComparator();
		}

		int compare(Object a, Object b) {
			// pretend we can compare anything
			@SuppressWarnings({ "rawtypes", "unchecked" })
			Comparator<Object> cmp = (Comparator) comparator();
			return cmp.compare(a, b);
		}

		boolean rangeContains(@Nullable Object o) {
			return o != null && (lowerBound == null || compare(lowerBound, o) <= 0)
					&& (upperBound == null || compare(upperBound, o) > 0);
		}

		@Override
		public SortedMap<C, V> subMap(C fromKey, C toKey) {
			checkArgument(rangeContains(checkNotNull(fromKey)) && rangeContains(checkNotNull(toKey)));
			return new TreeRow(rowKey, fromKey, toKey);
		}

		@Override
		public SortedMap<C, V> headMap(C toKey) {
			checkArgument(rangeContains(checkNotNull(toKey)));
			return new TreeRow(rowKey, lowerBound, toKey);
		}

		@Override
		public SortedMap<C, V> tailMap(C fromKey) {
			checkArgument(rangeContains(checkNotNull(fromKey)));
			return new TreeRow(rowKey, fromKey, upperBound);
		}

		@Override
		public C firstKey() {
			SortedMap<C, V> backing = backingRowMap();
			if (backing == null) {
				throw new NoSuchElementException();
			}
			return backingRowMap().firstKey();
		}

		@Override
		public C lastKey() {
			SortedMap<C, V> backing = backingRowMap();
			if (backing == null) {
				throw new NoSuchElementException();
			}
			return backingRowMap().lastKey();
		}

		transient SortedMap<C, V> wholeRow;

		/*
		 * If the row was previously empty, we check if there's a new row here every
		 * time we're queried.
		 */
		SortedMap<C, V> wholeRow() {
			if (wholeRow == null || (wholeRow.isEmpty() && backingMap.containsKey(rowKey))) {
				wholeRow = (SortedMap<C, V>) backingMap.get(rowKey);
			}
			return wholeRow;
		}

		@Override
		SortedMap<C, V> backingRowMap() {
			return (SortedMap<C, V>) super.backingRowMap();
		}

		@Override
		SortedMap<C, V> computeBackingRowMap() {
			SortedMap<C, V> map = wholeRow();
			if (map != null) {
				if (lowerBound != null) {
					map = map.tailMap(lowerBound);
				}
				if (upperBound != null) {
					map = map.headMap(upperBound);
				}
				return map;
			}
			return null;
		}

		@Override
		void maintainEmptyInvariant() {
			if (wholeRow() != null && wholeRow.isEmpty()) {
				backingMap.remove(rowKey);
				wholeRow = null;
				backingRowMap = null;
			}
		}

		@Override
		public boolean containsKey(Object key) {
			return rangeContains(key) && super.containsKey(key);
		}

		@Override
		public V put(C key, V value) {
			checkArgument(rangeContains(checkNotNull(key)));
			return super.put(key, value);
		}
	}

	// rowKeySet() and rowMap() are defined here so they appear in the Javadoc.

	@Override
	public SortedSet<R> rowKeySet() {
		return super.rowKeySet();
	}

	@Override
	public SortedMap<R, Map<C, V>> rowMap() {
		return super.rowMap();
	}

	/**
	 * Overridden column iterator to return columns values in globally sorted order.
	 */
	@Override
	Iterator<C> createColumnKeyIterator() {
		final Comparator<? super C> comparator = columnComparator();

		final Iterator<C> merged = Iterators
				.mergeSorted(Iterables.transform(backingMap.values(), new Function<Map<C, V>, Iterator<C>>() {
					@Override
					public Iterator<C> apply(Map<C, V> input) {
						return input.keySet().iterator();
					}
				}), comparator);

		return new AbstractIterator<C>() {
			C lastValue;

			@Override
			protected C computeNext() {
				while (merged.hasNext()) {
					C next = merged.next();
					boolean duplicate = lastValue != null && comparator.compare(next, lastValue) == 0;

					// Keep looping till we find a non-duplicate value.
					if (!duplicate) {
						lastValue = next;
						return lastValue;
					}
				}

				lastValue = null; // clear reference to unused data
				return endOfData();
			}
		};
	}

	private static final long serialVersionUID = 0;
}