src/classes/gnu/java/lang/reflect/Modifier.java

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