/* java.lang.reflect.Modifier Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation, Inc. This file is part of GNU Classpath. GNU Classpath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU Classpath is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Classpath; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. Linking this library statically or dynamically with other modules is making a combined work based on this library. Thus, the terms and conditions of the GNU General Public License cover the whole combination. As a special exception, the copyright holders of this library give you permission to link this library with independent modules to produce an executable, regardless of the license terms of these independent modules, and to copy and distribute the resulting executable under terms of your choice, provided that you also meet, for each linked independent module, the terms and conditions of the license of that module. An independent module is a module which is not derived from or based on this library. If you modify this library, you may extend this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version. */ package java.lang.reflect; /** * Modifier is a helper class with static methods to determine whether an * int returned from getModifiers() represents static, public, protected, * native, final, etc... and provides an additional method to print * out all of the modifiers in an int in order. *

* The methods in this class use the bitmask values in the VM spec to * determine the modifiers of an int. This means that a VM must return a * standard mask, conformant with the VM spec. I don't know if this is how * Sun does it, but I'm willing to bet money that it is. * * @author John Keiser * @author Tom Tromey * @author Eric Blake * @see Member#getModifiers() * @see Method#getModifiers() * @see Field#getModifiers() * @see Constructor#getModifiers() * @see Class#getModifiers() * @since 1.1 */ public class Modifier { /** This constructor really shouldn't be here ... there are no * instance methods or variables of this class, so instantiation is * worthless. However, this function is in the 1.1 spec, so it is added * for completeness. */ public Modifier() { } /** * Public: accessible from any other class. */ public static final int PUBLIC = 0x0001; /** * Private: accessible only from the same enclosing class. */ public static final int PRIVATE = 0x0002; /** * Protected: accessible only to subclasses, or within the package. */ public static final int PROTECTED = 0x0004; /** * Static:

*/ public static final int STATIC = 0x0008; /** * Final:
*/ public static final int FINAL = 0x0010; /** * Synchronized: Method: lock the class while calling this method. */ public static final int SYNCHRONIZED = 0x0020; /** * Volatile: Field: cannot be cached. */ public static final int VOLATILE = 0x0040; /** * Transient: Field: not serialized or deserialized. */ public static final int TRANSIENT = 0x0080; /** * Native: Method: use JNI to call this method. */ public static final int NATIVE = 0x0100; /** * Interface: Class: is an interface. */ public static final int INTERFACE = 0x0200; /** * Abstract:
*/ public static final int ABSTRACT = 0x0400; /** * Strictfp: Method: expressions are FP-strict.

* Also used as a modifier for classes, to mean that all initializers * and constructors are FP-strict, but does not show up in * Class.getModifiers. */ public static final int STRICT = 0x0800; /** * Super - treat invokespecial as polymorphic so that super.foo() works * according to the JLS. This is a reuse of the synchronized constant * to patch a hole in JDK 1.0. *shudder*. */ static final int SUPER = 0x0020; /** * All the flags, only used by code in this package. */ static final int ALL_FLAGS = 0xfff; /** * Check whether the given modifier is abstract. * @param mod the modifier. * @return true if abstract, false otherwise. */ public static boolean isAbstract(int mod) { return (mod & ABSTRACT) != 0; } /** * Check whether the given modifier is final. * @param mod the modifier. * @return true if final, false otherwise. */ public static boolean isFinal(int mod) { return (mod & FINAL) != 0; } /** * Check whether the given modifier is an interface. * @param mod the modifier. * @return true if an interface, false otherwise. */ public static boolean isInterface(int mod) { return (mod & INTERFACE) != 0; } /** * Check whether the given modifier is native. * @param mod the modifier. * @return true if native, false otherwise. */ public static boolean isNative(int mod) { return (mod & NATIVE) != 0; } /** * Check whether the given modifier is private. * @param mod the modifier. * @return true if private, false otherwise. */ public static boolean isPrivate(int mod) { return (mod & PRIVATE) != 0; } /** * Check whether the given modifier is protected. * @param mod the modifier. * @return true if protected, false otherwise. */ public static boolean isProtected(int mod) { return (mod & PROTECTED) != 0; } /** * Check whether the given modifier is public. * @param mod the modifier. * @return true if public, false otherwise. */ public static boolean isPublic(int mod) { return (mod & PUBLIC) != 0; } /** * Check whether the given modifier is static. * @param mod the modifier. * @return true if static, false otherwise. */ public static boolean isStatic(int mod) { return (mod & STATIC) != 0; } /** * Check whether the given modifier is strictfp. * @param mod the modifier. * @return true if strictfp, false otherwise. */ public static boolean isStrict(int mod) { return (mod & STRICT) != 0; } /** * Check whether the given modifier is synchronized. * @param mod the modifier. * @return true if synchronized, false otherwise. */ public static boolean isSynchronized(int mod) { return (mod & SYNCHRONIZED) != 0; } /** * Check whether the given modifier is transient. * @param mod the modifier. * @return true if transient, false otherwise. */ public static boolean isTransient(int mod) { return (mod & TRANSIENT) != 0; } /** * Check whether the given modifier is volatile. * @param mod the modifier. * @return true if volatile, false otherwise. */ public static boolean isVolatile(int mod) { return (mod & VOLATILE) != 0; } /** * Get a string representation of all the modifiers represented by the * given int. The keywords are printed in this order: * <public|protected|private> abstract static final transient * volatile synchronized native strictfp interface. * * @param mod the modifier. * @return the String representing the modifiers. */ public static String toString(int mod) { return toString(mod, new StringBuffer()).toString(); } /** * Package helper method that can take a StringBuffer. * @param mod the modifier * @param r the StringBuffer to which the String representation is appended * @return r, with information appended */ static StringBuffer toString(int mod, StringBuffer r) { if (isPublic(mod)) r.append("public "); if (isProtected(mod)) r.append("protected "); if (isPrivate(mod)) r.append("private "); if (isAbstract(mod)) r.append("abstract "); if (isStatic(mod)) r.append("static "); if (isFinal(mod)) r.append("final "); if (isTransient(mod)) r.append("transient "); if (isVolatile(mod)) r.append("volatile "); if (isSynchronized(mod)) r.append("synchronized "); if (isNative(mod)) r.append("native "); if (isStrict(mod)) r.append("strictfp "); if (isInterface(mod)) r.append("interface "); // Trim trailing space. if ((mod & ALL_FLAGS) != 0) r.setLength(r.length() - 1); return r; } }