package org.apache.commons.lang3;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class EnumUtils
{
  private static <E extends Enum<E>> Class<E> a(Class<E> paramClass)
  {
    Enum[] arrayOfEnum = (Enum[])b(paramClass).getEnumConstants();
    if (arrayOfEnum.length <= 64) {}
    for (boolean bool = true;; bool = false)
    {
      Validate.isTrue(bool, "Cannot store %s %s values in %s bits", new Object[] { Integer.valueOf(arrayOfEnum.length), paramClass.getSimpleName(), Integer.valueOf(64) });
      return paramClass;
    }
  }
  
  private static <E extends Enum<E>> Class<E> b(Class<E> paramClass)
  {
    Validate.notNull(paramClass, "EnumClass must be defined.", new Object[0]);
    Validate.isTrue(paramClass.isEnum(), "%s does not seem to be an Enum type", new Object[] { paramClass });
    return paramClass;
  }
  
  public static <E extends Enum<E>> long generateBitVector(Class<E> paramClass, Iterable<? extends E> paramIterable)
  {
    a(paramClass);
    Validate.notNull(paramIterable);
    paramClass = paramIterable.iterator();
    long l = 0L;
    if (paramClass.hasNext())
    {
      paramIterable = (Enum)paramClass.next();
      if (paramIterable != null) {}
      for (boolean bool = true;; bool = false)
      {
        Validate.isTrue(bool, "null elements not permitted", new Object[0]);
        l = 1L << paramIterable.ordinal() | l;
        break;
      }
    }
    return l;
  }
  
  public static <E extends Enum<E>> long generateBitVector(Class<E> paramClass, E... paramVarArgs)
  {
    Validate.noNullElements(paramVarArgs);
    return generateBitVector(paramClass, Arrays.asList(paramVarArgs));
  }
  
  public static <E extends Enum<E>> long[] generateBitVectors(Class<E> paramClass, Iterable<? extends E> paramIterable)
  {
    b(paramClass);
    Validate.notNull(paramIterable);
    Object localObject = EnumSet.noneOf(paramClass);
    paramIterable = paramIterable.iterator();
    if (paramIterable.hasNext())
    {
      Enum localEnum = (Enum)paramIterable.next();
      if (localEnum != null) {}
      for (boolean bool = true;; bool = false)
      {
        Validate.isTrue(bool, "null elements not permitted", new Object[0]);
        ((EnumSet)localObject).add(localEnum);
        break;
      }
    }
    paramClass = new long[(((Enum[])paramClass.getEnumConstants()).length - 1) / 64 + 1];
    paramIterable = ((EnumSet)localObject).iterator();
    while (paramIterable.hasNext())
    {
      localObject = (Enum)paramIterable.next();
      int i = ((Enum)localObject).ordinal() / 64;
      paramClass[i] |= 1L << ((Enum)localObject).ordinal() % 64;
    }
    ArrayUtils.reverse(paramClass);
    return paramClass;
  }
  
  public static <E extends Enum<E>> long[] generateBitVectors(Class<E> paramClass, E... paramVarArgs)
  {
    b(paramClass);
    Validate.noNullElements(paramVarArgs);
    Object localObject = EnumSet.noneOf(paramClass);
    Collections.addAll((Collection)localObject, paramVarArgs);
    paramClass = new long[(((Enum[])paramClass.getEnumConstants()).length - 1) / 64 + 1];
    paramVarArgs = ((EnumSet)localObject).iterator();
    while (paramVarArgs.hasNext())
    {
      localObject = (Enum)paramVarArgs.next();
      int i = ((Enum)localObject).ordinal() / 64;
      paramClass[i] |= 1L << ((Enum)localObject).ordinal() % 64;
    }
    ArrayUtils.reverse(paramClass);
    return paramClass;
  }
  
  public static <E extends Enum<E>> E getEnum(Class<E> paramClass, String paramString)
  {
    if (paramString == null) {
      return null;
    }
    try
    {
      paramClass = Enum.valueOf(paramClass, paramString);
      return paramClass;
    }
    catch (IllegalArgumentException paramClass) {}
    return null;
  }
  
  public static <E extends Enum<E>> List<E> getEnumList(Class<E> paramClass)
  {
    return new ArrayList(Arrays.asList(paramClass.getEnumConstants()));
  }
  
  public static <E extends Enum<E>> Map<String, E> getEnumMap(Class<E> paramClass)
  {
    LinkedHashMap localLinkedHashMap = new LinkedHashMap();
    paramClass = (Enum[])paramClass.getEnumConstants();
    int j = paramClass.length;
    int i = 0;
    while (i < j)
    {
      Object localObject = paramClass[i];
      localLinkedHashMap.put(((Enum)localObject).name(), localObject);
      i += 1;
    }
    return localLinkedHashMap;
  }
  
  public static <E extends Enum<E>> boolean isValidEnum(Class<E> paramClass, String paramString)
  {
    if (paramString == null) {
      return false;
    }
    try
    {
      Enum.valueOf(paramClass, paramString);
      return true;
    }
    catch (IllegalArgumentException paramClass) {}
    return false;
  }
  
  public static <E extends Enum<E>> EnumSet<E> processBitVector(Class<E> paramClass, long paramLong)
  {
    a(paramClass).getEnumConstants();
    return processBitVectors(paramClass, new long[] { paramLong });
  }
  
  public static <E extends Enum<E>> EnumSet<E> processBitVectors(Class<E> paramClass, long... paramVarArgs)
  {
    EnumSet localEnumSet = EnumSet.noneOf(b(paramClass));
    paramVarArgs = ArrayUtils.clone((long[])Validate.notNull(paramVarArgs));
    ArrayUtils.reverse(paramVarArgs);
    paramClass = (Enum[])paramClass.getEnumConstants();
    int j = paramClass.length;
    int i = 0;
    while (i < j)
    {
      Object localObject = paramClass[i];
      int k = ((Enum)localObject).ordinal() / 64;
      if ((k < paramVarArgs.length) && ((paramVarArgs[k] & 1L << ((Enum)localObject).ordinal() % 64) != 0L)) {
        localEnumSet.add(localObject);
      }
      i += 1;
    }
    return localEnumSet;
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/org/apache/commons/lang3/EnumUtils.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */