Source for java.lang.reflect.Modifier

   1: /* java.lang.reflect.Modifier
   2:    Copyright (C) 1998, 1999, 2001, 2002, 2005  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: /**
  42:  * Modifier is a helper class with static methods to determine whether an
  43:  * int returned from getModifiers() represents static, public, protected,
  44:  * native, final, etc... and provides an additional method to print
  45:  * out all of the modifiers in an int in order.
  46:  * <p>
  47:  * The methods in this class use the bitmask values in the VM spec to
  48:  * determine the modifiers of an int. This means that a VM must return a
  49:  * standard mask, conformant with the VM spec.  I don't know if this is how
  50:  * Sun does it, but I'm willing to bet money that it is.
  51:  *
  52:  * @author John Keiser
  53:  * @author Tom Tromey (tromey@cygnus.com)
  54:  * @author Eric Blake (ebb9@email.byu.edu)
  55:  * @see Member#getModifiers()
  56:  * @see Method#getModifiers()
  57:  * @see Field#getModifiers()
  58:  * @see Constructor#getModifiers()
  59:  * @see Class#getModifiers()
  60:  * @since 1.1
  61:  */
  62: public class Modifier
  63: {
  64:   /** <STRONG>This constructor really shouldn't be here ... there are no
  65:    * instance methods or variables of this class, so instantiation is
  66:    * worthless.  However, this function is in the 1.1 spec, so it is added
  67:    * for completeness.</STRONG>
  68:    */
  69:   public Modifier()
  70:   {
  71:   }
  72: 
  73:   /**
  74:    * Public: accessible from any other class.
  75:    */
  76:   public static final int PUBLIC = 0x0001;
  77: 
  78:   /**
  79:    * Private: accessible only from the same enclosing class.
  80:    */
  81:   public static final int PRIVATE = 0x0002;
  82: 
  83:   /**
  84:    * Protected: accessible only to subclasses, or within the package.
  85:    */
  86:   public static final int PROTECTED = 0x0004;
  87: 
  88:   /**
  89:    * Static:<br><ul>
  90:    * <li>Class: no enclosing instance for nested class.</li>
  91:    * <li>Field or Method: can be accessed or invoked without an
  92:    *     instance of the declaring class.</li>
  93:    * </ul>
  94:    */
  95:   public static final int STATIC = 0x0008;
  96: 
  97:   /**
  98:    * Final:<br><ul>
  99:    * <li>Class: no subclasses allowed.</li>
 100:    * <li>Field: cannot be changed.</li>
 101:    * <li>Method: cannot be overriden.</li>
 102:    * </ul>
 103:    */
 104:   public static final int FINAL = 0x0010;
 105: 
 106:   /**
 107:    * Synchronized: Method: lock the class while calling this method.
 108:    */
 109:   public static final int SYNCHRONIZED = 0x0020;
 110: 
 111:   /**
 112:    * Volatile: Field: cannot be cached.
 113:    */
 114:   public static final int VOLATILE = 0x0040;
 115: 
 116:   /**
 117:    * Transient: Field: not serialized or deserialized.
 118:    */
 119:   public static final int TRANSIENT = 0x0080;
 120: 
 121:   /**
 122:    * Native: Method: use JNI to call this method.
 123:    */
 124:   public static final int NATIVE = 0x0100;
 125: 
 126:   /**
 127:    * Interface: Class: is an interface.
 128:    */
 129:   public static final int INTERFACE = 0x0200;
 130: 
 131:   /**
 132:    * Abstract:<br><ul>
 133:    * <li>Class: may not be instantiated.</li>
 134:    * <li>Method: may not be called.</li>
 135:    * </ul>
 136:    */
 137:   public static final int ABSTRACT = 0x0400;
 138: 
 139:   /**
 140:    * Strictfp: Method: expressions are FP-strict.<p>
 141:    * Also used as a modifier for classes, to mean that all initializers
 142:    * and constructors are FP-strict, but does not show up in
 143:    * Class.getModifiers.
 144:    */
 145:   public static final int STRICT = 0x0800;
 146: 
 147: 
 148:   /**
 149:    * Super - treat invokespecial as polymorphic so that super.foo() works
 150:    * according to the JLS. This is a reuse of the synchronized constant
 151:    * to patch a hole in JDK 1.0. *shudder*.
 152:    */
 153:   static final int SUPER = 0x0020;
 154: 
 155:   /**
 156:    * All the flags, only used by code in this package.
 157:    */
 158:   static final int ALL_FLAGS = 0xfff;
 159: 
 160:   /**
 161:    * Flag indicating a bridge method.
 162:    */
 163:   static final int BRIDGE = 0x40;
 164: 
 165:   /**
 166:    * Flag indicating a varargs method.
 167:    */
 168:   static final int VARARGS = 0x80;
 169: 
 170:   /**
 171:    * Flag indicating a synthetic member.
 172:    */
 173:   static final int SYNTHETIC = 0x1000;
 174: 
 175:   /**
 176:    * Flag indicating an enum constant or an enum class.
 177:    */
 178:   static final int ENUM = 0x4000;
 179: 
 180:   /**
 181:    * Check whether the given modifier is abstract.
 182:    * @param mod the modifier.
 183:    * @return <code>true</code> if abstract, <code>false</code> otherwise.
 184:    */
 185:   public static boolean isAbstract(int mod)
 186:   {
 187:     return (mod & ABSTRACT) != 0;
 188:   }
 189: 
 190:   /**
 191:    * Check whether the given modifier is final.
 192:    * @param mod the modifier.
 193:    * @return <code>true</code> if final, <code>false</code> otherwise.
 194:    */
 195:   public static boolean isFinal(int mod)
 196:   {
 197:     return (mod & FINAL) != 0;
 198:   }
 199: 
 200:   /**
 201:    * Check whether the given modifier is an interface.
 202:    * @param mod the modifier.
 203:    * @return <code>true</code> if an interface, <code>false</code> otherwise.
 204:    */
 205:   public static boolean isInterface(int mod)
 206:   {
 207:     return (mod & INTERFACE) != 0;
 208:   }
 209: 
 210:   /**
 211:    * Check whether the given modifier is native.
 212:    * @param mod the modifier.
 213:    * @return <code>true</code> if native, <code>false</code> otherwise.
 214:    */
 215:   public static boolean isNative(int mod)
 216:   {
 217:     return (mod & NATIVE) != 0;
 218:   }
 219: 
 220:   /**
 221:    * Check whether the given modifier is private.
 222:    * @param mod the modifier.
 223:    * @return <code>true</code> if private, <code>false</code> otherwise.
 224:    */
 225:   public static boolean isPrivate(int mod)
 226:   {
 227:     return (mod & PRIVATE) != 0;
 228:   }
 229: 
 230:   /**
 231:    * Check whether the given modifier is protected.
 232:    * @param mod the modifier.
 233:    * @return <code>true</code> if protected, <code>false</code> otherwise.
 234:    */
 235:   public static boolean isProtected(int mod)
 236:   {
 237:     return (mod & PROTECTED) != 0;
 238:   }
 239: 
 240:   /**
 241:    * Check whether the given modifier is public.
 242:    * @param mod the modifier.
 243:    * @return <code>true</code> if public, <code>false</code> otherwise.
 244:    */
 245:   public static boolean isPublic(int mod)
 246:   {
 247:     return (mod & PUBLIC) != 0;
 248:   }
 249: 
 250:   /**
 251:    * Check whether the given modifier is static.
 252:    * @param mod the modifier.
 253:    * @return <code>true</code> if static, <code>false</code> otherwise.
 254:    */
 255:   public static boolean isStatic(int mod)
 256:   {
 257:     return (mod & STATIC) != 0;
 258:   }
 259: 
 260:   /**
 261:    * Check whether the given modifier is strictfp.
 262:    * @param mod the modifier.
 263:    * @return <code>true</code> if strictfp, <code>false</code> otherwise.
 264:    */
 265:   public static boolean isStrict(int mod)
 266:   {
 267:     return (mod & STRICT) != 0;
 268:   }
 269: 
 270:   /**
 271:    * Check whether the given modifier is synchronized.
 272:    * @param mod the modifier.
 273:    * @return <code>true</code> if synchronized, <code>false</code> otherwise.
 274:    */
 275:   public static boolean isSynchronized(int mod)
 276:   {
 277:     return (mod & SYNCHRONIZED) != 0;
 278:   }
 279: 
 280:   /**
 281:    * Check whether the given modifier is transient.
 282:    * @param mod the modifier.
 283:    * @return <code>true</code> if transient, <code>false</code> otherwise.
 284:    */
 285:   public static boolean isTransient(int mod)
 286:   {
 287:     return (mod & TRANSIENT) != 0;
 288:   }
 289: 
 290:   /**
 291:    * Check whether the given modifier is volatile.
 292:    * @param mod the modifier.
 293:    * @return <code>true</code> if volatile, <code>false</code> otherwise.
 294:    */
 295:   public static boolean isVolatile(int mod)
 296:   {
 297:     return (mod & VOLATILE) != 0;
 298:   }
 299: 
 300:   /**
 301:    * Get a string representation of all the modifiers represented by the
 302:    * given int. The keywords are printed in this order:
 303:    * <code>&lt;public|protected|private&gt; abstract static final transient
 304:    * volatile synchronized native strictfp interface</code>.
 305:    *
 306:    * @param mod the modifier.
 307:    * @return the String representing the modifiers.
 308:    */
 309:   public static String toString(int mod)
 310:   {
 311:     return toString(mod, new StringBuilder()).toString();
 312:   }
 313: 
 314:   /**
 315:    * Package helper method that can take a StringBuilder.
 316:    * @param mod the modifier
 317:    * @param r the StringBuilder to which the String representation is appended
 318:    * @return r, with information appended
 319:    */
 320:   static StringBuilder toString(int mod, StringBuilder r)
 321:   {
 322:     r.append(toString(mod, new StringBuffer()));
 323:     return r;
 324:   }
 325: 
 326:   /**
 327:    * Package helper method that can take a StringBuffer.
 328:    * @param mod the modifier
 329:    * @param r the StringBuffer to which the String representation is appended
 330:    * @return r, with information appended
 331:    */
 332:   static StringBuffer toString(int mod, StringBuffer r)
 333:   {
 334:     if (isPublic(mod))
 335:       r.append("public ");
 336:     if (isProtected(mod))
 337:       r.append("protected ");
 338:     if (isPrivate(mod))
 339:       r.append("private ");
 340:     if (isAbstract(mod))
 341:       r.append("abstract ");
 342:     if (isStatic(mod))
 343:       r.append("static ");
 344:     if (isFinal(mod))
 345:       r.append("final ");
 346:     if (isTransient(mod))
 347:       r.append("transient ");
 348:     if (isVolatile(mod))
 349:       r.append("volatile ");
 350:     if (isSynchronized(mod))
 351:       r.append("synchronized ");
 352:     if (isNative(mod))
 353:       r.append("native ");
 354:     if (isStrict(mod))
 355:       r.append("strictfp ");
 356:     if (isInterface(mod))
 357:       r.append("interface ");
 358:     
 359:     // Trim trailing space.
 360:     if ((mod & ALL_FLAGS) != 0)
 361:       r.setLength(r.length() - 1);
 362:     return r;
 363:   }
 364: }