// 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.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.lang3.ClassUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;

// Referenced classes of package org.apache.commons.lang3.reflect:
//            MemberUtils

public class FieldUtils
{

    public FieldUtils()
    {
    }

    public static Field[] getAllFields(Class class1)
    {
        class1 = getAllFieldsList(class1);
        return (Field[])class1.toArray(new Field[class1.size()]);
    }

    public static List getAllFieldsList(Class class1)
    {
        ArrayList arraylist;
        boolean flag;
        if (class1 != null)
        {
            flag = true;
        } else
        {
            flag = false;
        }
        Validate.isTrue(flag, "The class must not be null", new Object[0]);
        arraylist = new ArrayList();
        for (; class1 != null; class1 = class1.getSuperclass())
        {
            Field afield[] = class1.getDeclaredFields();
            int j = afield.length;
            for (int i = 0; i < j; i++)
            {
                arraylist.add(afield[i]);
            }

        }

        return arraylist;
    }

    public static Field getDeclaredField(Class class1, String s)
    {
        return getDeclaredField(class1, s, false);
    }

    public static Field getDeclaredField(Class class1, String s, boolean flag)
    {
        boolean flag1 = true;
        if (class1 == null)
        {
            flag1 = false;
        }
        Validate.isTrue(flag1, "The class must not be null", new Object[0]);
        Validate.isTrue(StringUtils.isNotBlank(s), "The field name must not be blank/empty", new Object[0]);
        class1 = class1.getDeclaredField(s);
        if (!MemberUtils.isAccessible(class1))
        {
            if (!flag)
            {
                break MISSING_BLOCK_LABEL_58;
            }
            try
            {
                class1.setAccessible(true);
            }
            // Misplaced declaration of an exception variable
            catch (Class class1)
            {
                return null;
            }
        }
        return class1;
        return null;
    }

    public static Field getField(Class class1, String s)
    {
        class1 = getField(class1, s, false);
        MemberUtils.setAccessibleWorkaround(class1);
        return class1;
    }

    public static Field getField(Class class1, String s, boolean flag)
    {
        Object obj;
        Field field;
        boolean flag1;
        if (class1 != null)
        {
            flag1 = true;
        } else
        {
            flag1 = false;
        }
        Validate.isTrue(flag1, "The class must not be null", new Object[0]);
        Validate.isTrue(StringUtils.isNotBlank(s), "The field name must not be blank/empty", new Object[0]);
        obj = class1;
_L3:
        if (obj == null) goto _L2; else goto _L1
_L1:
        field = ((Class) (obj)).getDeclaredField(s);
        if (Modifier.isPublic(field.getModifiers()))
        {
            break MISSING_BLOCK_LABEL_65;
        }
        if (!flag)
        {
            continue; /* Loop/switch isn't completed */
        }
        field.setAccessible(true);
        return field;
        NoSuchFieldException nosuchfieldexception;
        nosuchfieldexception;
        obj = ((Class) (obj)).getSuperclass();
          goto _L3
_L2:
        Iterator iterator;
        obj = null;
        iterator = ClassUtils.getAllInterfaces(class1).iterator();
_L5:
        Object obj1;
        if (!iterator.hasNext())
        {
            break MISSING_BLOCK_LABEL_162;
        }
        obj1 = (Class)iterator.next();
        obj1 = ((Class) (obj1)).getField(s);
        if (obj == null)
        {
            flag = true;
        } else
        {
            flag = false;
        }
        Validate.isTrue(flag, "Reference to field %s is ambiguous relative to %s; a matching field exists on two or more implemented interfaces.", new Object[] {
            s, class1
        });
        obj = obj1;
        continue; /* Loop/switch isn't completed */
        return ((Field) (obj));
        obj1;
        if (true) goto _L5; else goto _L4
_L4:
    }

    public static Object readDeclaredField(Object obj, String s)
        throws IllegalAccessException
    {
        return readDeclaredField(obj, s, false);
    }

    public static Object readDeclaredField(Object obj, String s, boolean flag)
        throws IllegalAccessException
    {
        Class class1;
        Field field;
        boolean flag1;
        if (obj != null)
        {
            flag1 = true;
        } else
        {
            flag1 = false;
        }
        Validate.isTrue(flag1, "target object must not be null", new Object[0]);
        class1 = obj.getClass();
        field = getDeclaredField(class1, s, flag);
        if (field != null)
        {
            flag = true;
        } else
        {
            flag = false;
        }
        Validate.isTrue(flag, "Cannot locate declared field %s.%s", new Object[] {
            class1, s
        });
        return readField(field, obj, false);
    }

    public static Object readDeclaredStaticField(Class class1, String s)
        throws IllegalAccessException
    {
        return readDeclaredStaticField(class1, s, false);
    }

    public static Object readDeclaredStaticField(Class class1, String s, boolean flag)
        throws IllegalAccessException
    {
        Field field = getDeclaredField(class1, s, flag);
        if (field != null)
        {
            flag = true;
        } else
        {
            flag = false;
        }
        Validate.isTrue(flag, "Cannot locate declared field %s.%s", new Object[] {
            class1.getName(), s
        });
        return readStaticField(field, false);
    }

    public static Object readField(Object obj, String s)
        throws IllegalAccessException
    {
        return readField(obj, s, false);
    }

    public static Object readField(Object obj, String s, boolean flag)
        throws IllegalAccessException
    {
        Class class1;
        Field field;
        boolean flag1;
        if (obj != null)
        {
            flag1 = true;
        } else
        {
            flag1 = false;
        }
        Validate.isTrue(flag1, "target object must not be null", new Object[0]);
        class1 = obj.getClass();
        field = getField(class1, s, flag);
        if (field != null)
        {
            flag = true;
        } else
        {
            flag = false;
        }
        Validate.isTrue(flag, "Cannot locate field %s on %s", new Object[] {
            s, class1
        });
        return readField(field, obj, false);
    }

    public static Object readField(Field field, Object obj)
        throws IllegalAccessException
    {
        return readField(field, obj, false);
    }

    public static Object readField(Field field, Object obj, boolean flag)
        throws IllegalAccessException
    {
        boolean flag1;
        if (field != null)
        {
            flag1 = true;
        } else
        {
            flag1 = false;
        }
        Validate.isTrue(flag1, "The field must not be null", new Object[0]);
        if (flag && !field.isAccessible())
        {
            field.setAccessible(true);
        } else
        {
            MemberUtils.setAccessibleWorkaround(field);
        }
        return field.get(obj);
    }

    public static Object readStaticField(Class class1, String s)
        throws IllegalAccessException
    {
        return readStaticField(class1, s, false);
    }

    public static Object readStaticField(Class class1, String s, boolean flag)
        throws IllegalAccessException
    {
        Field field = getField(class1, s, flag);
        if (field != null)
        {
            flag = true;
        } else
        {
            flag = false;
        }
        Validate.isTrue(flag, "Cannot locate field '%s' on %s", new Object[] {
            s, class1
        });
        return readStaticField(field, false);
    }

    public static Object readStaticField(Field field)
        throws IllegalAccessException
    {
        return readStaticField(field, false);
    }

    public static Object readStaticField(Field field, boolean flag)
        throws IllegalAccessException
    {
        boolean flag1;
        if (field != null)
        {
            flag1 = true;
        } else
        {
            flag1 = false;
        }
        Validate.isTrue(flag1, "The field must not be null", new Object[0]);
        Validate.isTrue(Modifier.isStatic(field.getModifiers()), "The field '%s' is not static", new Object[] {
            field.getName()
        });
        return readField(field, (Object)null, flag);
    }

    public static void removeFinalModifier(Field field)
    {
        removeFinalModifier(field, true);
    }

    public static void removeFinalModifier(Field field, boolean flag)
    {
        boolean flag1;
        Field field1;
        boolean flag2;
        if (field != null)
        {
            flag2 = true;
        } else
        {
            flag2 = false;
        }
        Validate.isTrue(flag2, "The field must not be null", new Object[0]);
        if (!Modifier.isFinal(field.getModifiers())) goto _L2; else goto _L1
_L1:
        field1 = java/lang/reflect/Field.getDeclaredField("modifiers");
        if (!flag) goto _L4; else goto _L3
_L3:
        if (field1.isAccessible()) goto _L4; else goto _L5
_L5:
        flag1 = true;
_L7:
        if (!flag1)
        {
            break MISSING_BLOCK_LABEL_58;
        }
        field1.setAccessible(true);
        field1.setInt(field, field.getModifiers() & 0xffffffef);
        if (flag1)
        {
            try
            {
                field1.setAccessible(false);
                return;
            }
            // Misplaced declaration of an exception variable
            catch (Field field)
            {
                return;
            }
            // Misplaced declaration of an exception variable
            catch (Field field) { }
        }
          goto _L2
        field;
        if (!flag1)
        {
            break MISSING_BLOCK_LABEL_90;
        }
        field1.setAccessible(false);
        throw field;
_L2:
        return;
_L4:
        flag1 = false;
        if (true) goto _L7; else goto _L6
_L6:
    }

    public static void writeDeclaredField(Object obj, String s, Object obj1)
        throws IllegalAccessException
    {
        writeDeclaredField(obj, s, obj1, false);
    }

    public static void writeDeclaredField(Object obj, String s, Object obj1, boolean flag)
        throws IllegalAccessException
    {
        Class class1;
        Field field;
        boolean flag1;
        if (obj != null)
        {
            flag1 = true;
        } else
        {
            flag1 = false;
        }
        Validate.isTrue(flag1, "target object must not be null", new Object[0]);
        class1 = obj.getClass();
        field = getDeclaredField(class1, s, flag);
        if (field != null)
        {
            flag = true;
        } else
        {
            flag = false;
        }
        Validate.isTrue(flag, "Cannot locate declared field %s.%s", new Object[] {
            class1.getName(), s
        });
        writeField(field, obj, obj1, false);
    }

    public static void writeDeclaredStaticField(Class class1, String s, Object obj)
        throws IllegalAccessException
    {
        writeDeclaredStaticField(class1, s, obj, false);
    }

    public static void writeDeclaredStaticField(Class class1, String s, Object obj, boolean flag)
        throws IllegalAccessException
    {
        Field field = getDeclaredField(class1, s, flag);
        if (field != null)
        {
            flag = true;
        } else
        {
            flag = false;
        }
        Validate.isTrue(flag, "Cannot locate declared field %s.%s", new Object[] {
            class1.getName(), s
        });
        writeField(field, (Object)null, obj, false);
    }

    public static void writeField(Object obj, String s, Object obj1)
        throws IllegalAccessException
    {
        writeField(obj, s, obj1, false);
    }

    public static void writeField(Object obj, String s, Object obj1, boolean flag)
        throws IllegalAccessException
    {
        Class class1;
        Field field;
        boolean flag1;
        if (obj != null)
        {
            flag1 = true;
        } else
        {
            flag1 = false;
        }
        Validate.isTrue(flag1, "target object must not be null", new Object[0]);
        class1 = obj.getClass();
        field = getField(class1, s, flag);
        if (field != null)
        {
            flag = true;
        } else
        {
            flag = false;
        }
        Validate.isTrue(flag, "Cannot locate declared field %s.%s", new Object[] {
            class1.getName(), s
        });
        writeField(field, obj, obj1, false);
    }

    public static void writeField(Field field, Object obj, Object obj1)
        throws IllegalAccessException
    {
        writeField(field, obj, obj1, false);
    }

    public static void writeField(Field field, Object obj, Object obj1, boolean flag)
        throws IllegalAccessException
    {
        boolean flag1;
        if (field != null)
        {
            flag1 = true;
        } else
        {
            flag1 = false;
        }
        Validate.isTrue(flag1, "The field must not be null", new Object[0]);
        if (flag && !field.isAccessible())
        {
            field.setAccessible(true);
        } else
        {
            MemberUtils.setAccessibleWorkaround(field);
        }
        field.set(obj, obj1);
    }

    public static void writeStaticField(Class class1, String s, Object obj)
        throws IllegalAccessException
    {
        writeStaticField(class1, s, obj, false);
    }

    public static void writeStaticField(Class class1, String s, Object obj, boolean flag)
        throws IllegalAccessException
    {
        Field field = getField(class1, s, flag);
        if (field != null)
        {
            flag = true;
        } else
        {
            flag = false;
        }
        Validate.isTrue(flag, "Cannot locate field %s on %s", new Object[] {
            s, class1
        });
        writeStaticField(field, obj, false);
    }

    public static void writeStaticField(Field field, Object obj)
        throws IllegalAccessException
    {
        writeStaticField(field, obj, false);
    }

    public static void writeStaticField(Field field, Object obj, boolean flag)
        throws IllegalAccessException
    {
        boolean flag1;
        if (field != null)
        {
            flag1 = true;
        } else
        {
            flag1 = false;
        }
        Validate.isTrue(flag1, "The field must not be null", new Object[0]);
        Validate.isTrue(Modifier.isStatic(field.getModifiers()), "The field %s.%s is not static", new Object[] {
            field.getDeclaringClass().getName(), field.getName()
        });
        writeField(field, (Object)null, obj, flag);
    }
}