public void setValue(T val)
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    if (setter == null) {
        throw new IllegalAccessException();
    }

    Object valideInstance = Beans.getInstanceOf(instance, setter.getDeclaringClass());

    try {
        setter.invoke(valideInstance, val);
    } catch (IllegalAccessException ex) {
        try {
            setter.setAccessible(true);
            setter.invoke(valideInstance, val);
        } finally {
            setter.setAccessible(false);
        }
    }
}
 

public void setValue(T val) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    if (!canWrite()) {
        throw new IllegalAccessException();
    }

    Object validInstance = Beans.getInstanceOf(instance, setter.getDeclaringClass());

    Object value = val;
    if (
        (val != null) && (setter.getParameterTypes()[0].getComponentType().isPrimitive()) &&
            (!val.getClass().getComponentType().isPrimitive())
    ) {
        value = Utilities.toPrimitiveArray((Object[]) val);
    }

    setter.invoke(validInstance, value);
}
 

private static void test(String[] path) {
    try {
        Beans.setDesignTime(true);
        Beans.setGuiAvailable(true);
        Introspector.setBeanInfoSearchPath(path);
        PropertyEditorManager.setEditorSearchPath(path);
    } catch (SecurityException exception) {
        throw new Error("unexpected security exception", exception);
    }
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isGuiAvailable() == GraphicsEnvironment.isHeadless()) {
        throw new Error("unexpected GuiAvailable property");
    }
    Beans.setGuiAvailable(!Beans.isGuiAvailable());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestGuiAvailable());
    thread.start();
    thread.join();
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isDesignTime()) {
        throw new Error("unexpected DesignTime property");
    }
    Beans.setDesignTime(!Beans.isDesignTime());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestDesignTime());
    thread.start();
    thread.join();
}
 

public static void main(String[] args) throws Exception {
    Class type = Beans.instantiate(null, "Test4144543").getClass();

    // try all the various places that this would break before

    Introspector.getBeanInfo(type);
    new PropertyDescriptor("value", type);
    new PropertyDescriptor("value", type, "getValue", "setValue");
}
 

private static void test(String[] path) {
    try {
        Beans.setDesignTime(true);
        Beans.setGuiAvailable(true);
        Introspector.setBeanInfoSearchPath(path);
        PropertyEditorManager.setEditorSearchPath(path);
    } catch (SecurityException exception) {
        throw new Error("unexpected security exception", exception);
    }
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isGuiAvailable() == GraphicsEnvironment.isHeadless()) {
        throw new Error("unexpected GuiAvailable property");
    }
    Beans.setGuiAvailable(!Beans.isGuiAvailable());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestGuiAvailable());
    thread.start();
    thread.join();
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isDesignTime()) {
        throw new Error("unexpected DesignTime property");
    }
    Beans.setDesignTime(!Beans.isDesignTime());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestDesignTime());
    thread.start();
    thread.join();
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isDesignTime()) {
        throw new Error("unexpected DesignTime property");
    }
    Beans.setDesignTime(!Beans.isDesignTime());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestDesignTime());
    thread.start();
    thread.join();
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isGuiAvailable() == GraphicsEnvironment.isHeadless()) {
        throw new Error("unexpected GuiAvailable property");
    }
    Beans.setGuiAvailable(!Beans.isGuiAvailable());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestGuiAvailable());
    thread.start();
    thread.join();
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isGuiAvailable() == GraphicsEnvironment.isHeadless()) {
        throw new Error("unexpected GuiAvailable property");
    }
    Beans.setGuiAvailable(!Beans.isGuiAvailable());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestGuiAvailable());
    thread.start();
    thread.join();
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isDesignTime()) {
        throw new Error("unexpected DesignTime property");
    }
    Beans.setDesignTime(!Beans.isDesignTime());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestDesignTime());
    thread.start();
    thread.join();
}
 

private static void test(String[] path) {
    try {
        Beans.setDesignTime(true);
        Beans.setGuiAvailable(true);
        Introspector.setBeanInfoSearchPath(path);
        PropertyEditorManager.setEditorSearchPath(path);
    } catch (SecurityException exception) {
        throw new Error("unexpected security exception", exception);
    }
}
 

private static void test(String[] path) {
    try {
        Beans.setDesignTime(true);
        Beans.setGuiAvailable(true);
        Introspector.setBeanInfoSearchPath(path);
        PropertyEditorManager.setEditorSearchPath(path);
    } catch (SecurityException exception) {
        throw new Error("unexpected security exception", exception);
    }
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isGuiAvailable() == GraphicsEnvironment.isHeadless()) {
        throw new Error("unexpected GuiAvailable property");
    }
    Beans.setGuiAvailable(!Beans.isGuiAvailable());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestGuiAvailable());
    thread.start();
    thread.join();
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isDesignTime()) {
        throw new Error("unexpected DesignTime property");
    }
    Beans.setDesignTime(!Beans.isDesignTime());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestDesignTime());
    thread.start();
    thread.join();
}
 

private static void test(String[] path) {
    try {
        Beans.setDesignTime(true);
        Beans.setGuiAvailable(true);
        Introspector.setBeanInfoSearchPath(path);
        PropertyEditorManager.setEditorSearchPath(path);
    } catch (SecurityException exception) {
        throw new Error("unexpected security exception", exception);
    }
}
 

public static void main(String[] args) throws Exception {
    Class type = Beans.instantiate(null, "Test4144543").getClass();

    // try all the various places that this would break before

    Introspector.getBeanInfo(type);
    new PropertyDescriptor("value", type);
    new PropertyDescriptor("value", type, "getValue", "setValue");
}
 

public T getValue() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    if (getter == null) {
        throw new IllegalAccessException();
    }

    Object valideInstance = Beans.getInstanceOf(instance, getter.getDeclaringClass());

    try {
        try {
            return cast(getValueType(), getter.invoke(valideInstance));
        } catch (IllegalAccessException ex) {
            try {
                getter.setAccessible(true);

                return cast(getValueType(), getter.invoke(valideInstance));
            } finally {
                getter.setAccessible(false);
            }
        }
    } catch (IllegalArgumentException iae) {
        //Provide a better message for debugging
        StringBuffer sb = new StringBuffer("Attempted to invoke method ");
        sb.append(getter.getName());
        sb.append(" from class ");
        sb.append(getter.getDeclaringClass().getName());
        sb.append(" on an instance of ");
        sb.append(valideInstance.getClass().getName());
        sb.append(" Problem:");
        sb.append(iae.getMessage());
        throw (IllegalArgumentException) new IllegalArgumentException(sb.toString()).initCause(iae);
    }
}
 

/**
 * Checks the type of an element matches the underlying list type.
 */
private void checkType(Object element) {
    if (element != null) {
        if (!Beans.isInstanceOf(element, listObjectType)) {
            throw new RuntimeException("element is not of correct type.");
        }
    }
}
 

public T getValue() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    if (!canRead()) {
        throw new IllegalAccessException();
    }

    Object validInstance = Beans.getInstanceOf(instance, getter.getDeclaringClass());

    return PropertySupport.cast(getValueType(), getter.invoke(validInstance));
}
 

public E getIndexedValue(int index)
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    if (!canIndexedRead()) {
        throw new IllegalAccessException();
    }

    Object validInstance = Beans.getInstanceOf(instance, indexedGetter.getDeclaringClass());

    return PropertySupport.cast(getElementType(), indexedGetter.invoke(validInstance, index));
}
 

public void setIndexedValue(int index, E val)
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    if (!canIndexedWrite()) {
        throw new IllegalAccessException();
    }

    Object validInstance = Beans.getInstanceOf(instance, indexedSetter.getDeclaringClass());
    indexedSetter.invoke(validInstance, new Object[] { new Integer(index), val });
}
 

private static void test(String[] path) {
    try {
        Beans.setDesignTime(true);
        Beans.setGuiAvailable(true);
        Introspector.setBeanInfoSearchPath(path);
        PropertyEditorManager.setEditorSearchPath(path);
    } catch (SecurityException exception) {
        throw new Error("unexpected security exception", exception);
    }
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isGuiAvailable() == GraphicsEnvironment.isHeadless()) {
        throw new Error("unexpected GuiAvailable property");
    }
    Beans.setGuiAvailable(!Beans.isGuiAvailable());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestGuiAvailable());
    thread.start();
    thread.join();
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isDesignTime()) {
        throw new Error("unexpected DesignTime property");
    }
    Beans.setDesignTime(!Beans.isDesignTime());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestDesignTime());
    thread.start();
    thread.join();
}
 

private static void test(String[] path) {
    try {
        Beans.setDesignTime(true);
        Beans.setGuiAvailable(true);
        Introspector.setBeanInfoSearchPath(path);
        PropertyEditorManager.setEditorSearchPath(path);
    } catch (SecurityException exception) {
        throw new Error("unexpected security exception", exception);
    }
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isGuiAvailable() == GraphicsEnvironment.isHeadless()) {
        throw new Error("unexpected GuiAvailable property");
    }
    Beans.setGuiAvailable(!Beans.isGuiAvailable());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestGuiAvailable());
    thread.start();
    thread.join();
}
 

public static void main(String[] args) throws InterruptedException {
    if (Beans.isDesignTime()) {
        throw new Error("unexpected DesignTime property");
    }
    Beans.setDesignTime(!Beans.isDesignTime());
    ThreadGroup group = new ThreadGroup("$$$");
    Thread thread = new Thread(group, new TestDesignTime());
    thread.start();
    thread.join();
}