KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > cojen > classfile > Modifiers


1 /*
2  * Copyright 2004 Brian S O'Neill
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package org.cojen.classfile;
18
19 import java.lang.reflect.Modifier JavaDoc;
20
21 /**
22  * The Modifiers class is an immutable wrapper around a modifier bitmask. The
23  * methods provided to manipulate the bitmask ensure that it is always
24  * legal. i.e. setting it public automatically clears it from being private or
25  * protected.
26  *
27  * @author Brian S O'Neill
28  */
29 public class Modifiers {
30     public static final Modifiers NONE;
31     public static final Modifiers PUBLIC;
32     public static final Modifiers PUBLIC_ABSTRACT;
33     public static final Modifiers PUBLIC_STATIC;
34     public static final Modifiers PROTECTED;
35     public static final Modifiers PRIVATE;
36
37     static {
38         NONE = new Modifiers(0);
39         PUBLIC = new Modifiers(Modifier.PUBLIC);
40         PUBLIC_ABSTRACT = new Modifiers(Modifier.PUBLIC | Modifier.ABSTRACT);
41         PUBLIC_STATIC = new Modifiers(Modifier.PUBLIC | Modifier.STATIC);
42         PROTECTED = new Modifiers(Modifier.PROTECTED);
43         PRIVATE = new Modifiers(Modifier.PRIVATE);
44     }
45
46     /**
47      * Returns a Modifiers object with the given bitmask.
48      */
49     public static Modifiers getInstance(int bitmask) {
50         switch (bitmask) {
51         case 0:
52             return NONE;
53         case Modifier.PUBLIC:
54             return PUBLIC;
55         case Modifier.PUBLIC | Modifier.ABSTRACT:
56             return PUBLIC_ABSTRACT;
57         case Modifier.PUBLIC | Modifier.STATIC:
58             return PUBLIC_STATIC;
59         case Modifier.PROTECTED:
60             return PROTECTED;
61         case Modifier.PRIVATE:
62             return PRIVATE;
63         }
64
65         return new Modifiers(bitmask);
66     }
67
68     private static int toPublic(int bitmask, boolean b) {
69         if (b) {
70             return (bitmask | Modifier.PUBLIC) & (~Modifier.PROTECTED & ~Modifier.PRIVATE);
71         } else {
72             return bitmask & ~Modifier.PUBLIC;
73         }
74     }
75     
76     private static int toPrivate(int bitmask, boolean b) {
77         if (b) {
78             return (bitmask | Modifier.PRIVATE) & (~Modifier.PUBLIC & ~Modifier.PROTECTED);
79         } else {
80             return bitmask & ~Modifier.PRIVATE;
81         }
82     }
83
84     private static int toProtected(int bitmask, boolean b) {
85         if (b) {
86             return (bitmask | Modifier.PROTECTED) & (~Modifier.PUBLIC & ~Modifier.PRIVATE);
87         } else {
88             return bitmask & ~Modifier.PROTECTED;
89         }
90     }
91     
92     private static int toStatic(int bitmask, boolean b) {
93         if (b) {
94             return bitmask | Modifier.STATIC;
95         } else {
96             return bitmask & ~Modifier.STATIC;
97         }
98     }
99
100     private static int toFinal(int bitmask, boolean b) {
101         if (b) {
102             return (bitmask | Modifier.FINAL) & (~Modifier.INTERFACE & ~Modifier.ABSTRACT);
103         } else {
104             return bitmask & ~Modifier.FINAL;
105         }
106     }
107     
108     private static int toSynchronized(int bitmask, boolean b) {
109         if (b) {
110             return (bitmask | Modifier.SYNCHRONIZED) &
111                 (~Modifier.VOLATILE & ~Modifier.TRANSIENT & ~Modifier.INTERFACE);
112         } else {
113             return bitmask & ~Modifier.SYNCHRONIZED;
114         }
115     }
116     
117     private static int toVolatile(int bitmask, boolean b) {
118         if (b) {
119             return (bitmask | Modifier.VOLATILE) &
120                 (~Modifier.SYNCHRONIZED & ~Modifier.NATIVE & ~Modifier.INTERFACE &
121                  ~Modifier.ABSTRACT & ~Modifier.STRICT);
122         } else {
123             return bitmask & ~Modifier.VOLATILE;
124         }
125     }
126     
127     private static int toTransient(int bitmask, boolean b) {
128         if (b) {
129             return (bitmask | Modifier.TRANSIENT) &
130                 (~Modifier.SYNCHRONIZED & ~Modifier.NATIVE &
131                  ~Modifier.INTERFACE & ~Modifier.ABSTRACT & ~Modifier.STRICT);
132         } else {
133             return bitmask & ~Modifier.TRANSIENT;
134         }
135     }
136     
137     private static int toNative(int bitmask, boolean b) {
138         if (b) {
139             return (bitmask | Modifier.NATIVE) &
140                 (~Modifier.VOLATILE & ~Modifier.TRANSIENT &
141                  ~Modifier.INTERFACE & ~Modifier.ABSTRACT & ~Modifier.STRICT);
142         } else {
143             return bitmask & ~Modifier.NATIVE;
144         }
145     }
146     
147     private static int toInterface(int bitmask, boolean b) {
148         if (b) {
149             return (bitmask | (Modifier.INTERFACE | Modifier.ABSTRACT)) &
150                 (~Modifier.FINAL & ~Modifier.SYNCHRONIZED &
151                  ~Modifier.VOLATILE & ~Modifier.TRANSIENT & ~Modifier.NATIVE);
152         } else {
153             return bitmask & ~Modifier.INTERFACE;
154         }
155     }
156
157     private static int toAbstract(int bitmask, boolean b) {
158         if (b) {
159             return (bitmask | Modifier.ABSTRACT) &
160                 (~Modifier.FINAL & ~Modifier.VOLATILE & ~Modifier.TRANSIENT & ~Modifier.NATIVE &
161                  ~Modifier.SYNCHRONIZED & ~Modifier.STRICT);
162         } else {
163             return bitmask & ~Modifier.ABSTRACT & ~Modifier.INTERFACE;
164         }
165     }
166
167     private static int toStrict(int bitmask, boolean b) {
168         if (b) {
169             return bitmask | Modifier.STRICT;
170         } else {
171             return bitmask & ~Modifier.STRICT;
172         }
173     }
174
175     private static int toBridge(int bitmask, boolean b) {
176         // Bridge re-uses the Modifier.VOLATILE modifier, which used to only
177 // apply to fields.
178 if (b) {
179             return (bitmask | Modifier.VOLATILE) &
180                 (~Modifier.NATIVE & ~Modifier.INTERFACE & ~Modifier.ABSTRACT);
181         } else {
182             return bitmask & ~Modifier.VOLATILE;
183         }
184     }
185
186     private static int toEnum(int bitmask, boolean b) {
187         // Enum re-uses the Modifier.NATIVE modifier, which used to only apply
188 // to methods.
189 if (b) {
190             return (bitmask | Modifier.NATIVE) &
191                 (~Modifier.ABSTRACT & ~Modifier.INTERFACE &
192                  ~Modifier.STRICT & ~Modifier.SYNCHRONIZED);
193         } else {
194             return bitmask & ~Modifier.NATIVE;
195         }
196     }
197
198     private static int toVarArgs(int bitmask, boolean b) {
199         // Enum re-uses the Modifier.TRANSIENT modifier, which used to only
200 // apply to fields.
201 if (b) {
202             return (bitmask | Modifier.TRANSIENT) &
203                 (~Modifier.INTERFACE & ~Modifier.VOLATILE);
204         } else {
205             return bitmask & ~Modifier.TRANSIENT;
206         }
207     }
208
209     private final int mBitmask;
210     
211     private Modifiers(int bitmask) {
212         mBitmask = bitmask;
213     }
214
215     /**
216      * Returns the bitmask.
217      */
218     public final int getBitmask() {
219         return mBitmask;
220     }
221     
222     public boolean isPublic() {
223         return Modifier.isPublic(mBitmask);
224     }
225
226     public boolean isPrivate() {
227         return Modifier.isPrivate(mBitmask);
228     }
229
230     public boolean isProtected() {
231         return Modifier.isProtected(mBitmask);
232     }
233     
234     public boolean isStatic() {
235         return Modifier.isStatic(mBitmask);
236     }
237
238     public boolean isFinal() {
239         return Modifier.isFinal(mBitmask);
240     }
241
242     public boolean isSynchronized() {
243         return Modifier.isSynchronized(mBitmask);
244     }
245
246     public boolean isVolatile() {
247         return Modifier.isVolatile(mBitmask);
248     }
249
250     public boolean isTransient() {
251         return Modifier.isTransient(mBitmask);
252     }
253     
254     public boolean isNative() {
255         return Modifier.isNative(mBitmask);
256     }
257     
258     public boolean isInterface() {
259         return Modifier.isInterface(mBitmask);
260     }
261     
262     public boolean isAbstract() {
263         return Modifier.isAbstract(mBitmask);
264     }
265
266     public boolean isStrict() {
267         return Modifier.isStrict(mBitmask);
268     }
269
270     public boolean isBridge() {
271         return Modifier.isVolatile(mBitmask);
272     }
273
274     public boolean isEnum() {
275         return Modifier.isNative(mBitmask);
276     }
277
278     public boolean isVarArgs() {
279         return Modifier.isTransient(mBitmask);
280     }
281
282     /**
283      * When set public, the bitmask is cleared from being private or protected.
284      *
285      * @param b true to set public, false otherwise
286      */
287     public Modifiers toPublic(boolean b) {
288         return convert(toPublic(mBitmask, b));
289     }
290     
291     /**
292      * When set private, the bitmask is cleared from being public or protected.
293      *
294      * @param b true to set private, false otherwise
295      */
296     public Modifiers toPrivate(boolean b) {
297         return convert(toPrivate(mBitmask, b));
298     }
299
300     /**
301      * When set protected, the bitmask is cleared from being public or private.
302      *
303      * @param b true to set protected, false otherwise
304      */
305     public Modifiers toProtected(boolean b) {
306         return convert(toProtected(mBitmask, b));
307     }
308
309     /**
310      * @param b true to set static, false otherwise
311      */
312     public Modifiers toStatic(boolean b) {
313         return convert(toStatic(mBitmask, b));
314     }
315
316     /**
317      * When set final, the bitmask is cleared from being an interface or
318      * abstract.
319      *
320      * @param b true to set final, false otherwise
321      */
322     public Modifiers toFinal(boolean b) {
323         return convert(toFinal(mBitmask, b));
324     }
325
326     /**
327      * When set synchronized, non-method settings are cleared.
328      *
329      * @param b true to set synchronized, false otherwise
330      */
331     public Modifiers toSynchronized(boolean b) {
332         return convert(toSynchronized(mBitmask, b));
333     }
334
335     /**
336      * When set volatile, non-field settings are cleared.
337      *
338      * @param b true to set volatile, false otherwise
339      */
340     public Modifiers toVolatile(boolean b) {
341         return convert(toVolatile(mBitmask, b));
342     }
343
344     /**
345      * When set transient, non-field settings are cleared.
346      *
347      * @param b true to set transient, false otherwise
348      */
349     public Modifiers toTransient(boolean b) {
350         return convert(toTransient(mBitmask, b));
351     }
352
353     /**
354      * When set native, non-native-method settings are cleared.
355      *
356      * @param b true to set native, false otherwise
357      */
358     public Modifiers toNative(boolean b) {
359         return convert(toNative(mBitmask, b));
360     }
361
362     /**
363      * When set as an interface, non-interface settings are cleared and the
364      * bitmask is set abstract.
365      *
366      * @param b true to set interface, false otherwise
367      */
368     public Modifiers toInterface(boolean b) {
369         return convert(toInterface(mBitmask, b));
370     }
371
372     /**
373      * When set abstract, the bitmask is cleared from being final, volatile,
374      * transient, native, synchronized, and strictfp. When cleared from being
375      * abstract, the bitmask is also cleared from being an interface.
376      *
377      * @param b true to set abstract, false otherwise
378      */
379     public Modifiers toAbstract(boolean b) {
380         return convert(toAbstract(mBitmask, b));
381     }
382
383     /**
384      * @param b true to set strictfp, false otherwise
385      */
386     public Modifiers toStrict(boolean b) {
387         return convert(toStrict(mBitmask, b));
388     }
389
390     /**
391      * Used to identify if a method is a bridge method.
392      *
393      * @param b true to set bridge, false otherwise
394      */
395     public Modifiers toBridge(boolean b) {
396         return convert(toBridge(mBitmask, b));
397     }
398
399     /**
400      * Used to identify if a field is an enum constant.
401      *
402      * @param b true to set enum, false otherwise
403      */
404     public Modifiers toEnum(boolean b) {
405         return convert(toEnum(mBitmask, b));
406     }
407
408     /**
409      * Used to identify if a method accepts a variable amount of
410      * arguments.
411      *
412      * @param b true to set varargs, false otherwise
413      */
414     public Modifiers toVarArgs(boolean b) {
415         return convert(toVarArgs(mBitmask, b));
416     }
417
418     public int hashCode() {
419         return mBitmask;
420     }
421
422     public boolean equals(Object JavaDoc obj) {
423         if (this == obj) {
424             return true;
425         }
426         if (obj instanceof Modifiers) {
427             Modifiers other = (Modifiers)obj;
428             return mBitmask == other.mBitmask;
429         }
430         return false;
431     }
432
433     /**
434      * Returns the string value generated by the Modifier class.
435      *
436      * @see java.lang.reflect.Modifier#toString()
437      */
438     public String JavaDoc toString() {
439         return Modifier.toString(mBitmask);
440     }
441
442     private Modifiers convert(int bitmask) {
443         return bitmask == mBitmask ? this : getInstance(bitmask);
444     }
445 }
446
Popular Tags