package com.google.common.base;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.annotation.CheckReturnValue;
import mh;

@GwtCompatible(emulated=true)
public final class Splitter
{
  private final CharMatcher a;
  private final boolean b;
  private final b c;
  private final int d;
  
  private Splitter(b paramb)
  {
    this(paramb, false, CharMatcher.NONE, Integer.MAX_VALUE);
  }
  
  private Splitter(b paramb, boolean paramBoolean, CharMatcher paramCharMatcher, int paramInt)
  {
    this.c = paramb;
    this.b = paramBoolean;
    this.a = paramCharMatcher;
    this.d = paramInt;
  }
  
  private Iterator<String> a(CharSequence paramCharSequence)
  {
    return this.c.a(this, paramCharSequence);
  }
  
  public static Splitter fixedLength(int paramInt)
  {
    if (paramInt > 0) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "The length may not be less than 1");
      new Splitter(new b() {});
    }
  }
  
  public static Splitter on(char paramChar)
  {
    return on(CharMatcher.is(paramChar));
  }
  
  public static Splitter on(CharMatcher paramCharMatcher)
  {
    Preconditions.checkNotNull(paramCharMatcher);
    new Splitter(new b() {});
  }
  
  public static Splitter on(String paramString)
  {
    if (paramString.length() != 0) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "The separator may not be the empty string.");
      new Splitter(new b() {});
    }
  }
  
  @GwtIncompatible("java.util.regex")
  public static Splitter on(Pattern paramPattern)
  {
    Preconditions.checkNotNull(paramPattern);
    if (!paramPattern.matcher("").matches()) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "The pattern may not match the empty string: %s", new Object[] { paramPattern });
      new Splitter(new b() {});
    }
  }
  
  @GwtIncompatible("java.util.regex")
  public static Splitter onPattern(String paramString)
  {
    return on(Pattern.compile(paramString));
  }
  
  @CheckReturnValue
  public final Splitter limit(int paramInt)
  {
    if (paramInt > 0) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "must be greater than zero: %s", new Object[] { Integer.valueOf(paramInt) });
      return new Splitter(this.c, this.b, this.a, paramInt);
    }
  }
  
  @CheckReturnValue
  public final Splitter omitEmptyStrings()
  {
    return new Splitter(this.c, true, this.a, this.d);
  }
  
  public final Iterable<String> split(final CharSequence paramCharSequence)
  {
    Preconditions.checkNotNull(paramCharSequence);
    new Iterable()
    {
      public final Iterator<String> iterator()
      {
        return Splitter.a(Splitter.this, paramCharSequence);
      }
      
      public final String toString()
      {
        return ']';
      }
    };
  }
  
  @Beta
  public final List<String> splitToList(CharSequence paramCharSequence)
  {
    Preconditions.checkNotNull(paramCharSequence);
    paramCharSequence = a(paramCharSequence);
    ArrayList localArrayList = new ArrayList();
    while (paramCharSequence.hasNext()) {
      localArrayList.add(paramCharSequence.next());
    }
    return Collections.unmodifiableList(localArrayList);
  }
  
  @CheckReturnValue
  public final Splitter trimResults()
  {
    return trimResults(CharMatcher.WHITESPACE);
  }
  
  @CheckReturnValue
  public final Splitter trimResults(CharMatcher paramCharMatcher)
  {
    Preconditions.checkNotNull(paramCharMatcher);
    return new Splitter(this.c, this.b, paramCharMatcher, this.d);
  }
  
  @CheckReturnValue
  @Beta
  public final MapSplitter withKeyValueSeparator(char paramChar)
  {
    return withKeyValueSeparator(on(paramChar));
  }
  
  @CheckReturnValue
  @Beta
  public final MapSplitter withKeyValueSeparator(Splitter paramSplitter)
  {
    return new MapSplitter(this, paramSplitter, (byte)0);
  }
  
  @CheckReturnValue
  @Beta
  public final MapSplitter withKeyValueSeparator(String paramString)
  {
    return withKeyValueSeparator(on(paramString));
  }
  
  @Beta
  public static final class MapSplitter
  {
    private final Splitter a;
    private final Splitter b;
    
    private MapSplitter(Splitter paramSplitter1, Splitter paramSplitter2)
    {
      this.a = paramSplitter1;
      this.b = ((Splitter)Preconditions.checkNotNull(paramSplitter2));
    }
    
    public final Map<String, String> split(CharSequence paramCharSequence)
    {
      LinkedHashMap localLinkedHashMap = new LinkedHashMap();
      paramCharSequence = this.a.split(paramCharSequence).iterator();
      if (paramCharSequence.hasNext())
      {
        String str1 = (String)paramCharSequence.next();
        Iterator localIterator = Splitter.a(this.b, str1);
        Preconditions.checkArgument(localIterator.hasNext(), "Chunk [%s] is not a valid entry", new Object[] { str1 });
        String str2 = (String)localIterator.next();
        if (!localLinkedHashMap.containsKey(str2))
        {
          bool = true;
          label99:
          Preconditions.checkArgument(bool, "Duplicate key [%s] found.", new Object[] { str2 });
          Preconditions.checkArgument(localIterator.hasNext(), "Chunk [%s] is not a valid entry", new Object[] { str1 });
          localLinkedHashMap.put(str2, (String)localIterator.next());
          if (localIterator.hasNext()) {
            break label189;
          }
        }
        label189:
        for (boolean bool = true;; bool = false)
        {
          Preconditions.checkArgument(bool, "Chunk [%s] is not a valid entry", new Object[] { str1 });
          break;
          bool = false;
          break label99;
        }
      }
      return Collections.unmodifiableMap(localLinkedHashMap);
    }
  }
  
  static abstract class a
    extends mh<String>
  {
    final CharSequence c;
    final CharMatcher d;
    final boolean e;
    int f = 0;
    int g;
    
    protected a(Splitter paramSplitter, CharSequence paramCharSequence)
    {
      this.d = Splitter.a(paramSplitter);
      this.e = Splitter.b(paramSplitter);
      this.g = Splitter.c(paramSplitter);
      this.c = paramCharSequence;
    }
    
    abstract int a(int paramInt);
    
    abstract int b(int paramInt);
  }
  
  static abstract interface b
  {
    public abstract Iterator<String> a(Splitter paramSplitter, CharSequence paramCharSequence);
  }
}


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