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 java.io.InputStream;
  42: import java.io.Serializable;
  43: import java.lang.reflect.Constructor;
  44: import java.lang.reflect.Field;
  45: import java.lang.reflect.Member;
  46: import java.lang.reflect.Method;
  47: import java.net.URL;
  48: import java.security.ProtectionDomain;
  49: import java.util.ArrayList;
  50: import java.util.Arrays;
  51: import java.util.HashSet;
  52: 
  53: /**
  54:  * A Class represents a Java type.  There will never be multiple Class
  55:  * objects with identical names and ClassLoaders. Primitive types, array
  56:  * types, and void also have a Class object.
  57:  *
  58:  * <p>Arrays with identical type and number of dimensions share the same class.
  59:  * The array class ClassLoader is the same as the ClassLoader of the element
  60:  * type of the array (which can be null to indicate the bootstrap classloader).
  61:  * The name of an array class is <code>[&lt;signature format&gt;;</code>.
  62:  * <p> For example,
  63:  * String[]'s class is <code>[Ljava.lang.String;</code>. boolean, byte,
  64:  * short, char, int, long, float and double have the "type name" of
  65:  * Z,B,S,C,I,J,F,D for the purposes of array classes.  If it's a
  66:  * multidimensioned array, the same principle applies:
  67:  * <code>int[][][]</code> == <code>[[[I</code>.
  68:  *
  69:  * <p>There is no public constructor - Class objects are obtained only through
  70:  * the virtual machine, as defined in ClassLoaders.
  71:  *
  72:  * @serialData Class objects serialize specially:
  73:  * <code>TC_CLASS ClassDescriptor</code>. For more serialization information,
  74:  * see {@link ObjectStreamClass}.
  75:  *
  76:  * @author John Keiser
  77:  * @author Eric Blake (ebb9@email.byu.edu)
  78:  * @author Tom Tromey (tromey@cygnus.com)
  79:  * @since 1.0
  80:  * @see ClassLoader
  81:  */
  82: public final class Class implements Serializable
  83: {
  84:   /**
  85:    * Class is non-instantiable from Java code; only the VM can create
  86:    * instances of this class.
  87:    */
  88:   private Class ()
  89:   {
  90:   }
  91: 
  92:   // Initialize the class.
  93:   private native void initializeClass ();
  94: 
  95:   // finalization
  96:   protected native void finalize () throws Throwable;
  97: 
  98:   /**
  99:    * Use the classloader of the current class to load, link, and initialize
 100:    * a class. This is equivalent to your code calling
 101:    * <code>Class.forName(name, true, getClass().getClassLoader())</code>.
 102:    *
 103:    * @param name the name of the class to find
 104:    * @return the Class object representing the class
 105:    * @throws ClassNotFoundException if the class was not found by the
 106:    *         classloader
 107:    * @throws LinkageError if linking the class fails
 108:    * @throws ExceptionInInitializerError if the class loads, but an exception
 109:    *         occurs during initialization
 110:    */
 111:   public static native Class forName (String className)
 112:     throws ClassNotFoundException;
 113: 
 114:   /**
 115:    * Use the specified classloader to load and link a class. If the loader
 116:    * is null, this uses the bootstrap class loader (provide the security
 117:    * check succeeds). Unfortunately, this method cannot be used to obtain
 118:    * the Class objects for primitive types or for void, you have to use
 119:    * the fields in the appropriate java.lang wrapper classes.
 120:    *
 121:    * <p>Calls <code>classloader.loadclass(name, initialize)</code>.
 122:    *
 123:    * @param name the name of the class to find
 124:    * @param initialize whether or not to initialize the class at this time
 125:    * @param classloader the classloader to use to find the class; null means
 126:    *        to use the bootstrap class loader
 127:    * @throws ClassNotFoundException if the class was not found by the
 128:    *         classloader
 129:    * @throws LinkageError if linking the class fails
 130:    * @throws ExceptionInInitializerError if the class loads, but an exception
 131:    *         occurs during initialization
 132:    * @throws SecurityException if the <code>classloader</code> argument
 133:    *         is <code>null</code> and the caller does not have the
 134:    *         <code>RuntimePermission("getClassLoader")</code> permission
 135:    * @see ClassLoader
 136:    * @since 1.2
 137:    */
 138:   public static native Class forName (String className, boolean initialize,
 139:                       ClassLoader loader)
 140:     throws ClassNotFoundException;
 141:   
 142:   /**
 143:    * Get all the public member classes and interfaces declared in this
 144:    * class or inherited from superclasses. This returns an array of length
 145:    * 0 if there are no member classes, including for primitive types. A
 146:    * security check may be performed, with
 147:    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 148:    * <code>checkPackageAccess</code> both having to succeed.
 149:    *
 150:    * @return all public member classes in this class
 151:    * @throws SecurityException if the security check fails
 152:    * @since 1.1
 153:    */
 154:   public Class[] getClasses()
 155:   {
 156:     memberAccessCheck(Member.PUBLIC);
 157:     return internalGetClasses();
 158:   }
 159: 
 160:   /**
 161:    * Like <code>getClasses()</code> but without the security checks.
 162:    */
 163:   private Class[] internalGetClasses()
 164:   {
 165:     ArrayList list = new ArrayList();
 166:     list.addAll(Arrays.asList(getDeclaredClasses(true)));
 167:     Class superClass = getSuperclass();
 168:     if (superClass != null)
 169:       list.addAll(Arrays.asList(superClass.internalGetClasses()));
 170:     return (Class[])list.toArray(new Class[list.size()]);
 171:   }
 172:   
 173:   /**
 174:    * Get the ClassLoader that loaded this class.  If the class was loaded
 175:    * by the bootstrap classloader, this method will return null.
 176:    * If there is a security manager, and the caller's class loader is not
 177:    * an ancestor of the requested one, a security check of
 178:    * <code>RuntimePermission("getClassLoader")</code>
 179:    * must first succeed. Primitive types and void return null.
 180:    *
 181:    * @return the ClassLoader that loaded this class
 182:    * @throws SecurityException if the security check fails
 183:    * @see ClassLoader
 184:    * @see RuntimePermission
 185:    */
 186:   public native ClassLoader getClassLoader ();
 187:   
 188:   /**
 189:    * If this is an array, get the Class representing the type of array.
 190:    * Examples: "[[Ljava.lang.String;" would return "[Ljava.lang.String;", and
 191:    * calling getComponentType on that would give "java.lang.String".  If
 192:    * this is not an array, returns null.
 193:    *
 194:    * @return the array type of this class, or null
 195:    * @see Array
 196:    * @since 1.1
 197:    */
 198:   public native Class getComponentType ();
 199: 
 200:   /**
 201:    * Get a public constructor declared in this class. If the constructor takes
 202:    * no argument, an array of zero elements and null are equivalent for the
 203:    * types argument. A security check may be performed, with
 204:    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 205:    * <code>checkPackageAccess</code> both having to succeed.
 206:    *
 207:    * @param types the type of each parameter
 208:    * @return the constructor
 209:    * @throws NoSuchMethodException if the constructor does not exist
 210:    * @throws SecurityException if the security check fails
 211:    * @see #getConstructors()
 212:    * @since 1.1
 213:    */
 214:   public native Constructor getConstructor(Class[] args)
 215:     throws NoSuchMethodException;
 216: 
 217:   /**
 218:    * Get all the public constructors of this class. This returns an array of
 219:    * length 0 if there are no constructors, including for primitive types,
 220:    * arrays, and interfaces. It does, however, include the default
 221:    * constructor if one was supplied by the compiler. A security check may
 222:    * be performed, with <code>checkMemberAccess(this, Member.PUBLIC)</code>
 223:    * as well as <code>checkPackageAccess</code> both having to succeed.
 224:    *
 225:    * @return all public constructors in this class
 226:    * @throws SecurityException if the security check fails
 227:    * @since 1.1
 228:    */
 229:   public Constructor[] getConstructors()
 230:   {
 231:     memberAccessCheck(Member.PUBLIC);
 232:     return getDeclaredConstructors(true);
 233:   }
 234: 
 235:   /**
 236:    * Get a constructor declared in this class. If the constructor takes no
 237:    * argument, an array of zero elements and null are equivalent for the
 238:    * types argument. A security check may be performed, with
 239:    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 240:    * <code>checkPackageAccess</code> both having to succeed.
 241:    *
 242:    * @param types the type of each parameter
 243:    * @return the constructor
 244:    * @throws NoSuchMethodException if the constructor does not exist
 245:    * @throws SecurityException if the security check fails
 246:    * @see #getDeclaredConstructors()
 247:    * @since 1.1
 248:    */
 249:   public native Constructor getDeclaredConstructor(Class[] args)
 250:     throws NoSuchMethodException;
 251: 
 252:   /**
 253:    * Get all the declared member classes and interfaces in this class, but
 254:    * not those inherited from superclasses. This returns an array of length
 255:    * 0 if there are no member classes, including for primitive types. A
 256:    * security check may be performed, with
 257:    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 258:    * <code>checkPackageAccess</code> both having to succeed.
 259:    *
 260:    * @return all declared member classes in this class
 261:    * @throws SecurityException if the security check fails
 262:    * @since 1.1
 263:    */
 264:   public Class[] getDeclaredClasses()
 265:   {
 266:     memberAccessCheck(Member.DECLARED);
 267:     return getDeclaredClasses(false);
 268:   }
 269: 
 270:   native Class[] getDeclaredClasses (boolean publicOnly);
 271: 
 272:   /**
 273:    * Get all the declared constructors of this class. This returns an array of
 274:    * length 0 if there are no constructors, including for primitive types,
 275:    * arrays, and interfaces. It does, however, include the default
 276:    * constructor if one was supplied by the compiler. A security check may
 277:    * be performed, with <code>checkMemberAccess(this, Member.DECLARED)</code>
 278:    * as well as <code>checkPackageAccess</code> both having to succeed.
 279:    *
 280:    * @return all constructors in this class
 281:    * @throws SecurityException if the security check fails
 282:    * @since 1.1
 283:    */
 284:   public Constructor[] getDeclaredConstructors()
 285:   {
 286:     memberAccessCheck(Member.DECLARED);
 287:     return getDeclaredConstructors(false);
 288:   }
 289: 
 290:   native Constructor[] getDeclaredConstructors (boolean publicOnly);
 291: 
 292:   /**
 293:    * Get a field declared in this class, where name is its simple name. The
 294:    * implicit length field of arrays is not available. A security check may
 295:    * be performed, with <code>checkMemberAccess(this, Member.DECLARED)</code>
 296:    * as well as <code>checkPackageAccess</code> both having to succeed.
 297:    *
 298:    * @param name the name of the field
 299:    * @return the field
 300:    * @throws NoSuchFieldException if the field does not exist
 301:    * @throws SecurityException if the security check fails
 302:    * @see #getDeclaredFields()
 303:    * @since 1.1
 304:    */
 305:   public native Field getDeclaredField(String fieldName)
 306:     throws NoSuchFieldException;
 307: 
 308:   /**
 309:    * Get all the declared fields in this class, but not those inherited from
 310:    * superclasses. This returns an array of length 0 if there are no fields,
 311:    * including for primitive types. This does not return the implicit length
 312:    * field of arrays. A security check may be performed, with
 313:    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 314:    * <code>checkPackageAccess</code> both having to succeed.
 315:    *
 316:    * @return all declared fields in this class
 317:    * @throws SecurityException if the security check fails
 318:    * @since 1.1
 319:    */
 320:   public Field[] getDeclaredFields()
 321:   {
 322:     memberAccessCheck(Member.DECLARED);
 323:     return getDeclaredFields(false);
 324:   }
 325: 
 326:   native Field[] getDeclaredFields (boolean publicOnly);
 327: 
 328:   private native Method _getDeclaredMethod(String methodName, Class[] args);
 329: 
 330:   /**
 331:    * Get a method declared in this class, where name is its simple name. The
 332:    * implicit methods of Object are not available from arrays or interfaces.
 333:    * Constructors (named "&lt;init&gt;" in the class file) and class initializers
 334:    * (name "&lt;clinit&gt;") are not available.  The Virtual Machine allows
 335:    * multiple methods with the same signature but differing return types; in
 336:    * such a case the most specific return types are favored, then the final
 337:    * choice is arbitrary. If the method takes no argument, an array of zero
 338:    * elements and null are equivalent for the types argument. A security
 339:    * check may be performed, with
 340:    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 341:    * <code>checkPackageAccess</code> both having to succeed.
 342:    *
 343:    * @param methodName the name of the method
 344:    * @param types the type of each parameter
 345:    * @return the method
 346:    * @throws NoSuchMethodException if the method does not exist
 347:    * @throws SecurityException if the security check fails
 348:    * @see #getDeclaredMethods()
 349:    * @since 1.1
 350:    */
 351:   public Method getDeclaredMethod(String methodName, Class[] args)
 352:     throws NoSuchMethodException
 353:   {
 354:     memberAccessCheck(Member.DECLARED);
 355: 
 356:     if ("<init>".equals(methodName) || "<clinit>".equals(methodName))
 357:       throw new NoSuchMethodException(methodName);
 358: 
 359:     Method match = _getDeclaredMethod(methodName, args);
 360:     if (match == null)
 361:       throw new NoSuchMethodException(methodName);
 362:     return match;
 363:   }
 364: 
 365:   /**
 366:    * Get all the declared methods in this class, but not those inherited from
 367:    * superclasses. This returns an array of length 0 if there are no methods,
 368:    * including for primitive types. This does include the implicit methods of
 369:    * arrays and interfaces which mirror methods of Object, nor does it
 370:    * include constructors or the class initialization methods. The Virtual
 371:    * Machine allows multiple methods with the same signature but differing
 372:    * return types; all such methods are in the returned array. A security
 373:    * check may be performed, with
 374:    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 375:    * <code>checkPackageAccess</code> both having to succeed.
 376:    *
 377:    * @return all declared methods in this class
 378:    * @throws SecurityException if the security check fails
 379:    * @since 1.1
 380:    */
 381:   public native Method[] getDeclaredMethods();
 382:  
 383:   /**
 384:    * If this is a nested or inner class, return the class that declared it.
 385:    * If not, return null.
 386:    *
 387:    * @return the declaring class of this class
 388:    * @since 1.1
 389:    */
 390:   // This is marked as unimplemented in the JCL book.
 391:   public native Class getDeclaringClass ();
 392: 
 393:   private native Field getField (String fieldName, int hash)
 394:     throws NoSuchFieldException;
 395: 
 396:   /**
 397:    * Get a public field declared or inherited in this class, where name is
 398:    * its simple name. If the class contains multiple accessible fields by
 399:    * that name, an arbitrary one is returned. The implicit length field of
 400:    * arrays is not available. A security check may be performed, with
 401:    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 402:    * <code>checkPackageAccess</code> both having to succeed.
 403:    *
 404:    * @param fieldName the name of the field
 405:    * @return the field
 406:    * @throws NoSuchFieldException if the field does not exist
 407:    * @throws SecurityException if the security check fails
 408:    * @see #getFields()
 409:    * @since 1.1
 410:    */
 411:   public Field getField(String fieldName)
 412:     throws NoSuchFieldException
 413:   {
 414:     memberAccessCheck(Member.PUBLIC);
 415:     Field field = getField(fieldName, fieldName.hashCode());
 416:     if (field == null)
 417:       throw new NoSuchFieldException(fieldName);
 418:     return field;
 419:   }
 420: 
 421:   /**
 422:    * Get all the public fields declared in this class or inherited from
 423:    * superclasses. This returns an array of length 0 if there are no fields,
 424:    * including for primitive types. This does not return the implicit length
 425:    * field of arrays. A security check may be performed, with
 426:    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 427:    * <code>checkPackageAccess</code> both having to succeed.
 428:    *
 429:    * @return all public fields in this class
 430:    * @throws SecurityException if the security check fails
 431:    * @since 1.1
 432:    */
 433:   public Field[] getFields()
 434:   {
 435:     memberAccessCheck(Member.PUBLIC);
 436:     return internalGetFields();
 437:   }
 438: 
 439:   /**
 440:    * Like <code>getFields()</code> but without the security checks.
 441:    */
 442:   private Field[] internalGetFields()
 443:   {
 444:     HashSet set = new HashSet();
 445:     set.addAll(Arrays.asList(getDeclaredFields(true)));
 446:     Class[] interfaces = getInterfaces();
 447:     for (int i = 0; i < interfaces.length; i++)
 448:       set.addAll(Arrays.asList(interfaces[i].internalGetFields()));
 449:     Class superClass = getSuperclass();
 450:     if (superClass != null)
 451:       set.addAll(Arrays.asList(superClass.internalGetFields()));
 452:     return (Field[])set.toArray(new Field[set.size()]);
 453:   }
 454: 
 455:   /**
 456:    * Returns the <code>Package</code> in which this class is defined
 457:    * Returns null when this information is not available from the
 458:    * classloader of this class.
 459:    *
 460:    * @return the package for this class, if it is available
 461:    * @since 1.2
 462:    */
 463:   public Package getPackage()
 464:   {
 465:     ClassLoader cl = getClassLoader();
 466:     if (cl != null)
 467:       return cl.getPackage(getPackagePortion(getName()));
 468:     else
 469:       return VMClassLoader.getPackage(getPackagePortion(getName()));
 470:   }
 471: 
 472:   /**
 473:    * Get the interfaces this class <em>directly</em> implements, in the
 474:    * order that they were declared. This returns an empty array, not null,
 475:    * for Object, primitives, void, and classes or interfaces with no direct
 476:    * superinterface. Array types return Cloneable and Serializable.
 477:    *
 478:    * @return the interfaces this class directly implements
 479:    */
 480:   public native Class[] getInterfaces ();
 481: 
 482:   private final native void getSignature(StringBuffer buffer);
 483:   private static final native String getSignature(Class[] args,
 484:                           boolean is_construtor);
 485: 
 486:   public native Method _getMethod(String methodName, Class[] args);
 487: 
 488:   /**
 489:    * Get a public method declared or inherited in this class, where name is
 490:    * its simple name. The implicit methods of Object are not available from
 491:    * interfaces.  Constructors (named "&lt;init&gt;" in the class file) and class
 492:    * initializers (name "&lt;clinit&gt;") are not available.  The Virtual
 493:    * Machine allows multiple methods with the same signature but differing
 494:    * return types, and the class can inherit multiple methods of the same
 495:    * return type; in such a case the most specific return types are favored,
 496:    * then the final choice is arbitrary. If the method takes no argument, an
 497:    * array of zero elements and null are equivalent for the types argument.
 498:    * A security check may be performed, with
 499:    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 500:    * <code>checkPackageAccess</code> both having to succeed.
 501:    *
 502:    * @param methodName the name of the method
 503:    * @param types the type of each parameter
 504:    * @return the method
 505:    * @throws NoSuchMethodException if the method does not exist
 506:    * @throws SecurityException if the security check fails
 507:    * @see #getMethods()
 508:    * @since 1.1
 509:    */
 510:   public Method getMethod(String methodName, Class[] args)
 511:     throws NoSuchMethodException
 512:   {
 513:     memberAccessCheck(Member.PUBLIC);
 514: 
 515:     if ("<init>".equals(methodName) || "<clinit>".equals(methodName))
 516:       throw new NoSuchMethodException(methodName);
 517: 
 518:     Method method = _getMethod(methodName, args);
 519:     if (method == null)
 520:       throw new NoSuchMethodException(methodName);
 521:     return method;
 522:   }
 523: 
 524:   private native int _getMethods (Method[] result, int offset);
 525:   
 526:   /**
 527:    * Get all the public methods declared in this class or inherited from
 528:    * superclasses. This returns an array of length 0 if there are no methods,
 529:    * including for primitive types. This does not include the implicit
 530:    * methods of interfaces which mirror methods of Object, nor does it
 531:    * include constructors or the class initialization methods. The Virtual
 532:    * Machine allows multiple methods with the same signature but differing
 533:    * return types; all such methods are in the returned array. A security
 534:    * check may be performed, with
 535:    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 536:    * <code>checkPackageAccess</code> both having to succeed.
 537:    *
 538:    * @return all public methods in this class
 539:    * @throws SecurityException if the security check fails
 540:    * @since 1.1
 541:    */
 542:   public native Method[] getMethods();
 543: 
 544:   /**
 545:    * Get the modifiers of this class.  These can be decoded using Modifier,
 546:    * and is limited to one of public, protected, or private, and any of
 547:    * final, static, abstract, or interface. An array class has the same
 548:    * public, protected, or private modifier as its component type, and is
 549:    * marked final but not an interface. Primitive types and void are marked
 550:    * public and final, but not an interface.
 551:    *
 552:    * @return the modifiers of this class
 553:    * @see Modifer
 554:    * @since 1.1
 555:    */
 556:   public native int getModifiers ();
 557:   
 558:   /**
 559:    * Get the name of this class, separated by dots for package separators.
 560:    * If the class represents a primitive type, or void, then the
 561:    * name of the type as it appears in the Java programming language
 562:    * is returned.  For instance, <code>Byte.TYPE.getName()</code>
 563:    * returns "byte".
 564:    *
 565:    * Arrays are specially encoded as shown on this table.
 566:    * <pre>
 567:    * array type          [<em>element type</em>
 568:    *                     (note that the element type is encoded per
 569:    *                      this table)
 570:    * boolean             Z
 571:    * byte                B
 572:    * char                C
 573:    * short               S
 574:    * int                 I
 575:    * long                J
 576:    * float               F
 577:    * double              D
 578:    * void                V
 579:    * class or interface, alone: &lt;dotted name&gt;
 580:    * class or interface, as element type: L&lt;dotted name&gt;;
 581:    * </pre>
 582:    *
 583:    * @return the name of this class
 584:    */
 585:   public native String getName ();
 586: 
 587:   /**
 588:    * Get a resource URL using this class's package using the
 589:    * getClassLoader().getResource() method.  If this class was loaded using
 590:    * the system classloader, ClassLoader.getSystemResource() is used instead.
 591:    *
 592:    * <p>If the name you supply is absolute (it starts with a <code>/</code>),
 593:    * then the leading <code>/</code> is removed and it is passed on to
 594:    * getResource(). If it is relative, the package name is prepended, and
 595:    * <code>.</code>'s are replaced with <code>/</code>.
 596:    *
 597:    * <p>The URL returned is system- and classloader-dependent, and could
 598:    * change across implementations.
 599:    *
 600:    * @param resourceName the name of the resource, generally a path
 601:    * @return the URL to the resource
 602:    * @throws NullPointerException if name is null
 603:    * @since 1.1
 604:    */
 605:   public URL getResource(String resourceName)
 606:   {
 607:     String name = resourcePath(resourceName);
 608:     ClassLoader loader = getClassLoader();
 609:     if (loader == null)
 610:       return ClassLoader.getSystemResource(name);
 611:     return loader.getResource(name);
 612:   }
 613: 
 614:   /**
 615:    * Get a resource using this class's package using the
 616:    * getClassLoader().getResourceAsStream() method.  If this class was loaded
 617:    * using the system classloader, ClassLoader.getSystemResource() is used
 618:    * instead.
 619:    *
 620:    * <p>If the name you supply is absolute (it starts with a <code>/</code>),
 621:    * then the leading <code>/</code> is removed and it is passed on to
 622:    * getResource(). If it is relative, the package name is prepended, and
 623:    * <code>.</code>'s are replaced with <code>/</code>.
 624:    *
 625:    * <p>The URL returned is system- and classloader-dependent, and could
 626:    * change across implementations.
 627:    *
 628:    * @param resourceName the name of the resource, generally a path
 629:    * @return an InputStream with the contents of the resource in it, or null
 630:    * @throws NullPointerException if name is null
 631:    * @since 1.1
 632:    */
 633:   public InputStream getResourceAsStream(String resourceName)
 634:   {
 635:     String name = resourcePath(resourceName);
 636:     ClassLoader loader = getClassLoader();
 637:     if (loader == null)
 638:       return ClassLoader.getSystemResourceAsStream(name);
 639:     return loader.getResourceAsStream(name);
 640:   }
 641: 
 642:   private String resourcePath(String resourceName)
 643:   {
 644:     if (resourceName.length() > 0)
 645:       {
 646:     if (resourceName.charAt(0) != '/')
 647:       {
 648:         String pkg = getPackagePortion(getName());
 649:         if (pkg.length() > 0)
 650:           resourceName = pkg.replace('.','/') + '/' + resourceName;
 651:       }
 652:     else
 653:       {
 654:         resourceName = resourceName.substring(1);
 655:       }
 656:       }
 657:     return resourceName;
 658:   }
 659: 
 660:   /**
 661:    * Get the signers of this class. This returns null if there are no signers,
 662:    * such as for primitive types or void.
 663:    *
 664:    * @return the signers of this class
 665:    * @since 1.1
 666:    */
 667:   public native Object[] getSigners ();
 668:   
 669:   /**
 670:    * Set the signers of this class.
 671:    *
 672:    * @param signers the signers of this class
 673:    */
 674:   native void setSigners(Object[] signers);
 675: 
 676:   /**
 677:    * Get the direct superclass of this class.  If this is an interface,
 678:    * Object, a primitive type, or void, it will return null. If this is an
 679:    * array type, it will return Object.
 680:    *
 681:    * @return the direct superclass of this class
 682:    */
 683:   public native Class getSuperclass ();
 684:   
 685:   /**
 686:    * Return whether this class is an array type.
 687:    *
 688:    * @return whether this class is an array type
 689:    * @since 1.1
 690:    */
 691:   public native boolean isArray ();
 692:   
 693:   /**
 694:    * Discover whether an instance of the Class parameter would be an
 695:    * instance of this Class as well.  Think of doing
 696:    * <code>isInstance(c.newInstance())</code> or even
 697:    * <code>c.newInstance() instanceof (this class)</code>. While this
 698:    * checks widening conversions for objects, it must be exact for primitive
 699:    * types.
 700:    *
 701:    * @param c the class to check
 702:    * @return whether an instance of c would be an instance of this class
 703:    *         as well
 704:    * @throws NullPointerException if c is null
 705:    * @since 1.1
 706:    */
 707:   public native boolean isAssignableFrom (Class c);
 708:  
 709:   /**
 710:    * Discover whether an Object is an instance of this Class.  Think of it
 711:    * as almost like <code>o instanceof (this class)</code>.
 712:    *
 713:    * @param o the Object to check
 714:    * @return whether o is an instance of this class
 715:    * @since 1.1
 716:    */
 717:   public native boolean isInstance (Object o);
 718:   
 719:   /**
 720:    * Check whether this class is an interface or not.  Array types are not
 721:    * interfaces.
 722:    *
 723:    * @return whether this class is an interface or not
 724:    */
 725:   public native boolean isInterface ();
 726:   
 727:   /**
 728:    * Return whether this class is a primitive type.  A primitive type class
 729:    * is a class representing a kind of "placeholder" for the various
 730:    * primitive types, or void.  You can access the various primitive type
 731:    * classes through java.lang.Boolean.TYPE, java.lang.Integer.TYPE, etc.,
 732:    * or through boolean.class, int.class, etc.
 733:    *
 734:    * @return whether this class is a primitive type
 735:    * @see Boolean#TYPE
 736:    * @see Byte#TYPE
 737:    * @see Character#TYPE
 738:    * @see Short#TYPE
 739:    * @see Integer#TYPE
 740:    * @see Long#TYPE
 741:    * @see Float#TYPE
 742:    * @see Double#TYPE
 743:    * @see Void#TYPE
 744:    * @since 1.1
 745:    */
 746:   public native boolean isPrimitive ();
 747:   
 748:   /**
 749:    * Get a new instance of this class by calling the no-argument constructor.
 750:    * The class is initialized if it has not been already. A security check
 751:    * may be performed, with <code>checkMemberAccess(this, Member.PUBLIC)</code>
 752:    * as well as <code>checkPackageAccess</code> both having to succeed.
 753:    *
 754:    * @return a new instance of this class
 755:    * @throws InstantiationException if there is not a no-arg constructor
 756:    *         for this class, including interfaces, abstract classes, arrays,
 757:    *         primitive types, and void; or if an exception occurred during
 758:    *         the constructor
 759:    * @throws IllegalAccessException if you are not allowed to access the
 760:    *         no-arg constructor because of scoping reasons
 761:    * @throws SecurityException if the security check fails
 762:    * @throws ExceptionInInitializerError if class initialization caused by
 763:    *         this call fails with an exception
 764:    */
 765:   public native Object newInstance ()
 766:     throws InstantiationException, IllegalAccessException;
 767: 
 768:   // We need a native method to retrieve the protection domain, because we
 769:   // can't add fields to java.lang.Class that are accessible from Java.
 770:   private native ProtectionDomain getProtectionDomain0();
 771: 
 772:   /**
 773:    * Returns the protection domain of this class. If the classloader did not
 774:    * record the protection domain when creating this class the unknown
 775:    * protection domain is returned which has a <code>null</code> code source
 776:    * and all permissions. A security check may be performed, with
 777:    * <code>RuntimePermission("getProtectionDomain")</code>.
 778:    *
 779:    * @return the protection domain
 780:    * @throws SecurityException if the security manager exists and the caller
 781:    * does not have <code>RuntimePermission("getProtectionDomain")</code>.
 782:    * @see RuntimePermission
 783:    * @since 1.2
 784:    */
 785:   public ProtectionDomain getProtectionDomain()
 786:   {
 787:     SecurityManager sm = System.getSecurityManager();
 788:     if (sm != null)
 789:       sm.checkPermission(VMClassLoader.protectionDomainPermission);
 790:     
 791:     ProtectionDomain protectionDomain = getProtectionDomain0();
 792: 
 793:     if (protectionDomain == null)
 794:       return VMClassLoader.unknownProtectionDomain;
 795:     else
 796:       return protectionDomain;
 797:   }
 798: 
 799:   /**
 800:    * Return the human-readable form of this Object.  For an object, this
 801:    * is either "interface " or "class " followed by <code>getName()</code>,
 802:    * for primitive types and void it is just <code>getName()</code>.
 803:    *
 804:    * @return the human-readable form of this Object
 805:    */
 806:   public String toString()
 807:   {
 808:     if (isPrimitive())
 809:       return getName();
 810:     return (isInterface() ? "interface " : "class ") + getName();
 811:   }
 812: 
 813:   /**
 814:    * Returns the desired assertion status of this class, if it were to be
 815:    * initialized at this moment. The class assertion status, if set, is
 816:    * returned; the backup is the default package status; then if there is
 817:    * a class loader, that default is returned; and finally the system default
 818:    * is returned. This method seldom needs calling in user code, but exists
 819:    * for compilers to implement the assert statement. Note that there is no
 820:    * guarantee that the result of this method matches the class's actual
 821:    * assertion status.
 822:    *
 823:    * @return the desired assertion status
 824:    * @see ClassLoader#setClassAssertionStatus(String, boolean)
 825:    * @see ClassLoader#setPackageAssertionStatus(String, boolean)
 826:    * @see ClassLoader#setDefaultAssertionStatus(boolean)
 827:    * @since 1.4
 828:    */
 829:   public boolean desiredAssertionStatus()
 830:   {
 831:     ClassLoader c = getClassLoader();
 832:     Object status;
 833:     if (c == null)
 834:       return VMClassLoader.defaultAssertionStatus();
 835:     if (c.classAssertionStatus != null)
 836:       synchronized (c)
 837:         {
 838:           status = c.classAssertionStatus.get(getName());
 839:           if (status != null)
 840:             return status.equals(Boolean.TRUE);
 841:         }
 842:     else
 843:       {
 844:         status = ClassLoader.systemClassAssertionStatus.get(getName());
 845:         if (status != null)
 846:           return status.equals(Boolean.TRUE);
 847:       }
 848:     if (c.packageAssertionStatus != null)
 849:       synchronized (c)
 850:         {
 851:           String name = getPackagePortion(getName());
 852:           if ("".equals(name))
 853:             status = c.packageAssertionStatus.get(null);
 854:           else
 855:             do
 856:               {
 857:                 status = c.packageAssertionStatus.get(name);
 858:                 name = getPackagePortion(name);
 859:               }
 860:             while (! "".equals(name) && status == null);
 861:           if (status != null)
 862:             return status.equals(Boolean.TRUE);
 863:         }
 864:     else
 865:       {
 866:         String name = getPackagePortion(getName());
 867:         if ("".equals(name))
 868:           status = ClassLoader.systemPackageAssertionStatus.get(null);
 869:         else
 870:           do
 871:             {
 872:               status = ClassLoader.systemPackageAssertionStatus.get(name);
 873:               name = getPackagePortion(name);
 874:             }
 875:           while (! "".equals(name) && status == null);
 876:         if (status != null)
 877:           return status.equals(Boolean.TRUE);
 878:       }
 879:     return c.defaultAssertionStatus;
 880:   }
 881: 
 882:   /**
 883:    * Strip the last portion of the name (after the last dot).
 884:    *
 885:    * @param name the name to get package of
 886:    * @return the package name, or "" if no package
 887:    */
 888:   private static String getPackagePortion(String name)
 889:   {
 890:     int lastInd = name.lastIndexOf('.');
 891:     if (lastInd == -1)
 892:       return "";
 893:     return name.substring(0, lastInd);
 894:   }
 895: 
 896:   /**
 897:    * Perform security checks common to all of the methods that
 898:    * get members of this Class.
 899:    */
 900:   private void memberAccessCheck(int which)
 901:   {
 902:     SecurityManager sm = System.getSecurityManager();
 903:     if (sm != null)
 904:       {
 905:     sm.checkMemberAccess(this, which);
 906:     Package pkg = getPackage();
 907:     if (pkg != null)
 908:       sm.checkPackageAccess(pkg.getName());
 909:       }
 910:   }
 911: }