*/  private void findMappedPropertyType() throws IntrospectionException  {    try    {      mappedPropertyType = null;      if(mappedReadMethod != null)      {        if(mappedReadMethod.getParameterTypes().length != 1)        {          throw new IntrospectionException("bad mapped read method arg count");        }        mappedPropertyType = mappedReadMethod.getReturnType();        if(mappedPropertyType == Void.TYPE)        {          throw new IntrospectionException("mapped read method " + mappedReadMethod.getName() + " returns void");        }      }      if(mappedWriteMethod != null)      {        Class params[] = mappedWriteMethod.getParameterTypes();        if(params.length != 2)        {          throw new IntrospectionException("bad mapped write method arg count");        }        if(mappedPropertyType != null && mappedPropertyType != params[1])        {          throw new IntrospectionException("type mismatch between mapped read and write methods");        }        mappedPropertyType = params[1];      }    }    catch(IntrospectionException ex)    {      throw ex;    }  }  /**   * Return a capitalized version of the specified property name.   *   * @param s The property name   */  private static String capitalizePropertyName(String s)  {    if(s.length() == 0)    {      return s;    }    char chars[] = s.toCharArray();    chars[0] = Character.toUpperCase(chars[0]);    return new String(chars);  }  //======================================================================  // Package private support methods (copied from java.beans.Introspector).  //======================================================================  // Cache of Class.getDeclaredMethods:  private static java.util.Hashtable declaredMethodCache = new java.util.Hashtable();  /*   * Internal method to return *public* methods within a class.   */  private static synchronized Method[] getPublicDeclaredMethods(Class clz)  {    // Looking up Class.getDeclaredMethods is relatively expensive,    // so we cache the results.    final Class fclz = clz;    Method[] result = (Method[])declaredMethodCache.get(fclz);    if(result != null)    {      return result;    }    // We have to raise privilege for getDeclaredMethods    result = (Method[])AccessController.doPrivileged(new PrivilegedAction()    {      public Object run()      {        return fclz.getDeclaredMethods();      }    });    // Null out any non-public methods.    for(int i = 0; i < result.length; i++)    {      Method method = result[i];      int mods = method.getModifiers();      if(!Modifier.isPublic(mods))      {        result[i] = null;      }    }    // Add it to the cache.    declaredMethodCache.put(clz, result);    return result;  }  /**   * Internal support for finding a target methodName on a given class.   */  private static Method internalFindMethod(Class start, String methodName, int argCount)  {    // For overridden methods we need to find the most derived version.    // So we start with the given class and walk up the superclass chain.    for(Class cl = start; cl != null; cl = cl.getSuperclass())    {      Method methods[] = getPublicDeclaredMethods(cl);      for(int i = 0; i < methods.length; i++)      {        Method method = methods[i];        if(method == null)        {          continue;        }        // skip static methods.        int mods = method.getModifiers();        if(Modifier.isStatic(mods))        {          continue;        }        if(method.getName().equals(methodName) && method.getParameterTypes().length == argCount)        {          return method;        }      }    }    // Now check any inherited interfaces.  This is necessary both when    // the argument class is itself an interface, and when the argument    // class is an abstract class.    Class ifcs[] = start.getInterfaces();    for(int i = 0; i < ifcs.length; i++)    {      Method m = internalFindMethod(ifcs[i], methodName, argCount);      if(m != null)      {        return m;      }    }    return null;  }  /**   * Internal support for finding a target methodName with a given   * parameter list on a given class.   */  private static Method internalFindMethod(Class start, String methodName, int argCount, Class args[])  {    // For overriden methods we need to find the most derived version.    // So we start with the given class and walk up the superclass chain.    for(Class cl = start; cl != null; cl = cl.getSuperclass())    {      Method methods[] = getPublicDeclaredMethods(cl);      for(int i = 0; i < methods.length; i++)      {        Method method = methods[i];        if(method == null)        {          continue;        }        // skip static methods.        int mods = method.getModifiers();        if(Modifier.isStatic(mods))        {          continue;        }        // make sure method signature matches.        Class params[] = method.getParameterTypes();        if(method.getName().equals(methodName) && params.length == argCount)        {          boolean different = false;          if(argCount > 0)          {            for(int j = 0; j < argCount; j++)            {              if(params[j] != args[j])              {                different = true;                continue;              }            }            if(different)            {              continue;            }          }          return method;        }      }    }    // Now check any inherited interfaces.  This is necessary both when    // the argument class is itself an interface, and when the argument    // class is an abstract class.    Class ifcs[] = start.getInterfaces();    for(int i = 0; i < ifcs.length; i++)    {      Method m = internalFindMethod(ifcs[i], methodName, argCount);      if(m != null)      {        return m;      }    }    return null;  }  /**   * Find a target methodName on a given class.   */  static Method findMethod(Class cls, String methodName, int argCount) throws IntrospectionException  {    if(methodName == null)    {      return null;    }    Method m = internalFindMethod(cls, methodName, argCount);    if(m != null)    {      return m;    }    // We failed to find a suitable method    throw new IntrospectionException("No method \"" + methodName + "\" with " + argCount + " arg(s)");  }  /**   * Find a target methodName with specific parameter list on a given class.   */  static Method findMethod(Class cls, String methodName, int argCount, Class args[]) throws IntrospectionException  {    if(methodName == null)    {      return null;    }    Method m = internalFindMethod(cls, methodName, argCount, args);    if(m != null)    {      return m;    }    // We failed to find a suitable method    throw new IntrospectionException("No method \"" + methodName + "\" with " + argCount + " arg(s) of matching types.");  }  /**   * Return true if class a is either equivalent to class b, or   * if class a is a subclass of class b, ie if a either "extends"   * or "implements" b.   * Note tht either or both "Class" objects may represent interfaces.   */  static boolean isSubclass(Class a, Class b)  {    // We rely on the fact that for any given java class or    // primtitive type there is a unqiue Class object, so    // we can use object equivalence in the comparisons.    if(a == b)    {      return true;    }    if(a == null || b == null)    {      return false;    }    for(Class x = a; x != null; x = x.getSuperclass())    {      if(x == b)      {        return true;      }      if(b.isInterface())      {        Class interfaces[] = x.getInterfaces();        for(int i = 0; i < interfaces.length; i++)        {          if(isSubclass(interfaces[i], b))          {            return true;          }        }      }    }    return false;  }}