forked from DrJavaAtRice/Java8
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathModifierSet.java
More file actions
173 lines (148 loc) · 5.57 KB
/
Copy pathModifierSet.java
File metadata and controls
173 lines (148 loc) · 5.57 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
package koala.dynamicjava.tree;
import java.util.EnumSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import koala.dynamicjava.tree.visitor.Visitor;
public class ModifierSet extends Node {
private final Set<Modifier> flags;
private final List<Annotation> annotations;
public ModifierSet(Set<Modifier> flgs, List<Annotation> annots) {
this(flgs, annots, SourceInfo.NONE);
}
public ModifierSet(Set<Modifier> flgs, List<Annotation> annots, SourceInfo si) {
super(si);
flags = flgs;
annotations = annots;
}
@Override public <T> T acceptVisitor(Visitor<T> visitor) {
return visitor.visit(this);
}
public Set<Modifier> getFlags() { return flags; }
public List<Annotation> getAnnotations() { return annotations; }
/**
* Get the standard Java bit vector corresponding to {@link #getFlags}. Optionally, some flags
* can be "forced" on by providing them as arguments.
*/
public int getBitVector(Modifier... forced) {
int result = 0;
for (Modifier m : flags) {
result |= m.getBits();
}
for (Modifier m : forced) {
result |= m.getBits();
}
return result;
}
public boolean isEmpty() { return flags.isEmpty() && annotations.isEmpty(); }
public boolean isPublic() { return flags.contains(Modifier.PUBLIC); }
public boolean isPrivate() { return flags.contains(Modifier.PRIVATE); }
public boolean isProtected() { return flags.contains(Modifier.PROTECTED); }
public boolean isStatic() { return flags.contains(Modifier.STATIC); }
public boolean isFinal() { return flags.contains(Modifier.FINAL); }
public boolean isAbstract() { return flags.contains(Modifier.ABSTRACT); }
public boolean isVolatile() { return flags.contains(Modifier.VOLATILE); }
public boolean isTransient() { return flags.contains(Modifier.TRANSIENT); }
public boolean isSynchronized() { return flags.contains(Modifier.SYNCHRONIZED); }
public boolean isNative() { return flags.contains(Modifier.NATIVE); }
public boolean isStrict() { return flags.contains(Modifier.STRICT); }
public boolean isInterface() { return flags.contains(Modifier.INTERFACE); }
public boolean isAnnotation() { return flags.contains(Modifier.ANNOTATION); }
public boolean isEnum() { return flags.contains(Modifier.ENUM); }
public boolean isBridge() { return flags.contains(Modifier.BRIDGE); }
public boolean isVarargs() { return flags.contains(Modifier.VARARGS); }
public boolean isSynthetic() { return flags.contains(Modifier.SYNTHETIC); }
public String toString() {
return "(" + getClass().getName() + ": " + flags + ", " + annotations + ")";
}
public static ModifierSet make() {
return new ModifierSet(EnumSet.noneOf(Modifier.class), new LinkedList<Annotation>());
}
public static ModifierSet make(Modifier mod, Modifier... mods) {
return new ModifierSet(EnumSet.of(mod, mods), new LinkedList<Annotation>());
}
public static ModifierSet make(Annotation ann, Annotation... anns) {
LinkedList<Annotation> l = new LinkedList<Annotation>();
l.add(ann);
for (Annotation a : anns) { l.add(a); }
return new ModifierSet(EnumSet.noneOf(Modifier.class), l);
}
public enum Modifier {
PUBLIC {
public int getBits() { return 0x0001; }
public String getName() { return "public"; }
},
PRIVATE {
public int getBits() { return 0x0002; }
public String getName() { return "private"; }
},
PROTECTED {
public int getBits() { return 0x0004; }
public String getName() { return "protected"; }
},
STATIC {
public int getBits() { return 0x0008; }
public String getName() { return "static"; }
},
FINAL {
public int getBits() { return 0x0010; }
public String getName() { return "final"; }
},
ABSTRACT {
public int getBits() { return 0x0400; }
public String getName() { return "abstract"; }
},
VOLATILE {
public int getBits() { return 0x0040; }
public String getName() { return "volatile"; }
},
TRANSIENT {
public int getBits() { return 0x0080; }
public String getName() { return "transient"; }
},
SYNCHRONIZED {
public int getBits() { return 0x0020; }
public String getName() { return "synchronized"; }
},
DEFAULT {
public int getBits() { return 0x8000; }
public String getName() { return "default"; }
},
NATIVE {
public int getBits() { return 0x0100; }
public String getName() { return "native"; }
},
STRICT {
public int getBits() { return 0x0800; }
public String getName() { return "strictfp"; }
},
INTERFACE {
public int getBits() { return 0x0200; }
public String getName() { return "[interface]"; }
},
ANNOTATION {
public int getBits() { return 0x2000; }
public String getName() { return "[annotation]"; }
},
ENUM {
public int getBits() { return 0x4000; }
public String getName() { return "[enum]"; }
},
BRIDGE {
public int getBits() { return 0x0040; }
public String getName() { return "[bridge]"; }
},
VARARGS {
public int getBits() { return 0x0080; }
public String getName() { return "[varargs]"; }
},
SYNTHETIC {
public int getBits() { return 0x1000; }
public String getName() { return "[synthetic]"; }
};
/** Get the bit mask used by the JVM to represent this modifier. */
public abstract int getBits();
/** Get the string used to represent this modifier in source code. Implicit modifiers are bracketed. */
public abstract String getName();
}
}