GNU Classpath (0.98) | |
Frames | No Frames |
1: /* java.lang.reflect.Field - reflection of Java fields 2: Copyright (C) 1998, 2001, 2005, 2008 Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package java.lang.reflect; 40: 41: import gnu.java.lang.ClassHelper; 42: import gnu.java.lang.CPStringBuilder; 43: 44: import gnu.java.lang.reflect.FieldSignatureParser; 45: 46: import java.lang.annotation.Annotation; 47: 48: /** 49: * The Field class represents a member variable of a class. It also allows 50: * dynamic access to a member, via reflection. This works for both 51: * static and instance fields. Operations on Field objects know how to 52: * do widening conversions, but throw {@link IllegalArgumentException} if 53: * a narrowing conversion would be necessary. You can query for information 54: * on this Field regardless of location, but get and set access may be limited 55: * by Java language access controls. If you can't do it in the compiler, you 56: * can't normally do it here either.<p> 57: * 58: * <B>Note:</B> This class returns and accepts types as Classes, even 59: * primitive types; there are Class types defined that represent each 60: * different primitive type. They are <code>java.lang.Boolean.TYPE, 61: * java.lang.Byte.TYPE,</code>, also available as <code>boolean.class, 62: * byte.class</code>, etc. These are not to be confused with the 63: * classes <code>java.lang.Boolean, java.lang.Byte</code>, etc., which are 64: * real classes.<p> 65: * 66: * Also note that this is not a serializable class. It is entirely feasible 67: * to make it serializable using the Externalizable interface, but this is 68: * on Sun, not me. 69: * 70: * @author John Keiser 71: * @author Eric Blake <ebb9@email.byu.edu> 72: * @see Member 73: * @see Class 74: * @see Class#getField(String) 75: * @see Class#getDeclaredField(String) 76: * @see Class#getFields() 77: * @see Class#getDeclaredFields() 78: * @since 1.1 79: * @status updated to 1.4 80: */ 81: public final class Field 82: extends AccessibleObject implements Member 83: { 84: static final int FIELD_MODIFIERS 85: = Modifier.FINAL | Modifier.PRIVATE | Modifier.PROTECTED 86: | Modifier.PUBLIC | Modifier.STATIC | Modifier.TRANSIENT 87: | Modifier.VOLATILE; 88: 89: private FieldSignatureParser p; 90: 91: VMField f; 92: 93: /** 94: * This class is uninstantiable outside the package. 95: */ 96: Field(VMField f) 97: { 98: this.f = f; 99: f.f = this; 100: } 101: 102: /** 103: * Gets the class that declared this field, or the class where this field 104: * is a non-inherited member. 105: * @return the class that declared this member 106: */ 107: public Class<?> getDeclaringClass() 108: { 109: return (Class<?>) f.getDeclaringClass(); 110: } 111: 112: /** 113: * Gets the name of this field. 114: * @return the name of this field 115: */ 116: public String getName() 117: { 118: return f.getName(); 119: } 120: 121: /** 122: * Gets the modifiers this field uses. Use the <code>Modifier</code> 123: * class to interpret the values. A field can only have a subset of the 124: * following modifiers: public, private, protected, static, final, 125: * transient, and volatile. 126: * 127: * @return an integer representing the modifiers to this Member 128: * @see Modifier 129: */ 130: public int getModifiers() 131: { 132: return f.getModifiersInternal() & FIELD_MODIFIERS; 133: } 134: 135: /** 136: * Return true if this field is synthetic, false otherwise. 137: * @since 1.5 138: */ 139: public boolean isSynthetic() 140: { 141: return (f.getModifiersInternal() & Modifier.SYNTHETIC) != 0; 142: } 143: 144: /** 145: * Return true if this field represents an enum constant, 146: * false otherwise. 147: * @since 1.5 148: */ 149: public boolean isEnumConstant() 150: { 151: return (f.getModifiersInternal() & Modifier.ENUM) != 0; 152: } 153: 154: /** 155: * Gets the type of this field. 156: * @return the type of this field 157: */ 158: public Class<?> getType() 159: { 160: return f.getType(); 161: } 162: 163: /** 164: * Compare two objects to see if they are semantically equivalent. 165: * Two Fields are semantically equivalent if they have the same declaring 166: * class, name, and type. Since you can't creat a Field except through 167: * the VM, this is just the == relation. 168: * 169: * @param o the object to compare to 170: * @return <code>true</code> if they are equal; <code>false</code> if not 171: */ 172: public boolean equals(Object o) 173: { 174: return f.equals(o); 175: } 176: 177: /** 178: * Get the hash code for the Field. The Field hash code is the hash code 179: * of its name XOR'd with the hash code of its class name. 180: * 181: * @return the hash code for the object. 182: */ 183: public int hashCode() 184: { 185: return f.getDeclaringClass().getName().hashCode() ^ f.getName().hashCode(); 186: } 187: 188: /** 189: * Get a String representation of the Field. A Field's String 190: * representation is "<modifiers> <type> 191: * <class>.<fieldname>".<br> Example: 192: * <code>public transient boolean gnu.parse.Parser.parseComplete</code> 193: * 194: * @return the String representation of the Field 195: */ 196: public String toString() 197: { 198: // 64 is a reasonable buffer initial size for field 199: CPStringBuilder sb = new CPStringBuilder(64); 200: Modifier.toString(getModifiers(), sb).append(' '); 201: sb.append(ClassHelper.getUserName(getType())).append(' '); 202: sb.append(getDeclaringClass().getName()).append('.'); 203: sb.append(getName()); 204: return sb.toString(); 205: } 206: 207: public String toGenericString() 208: { 209: CPStringBuilder sb = new CPStringBuilder(64); 210: Modifier.toString(getModifiers(), sb).append(' '); 211: sb.append(getGenericType()).append(' '); 212: sb.append(getDeclaringClass().getName()).append('.'); 213: sb.append(getName()); 214: return sb.toString(); 215: } 216: 217: /** 218: * Get the value of this Field. If it is primitive, it will be wrapped 219: * in the appropriate wrapper type (boolean = java.lang.Boolean).<p> 220: * 221: * If the field is static, <code>o</code> will be ignored. Otherwise, if 222: * <code>o</code> is null, you get a <code>NullPointerException</code>, 223: * and if it is incompatible with the declaring class of the field, you 224: * get an <code>IllegalArgumentException</code>.<p> 225: * 226: * Next, if this Field enforces access control, your runtime context is 227: * evaluated, and you may have an <code>IllegalAccessException</code> if 228: * you could not access this field in similar compiled code. If the field 229: * is static, and its class is uninitialized, you trigger class 230: * initialization, which may end in a 231: * <code>ExceptionInInitializerError</code>.<p> 232: * 233: * Finally, the field is accessed, and primitives are wrapped (but not 234: * necessarily in new objects). This method accesses the field of the 235: * declaring class, even if the instance passed in belongs to a subclass 236: * which declares another field to hide this one. 237: * 238: * @param o the object to get the value of this Field from 239: * @return the value of the Field 240: * @throws IllegalAccessException if you could not normally access this field 241: * (i.e. it is not public) 242: * @throws IllegalArgumentException if <code>o</code> is not an instance of 243: * the class or interface declaring this field 244: * @throws NullPointerException if <code>o</code> is null and this field 245: * requires an instance 246: * @throws ExceptionInInitializerError if accessing a static field triggered 247: * class initialization, which then failed 248: * @see #getBoolean(Object) 249: * @see #getByte(Object) 250: * @see #getChar(Object) 251: * @see #getShort(Object) 252: * @see #getInt(Object) 253: * @see #getLong(Object) 254: * @see #getFloat(Object) 255: * @see #getDouble(Object) 256: */ 257: public Object get(Object o) 258: throws IllegalAccessException 259: { 260: return f.get(o); 261: } 262: 263: /** 264: * Get the value of this boolean Field. If the field is static, 265: * <code>o</code> will be ignored. 266: * 267: * @param o the object to get the value of this Field from 268: * @return the value of the Field 269: * @throws IllegalAccessException if you could not normally access this field 270: * (i.e. it is not public) 271: * @throws IllegalArgumentException if this is not a boolean field of 272: * <code>o</code>, or if <code>o</code> is not an instance of the 273: * declaring class of this field 274: * @throws NullPointerException if <code>o</code> is null and this field 275: * requires an instance 276: * @throws ExceptionInInitializerError if accessing a static field triggered 277: * class initialization, which then failed 278: * @see #get(Object) 279: */ 280: public boolean getBoolean(Object o) 281: throws IllegalAccessException 282: { 283: return f.getBoolean(o); 284: } 285: 286: /** 287: * Get the value of this byte Field. If the field is static, 288: * <code>o</code> will be ignored. 289: * 290: * @param o the object to get the value of this Field from 291: * @return the value of the Field 292: * @throws IllegalAccessException if you could not normally access this field 293: * (i.e. it is not public) 294: * @throws IllegalArgumentException if this is not a byte field of 295: * <code>o</code>, or if <code>o</code> is not an instance of the 296: * declaring class of this field 297: * @throws NullPointerException if <code>o</code> is null and this field 298: * requires an instance 299: * @throws ExceptionInInitializerError if accessing a static field triggered 300: * class initialization, which then failed 301: * @see #get(Object) 302: */ 303: public byte getByte(Object o) 304: throws IllegalAccessException 305: { 306: return f.getByte(o); 307: } 308: 309: /** 310: * Get the value of this Field as a char. If the field is static, 311: * <code>o</code> will be ignored. 312: * 313: * @throws IllegalAccessException if you could not normally access this field 314: * (i.e. it is not public) 315: * @throws IllegalArgumentException if this is not a char field of 316: * <code>o</code>, or if <code>o</code> is not an instance 317: * of the declaring class of this field 318: * @throws NullPointerException if <code>o</code> is null and this field 319: * requires an instance 320: * @throws ExceptionInInitializerError if accessing a static field triggered 321: * class initialization, which then failed 322: * @see #get(Object) 323: */ 324: public char getChar(Object o) 325: throws IllegalAccessException 326: { 327: return f.getChar(o); 328: } 329: 330: /** 331: * Get the value of this Field as a short. If the field is static, 332: * <code>o</code> will be ignored. 333: * 334: * @param o the object to get the value of this Field from 335: * @return the value of the Field 336: * @throws IllegalAccessException if you could not normally access this field 337: * (i.e. it is not public) 338: * @throws IllegalArgumentException if this is not a byte or short 339: * field of <code>o</code>, or if <code>o</code> is not an instance 340: * of the declaring class of this field 341: * @throws NullPointerException if <code>o</code> is null and this field 342: * requires an instance 343: * @throws ExceptionInInitializerError if accessing a static field triggered 344: * class initialization, which then failed 345: * @see #get(Object) 346: */ 347: public short getShort(Object o) 348: throws IllegalAccessException 349: { 350: return f.getShort(o); 351: } 352: 353: /** 354: * Get the value of this Field as an int. If the field is static, 355: * <code>o</code> will be ignored. 356: * 357: * @param o the object to get the value of this Field from 358: * @return the value of the Field 359: * @throws IllegalAccessException if you could not normally access this field 360: * (i.e. it is not public) 361: * @throws IllegalArgumentException if this is not a byte, short, char, or 362: * int field of <code>o</code>, or if <code>o</code> is not an 363: * instance of the declaring class of this field 364: * @throws NullPointerException if <code>o</code> is null and this field 365: * requires an instance 366: * @throws ExceptionInInitializerError if accessing a static field triggered 367: * class initialization, which then failed 368: * @see #get(Object) 369: */ 370: public int getInt(Object o) 371: throws IllegalAccessException 372: { 373: return f.getInt(o); 374: } 375: 376: /** 377: * Get the value of this Field as a long. If the field is static, 378: * <code>o</code> will be ignored. 379: * 380: * @param o the object to get the value of this Field from 381: * @return the value of the Field 382: * @throws IllegalAccessException if you could not normally access this field 383: * (i.e. it is not public) 384: * @throws IllegalArgumentException if this is not a byte, short, char, int, 385: * or long field of <code>o</code>, or if <code>o</code> is not an 386: * instance of the declaring class of this field 387: * @throws NullPointerException if <code>o</code> is null and this field 388: * requires an instance 389: * @throws ExceptionInInitializerError if accessing a static field triggered 390: * class initialization, which then failed 391: * @see #get(Object) 392: */ 393: public long getLong(Object o) 394: throws IllegalAccessException 395: { 396: return f.getLong(o); 397: } 398: 399: /** 400: * Get the value of this Field as a float. If the field is static, 401: * <code>o</code> will be ignored. 402: * 403: * @param o the object to get the value of this Field from 404: * @return the value of the Field 405: * @throws IllegalAccessException if you could not normally access this field 406: * (i.e. it is not public) 407: * @throws IllegalArgumentException if this is not a byte, short, char, int, 408: * long, or float field of <code>o</code>, or if <code>o</code> is 409: * not an instance of the declaring class of this field 410: * @throws NullPointerException if <code>o</code> is null and this field 411: * requires an instance 412: * @throws ExceptionInInitializerError if accessing a static field triggered 413: * class initialization, which then failed 414: * @see #get(Object) 415: */ 416: public float getFloat(Object o) 417: throws IllegalAccessException 418: { 419: return f.getFloat(o); 420: } 421: 422: /** 423: * Get the value of this Field as a double. If the field is static, 424: * <code>o</code> will be ignored. 425: * 426: * @param o the object to get the value of this Field from 427: * @return the value of the Field 428: * @throws IllegalAccessException if you could not normally access this field 429: * (i.e. it is not public) 430: * @throws IllegalArgumentException if this is not a byte, short, char, int, 431: * long, float, or double field of <code>o</code>, or if 432: * <code>o</code> is not an instance of the declaring class of this 433: * field 434: * @throws NullPointerException if <code>o</code> is null and this field 435: * requires an instance 436: * @throws ExceptionInInitializerError if accessing a static field triggered 437: * class initialization, which then failed 438: * @see #get(Object) 439: */ 440: public double getDouble(Object o) 441: throws IllegalAccessException 442: { 443: return f.getDouble(o); 444: } 445: 446: /** 447: * Set the value of this Field. If it is a primitive field, the value 448: * will be unwrapped from the passed object (boolean = java.lang.Boolean).<p> 449: * 450: * If the field is static, <code>o</code> will be ignored. Otherwise, if 451: * <code>o</code> is null, you get a <code>NullPointerException</code>, 452: * and if it is incompatible with the declaring class of the field, you 453: * get an <code>IllegalArgumentException</code>.<p> 454: * 455: * Next, if this Field enforces access control, your runtime context is 456: * evaluated, and you may have an <code>IllegalAccessException</code> if 457: * you could not access this field in similar compiled code. This also 458: * occurs whether or not there is access control if the field is final. 459: * If the field is primitive, and unwrapping your argument fails, you will 460: * get an <code>IllegalArgumentException</code>; likewise, this error 461: * happens if <code>value</code> cannot be cast to the correct object type. 462: * If the field is static, and its class is uninitialized, you trigger class 463: * initialization, which may end in a 464: * <code>ExceptionInInitializerError</code>.<p> 465: * 466: * Finally, the field is set with the widened value. This method accesses 467: * the field of the declaring class, even if the instance passed in belongs 468: * to a subclass which declares another field to hide this one. 469: * 470: * @param o the object to set this Field on 471: * @param value the value to set this Field to 472: * @throws IllegalAccessException if you could not normally access this field 473: * (i.e. it is not public) 474: * @throws IllegalArgumentException if <code>value</code> cannot be 475: * converted by a widening conversion to the underlying type of 476: * the Field, or if <code>o</code> is not an instance of the class 477: * declaring this field 478: * @throws NullPointerException if <code>o</code> is null and this field 479: * requires an instance 480: * @throws ExceptionInInitializerError if accessing a static field triggered 481: * class initialization, which then failed 482: * @see #setBoolean(Object, boolean) 483: * @see #setByte(Object, byte) 484: * @see #setChar(Object, char) 485: * @see #setShort(Object, short) 486: * @see #setInt(Object, int) 487: * @see #setLong(Object, long) 488: * @see #setFloat(Object, float) 489: * @see #setDouble(Object, double) 490: */ 491: public void set(Object o, Object value) 492: throws IllegalAccessException 493: { 494: f.set(o, value); 495: } 496: 497: /** 498: * Set this boolean Field. If the field is static, <code>o</code> will be 499: * ignored. 500: * 501: * @param o the object to set this Field on 502: * @param value the value to set this Field to 503: * @throws IllegalAccessException if you could not normally access this field 504: * (i.e. it is not public) 505: * @throws IllegalArgumentException if this is not a boolean field, or if 506: * <code>o</code> is not an instance of the class declaring this 507: * field 508: * @throws NullPointerException if <code>o</code> is null and this field 509: * requires an instance 510: * @throws ExceptionInInitializerError if accessing a static field triggered 511: * class initialization, which then failed 512: * @see #set(Object, Object) 513: */ 514: public void setBoolean(Object o, boolean value) 515: throws IllegalAccessException 516: { 517: f.setBoolean(o, value); 518: } 519: 520: /** 521: * Set this byte Field. If the field is static, <code>o</code> will be 522: * ignored. 523: * 524: * @param o the object to set this Field on 525: * @param value the value to set this Field to 526: * @throws IllegalAccessException if you could not normally access this field 527: * (i.e. it is not public) 528: * @throws IllegalArgumentException if this is not a byte, short, int, long, 529: * float, or double field, or if <code>o</code> is not an instance 530: * of the class declaring this field 531: * @throws NullPointerException if <code>o</code> is null and this field 532: * requires an instance 533: * @throws ExceptionInInitializerError if accessing a static field triggered 534: * class initialization, which then failed 535: * @see #set(Object, Object) 536: */ 537: public void setByte(Object o, byte value) 538: throws IllegalAccessException 539: { 540: f.setByte(o, value); 541: } 542: 543: /** 544: * Set this char Field. If the field is static, <code>o</code> will be 545: * ignored. 546: * 547: * @param o the object to set this Field on 548: * @param value the value to set this Field to 549: * @throws IllegalAccessException if you could not normally access this field 550: * (i.e. it is not public) 551: * @throws IllegalArgumentException if this is not a char, int, long, 552: * float, or double field, or if <code>o</code> is not an instance 553: * of the class declaring this field 554: * @throws NullPointerException if <code>o</code> is null and this field 555: * requires an instance 556: * @throws ExceptionInInitializerError if accessing a static field triggered 557: * class initialization, which then failed 558: * @see #set(Object, Object) 559: */ 560: public void setChar(Object o, char value) 561: throws IllegalAccessException 562: { 563: f.setChar(o, value); 564: } 565: 566: /** 567: * Set this short Field. If the field is static, <code>o</code> will be 568: * ignored. 569: * 570: * @param o the object to set this Field on 571: * @param value the value to set this Field to 572: * @throws IllegalAccessException if you could not normally access this field 573: * (i.e. it is not public) 574: * @throws IllegalArgumentException if this is not a short, int, long, 575: * float, or double field, or if <code>o</code> is not an instance 576: * of the class declaring this field 577: * @throws NullPointerException if <code>o</code> is null and this field 578: * requires an instance 579: * @throws ExceptionInInitializerError if accessing a static field triggered 580: * class initialization, which then failed 581: * @see #set(Object, Object) 582: */ 583: public void setShort(Object o, short value) 584: throws IllegalAccessException 585: { 586: f.setShort(o, value); 587: } 588: 589: /** 590: * Set this int Field. If the field is static, <code>o</code> will be 591: * ignored. 592: * 593: * @param o the object to set this Field on 594: * @param value the value to set this Field to 595: * @throws IllegalAccessException if you could not normally access this field 596: * (i.e. it is not public) 597: * @throws IllegalArgumentException if this is not an int, long, float, or 598: * double field, or if <code>o</code> is not an instance of the 599: * class declaring this field 600: * @throws NullPointerException if <code>o</code> is null and this field 601: * requires an instance 602: * @throws ExceptionInInitializerError if accessing a static field triggered 603: * class initialization, which then failed 604: * @see #set(Object, Object) 605: */ 606: public void setInt(Object o, int value) 607: throws IllegalAccessException 608: { 609: f.setInt(o, value); 610: } 611: 612: /** 613: * Set this long Field. If the field is static, <code>o</code> will be 614: * ignored. 615: * 616: * @param o the object to set this Field on 617: * @param value the value to set this Field to 618: * @throws IllegalAccessException if you could not normally access this field 619: * (i.e. it is not public) 620: * @throws IllegalArgumentException if this is not a long, float, or double 621: * field, or if <code>o</code> is not an instance of the class 622: * declaring this field 623: * @throws NullPointerException if <code>o</code> is null and this field 624: * requires an instance 625: * @throws ExceptionInInitializerError if accessing a static field triggered 626: * class initialization, which then failed 627: * @see #set(Object, Object) 628: */ 629: public void setLong(Object o, long value) 630: throws IllegalAccessException 631: { 632: f.setLong(o, value); 633: } 634: 635: /** 636: * Set this float Field. If the field is static, <code>o</code> will be 637: * ignored. 638: * 639: * @param o the object to set this Field on 640: * @param value the value to set this Field to 641: * @throws IllegalAccessException if you could not normally access this field 642: * (i.e. it is not public) 643: * @throws IllegalArgumentException if this is not a float or long field, or 644: * if <code>o</code> is not an instance of the class declaring this 645: * field 646: * @throws NullPointerException if <code>o</code> is null and this field 647: * requires an instance 648: * @throws ExceptionInInitializerError if accessing a static field triggered 649: * class initialization, which then failed 650: * @see #set(Object, Object) 651: */ 652: public void setFloat(Object o, float value) 653: throws IllegalAccessException 654: { 655: f.setFloat(o, value); 656: } 657: 658: /** 659: * Set this double Field. If the field is static, <code>o</code> will be 660: * ignored. 661: * 662: * @param o the object to set this Field on 663: * @param value the value to set this Field to 664: * @throws IllegalAccessException if you could not normally access this field 665: * (i.e. it is not public) 666: * @throws IllegalArgumentException if this is not a double field, or if 667: * <code>o</code> is not an instance of the class declaring this 668: * field 669: * @throws NullPointerException if <code>o</code> is null and this field 670: * requires an instance 671: * @throws ExceptionInInitializerError if accessing a static field triggered 672: * class initialization, which then failed 673: * @see #set(Object, Object) 674: */ 675: public void setDouble(Object o, double value) 676: throws IllegalAccessException 677: { 678: f.setDouble(o, value); 679: } 680: 681: /** 682: * Return the generic type of the field. If the field type is not a generic 683: * type, the method returns the same as <code>getType()</code>. 684: * 685: * @throws GenericSignatureFormatError if the generic signature does 686: * not conform to the format specified in the Virtual Machine 687: * specification, version 3. 688: * @since 1.5 689: */ 690: public Type getGenericType() 691: { 692: if (p == null) 693: { 694: String signature = f.getSignature(); 695: if (signature == null) 696: return getType(); 697: p = new FieldSignatureParser(getDeclaringClass(), 698: signature); 699: } 700: return p.getFieldType(); 701: } 702: 703: /** 704: * Returns the element's annotation for the specified annotation type, 705: * or <code>null</code> if no such annotation exists. 706: * 707: * @param annotationClass the type of annotation to look for. 708: * @return this element's annotation for the specified type, or 709: * <code>null</code> if no such annotation exists. 710: * @throws NullPointerException if the annotation class is <code>null</code>. 711: */ 712: public <T extends Annotation> T getAnnotation(Class<T> annotationClass) 713: { 714: // Inescapable as the VM layer is 1.4 based. T will erase to Annotation anyway. 715: @SuppressWarnings("unchecked") T ann = (T) f.getAnnotation(annotationClass); 716: return ann; 717: } 718: 719: /** 720: * Returns all annotations directly defined by the element. If there are 721: * no annotations directly associated with the element, then a zero-length 722: * array will be returned. The returned array may be modified by the client 723: * code, but this will have no effect on the annotation content of this 724: * class, and hence no effect on the return value of this method for 725: * future callers. 726: * 727: * @return the annotations directly defined by the element. 728: * @since 1.5 729: */ 730: public Annotation[] getDeclaredAnnotations() 731: { 732: return f.getDeclaredAnnotations(); 733: } 734: 735: }
GNU Classpath (0.98) |