// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: braces fieldsfirst space lnc 

package org.apache.commons.lang3;

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

// Referenced classes of package org.apache.commons.lang3:
//            Validate, ArrayUtils

public class EnumUtils
{

    private static final String CANNOT_STORE_S_S_VALUES_IN_S_BITS = "Cannot store %s %s values in %s bits";
    private static final String ENUM_CLASS_MUST_BE_DEFINED = "EnumClass must be defined.";
    private static final String NULL_ELEMENTS_NOT_PERMITTED = "null elements not permitted";
    private static final String S_DOES_NOT_SEEM_TO_BE_AN_ENUM_TYPE = "%s does not seem to be an Enum type";

    public EnumUtils()
    {
    }

    private static Class asEnum(Class class1)
    {
        Validate.notNull(class1, "EnumClass must be defined.", new Object[0]);
        Validate.isTrue(class1.isEnum(), "%s does not seem to be an Enum type", new Object[] {
            class1
        });
        return class1;
    }

    private static Class checkBitVectorable(Class class1)
    {
        Enum aenum[] = (Enum[])asEnum(class1).getEnumConstants();
        boolean flag;
        if (aenum.length <= 64)
        {
            flag = true;
        } else
        {
            flag = false;
        }
        Validate.isTrue(flag, "Cannot store %s %s values in %s bits", new Object[] {
            Integer.valueOf(aenum.length), class1.getSimpleName(), Integer.valueOf(64)
        });
        return class1;
    }

    public static long generateBitVector(Class class1, Iterable iterable)
    {
        checkBitVectorable(class1);
        Validate.notNull(iterable);
        long l = 0L;
        class1 = iterable.iterator();
        while (class1.hasNext()) 
        {
            iterable = (Enum)class1.next();
            boolean flag;
            if (iterable != null)
            {
                flag = true;
            } else
            {
                flag = false;
            }
            Validate.isTrue(flag, "null elements not permitted", new Object[0]);
            l |= 1 << iterable.ordinal();
        }
        return l;
    }

    public static transient long generateBitVector(Class class1, Enum aenum[])
    {
        Validate.noNullElements(aenum);
        return generateBitVector(class1, ((Iterable) (Arrays.asList(aenum))));
    }

    public static long[] generateBitVectors(Class class1, Iterable iterable)
    {
        asEnum(class1);
        Validate.notNull(iterable);
        EnumSet enumset = EnumSet.noneOf(class1);
        iterable = iterable.iterator();
        while (iterable.hasNext()) 
        {
            Enum enum1 = (Enum)iterable.next();
            boolean flag;
            if (enum1 != null)
            {
                flag = true;
            } else
            {
                flag = false;
            }
            Validate.isTrue(flag, "null elements not permitted", new Object[0]);
            enumset.add(enum1);
        }
        class1 = new long[(((Enum[])class1.getEnumConstants()).length - 1) / 64 + 1];
        for (iterable = enumset.iterator(); iterable.hasNext();)
        {
            Enum enum = (Enum)iterable.next();
            int i = enum.ordinal() / 64;
            class1[i] = class1[i] | (long)(1 << enum.ordinal() % 64);
        }

        ArrayUtils.reverse(class1);
        return class1;
    }

    public static transient long[] generateBitVectors(Class class1, Enum aenum[])
    {
        asEnum(class1);
        Validate.noNullElements(aenum);
        EnumSet enumset = EnumSet.noneOf(class1);
        Collections.addAll(enumset, aenum);
        class1 = new long[(((Enum[])class1.getEnumConstants()).length - 1) / 64 + 1];
        for (aenum = enumset.iterator(); aenum.hasNext();)
        {
            Enum enum = (Enum)aenum.next();
            int i = enum.ordinal() / 64;
            class1[i] = class1[i] | (long)(1 << enum.ordinal() % 64);
        }

        ArrayUtils.reverse(class1);
        return class1;
    }

    public static Enum getEnum(Class class1, String s)
    {
        if (s == null)
        {
            return null;
        }
        try
        {
            class1 = Enum.valueOf(class1, s);
        }
        // Misplaced declaration of an exception variable
        catch (Class class1)
        {
            return null;
        }
        return class1;
    }

    public static List getEnumList(Class class1)
    {
        return new ArrayList(Arrays.asList(class1.getEnumConstants()));
    }

    public static Map getEnumMap(Class class1)
    {
        LinkedHashMap linkedhashmap = new LinkedHashMap();
        class1 = (Enum[])class1.getEnumConstants();
        int j = class1.length;
        for (int i = 0; i < j; i++)
        {
            Enum enum = class1[i];
            linkedhashmap.put(enum.name(), enum);
        }

        return linkedhashmap;
    }

    public static boolean isValidEnum(Class class1, String s)
    {
        if (s == null)
        {
            return false;
        }
        try
        {
            Enum.valueOf(class1, s);
        }
        // Misplaced declaration of an exception variable
        catch (Class class1)
        {
            return false;
        }
        return true;
    }

    public static EnumSet processBitVector(Class class1, long l)
    {
        checkBitVectorable(class1).getEnumConstants();
        return processBitVectors(class1, new long[] {
            l
        });
    }

    public static transient EnumSet processBitVectors(Class class1, long al[])
    {
        EnumSet enumset = EnumSet.noneOf(asEnum(class1));
        al = ArrayUtils.clone((long[])Validate.notNull(al));
        ArrayUtils.reverse(al);
        class1 = (Enum[])class1.getEnumConstants();
        int j = class1.length;
        for (int i = 0; i < j; i++)
        {
            Enum enum = class1[i];
            int k = enum.ordinal() / 64;
            if (k < al.length && (al[k] & (long)(1 << enum.ordinal() % 64)) != 0L)
            {
                enumset.add(enum);
            }
        }

        return enumset;
    }
}