package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nullable;
import nf;
import pq;
import px;
import qc;

@GwtCompatible
public abstract class ImmutableTable<R, C, V>
  extends nf<R, C, V>
{
  private static final ImmutableTable<Object, Object, Object> a = new qc(ImmutableList.of(), ImmutableSet.of(), ImmutableSet.of());
  
  protected static <R, C, V> Table.Cell<R, C, V> a(R paramR, C paramC, V paramV)
  {
    return Tables.immutableCell(Preconditions.checkNotNull(paramR), Preconditions.checkNotNull(paramC), Preconditions.checkNotNull(paramV));
  }
  
  public static <R, C, V> Builder<R, C, V> builder()
  {
    return new Builder();
  }
  
  public static <R, C, V> ImmutableTable<R, C, V> copyOf(Table<? extends R, ? extends C, ? extends V> paramTable)
  {
    if ((paramTable instanceof ImmutableTable)) {
      return (ImmutableTable)paramTable;
    }
    ImmutableSet.Builder localBuilder;
    switch (paramTable.size())
    {
    default: 
      localBuilder = ImmutableSet.builder();
      paramTable = paramTable.cellSet().iterator();
    }
    while (paramTable.hasNext())
    {
      Table.Cell localCell = (Table.Cell)paramTable.next();
      localBuilder.add(a(localCell.getRowKey(), localCell.getColumnKey(), localCell.getValue()));
      continue;
      return of();
      paramTable = (Table.Cell)Iterables.getOnlyElement(paramTable.cellSet());
      return of(paramTable.getRowKey(), paramTable.getColumnKey(), paramTable.getValue());
    }
    return pq.a(localBuilder.build(), null, null);
  }
  
  public static <R, C, V> ImmutableTable<R, C, V> of()
  {
    return a;
  }
  
  public static <R, C, V> ImmutableTable<R, C, V> of(R paramR, C paramC, V paramV)
  {
    return new px(paramR, paramC, paramV);
  }
  
  public ImmutableSet<Table.Cell<R, C, V>> cellSet()
  {
    return (ImmutableSet)super.cellSet();
  }
  
  @Deprecated
  public final void clear()
  {
    throw new UnsupportedOperationException();
  }
  
  public ImmutableMap<R, V> column(C paramC)
  {
    Preconditions.checkNotNull(paramC);
    return (ImmutableMap)MoreObjects.firstNonNull((ImmutableMap)columnMap().get(paramC), ImmutableMap.of());
  }
  
  public ImmutableSet<C> columnKeySet()
  {
    return columnMap().keySet();
  }
  
  public abstract ImmutableMap<C, Map<R, V>> columnMap();
  
  public boolean contains(@Nullable Object paramObject1, @Nullable Object paramObject2)
  {
    return get(paramObject1, paramObject2) != null;
  }
  
  public boolean containsValue(@Nullable Object paramObject)
  {
    return values().contains(paramObject);
  }
  
  final Iterator<V> d()
  {
    throw new AssertionError("should never be called");
  }
  
  protected abstract ImmutableSet<Table.Cell<R, C, V>> e();
  
  protected abstract ImmutableCollection<V> f();
  
  @Deprecated
  public final V put(R paramR, C paramC, V paramV)
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  public final void putAll(Table<? extends R, ? extends C, ? extends V> paramTable)
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  public final V remove(Object paramObject1, Object paramObject2)
  {
    throw new UnsupportedOperationException();
  }
  
  public ImmutableMap<C, V> row(R paramR)
  {
    Preconditions.checkNotNull(paramR);
    return (ImmutableMap)MoreObjects.firstNonNull((ImmutableMap)rowMap().get(paramR), ImmutableMap.of());
  }
  
  public ImmutableSet<R> rowKeySet()
  {
    return rowMap().keySet();
  }
  
  public abstract ImmutableMap<R, Map<C, V>> rowMap();
  
  public ImmutableCollection<V> values()
  {
    return (ImmutableCollection)super.values();
  }
  
  public static final class Builder<R, C, V>
  {
    private final List<Table.Cell<R, C, V>> a = Lists.newArrayList();
    private Comparator<? super R> b;
    private Comparator<? super C> c;
    
    public final ImmutableTable<R, C, V> build()
    {
      switch (this.a.size())
      {
      default: 
        return pq.a(this.a, this.b, this.c);
      case 0: 
        return ImmutableTable.of();
      }
      return new px((Table.Cell)Iterables.getOnlyElement(this.a));
    }
    
    public final Builder<R, C, V> orderColumnsBy(Comparator<? super C> paramComparator)
    {
      this.c = ((Comparator)Preconditions.checkNotNull(paramComparator));
      return this;
    }
    
    public final Builder<R, C, V> orderRowsBy(Comparator<? super R> paramComparator)
    {
      this.b = ((Comparator)Preconditions.checkNotNull(paramComparator));
      return this;
    }
    
    public final Builder<R, C, V> put(Table.Cell<? extends R, ? extends C, ? extends V> paramCell)
    {
      if ((paramCell instanceof Tables.b))
      {
        Preconditions.checkNotNull(paramCell.getRowKey());
        Preconditions.checkNotNull(paramCell.getColumnKey());
        Preconditions.checkNotNull(paramCell.getValue());
        this.a.add(paramCell);
        return this;
      }
      put(paramCell.getRowKey(), paramCell.getColumnKey(), paramCell.getValue());
      return this;
    }
    
    public final Builder<R, C, V> put(R paramR, C paramC, V paramV)
    {
      this.a.add(ImmutableTable.a(paramR, paramC, paramV));
      return this;
    }
    
    public final Builder<R, C, V> putAll(Table<? extends R, ? extends C, ? extends V> paramTable)
    {
      paramTable = paramTable.cellSet().iterator();
      while (paramTable.hasNext()) {
        put((Table.Cell)paramTable.next());
      }
      return this;
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/com/google/common/collect/ImmutableTable.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */