Source for java.lang.Class

   1: /* Class.java -- Representation of a Java class.
   2:    Copyright (C) 1998, 1999, 2000, 2002, 2003, 2004, 2005
   3:    Free Software Foundation
   4: 
   5: This file is part of GNU Classpath.
   6: 
   7: GNU Classpath is free software; you can redistribute it and/or modify
   8: it under the terms of the GNU General Public License as published by
   9: the Free Software Foundation; either version 2, or (at your option)
  10: any later version.
  11: 
  12: GNU Classpath is distributed in the hope that it will be useful, but
  13: WITHOUT ANY WARRANTY; without even the implied warranty of
  14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15: General Public License for more details.
  16: 
  17: You should have received a copy of the GNU General Public License
  18: along with GNU Classpath; see the file COPYING.  If not, write to the
  19: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20: 02110-1301 USA.
  21: 
  22: Linking this library statically or dynamically with other modules is
  23: making a combined work based on this library.  Thus, the terms and
  24: conditions of the GNU General Public License cover the whole
  25: combination.
  26: 
  27: As a special exception, the copyright holders of this library give you
  28: permission to link this library with independent modules to produce an
  29: executable, regardless of the license terms of these independent
  30: modules, and to copy and distribute the resulting executable under
  31: terms of your choice, provided that you also meet, for each linked
  32: independent module, the terms and conditions of the license of that
  33: module.  An independent module is a module which is not derived from
  34: or based on this library.  If you modify this library, you may extend
  35: this exception to your version of the library, but you are not
  36: obligated to do so.  If you do not wish to do so, delete this
  37: exception statement from your version. */
  38: 
  39: package java.lang;
  40: 
  41: import gnu.classpath.VMStackWalker;
  42: 
  43: import java.io.InputStream;
  44: import java.io.ObjectStreamClass;
  45: import java.io.Serializable;
  46: import java.lang.reflect.Array;
  47: import java.lang.reflect.Constructor;
  48: import java.lang.reflect.Field;
  49: import java.lang.reflect.InvocationTargetException;
  50: import java.lang.reflect.Member;
  51: import java.lang.reflect.Method;
  52: import java.lang.reflect.Modifier;
  53: import java.net.URL;
  54: import java.security.AccessController;
  55: import java.security.AllPermission;
  56: import java.security.Permissions;
  57: import java.security.PrivilegedAction;
  58: import java.security.ProtectionDomain;
  59: import java.util.ArrayList;
  60: import java.util.Arrays;
  61: import java.util.HashMap;
  62: import java.util.HashSet;
  63: 
  64: 
  65: /**
  66:  * A Class represents a Java type.  There will never be multiple Class
  67:  * objects with identical names and ClassLoaders. Primitive types, array
  68:  * types, and void also have a Class object.
  69:  *
  70:  * <p>Arrays with identical type and number of dimensions share the same class.
  71:  * The array class ClassLoader is the same as the ClassLoader of the element
  72:  * type of the array (which can be null to indicate the bootstrap classloader).
  73:  * The name of an array class is <code>[&lt;signature format&gt;;</code>.
  74:  * <p> For example,
  75:  * String[]'s class is <code>[Ljava.lang.String;</code>. boolean, byte,
  76:  * short, char, int, long, float and double have the "type name" of
  77:  * Z,B,S,C,I,J,F,D for the purposes of array classes.  If it's a
  78:  * multidimensioned array, the same principle applies:
  79:  * <code>int[][][]</code> == <code>[[[I</code>.
  80:  *
  81:  * <p>There is no public constructor - Class objects are obtained only through
  82:  * the virtual machine, as defined in ClassLoaders.
  83:  *
  84:  * @serialData Class objects serialize specially:
  85:  * <code>TC_CLASS ClassDescriptor</code>. For more serialization information,
  86:  * see {@link ObjectStreamClass}.
  87:  *
  88:  * @author John Keiser
  89:  * @author Eric Blake (ebb9@email.byu.edu)
  90:  * @author Tom Tromey (tromey@cygnus.com)
  91:  * @since 1.0
  92:  * @see ClassLoader
  93:  */
  94: public final class Class implements Serializable
  95: {
  96:   /**
  97:    * Compatible with JDK 1.0+.
  98:    */
  99:   private static final long serialVersionUID = 3206093459760846163L;
 100: 
 101:   /** The class signers. */
 102:   private Object[] signers = null;
 103:   /** The class protection domain. */
 104:   private final transient ProtectionDomain pd;
 105: 
 106:   /* We use an inner class, so that Class doesn't have a static initializer */
 107:   private static final class StaticData
 108:   {
 109:     static final ProtectionDomain unknownProtectionDomain;
 110: 
 111:     static
 112:     {
 113:       Permissions permissions = new Permissions();
 114:       permissions.add(new AllPermission());
 115:       unknownProtectionDomain = new ProtectionDomain(null, permissions);
 116:     }
 117:   }
 118: 
 119:   final transient Object vmdata;
 120: 
 121:   /** newInstance() caches the default constructor */
 122:   private transient Constructor constructor;
 123: 
 124:   /**
 125:    * Class is non-instantiable from Java code; only the VM can create
 126:    * instances of this class.
 127:    */
 128:   Class(Object vmdata)
 129:   {
 130:     this(vmdata, null);
 131:   }
 132: 
 133:   Class(Object vmdata, ProtectionDomain pd)
 134:   {
 135:     this.vmdata = vmdata;
 136:     // If the VM didn't supply a protection domain and the class is an array,
 137:     // we "inherit" the protection domain from the component type class. This
 138:     // saves the VM from having to worry about protection domains for array
 139:     // classes.
 140:     if (pd == null && isArray())
 141:       this.pd = getComponentType().pd;
 142:     else
 143:       this.pd = pd;
 144:   }
 145: 
 146:   /**
 147:    * Use the classloader of the current class to load, link, and initialize
 148:    * a class. This is equivalent to your code calling
 149:    * <code>Class.forName(name, true, getClass().getClassLoader())</code>.
 150:    *
 151:    * @param name the name of the class to find
 152:    * @return the Class object representing the class
 153:    * @throws ClassNotFoundException if the class was not found by the
 154:    *         classloader
 155:    * @throws LinkageError if linking the class fails
 156:    * @throws ExceptionInInitializerError if the class loads, but an exception
 157:    *         occurs during initialization
 158:    */
 159:   public static Class forName(String name) throws ClassNotFoundException
 160:   {
 161:     return VMClass.forName(name, true, VMStackWalker.getCallingClassLoader());
 162:   }
 163: 
 164:   /**
 165:    * Use the specified classloader to load and link a class. If the loader
 166:    * is null, this uses the bootstrap class loader (provide the security
 167:    * check succeeds). Unfortunately, this method cannot be used to obtain
 168:    * the Class objects for primitive types or for void, you have to use
 169:    * the fields in the appropriate java.lang wrapper classes.
 170:    *
 171:    * <p>Calls <code>classloader.loadclass(name, initialize)</code>.
 172:    *
 173:    * @param name the name of the class to find
 174:    * @param initialize whether or not to initialize the class at this time
 175:    * @param classloader the classloader to use to find the class; null means
 176:    *        to use the bootstrap class loader
 177:    *
 178:    * @return the class object for the given class
 179:    *
 180:    * @throws ClassNotFoundException if the class was not found by the
 181:    *         classloader
 182:    * @throws LinkageError if linking the class fails
 183:    * @throws ExceptionInInitializerError if the class loads, but an exception
 184:    *         occurs during initialization
 185:    * @throws SecurityException if the <code>classloader</code> argument
 186:    *         is <code>null</code> and the caller does not have the
 187:    *         <code>RuntimePermission("getClassLoader")</code> permission
 188:    * @see ClassLoader
 189:    * @since 1.2
 190:    */
 191:   public static Class forName(String name, boolean initialize,
 192:                               ClassLoader classloader)
 193:     throws ClassNotFoundException
 194:   {
 195:     if (classloader == null)
 196:       {
 197:         // Check if we may access the bootstrap classloader
 198:         SecurityManager sm = SecurityManager.current;
 199:         if (sm != null)
 200:           {
 201:             // Get the calling classloader
 202:             ClassLoader cl = VMStackWalker.getCallingClassLoader();
 203:             if (cl != null)
 204:               sm.checkPermission(new RuntimePermission("getClassLoader"));
 205:           }
 206:       }
 207:     return VMClass.forName(name, initialize, classloader);
 208:   }
 209:   
 210:   /**
 211:    * Get all the public member classes and interfaces declared in this
 212:    * class or inherited from superclasses. This returns an array of length
 213:    * 0 if there are no member classes, including for primitive types. A
 214:    * security check may be performed, with
 215:    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 216:    * <code>checkPackageAccess</code> both having to succeed.
 217:    *
 218:    * @return all public member classes in this class
 219:    * @throws SecurityException if the security check fails
 220:    * @since 1.1
 221:    */
 222:   public Class[] getClasses()
 223:   {
 224:     memberAccessCheck(Member.PUBLIC);
 225:     return internalGetClasses();
 226:   }
 227: 
 228:   /**
 229:    * Like <code>getClasses()</code> but without the security checks.
 230:    */
 231:   private Class[] internalGetClasses()
 232:   {
 233:     ArrayList list = new ArrayList();
 234:     list.addAll(Arrays.asList(getDeclaredClasses(true)));
 235:     Class superClass = getSuperclass();
 236:     if (superClass != null)
 237:       list.addAll(Arrays.asList(superClass.internalGetClasses()));
 238:     return (Class[])list.toArray(new Class[list.size()]);
 239:   }
 240:   
 241:   /**
 242:    * Get the ClassLoader that loaded this class.  If the class was loaded
 243:    * by the bootstrap classloader, this method will return null.
 244:    * If there is a security manager, and the caller's class loader is not
 245:    * an ancestor of the requested one, a security check of
 246:    * <code>RuntimePermission("getClassLoader")</code>
 247:    * must first succeed. Primitive types and void return null.
 248:    *
 249:    * @return the ClassLoader that loaded this class
 250:    * @throws SecurityException if the security check fails
 251:    * @see ClassLoader
 252:    * @see RuntimePermission
 253:    */
 254:   public ClassLoader getClassLoader()
 255:   {
 256:     if (isPrimitive())
 257:       return null;
 258: 
 259:     ClassLoader loader = VMClass.getClassLoader(this);
 260:     // Check if we may get the classloader
 261:     SecurityManager sm = SecurityManager.current;
 262:     if (sm != null)
 263:       {
 264:         // Get the calling classloader
 265:     ClassLoader cl = VMStackWalker.getCallingClassLoader();
 266:         if (cl != null && !cl.isAncestorOf(loader))
 267:           sm.checkPermission(new RuntimePermission("getClassLoader"));
 268:       }
 269:     return loader;
 270:   }
 271: 
 272:   /**
 273:    * If this is an array, get the Class representing the type of array.
 274:    * Examples: "[[Ljava.lang.String;" would return "[Ljava.lang.String;", and
 275:    * calling getComponentType on that would give "java.lang.String".  If
 276:    * this is not an array, returns null.
 277:    *
 278:    * @return the array type of this class, or null
 279:    * @see Array
 280:    * @since 1.1
 281:    */
 282:   public Class getComponentType()
 283:   {
 284:     return VMClass.getComponentType (this);
 285:   }
 286: 
 287:   /**
 288:    * Get a public constructor declared in this class. If the constructor takes
 289:    * no argument, an array of zero elements and null are equivalent for the
 290:    * types argument. A security check may be performed, with
 291:    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 292:    * <code>checkPackageAccess</code> both having to succeed.
 293:    *
 294:    * @param types the type of each parameter
 295:    * @return the constructor
 296:    * @throws NoSuchMethodException if the constructor does not exist
 297:    * @throws SecurityException if the security check fails
 298:    * @see #getConstructors()
 299:    * @since 1.1
 300:    */
 301:   public Constructor getConstructor(Class[] types) throws NoSuchMethodException
 302:   {
 303:     memberAccessCheck(Member.PUBLIC);
 304:     Constructor[] constructors = getDeclaredConstructors(true);
 305:     for (int i = 0; i < constructors.length; i++)
 306:       {
 307:     Constructor constructor = constructors[i];
 308:     if (matchParameters(types, constructor.getParameterTypes()))
 309:       return constructor;
 310:       }
 311:     throw new NoSuchMethodException();
 312:   }
 313: 
 314:   /**
 315:    * Get all the public constructors of this class. This returns an array of
 316:    * length 0 if there are no constructors, including for primitive types,
 317:    * arrays, and interfaces. It does, however, include the default
 318:    * constructor if one was supplied by the compiler. A security check may
 319:    * be performed, with <code>checkMemberAccess(this, Member.PUBLIC)</code>
 320:    * as well as <code>checkPackageAccess</code> both having to succeed.
 321:    *
 322:    * @return all public constructors in this class
 323:    * @throws SecurityException if the security check fails
 324:    * @since 1.1
 325:    */
 326:   public Constructor[] getConstructors()
 327:   {
 328:     memberAccessCheck(Member.PUBLIC);
 329:     return getDeclaredConstructors(true);
 330:   }
 331: 
 332:   /**
 333:    * Get a constructor declared in this class. If the constructor takes no
 334:    * argument, an array of zero elements and null are equivalent for the
 335:    * types argument. A security check may be performed, with
 336:    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 337:    * <code>checkPackageAccess</code> both having to succeed.
 338:    *
 339:    * @param types the type of each parameter
 340:    * @return the constructor
 341:    * @throws NoSuchMethodException if the constructor does not exist
 342:    * @throws SecurityException if the security check fails
 343:    * @see #getDeclaredConstructors()
 344:    * @since 1.1
 345:    */
 346:   public Constructor getDeclaredConstructor(Class[] types)
 347:     throws NoSuchMethodException
 348:   {
 349:     memberAccessCheck(Member.DECLARED);
 350:     Constructor[] constructors = getDeclaredConstructors(false);
 351:     for (int i = 0; i < constructors.length; i++)
 352:       {
 353:     Constructor constructor = constructors[i];
 354:     if (matchParameters(types, constructor.getParameterTypes()))
 355:       return constructor;
 356:       }
 357:     throw new NoSuchMethodException();
 358:   }
 359: 
 360:   /**
 361:    * Get all the declared member classes and interfaces in this class, but
 362:    * not those inherited from superclasses. This returns an array of length
 363:    * 0 if there are no member classes, including for primitive types. A
 364:    * security check may be performed, with
 365:    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 366:    * <code>checkPackageAccess</code> both having to succeed.
 367:    *
 368:    * @return all declared member classes in this class
 369:    * @throws SecurityException if the security check fails
 370:    * @since 1.1
 371:    */
 372:   public Class[] getDeclaredClasses()
 373:   {
 374:     memberAccessCheck(Member.DECLARED);
 375:     return getDeclaredClasses(false);
 376:   }
 377: 
 378:   Class[] getDeclaredClasses (boolean publicOnly)
 379:   {
 380:     return VMClass.getDeclaredClasses (this, publicOnly);
 381:   }
 382: 
 383:   /**
 384:    * Get all the declared constructors of this class. This returns an array of
 385:    * length 0 if there are no constructors, including for primitive types,
 386:    * arrays, and interfaces. It does, however, include the default
 387:    * constructor if one was supplied by the compiler. A security check may
 388:    * be performed, with <code>checkMemberAccess(this, Member.DECLARED)</code>
 389:    * as well as <code>checkPackageAccess</code> both having to succeed.
 390:    *
 391:    * @return all constructors in this class
 392:    * @throws SecurityException if the security check fails
 393:    * @since 1.1
 394:    */
 395:   public Constructor[] getDeclaredConstructors()
 396:   {
 397:     memberAccessCheck(Member.DECLARED);
 398:     return getDeclaredConstructors(false);
 399:   }
 400: 
 401:   Constructor[] getDeclaredConstructors (boolean publicOnly)
 402:   {
 403:     return VMClass.getDeclaredConstructors (this, publicOnly);
 404:   }
 405:   
 406:   /**
 407:    * Get a field declared in this class, where name is its simple name. The
 408:    * implicit length field of arrays is not available. A security check may
 409:    * be performed, with <code>checkMemberAccess(this, Member.DECLARED)</code>
 410:    * as well as <code>checkPackageAccess</code> both having to succeed.
 411:    *
 412:    * @param name the name of the field
 413:    * @return the field
 414:    * @throws NoSuchFieldException if the field does not exist
 415:    * @throws SecurityException if the security check fails
 416:    * @see #getDeclaredFields()
 417:    * @since 1.1
 418:    */
 419:   public Field getDeclaredField(String name) throws NoSuchFieldException
 420:   {
 421:     memberAccessCheck(Member.DECLARED);
 422:     Field[] fields = getDeclaredFields(false);
 423:     for (int i = 0; i < fields.length; i++)
 424:       {
 425:     if (fields[i].getName().equals(name))
 426:       return fields[i];
 427:       }
 428:     throw new NoSuchFieldException();
 429:   }
 430: 
 431:   /**
 432:    * Get all the declared fields in this class, but not those inherited from
 433:    * superclasses. This returns an array of length 0 if there are no fields,
 434:    * including for primitive types. This does not return the implicit length
 435:    * field of arrays. A security check may be performed, with
 436:    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 437:    * <code>checkPackageAccess</code> both having to succeed.
 438:    *
 439:    * @return all declared fields in this class
 440:    * @throws SecurityException if the security check fails
 441:    * @since 1.1
 442:    */
 443:   public Field[] getDeclaredFields()
 444:   {
 445:     memberAccessCheck(Member.DECLARED);
 446:     return getDeclaredFields(false);
 447:   }
 448: 
 449:   Field[] getDeclaredFields (boolean publicOnly)
 450:   {
 451:     return VMClass.getDeclaredFields (this, publicOnly);
 452:   }
 453: 
 454:   /**
 455:    * Get a method declared in this class, where name is its simple name. The
 456:    * implicit methods of Object are not available from arrays or interfaces.
 457:    * Constructors (named "&lt;init&gt;" in the class file) and class initializers
 458:    * (name "&lt;clinit&gt;") are not available.  The Virtual Machine allows
 459:    * multiple methods with the same signature but differing return types; in
 460:    * such a case the most specific return types are favored, then the final
 461:    * choice is arbitrary. If the method takes no argument, an array of zero
 462:    * elements and null are equivalent for the types argument. A security
 463:    * check may be performed, with
 464:    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 465:    * <code>checkPackageAccess</code> both having to succeed.
 466:    *
 467:    * @param methodName the name of the method
 468:    * @param types the type of each parameter
 469:    * @return the method
 470:    * @throws NoSuchMethodException if the method does not exist
 471:    * @throws SecurityException if the security check fails
 472:    * @see #getDeclaredMethods()
 473:    * @since 1.1
 474:    */
 475:   public Method getDeclaredMethod(String methodName, Class[] types)
 476:     throws NoSuchMethodException
 477:   {
 478:     memberAccessCheck(Member.DECLARED);
 479:     Method match = matchMethod(getDeclaredMethods(false), methodName, types);
 480:     if (match == null)
 481:       throw new NoSuchMethodException(methodName);
 482:     return match;
 483:   }
 484: 
 485:   /**
 486:    * Get all the declared methods in this class, but not those inherited from
 487:    * superclasses. This returns an array of length 0 if there are no methods,
 488:    * including for primitive types. This does include the implicit methods of
 489:    * arrays and interfaces which mirror methods of Object, nor does it
 490:    * include constructors or the class initialization methods. The Virtual
 491:    * Machine allows multiple methods with the same signature but differing
 492:    * return types; all such methods are in the returned array. A security
 493:    * check may be performed, with
 494:    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 495:    * <code>checkPackageAccess</code> both having to succeed.
 496:    *
 497:    * @return all declared methods in this class
 498:    * @throws SecurityException if the security check fails
 499:    * @since 1.1
 500:    */
 501:   public Method[] getDeclaredMethods()
 502:   {
 503:     memberAccessCheck(Member.DECLARED);
 504:     return getDeclaredMethods(false);
 505:   }
 506: 
 507:   Method[] getDeclaredMethods (boolean publicOnly)
 508:   {
 509:     return VMClass.getDeclaredMethods (this, publicOnly);
 510:   }
 511:  
 512:   /**
 513:    * If this is a nested or inner class, return the class that declared it.
 514:    * If not, return null.
 515:    *
 516:    * @return the declaring class of this class
 517:    * @since 1.1
 518:    */
 519:   public Class getDeclaringClass()
 520:   {
 521:     return VMClass.getDeclaringClass (this);
 522:   }
 523: 
 524:   /**
 525:    * Get a public field declared or inherited in this class, where name is
 526:    * its simple name. If the class contains multiple accessible fields by
 527:    * that name, an arbitrary one is returned. The implicit length field of
 528:    * arrays is not available. A security check may be performed, with
 529:    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 530:    * <code>checkPackageAccess</code> both having to succeed.
 531:    *
 532:    * @param fieldName the name of the field
 533:    * @return the field
 534:    * @throws NoSuchFieldException if the field does not exist
 535:    * @throws SecurityException if the security check fails
 536:    * @see #getFields()
 537:    * @since 1.1
 538:    */
 539:   public Field getField(String fieldName)
 540:     throws NoSuchFieldException
 541:   {
 542:     memberAccessCheck(Member.PUBLIC);
 543:     Field field = internalGetField(fieldName);
 544:     if (field == null)
 545:       throw new NoSuchFieldException(fieldName);
 546:     return field;
 547:   }
 548: 
 549:   /**
 550:    * Get all the public fields declared in this class or inherited from
 551:    * superclasses. This returns an array of length 0 if there are no fields,
 552:    * including for primitive types. This does not return the implicit length
 553:    * field of arrays. A security check may be performed, with
 554:    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 555:    * <code>checkPackageAccess</code> both having to succeed.
 556:    *
 557:    * @return all public fields in this class
 558:    * @throws SecurityException if the security check fails
 559:    * @since 1.1
 560:    */
 561:   public Field[] getFields()
 562:   {
 563:     memberAccessCheck(Member.PUBLIC);
 564:     return internalGetFields();
 565:   }
 566: 
 567:   /**
 568:    * Like <code>getFields()</code> but without the security checks.
 569:    */
 570:   private Field[] internalGetFields()
 571:   {
 572:     HashSet set = new HashSet();
 573:     set.addAll(Arrays.asList(getDeclaredFields(true)));
 574:     Class[] interfaces = getInterfaces();
 575:     for (int i = 0; i < interfaces.length; i++)
 576:       set.addAll(Arrays.asList(interfaces[i].internalGetFields()));
 577:     Class superClass = getSuperclass();
 578:     if (superClass != null)
 579:       set.addAll(Arrays.asList(superClass.internalGetFields()));
 580:     return (Field[])set.toArray(new Field[set.size()]);
 581:   }
 582: 
 583:   /**
 584:    * Returns the <code>Package</code> in which this class is defined
 585:    * Returns null when this information is not available from the
 586:    * classloader of this class.
 587:    *
 588:    * @return the package for this class, if it is available
 589:    * @since 1.2
 590:    */
 591:   public Package getPackage()
 592:   {
 593:     ClassLoader cl = getClassLoader();
 594:     if (cl != null)
 595:       return cl.getPackage(getPackagePortion(getName()));
 596:     else
 597:       return VMClassLoader.getPackage(getPackagePortion(getName()));
 598:   }
 599: 
 600:   /**
 601:    * Get the interfaces this class <em>directly</em> implements, in the
 602:    * order that they were declared. This returns an empty array, not null,
 603:    * for Object, primitives, void, and classes or interfaces with no direct
 604:    * superinterface. Array types return Cloneable and Serializable.
 605:    *
 606:    * @return the interfaces this class directly implements
 607:    */
 608:   public Class[] getInterfaces()
 609:   {
 610:     return VMClass.getInterfaces (this);
 611:   }
 612: 
 613:   private static final class MethodKey
 614:   {
 615:     private String name;
 616:     private Class[] params;
 617:     private Class returnType;
 618:     private int hash;
 619:     
 620:     MethodKey(Method m)
 621:     {
 622:       name = m.getName();
 623:       params = m.getParameterTypes();
 624:       returnType = m.getReturnType();
 625:       hash = name.hashCode() ^ returnType.hashCode();
 626:       for(int i = 0; i < params.length; i++)
 627:     {
 628:       hash ^= params[i].hashCode();
 629:     }
 630:     }
 631:     
 632:     public boolean equals(Object o)
 633:     {
 634:       if(o instanceof MethodKey)
 635:     {
 636:       MethodKey m = (MethodKey)o;
 637:       if(m.name.equals(name) && m.params.length == params.length && m.returnType == returnType)
 638:         {
 639:           for(int i = 0; i < params.length; i++)
 640:         {
 641:           if(m.params[i] != params[i])
 642:             {
 643:               return false;
 644:             }
 645:         }
 646:           return true;
 647:         }
 648:     }
 649:       return false;
 650:     }
 651:     
 652:     public int hashCode()
 653:     {
 654:       return hash;
 655:     }
 656:   }
 657:   
 658:   /**
 659:    * Get a public method declared or inherited in this class, where name is
 660:    * its simple name. The implicit methods of Object are not available from
 661:    * interfaces.  Constructors (named "&lt;init&gt;" in the class file) and class
 662:    * initializers (name "&lt;clinit&gt;") are not available.  The Virtual
 663:    * Machine allows multiple methods with the same signature but differing
 664:    * return types, and the class can inherit multiple methods of the same
 665:    * return type; in such a case the most specific return types are favored,
 666:    * then the final choice is arbitrary. If the method takes no argument, an
 667:    * array of zero elements and null are equivalent for the types argument.
 668:    * A security check may be performed, with
 669:    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 670:    * <code>checkPackageAccess</code> both having to succeed.
 671:    *
 672:    * @param methodName the name of the method
 673:    * @param types the type of each parameter
 674:    * @return the method
 675:    * @throws NoSuchMethodException if the method does not exist
 676:    * @throws SecurityException if the security check fails
 677:    * @see #getMethods()
 678:    * @since 1.1
 679:    */
 680:   public Method getMethod(String methodName, Class[] types)
 681:     throws NoSuchMethodException
 682:   {
 683:     memberAccessCheck(Member.PUBLIC);
 684:     Method method = internalGetMethod(methodName, types);
 685:     if (method == null)
 686:       throw new NoSuchMethodException(methodName);
 687:     return method;
 688:   }
 689: 
 690:   /**
 691:    * Like <code>getMethod(String,Class[])</code> but without the security
 692:    * checks and returns null instead of throwing NoSuchMethodException.
 693:    */
 694:   private Method internalGetMethod(String methodName, Class[] args)
 695:   {
 696:     Method match = matchMethod(getDeclaredMethods(true), methodName, args);
 697:     if (match != null)
 698:       return match;
 699:     Class superClass = getSuperclass();
 700:     if (superClass != null)
 701:       {
 702:     match = superClass.internalGetMethod(methodName, args);
 703:     if(match != null)
 704:       return match;
 705:       }
 706:     Class[] interfaces = getInterfaces();
 707:     for (int i = 0; i < interfaces.length; i++)
 708:       {
 709:     match = interfaces[i].internalGetMethod(methodName, args);
 710:     if (match != null)
 711:       return match;
 712:       }
 713:     return null;
 714:   }
 715: 
 716:   /** 
 717:    * Find the best matching method in <code>list</code> according to
 718:    * the definition of ``best matching'' used by <code>getMethod()</code>
 719:    *
 720:    * <p>
 721:    * Returns the method if any, otherwise <code>null</code>.
 722:    *
 723:    * @param list List of methods to search
 724:    * @param name Name of method
 725:    * @param args Method parameter types
 726:    * @see #getMethod(String, Class[])
 727:    */
 728:   private static Method matchMethod(Method[] list, String name, Class[] args)
 729:   {
 730:     Method match = null;
 731:     for (int i = 0; i < list.length; i++)
 732:       {
 733:     Method method = list[i];
 734:     if (!method.getName().equals(name))
 735:       continue;
 736:     if (!matchParameters(args, method.getParameterTypes()))
 737:       continue;
 738:     if (match == null
 739:         || match.getReturnType().isAssignableFrom(method.getReturnType()))
 740:       match = method;
 741:       }
 742:     return match;
 743:   }
 744: 
 745:   /**
 746:    * Check for an exact match between parameter type lists.
 747:    * Either list may be <code>null</code> to mean a list of
 748:    * length zero.
 749:    */
 750:   private static boolean matchParameters(Class[] types1, Class[] types2)
 751:   {
 752:     if (types1 == null)
 753:       return types2 == null || types2.length == 0;
 754:     if (types2 == null)
 755:       return types1 == null || types1.length == 0;
 756:     if (types1.length != types2.length)
 757:       return false;
 758:     for (int i = 0; i < types1.length; i++)
 759:       {
 760:     if (types1[i] != types2[i])
 761:       return false;
 762:       }
 763:     return true;
 764:   }
 765:   
 766:   /**
 767:    * Get all the public methods declared in this class or inherited from
 768:    * superclasses. This returns an array of length 0 if there are no methods,
 769:    * including for primitive types. This does not include the implicit
 770:    * methods of interfaces which mirror methods of Object, nor does it
 771:    * include constructors or the class initialization methods. The Virtual
 772:    * Machine allows multiple methods with the same signature but differing
 773:    * return types; all such methods are in the returned array. A security
 774:    * check may be performed, with
 775:    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 776:    * <code>checkPackageAccess</code> both having to succeed.
 777:    *
 778:    * @return all public methods in this class
 779:    * @throws SecurityException if the security check fails
 780:    * @since 1.1
 781:    */
 782:   public Method[] getMethods()
 783:   {
 784:     memberAccessCheck(Member.PUBLIC);
 785:     // NOTE the API docs claim that no methods are returned for arrays,
 786:     // but Sun's implementation *does* return the public methods of Object
 787:     // (as would be expected), so we follow their implementation instead
 788:     // of their documentation.
 789:     return internalGetMethods();
 790:   }
 791: 
 792:   /**
 793:    * Like <code>getMethods()</code> but without the security checks.
 794:    */
 795:   private Method[] internalGetMethods()
 796:   {
 797:     HashMap map = new HashMap();
 798:     Method[] methods;
 799:     Class[] interfaces = getInterfaces();
 800:     for(int i = 0; i < interfaces.length; i++)
 801:       {
 802:     methods = interfaces[i].internalGetMethods();
 803:     for(int j = 0; j < methods.length; j++)
 804:       {
 805:         map.put(new MethodKey(methods[j]), methods[j]);
 806:       }
 807:       }
 808:     Class superClass = getSuperclass();
 809:     if(superClass != null)
 810:       {
 811:     methods = superClass.internalGetMethods();
 812:     for(int i = 0; i < methods.length; i++)
 813:       {
 814:         map.put(new MethodKey(methods[i]), methods[i]);
 815:       }
 816:       }
 817:     methods = getDeclaredMethods(true);
 818:     for(int i = 0; i < methods.length; i++)
 819:       {
 820:     map.put(new MethodKey(methods[i]), methods[i]);
 821:       }
 822:     return (Method[])map.values().toArray(new Method[map.size()]);
 823:   }
 824: 
 825:   /**
 826:    * Get the modifiers of this class.  These can be decoded using Modifier,
 827:    * and is limited to one of public, protected, or private, and any of
 828:    * final, static, abstract, or interface. An array class has the same
 829:    * public, protected, or private modifier as its component type, and is
 830:    * marked final but not an interface. Primitive types and void are marked
 831:    * public and final, but not an interface.
 832:    *
 833:    * @return the modifiers of this class
 834:    * @see Modifier
 835:    * @since 1.1
 836:    */
 837:   public int getModifiers()
 838:   {
 839:     int mod = VMClass.getModifiers (this, false);
 840:     return (mod & (Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE |
 841:           Modifier.FINAL | Modifier.STATIC | Modifier.ABSTRACT |
 842:           Modifier.INTERFACE));
 843:   }
 844:   
 845:   /**
 846:    * Get the name of this class, separated by dots for package separators.
 847:    * If the class represents a primitive type, or void, then the
 848:    * name of the type as it appears in the Java programming language
 849:    * is returned.  For instance, <code>Byte.TYPE.getName()</code>
 850:    * returns "byte".
 851:    *
 852:    * Arrays are specially encoded as shown on this table.
 853:    * <pre>
 854:    * array type          [<em>element type</em>
 855:    *                     (note that the element type is encoded per
 856:    *                      this table)
 857:    * boolean             Z
 858:    * byte                B
 859:    * char                C
 860:    * short               S
 861:    * int                 I
 862:    * long                J
 863:    * float               F
 864:    * double              D
 865:    * void                V
 866:    * class or interface, alone: &lt;dotted name&gt;
 867:    * class or interface, as element type: L&lt;dotted name&gt;;
 868:    * </pre>
 869:    *
 870:    * @return the name of this class
 871:    */
 872:   public String getName()
 873:   { 
 874:     return VMClass.getName (this);
 875:   }
 876: 
 877:   /**
 878:    * Get a resource URL using this class's package using the
 879:    * getClassLoader().getResource() method.  If this class was loaded using
 880:    * the system classloader, ClassLoader.getSystemResource() is used instead.
 881:    *
 882:    * <p>If the name you supply is absolute (it starts with a <code>/</code>),
 883:    * then the leading <code>/</code> is removed and it is passed on to
 884:    * getResource(). If it is relative, the package name is prepended, and
 885:    * <code>.</code>'s are replaced with <code>/</code>.
 886:    *
 887:    * <p>The URL returned is system- and classloader-dependent, and could
 888:    * change across implementations.
 889:    *
 890:    * @param resourceName the name of the resource, generally a path
 891:    * @return the URL to the resource
 892:    * @throws NullPointerException if name is null
 893:    * @since 1.1
 894:    */
 895:   public URL getResource(String resourceName)
 896:   {
 897:     String name = resourcePath(resourceName);
 898:     ClassLoader loader = getClassLoader();
 899:     if (loader == null)
 900:       return ClassLoader.getSystemResource(name);
 901:     return loader.getResource(name);
 902:   }
 903: 
 904:   /**
 905:    * Get a resource using this class's package using the
 906:    * getClassLoader().getResourceAsStream() method.  If this class was loaded
 907:    * using the system classloader, ClassLoader.getSystemResource() is used
 908:    * instead.
 909:    *
 910:    * <p>If the name you supply is absolute (it starts with a <code>/</code>),
 911:    * then the leading <code>/</code> is removed and it is passed on to
 912:    * getResource(). If it is relative, the package name is prepended, and
 913:    * <code>.</code>'s are replaced with <code>/</code>.
 914:    *
 915:    * <p>The URL returned is system- and classloader-dependent, and could
 916:    * change across implementations.
 917:    *
 918:    * @param resourceName the name of the resource, generally a path
 919:    * @return an InputStream with the contents of the resource in it, or null
 920:    * @throws NullPointerException if name is null
 921:    * @since 1.1
 922:    */
 923:   public InputStream getResourceAsStream(String resourceName)
 924:   {
 925:     String name = resourcePath(resourceName);
 926:     ClassLoader loader = getClassLoader();
 927:     if (loader == null)
 928:       return ClassLoader.getSystemResourceAsStream(name);
 929:     return loader.getResourceAsStream(name);
 930:   }
 931: 
 932:   private String resourcePath(String resourceName)
 933:   {
 934:     if (resourceName.length() > 0)
 935:       {
 936:     if (resourceName.charAt(0) != '/')
 937:       {
 938:         String pkg = getPackagePortion(getName());
 939:         if (pkg.length() > 0)
 940:           resourceName = pkg.replace('.','/') + '/' + resourceName;
 941:       }
 942:     else
 943:       {
 944:         resourceName = resourceName.substring(1);
 945:       }
 946:       }
 947:     return resourceName;
 948:   }
 949: 
 950:   /**
 951:    * Get the signers of this class. This returns null if there are no signers,
 952:    * such as for primitive types or void.
 953:    *
 954:    * @return the signers of this class
 955:    * @since 1.1
 956:    */
 957:   public Object[] getSigners()
 958:   {
 959:     return signers == null ? null : (Object[]) signers.clone ();
 960:   }
 961:   
 962:   /**
 963:    * Set the signers of this class.
 964:    *
 965:    * @param signers the signers of this class
 966:    */
 967:   void setSigners(Object[] signers)
 968:   {
 969:     this.signers = signers;
 970:   }
 971: 
 972:   /**
 973:    * Get the direct superclass of this class.  If this is an interface,
 974:    * Object, a primitive type, or void, it will return null. If this is an
 975:    * array type, it will return Object.
 976:    *
 977:    * @return the direct superclass of this class
 978:    */
 979:   public Class getSuperclass()
 980:   {
 981:     return VMClass.getSuperclass (this);
 982:   }
 983:   
 984:   /**
 985:    * Return whether this class is an array type.
 986:    *
 987:    * @return whether this class is an array type
 988:    * @since 1.1
 989:    */
 990:   public boolean isArray()
 991:   {
 992:     return VMClass.isArray (this);
 993:   }
 994:   
 995:   /**
 996:    * Discover whether an instance of the Class parameter would be an
 997:    * instance of this Class as well.  Think of doing
 998:    * <code>isInstance(c.newInstance())</code> or even
 999:    * <code>c.newInstance() instanceof (this class)</code>. While this
1000:    * checks widening conversions for objects, it must be exact for primitive
1001:    * types.
1002:    *
1003:    * @param c the class to check
1004:    * @return whether an instance of c would be an instance of this class
1005:    *         as well
1006:    * @throws NullPointerException if c is null
1007:    * @since 1.1
1008:    */
1009:   public boolean isAssignableFrom(Class c)
1010:   {
1011:     return VMClass.isAssignableFrom (this, c);
1012:   }
1013:  
1014:   /**
1015:    * Discover whether an Object is an instance of this Class.  Think of it
1016:    * as almost like <code>o instanceof (this class)</code>.
1017:    *
1018:    * @param o the Object to check
1019:    * @return whether o is an instance of this class
1020:    * @since 1.1
1021:    */
1022:   public boolean isInstance(Object o)
1023:   {
1024:     return VMClass.isInstance (this, o);
1025:   }
1026:   
1027:   /**
1028:    * Check whether this class is an interface or not.  Array types are not
1029:    * interfaces.
1030:    *
1031:    * @return whether this class is an interface or not
1032:    */
1033:   public boolean isInterface()
1034:   {
1035:     return VMClass.isInterface (this);
1036:   }
1037:   
1038:   /**
1039:    * Return whether this class is a primitive type.  A primitive type class
1040:    * is a class representing a kind of "placeholder" for the various
1041:    * primitive types, or void.  You can access the various primitive type
1042:    * classes through java.lang.Boolean.TYPE, java.lang.Integer.TYPE, etc.,
1043:    * or through boolean.class, int.class, etc.
1044:    *
1045:    * @return whether this class is a primitive type
1046:    * @see Boolean#TYPE
1047:    * @see Byte#TYPE
1048:    * @see Character#TYPE
1049:    * @see Short#TYPE
1050:    * @see Integer#TYPE
1051:    * @see Long#TYPE
1052:    * @see Float#TYPE
1053:    * @see Double#TYPE
1054:    * @see Void#TYPE
1055:    * @since 1.1
1056:    */
1057:   public boolean isPrimitive()
1058:   {
1059:     return VMClass.isPrimitive (this);
1060:   }
1061:   
1062:   /**
1063:    * Get a new instance of this class by calling the no-argument constructor.
1064:    * The class is initialized if it has not been already. A security check
1065:    * may be performed, with <code>checkMemberAccess(this, Member.PUBLIC)</code>
1066:    * as well as <code>checkPackageAccess</code> both having to succeed.
1067:    *
1068:    * @return a new instance of this class
1069:    * @throws InstantiationException if there is not a no-arg constructor
1070:    *         for this class, including interfaces, abstract classes, arrays,
1071:    *         primitive types, and void; or if an exception occurred during
1072:    *         the constructor
1073:    * @throws IllegalAccessException if you are not allowed to access the
1074:    *         no-arg constructor because of scoping reasons
1075:    * @throws SecurityException if the security check fails
1076:    * @throws ExceptionInInitializerError if class initialization caused by
1077:    *         this call fails with an exception
1078:    */
1079:   public Object newInstance()
1080:     throws InstantiationException, IllegalAccessException
1081:   {
1082:     memberAccessCheck(Member.PUBLIC);
1083:     Constructor constructor;
1084:     synchronized(this)
1085:       {
1086:     constructor = this.constructor;
1087:       }
1088:     if (constructor == null)
1089:       {
1090:     Constructor[] constructors = getDeclaredConstructors(false);
1091:     for (int i = 0; i < constructors.length; i++)
1092:       {
1093:         if (constructors[i].getParameterTypes().length == 0)
1094:           {
1095:         constructor = constructors[i];
1096:         break;
1097:           }
1098:       }
1099:     if (constructor == null)
1100:       throw new InstantiationException(getName());
1101:     if (!Modifier.isPublic(constructor.getModifiers())
1102:             || !Modifier.isPublic(VMClass.getModifiers(this, true)))
1103:       {
1104:         final Constructor finalConstructor = constructor;
1105:         AccessController.doPrivileged(new PrivilegedAction()
1106:           {
1107:         public Object run()
1108:             {
1109:           finalConstructor.setAccessible(true);
1110:           return null;
1111:         }
1112:           });
1113:       }
1114:     synchronized(this)
1115:       {
1116:         if (this.constructor == null)
1117:           this.constructor = constructor;
1118:       }        
1119:       }
1120:     int modifiers = constructor.getModifiers();
1121:     if (!Modifier.isPublic(modifiers)
1122:         || !Modifier.isPublic(VMClass.getModifiers(this, true)))
1123:       {
1124:     Class caller = VMStackWalker.getCallingClass();
1125:     if (caller != null &&
1126:         caller != this &&
1127:         (Modifier.isPrivate(modifiers)
1128:          || getClassLoader() != caller.getClassLoader()
1129:          || !getPackagePortion(getName())
1130:          .equals(getPackagePortion(caller.getName()))))
1131:       throw new IllegalAccessException(getName()
1132:                        + " has an inaccessible constructor");
1133:       }
1134:     try
1135:       {
1136:         return constructor.newInstance(null);
1137:       }
1138:     catch (InvocationTargetException e)
1139:       {
1140:     VMClass.throwException(e.getTargetException());
1141:     throw (InternalError) new InternalError
1142:       ("VMClass.throwException returned").initCause(e);
1143:       }
1144:   }
1145: 
1146:   /**
1147:    * Returns the protection domain of this class. If the classloader did not
1148:    * record the protection domain when creating this class the unknown
1149:    * protection domain is returned which has a <code>null</code> code source
1150:    * and all permissions. A security check may be performed, with
1151:    * <code>RuntimePermission("getProtectionDomain")</code>.
1152:    *
1153:    * @return the protection domain
1154:    * @throws SecurityException if the security manager exists and the caller
1155:    * does not have <code>RuntimePermission("getProtectionDomain")</code>.
1156:    * @see RuntimePermission
1157:    * @since 1.2
1158:    */
1159:   public ProtectionDomain getProtectionDomain()
1160:   {
1161:     SecurityManager sm = SecurityManager.current;
1162:     if (sm != null)
1163:       sm.checkPermission(new RuntimePermission("getProtectionDomain"));
1164: 
1165:     return pd == null ? StaticData.unknownProtectionDomain : pd;
1166:   }
1167: 
1168:   /**
1169:    * Return the human-readable form of this Object.  For an object, this
1170:    * is either "interface " or "class " followed by <code>getName()</code>,
1171:    * for primitive types and void it is just <code>getName()</code>.
1172:    *
1173:    * @return the human-readable form of this Object
1174:    */
1175:   public String toString()
1176:   {
1177:     if (isPrimitive())
1178:       return getName();
1179:     return (isInterface() ? "interface " : "class ") + getName();
1180:   }
1181: 
1182:   /**
1183:    * Returns the desired assertion status of this class, if it were to be
1184:    * initialized at this moment. The class assertion status, if set, is
1185:    * returned; the backup is the default package status; then if there is
1186:    * a class loader, that default is returned; and finally the system default
1187:    * is returned. This method seldom needs calling in user code, but exists
1188:    * for compilers to implement the assert statement. Note that there is no
1189:    * guarantee that the result of this method matches the class's actual
1190:    * assertion status.
1191:    *
1192:    * @return the desired assertion status
1193:    * @see ClassLoader#setClassAssertionStatus(String, boolean)
1194:    * @see ClassLoader#setPackageAssertionStatus(String, boolean)
1195:    * @see ClassLoader#setDefaultAssertionStatus(boolean)
1196:    * @since 1.4
1197:    */
1198:   public boolean desiredAssertionStatus()
1199:   {
1200:     ClassLoader c = getClassLoader();
1201:     Object status;
1202:     if (c == null)
1203:       return VMClassLoader.defaultAssertionStatus();
1204:     if (c.classAssertionStatus != null)
1205:       synchronized (c)
1206:         {
1207:           status = c.classAssertionStatus.get(getName());
1208:           if (status != null)
1209:             return status.equals(Boolean.TRUE);
1210:         }
1211:     else
1212:       {
1213:         status = ClassLoader.StaticData.
1214:                     systemClassAssertionStatus.get(getName());
1215:         if (status != null)
1216:           return status.equals(Boolean.TRUE);
1217:       }
1218:     if (c.packageAssertionStatus != null)
1219:       synchronized (c)
1220:         {
1221:           String name = getPackagePortion(getName());
1222:           if ("".equals(name))
1223:             status = c.packageAssertionStatus.get(null);
1224:           else
1225:             do
1226:               {
1227:                 status = c.packageAssertionStatus.get(name);
1228:                 name = getPackagePortion(name);
1229:               }
1230:             while (! "".equals(name) && status == null);
1231:           if (status != null)
1232:             return status.equals(Boolean.TRUE);
1233:         }
1234:     else
1235:       {
1236:         String name = getPackagePortion(getName());
1237:         if ("".equals(name))
1238:           status = ClassLoader.StaticData.
1239:                     systemPackageAssertionStatus.get(null);
1240:         else
1241:           do
1242:             {
1243:               status = ClassLoader.StaticData.
1244:                         systemPackageAssertionStatus.get(name);
1245:               name = getPackagePortion(name);
1246:             }
1247:           while (! "".equals(name) && status == null);
1248:         if (status != null)
1249:           return status.equals(Boolean.TRUE);
1250:       }
1251:     return c.defaultAssertionStatus;
1252:   }
1253: 
1254:   /**
1255:    * Like <code>getField(String)</code> but without the security checks and returns null
1256:    * instead of throwing NoSuchFieldException.
1257:    */
1258:   private Field internalGetField(String name)
1259:   {
1260:     Field[] fields = getDeclaredFields(true);
1261:     for (int i = 0; i < fields.length; i++)
1262:       {
1263:     Field field = fields[i];
1264:     if (field.getName().equals(name))
1265:       return field;
1266:       }
1267:     Class[] interfaces = getInterfaces();
1268:     for (int i = 0; i < interfaces.length; i++)
1269:       {
1270:     Field field = interfaces[i].internalGetField(name);
1271:     if(field != null)
1272:       return field;
1273:       }
1274:     Class superClass = getSuperclass();
1275:     if (superClass != null)
1276:       return superClass.internalGetField(name);
1277:     return null;
1278:   }
1279: 
1280:   /**
1281:    * Strip the last portion of the name (after the last dot).
1282:    *
1283:    * @param name the name to get package of
1284:    * @return the package name, or "" if no package
1285:    */
1286:   private static String getPackagePortion(String name)
1287:   {
1288:     int lastInd = name.lastIndexOf('.');
1289:     if (lastInd == -1)
1290:       return "";
1291:     return name.substring(0, lastInd);
1292:   }
1293: 
1294:   /**
1295:    * Perform security checks common to all of the methods that
1296:    * get members of this Class.
1297:    */
1298:   private void memberAccessCheck(int which)
1299:   {
1300:     SecurityManager sm = SecurityManager.current;
1301:     if (sm != null)
1302:       {
1303:     sm.checkMemberAccess(this, which);
1304:     Package pkg = getPackage();
1305:     if (pkg != null)
1306:       sm.checkPackageAccess(pkg.getName());
1307:       }
1308:   }
1309: }