001 /* java.lang.reflect.Modifier
002 Copyright (C) 1998, 1999, 2001, 2002, 2005, 2006 Free Software Foundation, Inc.
003
004 This file is part of GNU Classpath.
005
006 GNU Classpath is free software; you can redistribute it and/or modify
007 it under the terms of the GNU General Public License as published by
008 the Free Software Foundation; either version 2, or (at your option)
009 any later version.
010
011 GNU Classpath is distributed in the hope that it will be useful, but
012 WITHOUT ANY WARRANTY; without even the implied warranty of
013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014 General Public License for more details.
015
016 You should have received a copy of the GNU General Public License
017 along with GNU Classpath; see the file COPYING. If not, write to the
018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019 02110-1301 USA.
020
021 Linking this library statically or dynamically with other modules is
022 making a combined work based on this library. Thus, the terms and
023 conditions of the GNU General Public License cover the whole
024 combination.
025
026 As a special exception, the copyright holders of this library give you
027 permission to link this library with independent modules to produce an
028 executable, regardless of the license terms of these independent
029 modules, and to copy and distribute the resulting executable under
030 terms of your choice, provided that you also meet, for each linked
031 independent module, the terms and conditions of the license of that
032 module. An independent module is a module which is not derived from
033 or based on this library. If you modify this library, you may extend
034 this exception to your version of the library, but you are not
035 obligated to do so. If you do not wish to do so, delete this
036 exception statement from your version. */
037
038
039 package java.lang.reflect;
040
041 /**
042 * Modifier is a helper class with static methods to determine whether an
043 * int returned from getModifiers() represents static, public, protected,
044 * native, final, etc... and provides an additional method to print
045 * out all of the modifiers in an int in order.
046 * <p>
047 * The methods in this class use the bitmask values in the VM spec to
048 * determine the modifiers of an int. This means that a VM must return a
049 * standard mask, conformant with the VM spec. I don't know if this is how
050 * Sun does it, but I'm willing to bet money that it is.
051 *
052 * @author John Keiser
053 * @author Tom Tromey (tromey@cygnus.com)
054 * @author Eric Blake (ebb9@email.byu.edu)
055 * @see Member#getModifiers()
056 * @see Method#getModifiers()
057 * @see Field#getModifiers()
058 * @see Constructor#getModifiers()
059 * @see Class#getModifiers()
060 * @since 1.1
061 */
062 public class Modifier
063 {
064 /** <STRONG>This constructor really shouldn't be here ... there are no
065 * instance methods or variables of this class, so instantiation is
066 * worthless. However, this function is in the 1.1 spec, so it is added
067 * for completeness.</STRONG>
068 */
069 public Modifier()
070 {
071 }
072
073 /**
074 * Public: accessible from any other class.
075 */
076 public static final int PUBLIC = 0x0001;
077
078 /**
079 * Private: accessible only from the same enclosing class.
080 */
081 public static final int PRIVATE = 0x0002;
082
083 /**
084 * Protected: accessible only to subclasses, or within the package.
085 */
086 public static final int PROTECTED = 0x0004;
087
088 /**
089 * Static:<br><ul>
090 * <li>Class: no enclosing instance for nested class.</li>
091 * <li>Field or Method: can be accessed or invoked without an
092 * instance of the declaring class.</li>
093 * </ul>
094 */
095 public static final int STATIC = 0x0008;
096
097 /**
098 * Final:<br><ul>
099 * <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 * GCJ-LOCAL: This access flag is set on methods we declare
182 * internally but which must not be visible to reflection.
183 */
184 static final int INVISIBLE = 0x8000;
185
186 /**
187 * GCJ-LOCAL: This access flag is set on interpreted classes.
188 */
189 static final int INTERPRETED = 0x1000;
190
191 /**
192 * Check whether the given modifier is abstract.
193 * @param mod the modifier.
194 * @return <code>true</code> if abstract, <code>false</code> otherwise.
195 */
196 public static boolean isAbstract(int mod)
197 {
198 return (mod & ABSTRACT) != 0;
199 }
200
201 /**
202 * Check whether the given modifier is final.
203 * @param mod the modifier.
204 * @return <code>true</code> if final, <code>false</code> otherwise.
205 */
206 public static boolean isFinal(int mod)
207 {
208 return (mod & FINAL) != 0;
209 }
210
211 /**
212 * Check whether the given modifier is an interface.
213 * @param mod the modifier.
214 * @return <code>true</code> if an interface, <code>false</code> otherwise.
215 */
216 public static boolean isInterface(int mod)
217 {
218 return (mod & INTERFACE) != 0;
219 }
220
221 /**
222 * Check whether the given modifier is native.
223 * @param mod the modifier.
224 * @return <code>true</code> if native, <code>false</code> otherwise.
225 */
226 public static boolean isNative(int mod)
227 {
228 return (mod & NATIVE) != 0;
229 }
230
231 /**
232 * Check whether the given modifier is private.
233 * @param mod the modifier.
234 * @return <code>true</code> if private, <code>false</code> otherwise.
235 */
236 public static boolean isPrivate(int mod)
237 {
238 return (mod & PRIVATE) != 0;
239 }
240
241 /**
242 * Check whether the given modifier is protected.
243 * @param mod the modifier.
244 * @return <code>true</code> if protected, <code>false</code> otherwise.
245 */
246 public static boolean isProtected(int mod)
247 {
248 return (mod & PROTECTED) != 0;
249 }
250
251 /**
252 * Check whether the given modifier is public.
253 * @param mod the modifier.
254 * @return <code>true</code> if public, <code>false</code> otherwise.
255 */
256 public static boolean isPublic(int mod)
257 {
258 return (mod & PUBLIC) != 0;
259 }
260
261 /**
262 * Check whether the given modifier is static.
263 * @param mod the modifier.
264 * @return <code>true</code> if static, <code>false</code> otherwise.
265 */
266 public static boolean isStatic(int mod)
267 {
268 return (mod & STATIC) != 0;
269 }
270
271 /**
272 * Check whether the given modifier is strictfp.
273 * @param mod the modifier.
274 * @return <code>true</code> if strictfp, <code>false</code> otherwise.
275 */
276 public static boolean isStrict(int mod)
277 {
278 return (mod & STRICT) != 0;
279 }
280
281 /**
282 * Check whether the given modifier is synchronized.
283 * @param mod the modifier.
284 * @return <code>true</code> if synchronized, <code>false</code> otherwise.
285 */
286 public static boolean isSynchronized(int mod)
287 {
288 return (mod & SYNCHRONIZED) != 0;
289 }
290
291 /**
292 * Check whether the given modifier is transient.
293 * @param mod the modifier.
294 * @return <code>true</code> if transient, <code>false</code> otherwise.
295 */
296 public static boolean isTransient(int mod)
297 {
298 return (mod & TRANSIENT) != 0;
299 }
300
301 /**
302 * Check whether the given modifier is volatile.
303 * @param mod the modifier.
304 * @return <code>true</code> if volatile, <code>false</code> otherwise.
305 */
306 public static boolean isVolatile(int mod)
307 {
308 return (mod & VOLATILE) != 0;
309 }
310
311 /**
312 * Get a string representation of all the modifiers represented by the
313 * given int. The keywords are printed in this order:
314 * <code><public|protected|private> abstract static final transient
315 * volatile synchronized native strictfp interface</code>.
316 *
317 * @param mod the modifier.
318 * @return the String representing the modifiers.
319 */
320 public static String toString(int mod)
321 {
322 return toString(mod, new StringBuffer()).toString();
323 }
324
325 /**
326 * Package helper method that can take a StringBuilder.
327 * @param mod the modifier
328 * @param r the StringBuilder to which the String representation is appended
329 * @return r, with information appended
330 */
331 static StringBuilder toString(int mod, StringBuilder r)
332 {
333 r.append(toString(mod, new StringBuffer()));
334 return r;
335 }
336
337 /**
338 * Package helper method that can take a StringBuffer.
339 * @param mod the modifier
340 * @param r the StringBuffer to which the String representation is appended
341 * @return r, with information appended
342 */
343 static StringBuffer toString(int mod, StringBuffer r)
344 {
345 if (isPublic(mod))
346 r.append("public ");
347 if (isProtected(mod))
348 r.append("protected ");
349 if (isPrivate(mod))
350 r.append("private ");
351 if (isAbstract(mod))
352 r.append("abstract ");
353 if (isStatic(mod))
354 r.append("static ");
355 if (isFinal(mod))
356 r.append("final ");
357 if (isTransient(mod))
358 r.append("transient ");
359 if (isVolatile(mod))
360 r.append("volatile ");
361 if (isSynchronized(mod))
362 r.append("synchronized ");
363 if (isNative(mod))
364 r.append("native ");
365 if (isStrict(mod))
366 r.append("strictfp ");
367 if (isInterface(mod))
368 r.append("interface ");
369
370 // Trim trailing space.
371 if ((mod & ALL_FLAGS) != 0)
372 r.setLength(r.length() - 1);
373 return r;
374 }
375 }