* 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 (tromey@cygnus.com)
* @author Eric Blake (ebb9@email.byu.edu)
* @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:
* 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;
/**
* Flag indicating a bridge method.
*/
static final int BRIDGE = 0x40;
/**
* Flag indicating a varargs method.
*/
static final int VARARGS = 0x80;
/**
* Flag indicating a synthetic member.
*/
static final int SYNTHETIC = 0x1000;
/**
* Flag indicating an enum constant or an enum class.
*/
static final int ENUM = 0x4000;
/**
* GCJ-LOCAL: This access flag is set on methods we declare
* internally but which must not be visible to reflection.
*/
static final int INVISIBLE = 0x8000;
/**
* GCJ-LOCAL: This access flag is set on interpreted classes.
*/
static final int INTERPRETED = 0x1000;
/**
* 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 StringBuilder.
* @param mod the modifier
* @param r the StringBuilder to which the String representation is appended
* @return r, with information appended
*/
static StringBuilder toString(int mod, StringBuilder r)
{
r.append(toString(mod, new StringBuffer()));
return r;
}
/**
* 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;
}
}