package com.google.common.collect;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Function;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
import com.google.common.base.Supplier;
import java.io.Serializable;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import javax.annotation.Nullable;
import nf;
import qe;

@GwtCompatible
public final class Tables
{
  private static final Function<? extends Map<?, ?>, ? extends Map<?, ?>> a = new Function() {};
  
  public static boolean a(Table<?, ?, ?> paramTable, @Nullable Object paramObject)
  {
    if (paramObject == paramTable) {
      return true;
    }
    if ((paramObject instanceof Table))
    {
      paramObject = (Table)paramObject;
      return paramTable.cellSet().equals(((Table)paramObject).cellSet());
    }
    return false;
  }
  
  public static <R, C, V> Table.Cell<R, C, V> immutableCell(@Nullable R paramR, @Nullable C paramC, @Nullable V paramV)
  {
    return new b(paramR, paramC, paramV);
  }
  
  @Beta
  public static <R, C, V> Table<R, C, V> newCustomTable(Map<R, Map<C, V>> paramMap, Supplier<? extends Map<C, V>> paramSupplier)
  {
    Preconditions.checkArgument(paramMap.isEmpty());
    Preconditions.checkNotNull(paramSupplier);
    return new qe(paramMap, paramSupplier);
  }
  
  @Beta
  public static <R, C, V1, V2> Table<R, C, V2> transformValues(Table<R, C, V1> paramTable, Function<? super V1, V2> paramFunction)
  {
    return new c(paramTable, paramFunction);
  }
  
  public static <R, C, V> Table<C, R, V> transpose(Table<R, C, V> paramTable)
  {
    if ((paramTable instanceof d)) {
      return ((d)paramTable).a;
    }
    return new d(paramTable);
  }
  
  @Beta
  public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(RowSortedTable<R, ? extends C, ? extends V> paramRowSortedTable)
  {
    return new e(paramRowSortedTable);
  }
  
  public static <R, C, V> Table<R, C, V> unmodifiableTable(Table<? extends R, ? extends C, ? extends V> paramTable)
  {
    return new f(paramTable);
  }
  
  static abstract class a<R, C, V>
    implements Table.Cell<R, C, V>
  {
    public boolean equals(Object paramObject)
    {
      if (paramObject == this) {}
      do
      {
        return true;
        if (!(paramObject instanceof Table.Cell)) {
          break;
        }
        paramObject = (Table.Cell)paramObject;
      } while ((Objects.equal(getRowKey(), ((Table.Cell)paramObject).getRowKey())) && (Objects.equal(getColumnKey(), ((Table.Cell)paramObject).getColumnKey())) && (Objects.equal(getValue(), ((Table.Cell)paramObject).getValue())));
      return false;
      return false;
    }
    
    public int hashCode()
    {
      return Objects.hashCode(new Object[] { getRowKey(), getColumnKey(), getValue() });
    }
    
    public String toString()
    {
      String str1 = String.valueOf(String.valueOf(getRowKey()));
      String str2 = String.valueOf(String.valueOf(getColumnKey()));
      String str3 = String.valueOf(String.valueOf(getValue()));
      return str1.length() + 4 + str2.length() + str3.length() + "(" + str1 + "," + str2 + ")=" + str3;
    }
  }
  
  static final class b<R, C, V>
    extends Tables.a<R, C, V>
    implements Serializable
  {
    private static final long serialVersionUID = 0L;
    private final R a;
    private final C b;
    private final V c;
    
    b(@Nullable R paramR, @Nullable C paramC, @Nullable V paramV)
    {
      this.a = paramR;
      this.b = paramC;
      this.c = paramV;
    }
    
    public final C getColumnKey()
    {
      return (C)this.b;
    }
    
    public final R getRowKey()
    {
      return (R)this.a;
    }
    
    public final V getValue()
    {
      return (V)this.c;
    }
  }
  
  static final class c<R, C, V1, V2>
    extends nf<R, C, V2>
  {
    final Table<R, C, V1> a;
    final Function<? super V1, V2> b;
    
    c(Table<R, C, V1> paramTable, Function<? super V1, V2> paramFunction)
    {
      this.a = ((Table)Preconditions.checkNotNull(paramTable));
      this.b = ((Function)Preconditions.checkNotNull(paramFunction));
    }
    
    final Iterator<Table.Cell<R, C, V2>> b()
    {
      Iterators.transform(this.a.cellSet().iterator(), new Function() {});
    }
    
    final Collection<V2> c()
    {
      return Collections2.transform(this.a.values(), this.b);
    }
    
    public final void clear()
    {
      this.a.clear();
    }
    
    public final Map<R, V2> column(C paramC)
    {
      return Maps.transformValues(this.a.column(paramC), this.b);
    }
    
    public final Set<C> columnKeySet()
    {
      return this.a.columnKeySet();
    }
    
    public final Map<C, Map<R, V2>> columnMap()
    {
      Function local3 = new Function() {};
      return Maps.transformValues(this.a.columnMap(), local3);
    }
    
    public final boolean contains(Object paramObject1, Object paramObject2)
    {
      return this.a.contains(paramObject1, paramObject2);
    }
    
    public final V2 get(Object paramObject1, Object paramObject2)
    {
      if (contains(paramObject1, paramObject2)) {
        return (V2)this.b.apply(this.a.get(paramObject1, paramObject2));
      }
      return null;
    }
    
    public final V2 put(R paramR, C paramC, V2 paramV2)
    {
      throw new UnsupportedOperationException();
    }
    
    public final void putAll(Table<? extends R, ? extends C, ? extends V2> paramTable)
    {
      throw new UnsupportedOperationException();
    }
    
    public final V2 remove(Object paramObject1, Object paramObject2)
    {
      if (contains(paramObject1, paramObject2)) {
        return (V2)this.b.apply(this.a.remove(paramObject1, paramObject2));
      }
      return null;
    }
    
    public final Map<C, V2> row(R paramR)
    {
      return Maps.transformValues(this.a.row(paramR), this.b);
    }
    
    public final Set<R> rowKeySet()
    {
      return this.a.rowKeySet();
    }
    
    public final Map<R, Map<C, V2>> rowMap()
    {
      Function local2 = new Function() {};
      return Maps.transformValues(this.a.rowMap(), local2);
    }
    
    public final int size()
    {
      return this.a.size();
    }
  }
  
  static final class d<C, R, V>
    extends nf<C, R, V>
  {
    private static final Function<Table.Cell<?, ?, ?>, Table.Cell<?, ?, ?>> b = new Function() {};
    final Table<R, C, V> a;
    
    d(Table<R, C, V> paramTable)
    {
      this.a = ((Table)Preconditions.checkNotNull(paramTable));
    }
    
    final Iterator<Table.Cell<C, R, V>> b()
    {
      return Iterators.transform(this.a.cellSet().iterator(), b);
    }
    
    public final void clear()
    {
      this.a.clear();
    }
    
    public final Map<C, V> column(R paramR)
    {
      return this.a.row(paramR);
    }
    
    public final Set<R> columnKeySet()
    {
      return this.a.rowKeySet();
    }
    
    public final Map<R, Map<C, V>> columnMap()
    {
      return this.a.rowMap();
    }
    
    public final boolean contains(@Nullable Object paramObject1, @Nullable Object paramObject2)
    {
      return this.a.contains(paramObject2, paramObject1);
    }
    
    public final boolean containsColumn(@Nullable Object paramObject)
    {
      return this.a.containsRow(paramObject);
    }
    
    public final boolean containsRow(@Nullable Object paramObject)
    {
      return this.a.containsColumn(paramObject);
    }
    
    public final boolean containsValue(@Nullable Object paramObject)
    {
      return this.a.containsValue(paramObject);
    }
    
    public final V get(@Nullable Object paramObject1, @Nullable Object paramObject2)
    {
      return (V)this.a.get(paramObject2, paramObject1);
    }
    
    public final V put(C paramC, R paramR, V paramV)
    {
      return (V)this.a.put(paramR, paramC, paramV);
    }
    
    public final void putAll(Table<? extends C, ? extends R, ? extends V> paramTable)
    {
      this.a.putAll(Tables.transpose(paramTable));
    }
    
    public final V remove(@Nullable Object paramObject1, @Nullable Object paramObject2)
    {
      return (V)this.a.remove(paramObject2, paramObject1);
    }
    
    public final Map<R, V> row(C paramC)
    {
      return this.a.column(paramC);
    }
    
    public final Set<C> rowKeySet()
    {
      return this.a.columnKeySet();
    }
    
    public final Map<C, Map<R, V>> rowMap()
    {
      return this.a.columnMap();
    }
    
    public final int size()
    {
      return this.a.size();
    }
    
    public final Collection<V> values()
    {
      return this.a.values();
    }
  }
  
  static final class e<R, C, V>
    extends Tables.f<R, C, V>
    implements RowSortedTable<R, C, V>
  {
    private static final long serialVersionUID = 0L;
    
    public e(RowSortedTable<R, ? extends C, ? extends V> paramRowSortedTable)
    {
      super();
    }
    
    public final SortedSet<R> rowKeySet()
    {
      return Collections.unmodifiableSortedSet(((RowSortedTable)super.delegate()).rowKeySet());
    }
    
    public final SortedMap<R, Map<C, V>> rowMap()
    {
      Function localFunction = Tables.a();
      return Collections.unmodifiableSortedMap(Maps.transformValues(((RowSortedTable)super.delegate()).rowMap(), localFunction));
    }
  }
  
  static class f<R, C, V>
    extends ForwardingTable<R, C, V>
    implements Serializable
  {
    private static final long serialVersionUID = 0L;
    final Table<? extends R, ? extends C, ? extends V> a;
    
    f(Table<? extends R, ? extends C, ? extends V> paramTable)
    {
      this.a = ((Table)Preconditions.checkNotNull(paramTable));
    }
    
    public Set<Table.Cell<R, C, V>> cellSet()
    {
      return Collections.unmodifiableSet(super.cellSet());
    }
    
    public void clear()
    {
      throw new UnsupportedOperationException();
    }
    
    public Map<R, V> column(@Nullable C paramC)
    {
      return Collections.unmodifiableMap(super.column(paramC));
    }
    
    public Set<C> columnKeySet()
    {
      return Collections.unmodifiableSet(super.columnKeySet());
    }
    
    public Map<C, Map<R, V>> columnMap()
    {
      Function localFunction = Tables.a();
      return Collections.unmodifiableMap(Maps.transformValues(super.columnMap(), localFunction));
    }
    
    protected Table<R, C, V> delegate()
    {
      return this.a;
    }
    
    public V put(@Nullable R paramR, @Nullable C paramC, @Nullable V paramV)
    {
      throw new UnsupportedOperationException();
    }
    
    public void putAll(Table<? extends R, ? extends C, ? extends V> paramTable)
    {
      throw new UnsupportedOperationException();
    }
    
    public V remove(@Nullable Object paramObject1, @Nullable Object paramObject2)
    {
      throw new UnsupportedOperationException();
    }
    
    public Map<C, V> row(@Nullable R paramR)
    {
      return Collections.unmodifiableMap(super.row(paramR));
    }
    
    public Set<R> rowKeySet()
    {
      return Collections.unmodifiableSet(super.rowKeySet());
    }
    
    public Map<R, Map<C, V>> rowMap()
    {
      Function localFunction = Tables.a();
      return Collections.unmodifiableMap(Maps.transformValues(super.rowMap(), localFunction));
    }
    
    public Collection<V> values()
    {
      return Collections.unmodifiableCollection(super.values());
    }
  }
}


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