gomp-20050608-branch/libjava/classpath/java/lang/reflect/Modifier.java

   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    * Check whether the given modifier is abstract.
 162    * @param mod the modifier.
 163    * @return <code>true</code> if abstract, <code>false</code> otherwise.
 164    */
 165   public static boolean isAbstract(int mod)
 166   {
 167     return (mod & ABSTRACT) != 0;
 168   }
 169
 170   /**
 171    * Check whether the given modifier is final.
 172    * @param mod the modifier.
 173    * @return <code>true</code> if final, <code>false</code> otherwise.
 174    */
 175   public static boolean isFinal(int mod)
 176   {
 177     return (mod & FINAL) != 0;
 178   }
 179
 180   /**
 181    * Check whether the given modifier is an interface.
 182    * @param mod the modifier.
 183    * @return <code>true</code> if an interface, <code>false</code> otherwise.
 184    */
 185   public static boolean isInterface(int mod)
 186   {
 187     return (mod & INTERFACE) != 0;
 188   }
 189
 190   /**
 191    * Check whether the given modifier is native.
 192    * @param mod the modifier.
 193    * @return <code>true</code> if native, <code>false</code> otherwise.
 194    */
 195   public static boolean isNative(int mod)
 196   {
 197     return (mod & NATIVE) != 0;
 198   }
 199
 200   /**
 201    * Check whether the given modifier is private.
 202    * @param mod the modifier.
 203    * @return <code>true</code> if private, <code>false</code> otherwise.
 204    */
 205   public static boolean isPrivate(int mod)
 206   {
 207     return (mod & PRIVATE) != 0;
 208   }
 209
 210   /**
 211    * Check whether the given modifier is protected.
 212    * @param mod the modifier.
 213    * @return <code>true</code> if protected, <code>false</code> otherwise.
 214    */
 215   public static boolean isProtected(int mod)
 216   {
 217     return (mod & PROTECTED) != 0;
 218   }
 219
 220   /**
 221    * Check whether the given modifier is public.
 222    * @param mod the modifier.
 223    * @return <code>true</code> if public, <code>false</code> otherwise.
 224    */
 225   public static boolean isPublic(int mod)
 226   {
 227     return (mod & PUBLIC) != 0;
 228   }
 229
 230   /**
 231    * Check whether the given modifier is static.
 232    * @param mod the modifier.
 233    * @return <code>true</code> if static, <code>false</code> otherwise.
 234    */
 235   public static boolean isStatic(int mod)
 236   {
 237     return (mod & STATIC) != 0;
 238   }
 239
 240   /**
 241    * Check whether the given modifier is strictfp.
 242    * @param mod the modifier.
 243    * @return <code>true</code> if strictfp, <code>false</code> otherwise.
 244    */
 245   public static boolean isStrict(int mod)
 246   {
 247     return (mod & STRICT) != 0;
 248   }
 249
 250   /**
 251    * Check whether the given modifier is synchronized.
 252    * @param mod the modifier.
 253    * @return <code>true</code> if synchronized, <code>false</code> otherwise.
 254    */
 255   public static boolean isSynchronized(int mod)
 256   {
 257     return (mod & SYNCHRONIZED) != 0;
 258   }
 259
 260   /**
 261    * Check whether the given modifier is transient.
 262    * @param mod the modifier.
 263    * @return <code>true</code> if transient, <code>false</code> otherwise.
 264    */
 265   public static boolean isTransient(int mod)
 266   {
 267     return (mod & TRANSIENT) != 0;
 268   }
 269
 270   /**
 271    * Check whether the given modifier is volatile.
 272    * @param mod the modifier.
 273    * @return <code>true</code> if volatile, <code>false</code> otherwise.
 274    */
 275   public static boolean isVolatile(int mod)
 276   {
 277     return (mod & VOLATILE) != 0;
 278   }
 279
 280   /**
 281    * Get a string representation of all the modifiers represented by the
 282    * given int. The keywords are printed in this order:
 283    * <code>&lt;public|protected|private&gt; abstract static final transient
 284    * volatile synchronized native strictfp interface</code>.
 285    *
 286    * @param mod the modifier.
 287    * @return the String representing the modifiers.
 288    */
 289   public static String toString(int mod)
 290   {
 291     return toString(mod, new StringBuffer()).toString();
 292   }
 293
 294   /**
 295    * Package helper method that can take a StringBuffer.
 296    * @param mod the modifier
 297    * @param r the StringBuffer to which the String representation is appended
 298    * @return r, with information appended
 299    */
 300   static StringBuffer toString(int mod, StringBuffer r)
 301   {
 302     if (isPublic(mod))
 303       r.append("public ");
 304     if (isProtected(mod))
 305       r.append("protected ");
 306     if (isPrivate(mod))
 307       r.append("private ");
 308     if (isAbstract(mod))
 309       r.append("abstract ");
 310     if (isStatic(mod))
 311       r.append("static ");
 312     if (isFinal(mod))
 313       r.append("final ");
 314     if (isTransient(mod))
 315       r.append("transient ");
 316     if (isVolatile(mod))
 317       r.append("volatile ");
 318     if (isSynchronized(mod))
 319       r.append("synchronized ");
 320     if (isNative(mod))
 321       r.append("native ");
 322     if (isStrict(mod))
 323       r.append("strictfp ");
 324     if (isInterface(mod))
 325       r.append("interface ");
 326
 327     // Trim trailing space.
 328     if ((mod & ALL_FLAGS) != 0)
 329       r.setLength(r.length() - 1);
 330     return r;
 331   }
 332 }