Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.Map;
 
 import  javax.annotation.concurrent.Immutable;

A RegularImmutableTable optimized for sparse data.
 
 @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> rowSpaceImmutableSet<C> columnSpace) {
     Map<R, IntegerrowIndex = Maps.newHashMap();
     Map<R, Map<C, V>> rows = Maps.newLinkedHashMap();
     for (R row : rowSpace) {
       rowIndex.put(rowrows.size());
       rows.put(rownew LinkedHashMap<C, V>());
     }
     Map<C, Map<R, V>> columns = Maps.newLinkedHashMap();
     for (C col : columnSpace) {
       columns.put(colnew 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(columnKeyvalue);
       if (oldValue != null) {
         throw new IllegalArgumentException("Duplicate value for row=" + rowKey + ", column="
             + columnKey + ": " + value + ", " + oldValue);
       }
       columns.get(columnKey).put(rowKeyvalue);
     }
     this. = iterationOrderRow;
     this. = 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. = 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. = columnBuilder.build();
   }
 
   @Override public ImmutableMap<C, Map<R, V>> columnMap() {
     return ;
   }
 
   @Override public ImmutableMap<R, Map<C, V>> rowMap() {
     return ;
   }
 
   @Override
   public int size() {
     return .;
   }
   
   @Override
   Cell<R, C, V> getCell(int index) {
     int rowIndex = [index];
     Map.Entry<R, Map<C, V>> rowEntry = .entrySet().asList().get(rowIndex);
     ImmutableMap<C, V> row = (ImmutableMap<C, V>) rowEntry.getValue();
    int columnIndex = [index];
    Map.Entry<C, V> colEntry = row.entrySet().asList().get(columnIndex);
    return cellOf(rowEntry.getKey(), colEntry.getKey(), colEntry.getValue());
  }
  V getValue(int index) {
    int rowIndex = [index];
    ImmutableMap<C, V> row = (ImmutableMap<C, V>) .values().asList().get(rowIndex);
    int columnIndex = [index];
    return row.values().asList().get(columnIndex);
  }
New to GrepCode? Check out our FAQ X