Frames | No Frames |
1: /* Class.java -- Representation of a Java class. 2: Copyright (C) 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007 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.java.lang.reflect.ClassSignatureParser; 42: import java.io.InputStream; 43: import java.io.Serializable; 44: import java.lang.annotation.Annotation; 45: import java.lang.reflect.Constructor; 46: import java.lang.reflect.Field; 47: import java.lang.reflect.GenericDeclaration; 48: import java.lang.reflect.InvocationTargetException; 49: import java.lang.reflect.Member; 50: import java.lang.reflect.Method; 51: import java.lang.reflect.Type; 52: import java.lang.reflect.TypeVariable; 53: import java.net.URL; 54: import java.security.AccessController; 55: import java.security.PrivilegedAction; 56: import java.security.ProtectionDomain; 57: import java.util.ArrayList; 58: import java.util.Arrays; 59: import java.util.LinkedHashSet; 60: import java.util.HashMap; 61: import java.util.Collection; 62: import java.lang.reflect.AnnotatedElement; 63: import java.lang.annotation.Annotation; 64: import java.lang.annotation.Inherited; 65: import java.lang.reflect.AccessibleObject; 66: 67: /** 68: * A Class represents a Java type. There will never be multiple Class 69: * objects with identical names and ClassLoaders. Primitive types, array 70: * types, and void also have a Class object. 71: * 72: * <p>Arrays with identical type and number of dimensions share the same class. 73: * The array class ClassLoader is the same as the ClassLoader of the element 74: * type of the array (which can be null to indicate the bootstrap classloader). 75: * The name of an array class is <code>[<signature format>;</code>. 76: * <p> For example, 77: * String[]'s class is <code>[Ljava.lang.String;</code>. boolean, byte, 78: * short, char, int, long, float and double have the "type name" of 79: * Z,B,S,C,I,J,F,D for the purposes of array classes. If it's a 80: * multidimensioned array, the same principle applies: 81: * <code>int[][][]</code> == <code>[[[I</code>. 82: * 83: * <p>There is no public constructor - Class objects are obtained only through 84: * the virtual machine, as defined in ClassLoaders. 85: * 86: * @serialData Class objects serialize specially: 87: * <code>TC_CLASS ClassDescriptor</code>. For more serialization information, 88: * see {@link ObjectStreamClass}. 89: * 90: * @author John Keiser 91: * @author Eric Blake (ebb9@email.byu.edu) 92: * @author Tom Tromey (tromey@cygnus.com) 93: * @since 1.0 94: * @see ClassLoader 95: */ 96: public final class Class<T> 97: implements Type, AnnotatedElement, GenericDeclaration, Serializable 98: { 99: /** 100: * Class is non-instantiable from Java code; only the VM can create 101: * instances of this class. 102: */ 103: private Class () 104: { 105: } 106: 107: // Initialize the class. 108: private native void initializeClass (); 109: 110: // finalization 111: protected native void finalize () throws Throwable; 112: 113: /** 114: * Use the classloader of the current class to load, link, and initialize 115: * a class. This is equivalent to your code calling 116: * <code>Class.forName(name, true, getClass().getClassLoader())</code>. 117: * 118: * @param name the name of the class to find 119: * @return the Class object representing the class 120: * @throws ClassNotFoundException if the class was not found by the 121: * classloader 122: * @throws LinkageError if linking the class fails 123: * @throws ExceptionInInitializerError if the class loads, but an exception 124: * occurs during initialization 125: */ 126: public static native Class<?> forName (String className) 127: throws ClassNotFoundException; 128: 129: // A private internal method that is called by compiler-generated code. 130: private static Class forName (String className, Class caller) 131: throws ClassNotFoundException 132: { 133: return forName(className, true, caller.getClassLoaderInternal()); 134: } 135: 136: 137: /** 138: * Use the specified classloader to load and link a class. If the loader 139: * is null, this uses the bootstrap class loader (provide the security 140: * check succeeds). Unfortunately, this method cannot be used to obtain 141: * the Class objects for primitive types or for void, you have to use 142: * the fields in the appropriate java.lang wrapper classes. 143: * 144: * <p>Calls <code>classloader.loadclass(name, initialize)</code>. 145: * 146: * @param name the name of the class to find 147: * @param initialize whether or not to initialize the class at this time 148: * @param classloader the classloader to use to find the class; null means 149: * to use the bootstrap class loader 150: * @throws ClassNotFoundException if the class was not found by the 151: * classloader 152: * @throws LinkageError if linking the class fails 153: * @throws ExceptionInInitializerError if the class loads, but an exception 154: * occurs during initialization 155: * @throws SecurityException if the <code>classloader</code> argument 156: * is <code>null</code> and the caller does not have the 157: * <code>RuntimePermission("getClassLoader")</code> permission 158: * @see ClassLoader 159: * @since 1.2 160: */ 161: public static native Class<?> forName (String className, boolean initialize, 162: ClassLoader loader) 163: throws ClassNotFoundException; 164: 165: /** 166: * Get all the public member classes and interfaces declared in this 167: * class or inherited from superclasses. This returns an array of length 168: * 0 if there are no member classes, including for primitive types. A 169: * security check may be performed, with 170: * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as 171: * <code>checkPackageAccess</code> both having to succeed. 172: * 173: * @return all public member classes in this class 174: * @throws SecurityException if the security check fails 175: * @since 1.1 176: */ 177: public Class<?>[] getClasses() 178: { 179: memberAccessCheck(Member.PUBLIC); 180: return internalGetClasses(); 181: } 182: 183: /** 184: * Like <code>getClasses()</code> but without the security checks. 185: */ 186: private Class<?>[] internalGetClasses() 187: { 188: ArrayList<Class> list = new ArrayList<Class>(); 189: list.addAll(Arrays.asList(getDeclaredClasses(true))); 190: Class superClass = getSuperclass(); 191: if (superClass != null) 192: list.addAll(Arrays.asList(superClass.internalGetClasses())); 193: return list.toArray(new Class<?>[list.size()]); 194: } 195: 196: /** 197: * Get the ClassLoader that loaded this class. If the class was loaded 198: * by the bootstrap classloader, this method will return null. 199: * If there is a security manager, and the caller's class loader is not 200: * an ancestor of the requested one, a security check of 201: * <code>RuntimePermission("getClassLoader")</code> 202: * must first succeed. Primitive types and void return null. 203: * 204: * @return the ClassLoader that loaded this class 205: * @throws SecurityException if the security check fails 206: * @see ClassLoader 207: * @see RuntimePermission 208: */ 209: public native ClassLoader getClassLoader (); 210: 211: // A private internal method that is called by compiler-generated code. 212: private final native ClassLoader getClassLoader (Class caller); 213: 214: /** 215: * Internal method that circumvents the usual security checks when 216: * getting the class loader. 217: */ 218: private native ClassLoader getClassLoaderInternal (); 219: 220: /** 221: * If this is an array, get the Class representing the type of array. 222: * Examples: "[[Ljava.lang.String;" would return "[Ljava.lang.String;", and 223: * calling getComponentType on that would give "java.lang.String". If 224: * this is not an array, returns null. 225: * 226: * @return the array type of this class, or null 227: * @see Array 228: * @since 1.1 229: */ 230: public native Class<?> getComponentType (); 231: 232: /** 233: * Get a public constructor declared in this class. If the constructor takes 234: * no argument, an array of zero elements and null are equivalent for the 235: * types argument. A security check may be performed, with 236: * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as 237: * <code>checkPackageAccess</code> both having to succeed. 238: * 239: * @param types the type of each parameter 240: * @return the constructor 241: * @throws NoSuchMethodException if the constructor does not exist 242: * @throws SecurityException if the security check fails 243: * @see #getConstructors() 244: * @since 1.1 245: */ 246: public native Constructor<T> getConstructor(Class<?>... args) 247: throws NoSuchMethodException; 248: 249: /** 250: * Get all the public constructors of this class. This returns an array of 251: * length 0 if there are no constructors, including for primitive types, 252: * arrays, and interfaces. It does, however, include the default 253: * constructor if one was supplied by the compiler. A security check may 254: * be performed, with <code>checkMemberAccess(this, Member.PUBLIC)</code> 255: * as well as <code>checkPackageAccess</code> both having to succeed. 256: * 257: * @return all public constructors in this class 258: * @throws SecurityException if the security check fails 259: * @since 1.1 260: */ 261: public Constructor<?>[] getConstructors() 262: { 263: memberAccessCheck(Member.PUBLIC); 264: return getDeclaredConstructors(true); 265: } 266: 267: /** 268: * Get a constructor declared in this class. If the constructor takes no 269: * argument, an array of zero elements and null are equivalent for the 270: * types argument. A security check may be performed, with 271: * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as 272: * <code>checkPackageAccess</code> both having to succeed. 273: * 274: * @param types the type of each parameter 275: * @return the constructor 276: * @throws NoSuchMethodException if the constructor does not exist 277: * @throws SecurityException if the security check fails 278: * @see #getDeclaredConstructors() 279: * @since 1.1 280: */ 281: public native Constructor<T> getDeclaredConstructor(Class<?>... args) 282: throws NoSuchMethodException; 283: 284: /** 285: * Get all the declared member classes and interfaces in this class, but 286: * not those inherited from superclasses. This returns an array of length 287: * 0 if there are no member classes, including for primitive types. A 288: * security check may be performed, with 289: * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as 290: * <code>checkPackageAccess</code> both having to succeed. 291: * 292: * @return all declared member classes in this class 293: * @throws SecurityException if the security check fails 294: * @since 1.1 295: */ 296: public Class<?>[] getDeclaredClasses() 297: { 298: memberAccessCheck(Member.DECLARED); 299: return getDeclaredClasses(false); 300: } 301: 302: native Class<?>[] getDeclaredClasses (boolean publicOnly); 303: 304: /** 305: * Get all the declared constructors of this class. This returns an array of 306: * length 0 if there are no constructors, including for primitive types, 307: * arrays, and interfaces. It does, however, include the default 308: * constructor if one was supplied by the compiler. A security check may 309: * be performed, with <code>checkMemberAccess(this, Member.DECLARED)</code> 310: * as well as <code>checkPackageAccess</code> both having to succeed. 311: * 312: * @return all constructors in this class 313: * @throws SecurityException if the security check fails 314: * @since 1.1 315: */ 316: public Constructor<?>[] getDeclaredConstructors() 317: { 318: memberAccessCheck(Member.DECLARED); 319: return getDeclaredConstructors(false); 320: } 321: 322: native Constructor<?>[] getDeclaredConstructors (boolean publicOnly); 323: 324: /** 325: * Get a field declared in this class, where name is its simple name. The 326: * implicit length field of arrays is not available. A security check may 327: * be performed, with <code>checkMemberAccess(this, Member.DECLARED)</code> 328: * as well as <code>checkPackageAccess</code> both having to succeed. 329: * 330: * @param name the name of the field 331: * @return the field 332: * @throws NoSuchFieldException if the field does not exist 333: * @throws SecurityException if the security check fails 334: * @see #getDeclaredFields() 335: * @since 1.1 336: */ 337: public native Field getDeclaredField(String fieldName) 338: throws NoSuchFieldException; 339: 340: /** 341: * Get all the declared fields in this class, but not those inherited from 342: * superclasses. This returns an array of length 0 if there are no fields, 343: * including for primitive types. This does not return the implicit length 344: * field of arrays. A security check may be performed, with 345: * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as 346: * <code>checkPackageAccess</code> both having to succeed. 347: * 348: * @return all declared fields in this class 349: * @throws SecurityException if the security check fails 350: * @since 1.1 351: */ 352: public Field[] getDeclaredFields() 353: { 354: memberAccessCheck(Member.DECLARED); 355: return getDeclaredFields(false); 356: } 357: 358: native Field[] getDeclaredFields (boolean publicOnly); 359: 360: private native Method _getDeclaredMethod(String methodName, Class[] args); 361: 362: /** 363: * Get a method declared in this class, where name is its simple name. The 364: * implicit methods of Object are not available from arrays or interfaces. 365: * Constructors (named "<init>" in the class file) and class initializers 366: * (name "<clinit>") are not available. The Virtual Machine allows 367: * multiple methods with the same signature but differing return types; in 368: * such a case the most specific return types are favored, then the final 369: * choice is arbitrary. If the method takes no argument, an array of zero 370: * elements and null are equivalent for the types argument. A security 371: * check may be performed, with 372: * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as 373: * <code>checkPackageAccess</code> both having to succeed. 374: * 375: * @param methodName the name of the method 376: * @param types the type of each parameter 377: * @return the method 378: * @throws NoSuchMethodException if the method does not exist 379: * @throws SecurityException if the security check fails 380: * @see #getDeclaredMethods() 381: * @since 1.1 382: */ 383: public Method getDeclaredMethod(String methodName, Class<?>... args) 384: throws NoSuchMethodException 385: { 386: memberAccessCheck(Member.DECLARED); 387: 388: if ("<init>".equals(methodName) || "<clinit>".equals(methodName)) 389: throw new NoSuchMethodException(methodName); 390: 391: Method match = _getDeclaredMethod(methodName, args); 392: if (match == null) 393: throw new NoSuchMethodException(methodName); 394: return match; 395: } 396: 397: /** 398: * Get all the declared methods in this class, but not those inherited from 399: * superclasses. This returns an array of length 0 if there are no methods, 400: * including for primitive types. This does include the implicit methods of 401: * arrays and interfaces which mirror methods of Object, nor does it 402: * include constructors or the class initialization methods. The Virtual 403: * Machine allows multiple methods with the same signature but differing 404: * return types; all such methods are in the returned array. A security 405: * check may be performed, with 406: * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as 407: * <code>checkPackageAccess</code> both having to succeed. 408: * 409: * @return all declared methods in this class 410: * @throws SecurityException if the security check fails 411: * @since 1.1 412: */ 413: public native Method[] getDeclaredMethods(); 414: 415: /** 416: * If this is a nested or inner class, return the class that declared it. 417: * If not, return null. 418: * 419: * @return the declaring class of this class 420: * @since 1.1 421: */ 422: // This is marked as unimplemented in the JCL book. 423: public native Class<?> getDeclaringClass (); 424: 425: private native Field getField (String fieldName, int hash) 426: throws NoSuchFieldException; 427: 428: /** 429: * Get a public field declared or inherited in this class, where name is 430: * its simple name. If the class contains multiple accessible fields by 431: * that name, an arbitrary one is returned. The implicit length field of 432: * arrays is not available. A security check may be performed, with 433: * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as 434: * <code>checkPackageAccess</code> both having to succeed. 435: * 436: * @param fieldName the name of the field 437: * @return the field 438: * @throws NoSuchFieldException if the field does not exist 439: * @throws SecurityException if the security check fails 440: * @see #getFields() 441: * @since 1.1 442: */ 443: public Field getField(String fieldName) 444: throws NoSuchFieldException 445: { 446: memberAccessCheck(Member.PUBLIC); 447: Field field = getField(fieldName, fieldName.hashCode()); 448: if (field == null) 449: throw new NoSuchFieldException(fieldName); 450: return field; 451: } 452: 453: /** 454: * Get all the public fields declared in this class or inherited from 455: * superclasses. This returns an array of length 0 if there are no fields, 456: * including for primitive types. This does not return the implicit length 457: * field of arrays. A security check may be performed, with 458: * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as 459: * <code>checkPackageAccess</code> both having to succeed. 460: * 461: * @return all public fields in this class 462: * @throws SecurityException if the security check fails 463: * @since 1.1 464: */ 465: public Field[] getFields() 466: { 467: memberAccessCheck(Member.PUBLIC); 468: return internalGetFields(); 469: } 470: 471: /** 472: * Like <code>getFields()</code> but without the security checks. 473: */ 474: private Field[] internalGetFields() 475: { 476: LinkedHashSet set = new LinkedHashSet(); 477: set.addAll(Arrays.asList(getDeclaredFields(true))); 478: Class[] interfaces = getInterfaces(); 479: for (int i = 0; i < interfaces.length; i++) 480: set.addAll(Arrays.asList(interfaces[i].internalGetFields())); 481: Class superClass = getSuperclass(); 482: if (superClass != null) 483: set.addAll(Arrays.asList(superClass.internalGetFields())); 484: return (Field[])set.toArray(new Field[set.size()]); 485: } 486: 487: /** 488: * Returns the <code>Package</code> in which this class is defined 489: * Returns null when this information is not available from the 490: * classloader of this class. 491: * 492: * @return the package for this class, if it is available 493: * @since 1.2 494: */ 495: public Package getPackage() 496: { 497: ClassLoader cl = getClassLoaderInternal(); 498: if (cl != null) 499: return cl.getPackage(getPackagePortion(getName())); 500: else 501: return VMClassLoader.getPackage(getPackagePortion(getName())); 502: } 503: 504: /** 505: * Get the interfaces this class <em>directly</em> implements, in the 506: * order that they were declared. This returns an empty array, not null, 507: * for Object, primitives, void, and classes or interfaces with no direct 508: * superinterface. Array types return Cloneable and Serializable. 509: * 510: * @return the interfaces this class directly implements 511: */ 512: public native Class<?>[] getInterfaces (); 513: 514: private final native void getSignature(StringBuffer buffer); 515: private static final native String getSignature(Class[] args, 516: boolean is_construtor); 517: 518: public native Method _getMethod(String methodName, Class[] args); 519: 520: /** 521: * Get a public method declared or inherited in this class, where name is 522: * its simple name. The implicit methods of Object are not available from 523: * interfaces. Constructors (named "<init>" in the class file) and class 524: * initializers (name "<clinit>") are not available. The Virtual 525: * Machine allows multiple methods with the same signature but differing 526: * return types, and the class can inherit multiple methods of the same 527: * return type; in such a case the most specific return types are favored, 528: * then the final choice is arbitrary. If the method takes no argument, an 529: * array of zero elements and null are equivalent for the types argument. 530: * A security check may be performed, with 531: * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as 532: * <code>checkPackageAccess</code> both having to succeed. 533: * 534: * @param methodName the name of the method 535: * @param types the type of each parameter 536: * @return the method 537: * @throws NoSuchMethodException if the method does not exist 538: * @throws SecurityException if the security check fails 539: * @see #getMethods() 540: * @since 1.1 541: */ 542: public Method getMethod(String methodName, Class<?>... args) 543: throws NoSuchMethodException 544: { 545: memberAccessCheck(Member.PUBLIC); 546: 547: if ("<init>".equals(methodName) || "<clinit>".equals(methodName)) 548: throw new NoSuchMethodException(methodName); 549: 550: Method method = _getMethod(methodName, args); 551: if (method == null) 552: throw new NoSuchMethodException(methodName); 553: return method; 554: } 555: 556: private native int _getMethods (Method[] result, int offset); 557: 558: /** 559: * Get all the public methods declared in this class or inherited from 560: * superclasses. This returns an array of length 0 if there are no methods, 561: * including for primitive types. This does not include the implicit 562: * methods of interfaces which mirror methods of Object, nor does it 563: * include constructors or the class initialization methods. The Virtual 564: * Machine allows multiple methods with the same signature but differing 565: * return types; all such methods are in the returned array. A security 566: * check may be performed, with 567: * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as 568: * <code>checkPackageAccess</code> both having to succeed. 569: * 570: * @return all public methods in this class 571: * @throws SecurityException if the security check fails 572: * @since 1.1 573: */ 574: public native Method[] getMethods(); 575: 576: /** 577: * Get the modifiers of this class. These can be decoded using Modifier, 578: * and is limited to one of public, protected, or private, and any of 579: * final, static, abstract, or interface. An array class has the same 580: * public, protected, or private modifier as its component type, and is 581: * marked final but not an interface. Primitive types and void are marked 582: * public and final, but not an interface. 583: * 584: * @return the modifiers of this class 585: * @see Modifer 586: * @since 1.1 587: */ 588: public native int getModifiers (); 589: 590: /** 591: * Get the name of this class, separated by dots for package separators. 592: * If the class represents a primitive type, or void, then the 593: * name of the type as it appears in the Java programming language 594: * is returned. For instance, <code>Byte.TYPE.getName()</code> 595: * returns "byte". 596: * 597: * Arrays are specially encoded as shown on this table. 598: * <pre> 599: * array type [<em>element type</em> 600: * (note that the element type is encoded per 601: * this table) 602: * boolean Z 603: * byte B 604: * char C 605: * short S 606: * int I 607: * long J 608: * float F 609: * double D 610: * void V 611: * class or interface, alone: <dotted name> 612: * class or interface, as element type: L<dotted name>; 613: * </pre> 614: * 615: * @return the name of this class 616: */ 617: public native String getName (); 618: 619: /** 620: * Get a resource URL using this class's package using the 621: * getClassLoader().getResource() method. If this class was loaded using 622: * the system classloader, ClassLoader.getSystemResource() is used instead. 623: * 624: * <p>If the name you supply is absolute (it starts with a <code>/</code>), 625: * then the leading <code>/</code> is removed and it is passed on to 626: * getResource(). If it is relative, the package name is prepended, and 627: * <code>.</code>'s are replaced with <code>/</code>. 628: * 629: * <p>The URL returned is system- and classloader-dependent, and could 630: * change across implementations. 631: * 632: * @param resourceName the name of the resource, generally a path 633: * @return the URL to the resource 634: * @throws NullPointerException if name is null 635: * @since 1.1 636: */ 637: public URL getResource(String resourceName) 638: { 639: String name = resourcePath(resourceName); 640: ClassLoader loader = getClassLoaderInternal(); 641: if (loader == null) 642: return ClassLoader.getSystemResource(name); 643: return loader.getResource(name); 644: } 645: 646: /** 647: * Get a resource using this class's package using the 648: * getClassLoader().getResourceAsStream() method. If this class was loaded 649: * using the system classloader, ClassLoader.getSystemResource() is used 650: * instead. 651: * 652: * <p>If the name you supply is absolute (it starts with a <code>/</code>), 653: * then the leading <code>/</code> is removed and it is passed on to 654: * getResource(). If it is relative, the package name is prepended, and 655: * <code>.</code>'s are replaced with <code>/</code>. 656: * 657: * <p>The URL returned is system- and classloader-dependent, and could 658: * change across implementations. 659: * 660: * @param resourceName the name of the resource, generally a path 661: * @return an InputStream with the contents of the resource in it, or null 662: * @throws NullPointerException if name is null 663: * @since 1.1 664: */ 665: public InputStream getResourceAsStream(String resourceName) 666: { 667: String name = resourcePath(resourceName); 668: ClassLoader loader = getClassLoaderInternal(); 669: if (loader == null) 670: return ClassLoader.getSystemResourceAsStream(name); 671: return loader.getResourceAsStream(name); 672: } 673: 674: private String resourcePath(String resourceName) 675: { 676: if (resourceName.length() > 0) 677: { 678: if (resourceName.charAt(0) != '/') 679: { 680: String pkg = getPackagePortion(getName()); 681: if (pkg.length() > 0) 682: resourceName = pkg.replace('.','/') + '/' + resourceName; 683: } 684: else 685: { 686: resourceName = resourceName.substring(1); 687: } 688: } 689: return resourceName; 690: } 691: 692: /** 693: * Get the signers of this class. This returns null if there are no signers, 694: * such as for primitive types or void. 695: * 696: * @return the signers of this class 697: * @since 1.1 698: */ 699: public native Object[] getSigners (); 700: 701: /** 702: * Set the signers of this class. 703: * 704: * @param signers the signers of this class 705: */ 706: native void setSigners(Object[] signers); 707: 708: /** 709: * Get the direct superclass of this class. If this is an interface, 710: * Object, a primitive type, or void, it will return null. If this is an 711: * array type, it will return Object. 712: * 713: * @return the direct superclass of this class 714: */ 715: public native Class<? super T> getSuperclass (); 716: 717: /** 718: * Return whether this class is an array type. 719: * 720: * @return whether this class is an array type 721: * @since 1.1 722: */ 723: public native boolean isArray (); 724: 725: /** 726: * Discover whether an instance of the Class parameter would be an 727: * instance of this Class as well. Think of doing 728: * <code>isInstance(c.newInstance())</code> or even 729: * <code>c.newInstance() instanceof (this class)</code>. While this 730: * checks widening conversions for objects, it must be exact for primitive 731: * types. 732: * 733: * @param c the class to check 734: * @return whether an instance of c would be an instance of this class 735: * as well 736: * @throws NullPointerException if c is null 737: * @since 1.1 738: */ 739: public native boolean isAssignableFrom (Class<?> c); 740: 741: /** 742: * Discover whether an Object is an instance of this Class. Think of it 743: * as almost like <code>o instanceof (this class)</code>. 744: * 745: * @param o the Object to check 746: * @return whether o is an instance of this class 747: * @since 1.1 748: */ 749: public native boolean isInstance (Object o); 750: 751: /** 752: * Check whether this class is an interface or not. Array types are not 753: * interfaces. 754: * 755: * @return whether this class is an interface or not 756: */ 757: public native boolean isInterface (); 758: 759: /** 760: * Return whether this class is a primitive type. A primitive type class 761: * is a class representing a kind of "placeholder" for the various 762: * primitive types, or void. You can access the various primitive type 763: * classes through java.lang.Boolean.TYPE, java.lang.Integer.TYPE, etc., 764: * or through boolean.class, int.class, etc. 765: * 766: * @return whether this class is a primitive type 767: * @see Boolean#TYPE 768: * @see Byte#TYPE 769: * @see Character#TYPE 770: * @see Short#TYPE 771: * @see Integer#TYPE 772: * @see Long#TYPE 773: * @see Float#TYPE 774: * @see Double#TYPE 775: * @see Void#TYPE 776: * @since 1.1 777: */ 778: public native boolean isPrimitive (); 779: 780: /** 781: * Get a new instance of this class by calling the no-argument constructor. 782: * The class is initialized if it has not been already. A security check 783: * may be performed, with <code>checkMemberAccess(this, Member.PUBLIC)</code> 784: * as well as <code>checkPackageAccess</code> both having to succeed. 785: * 786: * @return a new instance of this class 787: * @throws InstantiationException if there is not a no-arg constructor 788: * for this class, including interfaces, abstract classes, arrays, 789: * primitive types, and void; or if an exception occurred during 790: * the constructor 791: * @throws IllegalAccessException if you are not allowed to access the 792: * no-arg constructor because of scoping reasons 793: * @throws SecurityException if the security check fails 794: * @throws ExceptionInInitializerError if class initialization caused by 795: * this call fails with an exception 796: */ 797: public native T newInstance () 798: throws InstantiationException, IllegalAccessException; 799: 800: // We need a native method to retrieve the protection domain, because we 801: // can't add fields to java.lang.Class that are accessible from Java. 802: private native ProtectionDomain getProtectionDomain0(); 803: 804: /** 805: * Returns the protection domain of this class. If the classloader did not 806: * record the protection domain when creating this class the unknown 807: * protection domain is returned which has a <code>null</code> code source 808: * and all permissions. A security check may be performed, with 809: * <code>RuntimePermission("getProtectionDomain")</code>. 810: * 811: * @return the protection domain 812: * @throws SecurityException if the security manager exists and the caller 813: * does not have <code>RuntimePermission("getProtectionDomain")</code>. 814: * @see RuntimePermission 815: * @since 1.2 816: */ 817: public ProtectionDomain getProtectionDomain() 818: { 819: SecurityManager sm = System.getSecurityManager(); 820: if (sm != null) 821: sm.checkPermission(VMClassLoader.protectionDomainPermission); 822: 823: ProtectionDomain protectionDomain = getProtectionDomain0(); 824: 825: if (protectionDomain == null) 826: return VMClassLoader.unknownProtectionDomain; 827: else 828: return protectionDomain; 829: } 830: 831: /** 832: * Return the human-readable form of this Object. For an object, this 833: * is either "interface " or "class " followed by <code>getName()</code>, 834: * for primitive types and void it is just <code>getName()</code>. 835: * 836: * @return the human-readable form of this Object 837: */ 838: public String toString() 839: { 840: if (isPrimitive()) 841: return getName(); 842: return (isInterface() ? "interface " : "class ") + getName(); 843: } 844: 845: /** 846: * Returns the desired assertion status of this class, if it were to be 847: * initialized at this moment. The class assertion status, if set, is 848: * returned; the backup is the default package status; then if there is 849: * a class loader, that default is returned; and finally the system default 850: * is returned. This method seldom needs calling in user code, but exists 851: * for compilers to implement the assert statement. Note that there is no 852: * guarantee that the result of this method matches the class's actual 853: * assertion status. 854: * 855: * @return the desired assertion status 856: * @see ClassLoader#setClassAssertionStatus(String, boolean) 857: * @see ClassLoader#setPackageAssertionStatus(String, boolean) 858: * @see ClassLoader#setDefaultAssertionStatus(boolean) 859: * @since 1.4 860: */ 861: public boolean desiredAssertionStatus() 862: { 863: ClassLoader c = getClassLoaderInternal(); 864: Object status; 865: if (c == null) 866: return VMClassLoader.defaultAssertionStatus(); 867: if (c.classAssertionStatus != null) 868: synchronized (c) 869: { 870: status = c.classAssertionStatus.get(getName()); 871: if (status != null) 872: return status.equals(Boolean.TRUE); 873: } 874: else 875: { 876: status = ClassLoader.systemClassAssertionStatus.get(getName()); 877: if (status != null) 878: return status.equals(Boolean.TRUE); 879: } 880: if (c.packageAssertionStatus != null) 881: synchronized (c) 882: { 883: String name = getPackagePortion(getName()); 884: if ("".equals(name)) 885: status = c.packageAssertionStatus.get(null); 886: else 887: do 888: { 889: status = c.packageAssertionStatus.get(name); 890: name = getPackagePortion(name); 891: } 892: while (! "".equals(name) && status == null); 893: if (status != null) 894: return status.equals(Boolean.TRUE); 895: } 896: else 897: { 898: String name = getPackagePortion(getName()); 899: if ("".equals(name)) 900: status = ClassLoader.systemPackageAssertionStatus.get(null); 901: else 902: do 903: { 904: status = ClassLoader.systemPackageAssertionStatus.get(name); 905: name = getPackagePortion(name); 906: } 907: while (! "".equals(name) && status == null); 908: if (status != null) 909: return status.equals(Boolean.TRUE); 910: } 911: return c.defaultAssertionStatus; 912: } 913: 914: /** 915: * Strip the last portion of the name (after the last dot). 916: * 917: * @param name the name to get package of 918: * @return the package name, or "" if no package 919: */ 920: private static String getPackagePortion(String name) 921: { 922: int lastInd = name.lastIndexOf('.'); 923: if (lastInd == -1) 924: return ""; 925: return name.substring(0, lastInd); 926: } 927: 928: /** 929: * Perform security checks common to all of the methods that 930: * get members of this Class. 931: */ 932: private void memberAccessCheck(int which) 933: { 934: SecurityManager sm = System.getSecurityManager(); 935: if (sm != null) 936: { 937: sm.checkMemberAccess(this, which); 938: Package pkg = getPackage(); 939: if (pkg != null) 940: sm.checkPackageAccess(pkg.getName()); 941: } 942: } 943: 944: 945: /** 946: * <p> 947: * Casts this class to represent a subclass of the specified class. 948: * This method is useful for `narrowing' the type of a class so that 949: * the class object, and instances of that class, can match the contract 950: * of a more restrictive method. For example, if this class has the 951: * static type of <code>Class<Object></code>, and a dynamic type of 952: * <code>Class<Rectangle></code>, then, assuming <code>Shape</code> is 953: * a superclass of <code>Rectangle</code>, this method can be used on 954: * this class with the parameter, <code>Class<Shape></code>, to retain 955: * the same instance but with the type 956: * <code>Class<? extends Shape></code>. 957: * </p> 958: * <p> 959: * If this class can be converted to an instance which is parameterised 960: * over a subtype of the supplied type, <code>U</code>, then this method 961: * returns an appropriately cast reference to this object. Otherwise, 962: * a <code>ClassCastException</code> is thrown. 963: * </p> 964: * 965: * @param klass the class object, the parameterized type (<code>U</code>) of 966: * which should be a superclass of the parameterized type of 967: * this instance. 968: * @return a reference to this object, appropriately cast. 969: * @throws ClassCastException if this class can not be converted to one 970: * which represents a subclass of the specified 971: * type, <code>U</code>. 972: * @since 1.5 973: */ 974: public <U> Class<? extends U> asSubclass(Class<U> klass) 975: { 976: if (! klass.isAssignableFrom(this)) 977: throw new ClassCastException(); 978: return (Class<? extends U>) this; 979: } 980: 981: /** 982: * Returns the specified object, cast to this <code>Class</code>' type. 983: * 984: * @param obj the object to cast 985: * @throws ClassCastException if obj is not an instance of this class 986: * @since 1.5 987: */ 988: public T cast(Object obj) 989: { 990: if (obj != null && ! isInstance(obj)) 991: throw new ClassCastException(); 992: return (T) obj; 993: } 994: 995: /** 996: * Returns the enumeration constants of this class, or 997: * null if this class is not an <code>Enum</code>. 998: * 999: * @return an array of <code>Enum</code> constants 1000: * associated with this class, or null if this 1001: * class is not an <code>enum</code>. 1002: * @since 1.5 1003: */ 1004: public T[] getEnumConstants() 1005: { 1006: if (isEnum()) 1007: { 1008: try 1009: { 1010: Method m = getMethod("values"); 1011: setAccessible(m); 1012: return (T[]) m.invoke(null); 1013: } 1014: catch (NoSuchMethodException exception) 1015: { 1016: throw new Error("Enum lacks values() method"); 1017: } 1018: catch (IllegalAccessException exception) 1019: { 1020: throw new Error("Unable to access Enum class"); 1021: } 1022: catch (InvocationTargetException exception) 1023: { 1024: throw new 1025: RuntimeException("The values method threw an exception", 1026: exception); 1027: } 1028: } 1029: else 1030: { 1031: return null; 1032: } 1033: } 1034: 1035: /** 1036: * Returns true if this class is an <code>Enum</code>. 1037: * 1038: * @return true if this is an enumeration class. 1039: * @since 1.5 1040: */ 1041: public native boolean isEnum(); 1042: 1043: 1044: /** 1045: * Returns true if this class is a synthetic class, generated by 1046: * the compiler. 1047: * 1048: * @return true if this is a synthetic class. 1049: * @since 1.5 1050: */ 1051: public native boolean isSynthetic(); 1052: 1053: 1054: /** 1055: * Returns true if this class is an <code>Annotation</code>. 1056: * 1057: * @return true if this is an annotation class. 1058: * @since 1.5 1059: */ 1060: public native boolean isAnnotation(); 1061: 1062: 1063: /** 1064: * Returns the simple name for this class, as used in the source 1065: * code. For normal classes, this is the content returned by 1066: * <code>getName()</code> which follows the last ".". Anonymous 1067: * classes have no name, and so the result of calling this method is 1068: * "". The simple name of an array consists of the simple name of 1069: * its component type, followed by "[]". Thus, an array with the 1070: * component type of an anonymous class has a simple name of simply 1071: * "[]". 1072: * 1073: * @return the simple name for this class. 1074: * @since 1.5 1075: */ 1076: public String getSimpleName() 1077: { 1078: StringBuffer sb = new StringBuffer(); 1079: Class klass = this; 1080: int arrayCount = 0; 1081: while (klass.isArray()) 1082: { 1083: klass = klass.getComponentType(); 1084: ++arrayCount; 1085: } 1086: if (! klass.isAnonymousClass()) 1087: { 1088: String fullName = klass.getName(); 1089: sb.append(fullName, fullName.lastIndexOf(".") + 1, fullName.length()); 1090: } 1091: while (arrayCount-- > 0) 1092: sb.append("[]"); 1093: return sb.toString(); 1094: } 1095: 1096: /** 1097: * Returns the class which immediately encloses this class. If this class 1098: * is a top-level class, this method returns <code>null</code>. 1099: * 1100: * @return the immediate enclosing class, or <code>null</code> if this is 1101: * a top-level class. 1102: * @since 1.5 1103: */ 1104: public native Class<?> getEnclosingClass(); 1105: 1106: /** 1107: * Returns the constructor which immediately encloses this class. If 1108: * this class is a top-level class, or a local or anonymous class 1109: * immediately enclosed by a type definition, instance initializer 1110: * or static initializer, then <code>null</code> is returned. 1111: * 1112: * @return the immediate enclosing constructor if this class is 1113: * declared within a constructor. Otherwise, <code>null</code> 1114: * is returned. 1115: * @since 1.5 1116: */ 1117: public native Constructor<T> getEnclosingConstructor(); 1118: 1119: /** 1120: * Returns the method which immediately encloses this class. If 1121: * this class is a top-level class, or a local or anonymous class 1122: * immediately enclosed by a type definition, instance initializer 1123: * or static initializer, then <code>null</code> is returned. 1124: * 1125: * @return the immediate enclosing method if this class is 1126: * declared within a method. Otherwise, <code>null</code> 1127: * is returned. 1128: * @since 1.5 1129: */ 1130: public native Method getEnclosingMethod(); 1131: 1132: private native String getClassSignature(); 1133: 1134: /** 1135: * <p> 1136: * Returns an array of <code>Type</code> objects which represent the 1137: * interfaces directly implemented by this class or extended by this 1138: * interface. 1139: * </p> 1140: * <p> 1141: * If one of the superinterfaces is a parameterized type, then the 1142: * object returned for this interface reflects the actual type 1143: * parameters used in the source code. Type parameters are created 1144: * using the semantics specified by the <code>ParameterizedType</code> 1145: * interface, and only if an instance has not already been created. 1146: * </p> 1147: * <p> 1148: * The order of the interfaces in the array matches the order in which 1149: * the interfaces are declared. For classes which represent an array, 1150: * an array of two interfaces, <code>Cloneable</code> and 1151: * <code>Serializable</code>, is always returned, with the objects in 1152: * that order. A class representing a primitive type or void always 1153: * returns an array of zero size. 1154: * </p> 1155: * 1156: * @return an array of interfaces implemented or extended by this class. 1157: * @throws GenericSignatureFormatError if the generic signature of one 1158: * of the interfaces does not comply with that specified by the Java 1159: * Virtual Machine specification, 3rd edition. 1160: * @throws TypeNotPresentException if any of the superinterfaces refers 1161: * to a non-existant type. 1162: * @throws MalformedParameterizedTypeException if any of the interfaces 1163: * refer to a parameterized type that can not be instantiated for 1164: * some reason. 1165: * @since 1.5 1166: * @see java.lang.reflect.ParameterizedType 1167: */ 1168: public Type[] getGenericInterfaces() 1169: { 1170: if (isPrimitive()) 1171: return new Type[0]; 1172: 1173: String sig = getClassSignature(); 1174: if (sig == null) 1175: return getInterfaces(); 1176: 1177: ClassSignatureParser p = new ClassSignatureParser(this, sig); 1178: return p.getInterfaceTypes(); 1179: } 1180: 1181: /** 1182: * <p> 1183: * Returns a <code>Type</code> object representing the direct superclass, 1184: * whether class, interface, primitive type or void, of this class. 1185: * If this class is an array class, then a class instance representing 1186: * the <code>Object</code> class is returned. If this class is primitive, 1187: * an interface, or a representation of either the <code>Object</code> 1188: * class or void, then <code>null</code> is returned. 1189: * </p> 1190: * <p> 1191: * If the superclass is a parameterized type, then the 1192: * object returned for this interface reflects the actual type 1193: * parameters used in the source code. Type parameters are created 1194: * using the semantics specified by the <code>ParameterizedType</code> 1195: * interface, and only if an instance has not already been created. 1196: * </p> 1197: * 1198: * @return the superclass of this class. 1199: * @throws GenericSignatureFormatError if the generic signature of the 1200: * class does not comply with that specified by the Java 1201: * Virtual Machine specification, 3rd edition. 1202: * @throws TypeNotPresentException if the superclass refers 1203: * to a non-existant type. 1204: * @throws MalformedParameterizedTypeException if the superclass 1205: * refers to a parameterized type that can not be instantiated for 1206: * some reason. 1207: * @since 1.5 1208: * @see java.lang.reflect.ParameterizedType 1209: */ 1210: public Type getGenericSuperclass() 1211: { 1212: if (isArray()) 1213: return Object.class; 1214: 1215: if (isPrimitive() || isInterface() || this == Object.class) 1216: return null; 1217: 1218: String sig = getClassSignature(); 1219: if (sig == null) 1220: return getSuperclass(); 1221: 1222: ClassSignatureParser p = new ClassSignatureParser(this, sig); 1223: return p.getSuperclassType(); 1224: } 1225: 1226: /** 1227: * Returns an array of <code>TypeVariable</code> objects that represents 1228: * the type variables declared by this class, in declaration order. 1229: * An array of size zero is returned if this class has no type 1230: * variables. 1231: * 1232: * @return the type variables associated with this class. 1233: * @throws GenericSignatureFormatError if the generic signature does 1234: * not conform to the format specified in the Virtual Machine 1235: * specification, version 3. 1236: * @since 1.5 1237: */ 1238: public TypeVariable<Class<T>>[] getTypeParameters() 1239: { 1240: String sig = getClassSignature(); 1241: if (sig == null) 1242: return (TypeVariable<Class<T>>[])new TypeVariable[0]; 1243: 1244: ClassSignatureParser p = new ClassSignatureParser(this, sig); 1245: return p.getTypeParameters(); 1246: } 1247: 1248: /** 1249: * Returns this class' annotation for the specified annotation type, 1250: * or <code>null</code> if no such annotation exists. 1251: * 1252: * @param annotationClass the type of annotation to look for. 1253: * @return this class' annotation for the specified type, or 1254: * <code>null</code> if no such annotation exists. 1255: * @since 1.5 1256: */ 1257: public <A extends Annotation> A getAnnotation(Class<A> annotationClass) 1258: { 1259: A foundAnnotation = null; 1260: Annotation[] annotations = getAnnotations(); 1261: for (Annotation annotation : annotations) 1262: if (annotation.annotationType() == annotationClass) 1263: foundAnnotation = (A) annotation; 1264: return foundAnnotation; 1265: } 1266: 1267: /** 1268: * Returns all annotations associated with this class. If there are 1269: * no annotations associated with this class, then a zero-length array 1270: * will be returned. The returned array may be modified by the client 1271: * code, but this will have no effect on the annotation content of this 1272: * class, and hence no effect on the return value of this method for 1273: * future callers. 1274: * 1275: * @return this class' annotations. 1276: * @since 1.5 1277: */ 1278: public Annotation[] getAnnotations() 1279: { 1280: HashMap<Class, Annotation> map = new HashMap<Class, Annotation>(); 1281: for (Annotation a : getDeclaredAnnotations()) 1282: map.put((Class) a.annotationType(), a); 1283: for (Class<? super T> s = getSuperclass(); 1284: s != null; 1285: s = s.getSuperclass()) 1286: { 1287: for (Annotation a : s.getDeclaredAnnotations()) 1288: { 1289: Class k = (Class) a.annotationType(); 1290: if (! map.containsKey(k) && k.isAnnotationPresent(Inherited.class)) 1291: map.put(k, a); 1292: } 1293: } 1294: Collection<Annotation> v = map.values(); 1295: return v.toArray(new Annotation[v.size()]); 1296: } 1297: 1298: /** 1299: * <p> 1300: * Returns the canonical name of this class, as defined by section 1301: * 6.7 of the Java language specification. Each package, top-level class, 1302: * top-level interface and primitive type has a canonical name. A member 1303: * class has a canonical name, if its parent class has one. Likewise, 1304: * an array type has a canonical name, if its component type does. 1305: * Local or anonymous classes do not have canonical names. 1306: * </p> 1307: * <p> 1308: * The canonical name for top-level classes, top-level interfaces and 1309: * primitive types is always the same as the fully-qualified name. 1310: * For array types, the canonical name is the canonical name of its 1311: * component type with `[]' appended. 1312: * </p> 1313: * <p> 1314: * The canonical name of a member class always refers to the place where 1315: * the class was defined, and is composed of the canonical name of the 1316: * defining class and the simple name of the member class, joined by `.'. 1317: * For example, if a <code>Person</code> class has an inner class, 1318: * <code>M</code>, then both its fully-qualified name and canonical name 1319: * is <code>Person.M</code>. A subclass, <code>Staff</code>, of 1320: * <code>Person</code> refers to the same inner class by the fully-qualified 1321: * name of <code>Staff.M</code>, but its canonical name is still 1322: * <code>Person.M</code>. 1323: * </p> 1324: * <p> 1325: * Where no canonical name is present, <code>null</code> is returned. 1326: * </p> 1327: * 1328: * @return the canonical name of the class, or <code>null</code> if the 1329: * class doesn't have a canonical name. 1330: * @since 1.5 1331: */ 1332: public String getCanonicalName() 1333: { 1334: if (isArray()) 1335: { 1336: String componentName = getComponentType().getCanonicalName(); 1337: if (componentName != null) 1338: return componentName + "[]"; 1339: } 1340: if (isMemberClass()) 1341: { 1342: String memberName = getDeclaringClass().getCanonicalName(); 1343: if (memberName != null) 1344: return memberName + "." + getSimpleName(); 1345: } 1346: if (isLocalClass() || isAnonymousClass()) 1347: return null; 1348: return getName(); 1349: } 1350: 1351: /** 1352: * Returns all annotations directly defined by this class. If there are 1353: * no annotations associated with this class, then a zero-length array 1354: * will be returned. The returned array may be modified by the client 1355: * code, but this will have no effect on the annotation content of this 1356: * class, and hence no effect on the return value of this method for 1357: * future callers. 1358: * 1359: * @return the annotations directly defined by this class. 1360: * @since 1.5 1361: */ 1362: public Annotation[] getDeclaredAnnotations() 1363: { 1364: Annotation[] result = getDeclaredAnnotationsInternal(); 1365: if (result == null) 1366: result = new Annotation[0]; 1367: return result; 1368: } 1369: 1370: private native Annotation[] getDeclaredAnnotationsInternal(); 1371: 1372: /** 1373: * Returns true if an annotation for the specified type is associated 1374: * with this class. This is primarily a short-hand for using marker 1375: * annotations. 1376: * 1377: * @param annotationClass the type of annotation to look for. 1378: * @return true if an annotation exists for the specified type. 1379: * @since 1.5 1380: */ 1381: public boolean isAnnotationPresent(Class<? extends Annotation> 1382: annotationClass) 1383: { 1384: return getAnnotation(annotationClass) != null; 1385: } 1386: 1387: /** 1388: * Returns true if this object represents an anonymous class. 1389: * 1390: * @return true if this object represents an anonymous class. 1391: * @since 1.5 1392: */ 1393: public native boolean isAnonymousClass(); 1394: 1395: /** 1396: * Returns true if this object represents an local class. 1397: * 1398: * @return true if this object represents an local class. 1399: * @since 1.5 1400: */ 1401: public native boolean isLocalClass(); 1402: 1403: /** 1404: * Returns true if this object represents an member class. 1405: * 1406: * @return true if this object represents an member class. 1407: * @since 1.5 1408: */ 1409: public native boolean isMemberClass(); 1410: 1411: /** 1412: * Utility method for use by classes in this package. 1413: */ 1414: static void setAccessible(final AccessibleObject obj) 1415: { 1416: AccessController.doPrivileged(new PrivilegedAction() 1417: { 1418: public Object run() 1419: { 1420: obj.setAccessible(true); 1421: return null; 1422: } 1423: }); 1424: } 1425: }