All Downloads are FREE. Search and download functionalities are using the official Maven repository.

nl.topicus.jdbc.shaded.com.google.common.collect.TreeBasedTable Maven / Gradle / Ivy

Go to download

JDBC Driver for Google Cloud Spanner

There is a newer version: 1.1.6
Show newest version
/*
 * Copyright (C) 2008 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in nl.topicus.jdbc.shaded.com.liance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.nl.topicus.jdbc.shaded.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 nl.topicus.jdbc.shaded.com.google.nl.topicus.jdbc.shaded.com.on.collect;

import static nl.topicus.jdbc.shaded.com.google.nl.topicus.jdbc.shaded.com.on.base.Preconditions.checkArgument;
import static nl.topicus.jdbc.shaded.com.google.nl.topicus.jdbc.shaded.com.on.base.Preconditions.checkNotNull;

import nl.topicus.jdbc.shaded.com.google.nl.topicus.jdbc.shaded.com.on.annotations.GwtCompatible;
import nl.topicus.jdbc.shaded.com.google.nl.topicus.jdbc.shaded.com.on.base.Function;
import nl.topicus.jdbc.shaded.com.google.nl.topicus.jdbc.shaded.com.on.base.Supplier;
import java.nl.topicus.jdbc.shaded.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 nl.topicus.jdbc.shaded.javax.annotation.Nullable;

/**
 * Implementation of {@code Table} whose row keys and column keys are ordered
 * by their natural ordering or by supplied nl.topicus.jdbc.shaded.com.arators. When constructing a
 * {@code TreeBasedTable}, you may provide nl.topicus.jdbc.shaded.com.arators for the row keys and
 * the column keys, or you may use natural ordering for both.
 *
 * 
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.
 *
 * 
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.
 *
 * 
Lookups by row key are often faster than lookups by column key, because
 * the data is stored in a {@code Map>}. 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.
 *
 * 
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.
 *
 * 
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.
 *
 * 
See the Guava User Guide article on 
 * {@code Table}.
 *
 * @author Jared Levy
 * @author Louis Wasserman
 * @since 7.0
 */
@GwtCompatible(serializable = true)
public class TreeBasedTable extends StandardRowSortedTable {
  private final Comparator columnComparator;

  private static class Factory implements Supplier>, Serializable {
    final Comparator nl.topicus.jdbc.shaded.com.arator;

    Factory(Comparator nl.topicus.jdbc.shaded.com.arator) {
      this.nl.topicus.jdbc.shaded.com.arator = nl.topicus.jdbc.shaded.com.arator;
    }

    @Override
    public TreeMap get() {
      return new TreeMap(nl.topicus.jdbc.shaded.com.arator);
    }

    private static final long serialVersionUID = 0;
  }

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

  /**
   * Creates an empty {@code TreeBasedTable} that is ordered by the specified
   * nl.topicus.jdbc.shaded.com.arators.
   *
   * @param rowComparator the nl.topicus.jdbc.shaded.com.arator that orders the row keys
   * @param columnComparator the nl.topicus.jdbc.shaded.com.arator that orders the column keys
   */
  public static  TreeBasedTable create(
      Comparator rowComparator, Comparator columnComparator) {
    checkNotNull(rowComparator);
    checkNotNull(columnComparator);
    return new TreeBasedTable(rowComparator, columnComparator);
  }

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

  TreeBasedTable(Comparator rowComparator, Comparator columnComparator) {
    super(new TreeMap>(rowComparator), new Factory(columnComparator));
    this.columnComparator = columnComparator;
  }

  // TODO(jlevy): Move to StandardRowSortedTable?

  /**
   * Returns the nl.topicus.jdbc.shaded.com.arator that orders the rows. With natural ordering,
   * {@link Ordering#natural()} is returned.
   */
  public Comparator rowComparator() {
    return rowKeySet().nl.topicus.jdbc.shaded.com.arator();
  }

  /**
   * Returns the nl.topicus.jdbc.shaded.com.arator that orders the columns. With natural ordering,
   * {@link Ordering#natural()} is returned.
   */
  public Comparator columnComparator() {
    return columnComparator;
  }

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

  /**
   * {@inheritDoc}
   *
   * 
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
   *     (mostly source-nl.topicus.jdbc.shaded.com.atible since 7.0)
   */
  @Override
  public SortedMap row(R rowKey) {
    return new TreeRow(rowKey);
  }

  private class TreeRow extends Row implements SortedMap {
    @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 || nl.topicus.jdbc.shaded.com.are(lowerBound, upperBound) <= 0);
    }

    @Override
    public SortedSet keySet() {
      return new Maps.SortedKeySet(this);
    }

    @Override
    public Comparator nl.topicus.jdbc.shaded.com.arator() {
      return columnComparator();
    }

    int nl.topicus.jdbc.shaded.com.are(Object a, Object b) {
      // pretend we can nl.topicus.jdbc.shaded.com.are anything
      @SuppressWarnings({"rawtypes", "unchecked"})
      Comparator cmp = (Comparator) nl.topicus.jdbc.shaded.com.arator();
      return cmp.nl.topicus.jdbc.shaded.com.are(a, b);
    }

    boolean rangeContains(@Nullable Object o) {
      return o != null
          && (lowerBound == null || nl.topicus.jdbc.shaded.com.are(lowerBound, o) <= 0)
          && (upperBound == null || nl.topicus.jdbc.shaded.com.are(upperBound, o) > 0);
    }

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

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

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

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

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

    transient SortedMap wholeRow;

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

    @Override
    SortedMap backingRowMap() {
      return (SortedMap) super.backingRowMap();
    }

    @Override
    SortedMap nl.topicus.jdbc.shaded.com.uteBackingRowMap() {
      SortedMap 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 rowKeySet() {
    return super.rowKeySet();
  }

  @Override
  public SortedMap> rowMap() {
    return super.rowMap();
  }

  /**
   * Overridden column iterator to return columns values in globally sorted
   * order.
   */
  @Override
  Iterator createColumnKeyIterator() {
    final Comparator nl.topicus.jdbc.shaded.com.arator = columnComparator();

    final Iterator merged =
        Iterators.mergeSorted(
            Iterables.transform(
                backingMap.values(),
                new Function, Iterator>() {
                  @Override
                  public Iterator apply(Map input) {
                    return input.keySet().iterator();
                  }
                }),
            nl.topicus.jdbc.shaded.com.arator);

    return new AbstractIterator() {
      C lastValue;

      @Override
      protected C nl.topicus.jdbc.shaded.com.uteNext() {
        while (merged.hasNext()) {
          C next = merged.next();
          boolean duplicate = lastValue != null && nl.topicus.jdbc.shaded.com.arator.nl.topicus.jdbc.shaded.com.are(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;
}
    

    

    

            

    

            



    
    






    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy