Makefile.def: Remove libjava.

2016-09-30  Andrew Haley  <aph@redhat.com>

	* Makefile.def: Remove libjava.
	* Makefile.tpl: Likewise.
	* Makefile.in: Regenerate.
	* configure.ac: Likewise.
	* configure: Likewise.
	* gcc/java: Remove.
	* libjava: Likewise.

From-SVN: r240662

1 files changed, 0 insertions, 763 deletions

diff --git a/libjava/classpath/java/beans/EventSetDescriptor.java b/libjava/classpath/java/beans/EventSetDescriptor.java
deleted file mode 100644
index 3f537c7..0000000
--- a/libjava/classpath/java/beans/EventSetDescriptor.java
+++ /dev/null
@@ -1,763 +0,0 @@
-/* java.beans.EventSetDescriptor
- Copyright (C) 1998, 2006 Free Software Foundation, Inc.
-
- This file is part of GNU Classpath.
-
- GNU Classpath is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- GNU Classpath is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with GNU Classpath; see the file COPYING.  If not, write to the
- Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- 02110-1301 USA.
-
- Linking this library statically or dynamically with other modules is
- making a combined work based on this library.  Thus, the terms and
- conditions of the GNU General Public License cover the whole
- combination.
-
- As a special exception, the copyright holders of this library give you
- permission to link this library with independent modules to produce an
- executable, regardless of the license terms of these independent
- modules, and to copy and distribute the resulting executable under
- terms of your choice, provided that you also meet, for each linked
- independent module, the terms and conditions of the license of that
- module.  An independent module is a module which is not derived from
- or based on this library.  If you modify this library, you may extend
- this exception to your version of the library, but you are not
- obligated to do so.  If you do not wish to do so, delete this
- exception statement from your version. */
-
-
-package java.beans;
-
-import gnu.java.lang.ClassHelper;
-
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.Vector;
-
-/**
- * EventSetDescriptor describes the hookup between an event source class and
- * an event listener class.
- *
- * <p>EventSets have several attributes: the listener class,
- * the events that can be fired to the listener (methods in the listener
- * class), and an add and remove listener method from the event firer's
- * class.
- * </p>
- *
- * <p>
- * The methods have these constraints on them:
- * <ul>
- * <li>event firing methods: must have <code>void</code> return value. Any
- * parameters and exceptions are allowed. May be public, protected or
- * package-protected. (Don't ask me why that is, I'm just following the spec.
- * The only place it is even mentioned is in the Java Beans white paper, and
- * there it is only implied.)</li>
- *
- * <li>add listener method: must have <code>void</code> return value. Must
- * take exactly one argument, of the listener class's type. May fire either
- * zero exceptions, or one exception of type
- * <code>java.util.TooManyListenersException</code>.
- * Must be public.</li>
- *
- * <li>remove listener method: must have <code>void</code> return value. Must
- * take exactly one argument, of the listener class's type. May not fire any
- * exceptions. Must be public.</li>
- * </ul>
- *
- * <p>
- * A final constraint is that event listener classes must extend from
- * EventListener.
- * </p>
- *
- * <p>
- * There are also various design patterns associated with some of the methods
- * of construction. Those are explained in more detail in the appropriate
- * constructors.
- * </p>
- *
- * <p>
- * <strong>Documentation Convention:</strong> for proper Internalization of
- * Beans inside an RAD tool, sometimes there are two names for a property or
- * method: a programmatic, or locale-independent name, which can be used
- * anywhere, and a localized, display name, for ease of use. In the
- * documentation I will specify different String values as either
- * <em>programmatic</em> or <em>localized</em> to make this distinction clear.
- *
- * @author John Keiser
- * @author Robert Schuster (robertschuster@fsfe.org)
- * @since 1.1
- */
-
-public class EventSetDescriptor extends FeatureDescriptor
-{
-  private Method addListenerMethod;
-
-  private Method removeListenerMethod;
-
-  private Class listenerType;
-
-  private MethodDescriptor[] listenerMethodDescriptors;
-
-  private Method[] listenerMethods;
-
-  private Method getListenerMethod;
-
-  private boolean unicast;
-
-  private boolean inDefaultEventSet = true;
-
-  /**
-   * Creates a new <code>EventSetDescriptor</code<.
-   *
-   * <p>
-   * This version of the constructor enforces the rules imposed on the methods
-   * described at the top of this class, as well as searching for:
-   * </p>
-   *
-   * <ol>
-   * <li>
-   * The event-firing method must be non-private with signature <code>void
-   * &lt;listenerMethodName&gt;(&lt;eventSetName&gt;Event)</code> (where
-   * <code>&lt;eventSetName&gt;</code> has its first character capitalized
-   * by the constructor and the Event is a descendant of
-   * {@link java.util.EventObject}) in class <code>listenerType</code>
-   * (any exceptions may be thrown). <b>Implementation note:</b> Note that
-   * there could conceivably be multiple methods with this type of signature
-   * (example: <code>java.util.MouseEvent</code> vs.
-   * <code>my.very.own.MouseEvent</code>). In this implementation, all
-   * methods fitting the description will be put into the
-   * <code>EventSetDescriptor</code>, even though the spec says only one
-   * should be chosen (they probably weren't thinking as pathologically as I
-   * was). I don't like arbitrarily choosing things. If your class has only one
-   * such signature, as most do, you'll have no problems.</li>
-   *
-   * <li>The add and remove methods must be public and named <code>void
-   * add&lt;eventSetName&gt;Listener(&lt;listenerType&gt;)</code> and
-   * <code>void remove&lt;eventSetName&gt;Listener(&lt;listenerType&gt;)</code>
-   * in in class <code>eventSourceClass</code>, where
-   * <code>&lt;eventSetName&gt;</code> will have its first letter capitalized.
-   * Standard exception rules (see class description) apply.</li>
-   * </ol>
-   *
-   * @param eventSourceClass
-   *          the class containing the add/remove listener methods.
-   * @param eventSetName
-   *          the programmatic name of the event set, generally starting with a
-   *          lowercase letter (i.e. fooManChu instead of FooManChu). This will
-   *          be used to generate the name of the event object as well as the
-   *          names of the add and remove methods.
-   * @param listenerType
-   *          the class containing the event firing method.
-   * @param listenerMethodName
-   *          the name of the event firing method.
-   * @exception IntrospectionException
-   *              if listenerType is not an EventListener, or if methods are not
-   *              found or are invalid.
-   */
-  public EventSetDescriptor(Class<?> eventSourceClass, String eventSetName,
-                            Class<?> listenerType, String listenerMethodName)
-      throws IntrospectionException
-  {
-    setName(eventSetName);
-    if (!java.util.EventListener.class.isAssignableFrom(listenerType))
-      {
-        throw new IntrospectionException(
-                  "Listener type is not an EventListener.");
-      }
-
-    String[] names = new String[1];
-    names[0] = listenerMethodName;
-
-    try
-      {
-        eventSetName = Character.toUpperCase(eventSetName.charAt(0))
-                       + eventSetName.substring(1);
-      }
-    catch (StringIndexOutOfBoundsException e)
-      {
-        eventSetName = "";
-      }
-
-    findMethods(eventSourceClass, listenerType, names,
-                "add" + eventSetName + "Listener",
-                "remove" + eventSetName + "Listener", eventSetName + "Event");
-    this.listenerType = listenerType;
-    checkAddListenerUnicast();
-    if (this.removeListenerMethod.getExceptionTypes().length > 0)
-      {
-        throw new IntrospectionException(
-                  "Listener remove method throws exceptions.");
-      }
-  }
-
-  /**
-   * Creates a new <code>EventSetDescriptor</code>.
-   *
-   * <p>This form of the constructor allows you to specify the names of the
-   * methods and adds no new constraints on top of the rules already described
-   * at the top of the class.
-   * </p>
-   *
-   * @param eventSourceClass
-   *          the class containing the add and remove listener methods.
-   * @param eventSetName
-   *          the programmatic name of the event set, generally starting with a
-   *          lowercase letter (i.e. fooManChu instead of FooManChu).
-   * @param listenerType
-   *          the class containing the event firing methods.
-   * @param listenerMethodNames
-   *          the names of the even firing methods.
-   * @param addListenerMethodName
-   *          the name of the add listener method.
-   * @param removeListenerMethodName
-   *          the name of the remove listener method.
-   * @exception IntrospectionException
-   *              if listenerType is not an EventListener or if methods are not
-   *              found or are invalid.
-   */
-  public EventSetDescriptor(Class<?> eventSourceClass, String eventSetName,
-                            Class<?> listenerType, String[] listenerMethodNames,
-                            String addListenerMethodName,
-                            String removeListenerMethodName)
-      throws IntrospectionException
-  {
-    setName(eventSetName);
-    if (!java.util.EventListener.class.isAssignableFrom(listenerType))
-      {
-        throw new IntrospectionException(
-                  "Listener type is not an EventListener.");
-      }
-
-    findMethods(eventSourceClass, listenerType, listenerMethodNames,
-                addListenerMethodName, removeListenerMethodName, null);
-    this.listenerType = listenerType;
-    checkAddListenerUnicast();
-    if (this.removeListenerMethod.getExceptionTypes().length > 0)
-      {
-        throw new IntrospectionException(
-                  "Listener remove method throws exceptions.");
-      }
-  }
-
-  /**
-   * Creates a new <code>EventSetDescriptor</code>.
-   *
-   * <p>
-   * This variant of the constructor allows you to specify the names of the
-   * methods and adds no new constraints on top of the rules already described
-   * at the top of the class.
-   * </p>
-   * <p>
-   * A valid GetListener method is public, flags no exceptions and has one
-   * argument which is of type <code>Class</code>
-   * {@link java.awt.Component#getListeners(Class)} is such a method.
-   * </p>
-   * <p>
-   * Note: The validity of the return value of the GetListener method is not
-   * checked.
-   * </p>
-   *
-   * @param eventSourceClass
-   *          the class containing the add and remove listener methods.
-   * @param eventSetName
-   *          the programmatic name of the event set, generally starting with a
-   *          lowercase letter (i.e. fooManChu instead of FooManChu).
-   * @param listenerType
-   *          the class containing the event firing methods.
-   * @param listenerMethodNames
-   *          the names of the even firing methods.
-   * @param addListenerMethodName
-   *          the name of the add listener method.
-   * @param removeListenerMethodName
-   *          the name of the remove listener method.
-   * @param getListenerMethodName
-   *          Name of a method which returns the array of listeners.
-   * @exception IntrospectionException
-   *              if listenerType is not an EventListener or if methods are not
-   *              found or are invalid.
-   * @since 1.4
-   */
-  public EventSetDescriptor(Class<?> eventSourceClass, String eventSetName,
-                            Class<?> listenerType, String[] listenerMethodNames,
-                            String addListenerMethodName,
-                            String removeListenerMethodName,
-                            String getListenerMethodName)
-      throws IntrospectionException
-  {
-    this(eventSourceClass, eventSetName, listenerType, listenerMethodNames,
-         addListenerMethodName, removeListenerMethodName);
-
-    Method newGetListenerMethod = null;
-
-    try
-      {
-        newGetListenerMethod
-          = eventSourceClass.getMethod(getListenerMethodName,
-                                       new Class[] { Class.class });
-      }
-    catch (NoSuchMethodException nsme)
-      {
-        throw (IntrospectionException)
-          new IntrospectionException("No method named " + getListenerMethodName
-                                      + " in class " + listenerType
-                                      + " which can be used as"
-                                      + " getListenerMethod.").initCause(nsme);
-      }
-
-    // Note: This does not check the return value (which
-    // should be EventListener[]) but the JDK does not either.
-
-    getListenerMethod = newGetListenerMethod;
-
-  }
-
-  /**
-   * Creates a new <code>EventSetDescriptor.</code>
-   *
-   * <p>
-   * This variant of the constructor allows you to specify the names of the
-   * methods and adds no new constraints on top of the rules already described
-   * at the top of the class.
-   * </p>
-   * <p>
-   * A valid GetListener method is public, flags no exceptions and has one
-   * argument which is of type <code>Class</code>
-   * {@link java.awt.Component#getListeners(Class)} is such a method.
-   * </p>
-   * <p>
-   * Note: The validity of the return value of the GetListener method is not
-   * checked.
-   * </p>
-   *
-   * @param eventSetName
-   *          the programmatic name of the event set, generally starting with a
-   *          lowercase letter (i.e. fooManChu instead of FooManChu).
-   * @param listenerType
-   *          the class containing the listenerMethods.
-   * @param listenerMethods
-   *          the event firing methods.
-   * @param addListenerMethod
-   *          the add listener method.
-   * @param removeListenerMethod
-   *          the remove listener method.
-   * @param getListenerMethod
-   *          The method which returns an array of the listeners.
-   * @exception IntrospectionException
-   *              if the listenerType is not an EventListener, or any of the
-   *              methods are invalid.
-   * @since 1.4
-   */
-  public EventSetDescriptor(String eventSetName, Class<?> listenerType,
-                            Method[] listenerMethods, Method addListenerMethod,
-                            Method removeListenerMethod,
-                            Method getListenerMethod)
-      throws IntrospectionException
-  {
-    this(eventSetName, listenerType, listenerMethods, addListenerMethod,
-         removeListenerMethod);
-
-    // Do no checks if the getListenerMethod is null.
-    if (getListenerMethod.getParameterTypes().length != 1
-        || getListenerMethod.getParameterTypes()[0] != Class.class
-        || getListenerMethod.getExceptionTypes().length > 0
-        || !Modifier.isPublic(getListenerMethod.getModifiers()))
-      throw new IntrospectionException("GetListener method is invalid.");
-
-    // Note: This does not check the return value (which
-    // should be EventListener[]) but the JDK does not either.
-
-    this.getListenerMethod = getListenerMethod;
-  }
-
-  /**
-   * Creates a new <code>EventSetDescriptor</code>.
-   *
-   * <p>This form of constructor allows you to explicitly say which methods
-   * do what, and no reflection is done by the <code>EventSetDescriptor</code>.
-   * The methods are, however, checked to ensure that they follow the rules
-   * set forth at the top of the class.
-   *
-   * @param eventSetName
-   *          the programmatic name of the event set, generally starting with a
-   *          lowercase letter (i.e. fooManChu instead of FooManChu).
-   * @param listenerType
-   *          the class containing the listenerMethods.
-   * @param listenerMethods
-   *          the event firing methods.
-   * @param addListenerMethod
-   *          the add listener method.
-   * @param removeListenerMethod
-   *          the remove listener method.
-   * @exception IntrospectionException
-   *              if the listenerType is not an EventListener, or any of the
-   *              methods are invalid.
-   */
-  public EventSetDescriptor(String eventSetName, Class<?> listenerType,
-                            Method[] listenerMethods, Method addListenerMethod,
-                            Method removeListenerMethod)
-      throws IntrospectionException
-  {
-    setName(eventSetName);
-    if (!java.util.EventListener.class.isAssignableFrom(listenerType))
-      {
-        throw new IntrospectionException(
-                  "Listener type is not an EventListener.");
-      }
-
-    this.listenerMethods = listenerMethods;
-    this.addListenerMethod = addListenerMethod;
-    this.removeListenerMethod = removeListenerMethod;
-    this.listenerType = listenerType;
-    checkMethods();
-    checkAddListenerUnicast();
-    if (this.removeListenerMethod.getExceptionTypes().length > 0)
-      {
-        throw new IntrospectionException(
-                  "Listener remove method throws exceptions.");
-      }
-  }
-
-  /** Creates a new <code>EventSetDescriptor</code>.
-   *
-   * <p>This form of constructor allows you to explicitly say which methods do
-   * what, and no reflection is done by the <code>EventSetDescriptor</code>.
-   * The methods are, however, checked to ensure that they follow the rules
-   * set forth at the top of the class.
-   *
-   * @param eventSetName
-   *          the programmatic name of the event set, generally starting with a
-   *          lowercase letter (i.e. fooManChu instead of FooManChu).
-   * @param listenerType
-   *          the class containing the listenerMethods.
-   * @param listenerMethodDescriptors
-   *          the event firing methods.
-   * @param addListenerMethod
-   *          the add listener method.
-   * @param removeListenerMethod
-   *          the remove listener method.
-   * @exception IntrospectionException
-   *              if the listenerType is not an EventListener, or any of the
-   *              methods are invalid.
-   */
-  public EventSetDescriptor(String eventSetName, Class<?> listenerType,
-                            MethodDescriptor[] listenerMethodDescriptors,
-                            Method addListenerMethod,
-                            Method removeListenerMethod)
-      throws IntrospectionException
-  {
-    setName(eventSetName);
-    if (!java.util.EventListener.class.isAssignableFrom(listenerType))
-      {
-        throw new IntrospectionException(
-                  "Listener type is not an EventListener.");
-      }
-
-    this.listenerMethodDescriptors = listenerMethodDescriptors;
-    this.listenerMethods = new Method[listenerMethodDescriptors.length];
-    for (int i = 0; i < this.listenerMethodDescriptors.length; i++)
-      {
-        this.listenerMethods[i]
-           = this.listenerMethodDescriptors[i].getMethod();
-      }
-
-    this.addListenerMethod = addListenerMethod;
-    this.removeListenerMethod = removeListenerMethod;
-    this.listenerType = listenerType;
-    checkMethods();
-    checkAddListenerUnicast();
-    if (this.removeListenerMethod.getExceptionTypes().length > 0)
-      {
-        throw new IntrospectionException(
-                  "Listener remove method throws exceptions.");
-      }
-  }
-
-  /** Returns the class that contains the event firing methods.
-   */
-  public Class<?> getListenerType()
-  {
-    return listenerType;
-  }
-
-  /** Returns the event firing methods.
-   */
-  public Method[] getListenerMethods()
-  {
-    return listenerMethods;
-  }
-
-  /** Returns the event firing methods as {@link MethodDescriptor}.
-   */
-  public MethodDescriptor[] getListenerMethodDescriptors()
-  {
-    if (listenerMethodDescriptors == null)
-      {
-        listenerMethodDescriptors
-          = new MethodDescriptor[listenerMethods.length];
-
-        for (int i = 0; i < listenerMethods.length; i++)
-          {
-            listenerMethodDescriptors[i]
-              = new MethodDescriptor(listenerMethods[i]);
-          }
-      }
-
-    return listenerMethodDescriptors;
-  }
-
-  /** Returns the add listener method.
-   */
-  public Method getAddListenerMethod()
-  {
-    return addListenerMethod;
-  }
-
-  /* Returns the remove listener method.
-   */
-  public Method getRemoveListenerMethod()
-  {
-    return removeListenerMethod;
-  }
-
-  /**
-   * Returns the method that retrieves the listeners or <code>null</code> if
-   * it does not exist.
-   */
-  public Method getGetListenerMethod()
-  {
-    return getListenerMethod;
-  }
-
-  /** Sets whether or not multiple listeners may be added.
-   *
-   * @param unicast
-   *          whether or not multiple listeners may be added.
-   */
-  public void setUnicast(boolean unicast)
-  {
-    this.unicast = unicast;
-  }
-
-  /** Returns whether or not multiple listeners may be added.
-   * (Defaults to false.)
-   */
-  public boolean isUnicast()
-  {
-    return unicast;
-  }
-
-  /** Sets whether or not this is in the default event set.
-   *
-   * @param inDefaultEventSet
-   *          whether this is in the default event set.
-   */
-  public void setInDefaultEventSet(boolean inDefaultEventSet)
-  {
-    this.inDefaultEventSet = inDefaultEventSet;
-  }
-
-  /** Returns whether or not this is in the default event set.
-   * (Defaults to true.)
-   */
-  public boolean isInDefaultEventSet()
-  {
-    return inDefaultEventSet;
-  }
-
-  private void checkAddListenerUnicast() throws IntrospectionException
-  {
-    Class[] addListenerExceptions = this.addListenerMethod.getExceptionTypes();
-    if (addListenerExceptions.length > 1)
-      {
-        throw new IntrospectionException(
-                  "Listener add method throws too many exceptions.");
-      }
-    else if (addListenerExceptions.length == 1
-             && !java.util.TooManyListenersException.class
-                .isAssignableFrom(addListenerExceptions[0]))
-      {
-        throw new IntrospectionException(
-                  "Listener add method throws too many exceptions.");
-      }
-  }
-
-  private void checkMethods() throws IntrospectionException
-  {
-    if (!addListenerMethod.getDeclaringClass()
-        .isAssignableFrom(removeListenerMethod.getDeclaringClass())
-        && !removeListenerMethod.getDeclaringClass()
-        .isAssignableFrom(addListenerMethod.getDeclaringClass()))
-      {
-        throw new IntrospectionException(
-                  "add and remove listener methods do not come from the"
-                  + " same class.  This is bad.");
-      }
-    if (!addListenerMethod.getReturnType().equals(java.lang.Void.TYPE)
-        || addListenerMethod.getParameterTypes().length != 1
-        || !listenerType.equals(addListenerMethod.getParameterTypes()[0])
-        || !Modifier.isPublic(addListenerMethod.getModifiers()))
-      {
-        throw new IntrospectionException("Add Listener Method invalid.");
-      }
-    if (!removeListenerMethod.getReturnType().equals(java.lang.Void.TYPE)
-        || removeListenerMethod.getParameterTypes().length != 1
-        || !listenerType.equals(removeListenerMethod.getParameterTypes()[0])
-        || removeListenerMethod.getExceptionTypes().length > 0
-        || !Modifier.isPublic(removeListenerMethod.getModifiers()))
-      {
-        throw new IntrospectionException("Remove Listener Method invalid.");
-      }
-
-    for (int i = 0; i < listenerMethods.length; i++)
-      {
-        if (!listenerMethods[i].getReturnType().equals(java.lang.Void.TYPE)
-            || Modifier.isPrivate(listenerMethods[i].getModifiers()))
-          {
-            throw new IntrospectionException("Event Method "
-                                             + listenerMethods[i].getName()
-                                             + " non-void or private.");
-          }
-        if (!listenerMethods[i].getDeclaringClass()
-            .isAssignableFrom(listenerType))
-          {
-            throw new IntrospectionException("Event Method "
-                                             + listenerMethods[i].getName()
-                                             + " not from class "
-                                             + listenerType.getName());
-          }
-      }
-  }
-
-  private void findMethods(Class eventSourceClass, Class listenerType,
-                           String listenerMethodNames[],
-                           String addListenerMethodName,
-                           String removeListenerMethodName,
-                           String absurdEventClassCheckName)
-      throws IntrospectionException
-  {
-
-    /* Find add listener method and remove listener method. */
-    Class[] listenerArgList = new Class[1];
-    listenerArgList[0] = listenerType;
-    try
-      {
-        this.addListenerMethod
-          = eventSourceClass.getMethod(addListenerMethodName,
-                                       listenerArgList);
-      }
-    catch (SecurityException E)
-      {
-        throw new IntrospectionException(
-                  "SecurityException trying to access method "
-                  + addListenerMethodName + ".");
-      }
-    catch (NoSuchMethodException E)
-      {
-        throw new IntrospectionException("Could not find method "
-                                         + addListenerMethodName + ".");
-      }
-
-    if (this.addListenerMethod == null
-        || !this.addListenerMethod.getReturnType().equals(java.lang.Void.TYPE))
-      {
-        throw new IntrospectionException(
-                  "Add listener method does not exist, is not public,"
-                  + " or is not void.");
-      }
-
-    try
-      {
-        this.removeListenerMethod
-          = eventSourceClass.getMethod(removeListenerMethodName,
-                                       listenerArgList);
-      }
-    catch (SecurityException E)
-      {
-        throw new IntrospectionException(
-                  "SecurityException trying to access method "
-                  + removeListenerMethodName + ".");
-      }
-    catch (NoSuchMethodException E)
-      {
-        throw new IntrospectionException("Could not find method "
-                                         + removeListenerMethodName + ".");
-      }
-    if (this.removeListenerMethod == null
-        || !this.removeListenerMethod.getReturnType()
-           .equals(java.lang.Void.TYPE))
-      {
-        throw new IntrospectionException(
-                  "Remove listener method does not exist, is not public,"
-                  + " or is not void.");
-      }
-
-    /* Find the listener methods. */
-    Method[] methods;
-    try
-      {
-        methods = ClassHelper.getAllMethods(listenerType);
-      }
-    catch (SecurityException E)
-      {
-        throw new IntrospectionException(
-                  "Security: You cannot access fields in this class.");
-      }
-
-    Vector chosenMethods = new Vector();
-    boolean[] listenerMethodFound = new boolean[listenerMethodNames.length];
-    for (int i = 0; i < methods.length; i++)
-      {
-        if (Modifier.isPrivate(methods[i].getModifiers()))
-          {
-            continue;
-          }
-        Method currentMethod = methods[i];
-        Class retval = currentMethod.getReturnType();
-        if (retval.equals(java.lang.Void.TYPE))
-          {
-            for (int j = 0; j < listenerMethodNames.length; j++)
-              {
-                if (currentMethod.getName().equals(listenerMethodNames[j])
-                    && (absurdEventClassCheckName == null
-                    || (currentMethod.getParameterTypes().length == 1
-                    && ((currentMethod.getParameterTypes()[0])
-                        .getName().equals(absurdEventClassCheckName)
-                    || (currentMethod.getParameterTypes()[0])
-                       .getName().endsWith("." + absurdEventClassCheckName)))))
-                  {
-                    chosenMethods.addElement(currentMethod);
-                    listenerMethodFound[j] = true;
-                  }
-              }
-          }
-      }
-
-    /* Make sure we found all the methods we were looking for. */
-    for (int i = 0; i < listenerMethodFound.length; i++)
-      {
-        if (!listenerMethodFound[i])
-          {
-            throw new IntrospectionException("Could not find event method "
-                                             + listenerMethodNames[i]);
-          }
-      }
-
-    /* Now that we've chosen the listener methods we want, store them. */
-    this.listenerMethods = new Method[chosenMethods.size()];
-    for (int i = 0; i < chosenMethods.size(); i++)
-      {
-        this.listenerMethods[i] = (Method) chosenMethods.elementAt(i);
-      }
-  }
-
-}