1 /*
2 * Copyright (c) 1999, 2022, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.tools.javac.code;
27
28 import java.util.Collections;
29 import java.util.EnumSet;
30 import java.util.Map;
31 import java.util.Set;
32 import java.util.concurrent.ConcurrentHashMap;
33
34 import javax.lang.model.element.Modifier;
35
36 import com.sun.tools.javac.util.Assert;
37 import com.sun.tools.javac.util.StringUtils;
38
39 /** Access flags and other modifiers for Java classes and members.
40 *
41 * <p><b>This is NOT part of any supported API.
42 * If you write code that depends on this, you do so at your own risk.
43 * This code and its internal interfaces are subject to change or
44 * deletion without notice.</b>
45 */
46 public class Flags {
47
48 private Flags() {} // uninstantiable
49
50 public static String toString(long flags) {
51 StringBuilder buf = new StringBuilder();
52 String sep = "";
53 for (Flag flag : asFlagSet(flags)) {
54 buf.append(sep);
55 buf.append(flag);
56 sep = " ";
57 }
58 return buf.toString();
59 }
60
61 public static EnumSet<Flag> asFlagSet(long flags) {
62 EnumSet<Flag> flagSet = EnumSet.noneOf(Flag.class);
63 for (Flag flag : Flag.values()) {
64 if ((flags & flag.value) != 0) {
65 flagSet.add(flag);
66 flags &= ~flag.value;
67 }
68 }
69 Assert.check(flags == 0);
70 return flagSet;
71 }
72
73 /* Standard Java flags.
74 */
75 public static final int PUBLIC = 1;
76 public static final int PRIVATE = 1<<1;
77 public static final int PROTECTED = 1<<2;
78 public static final int STATIC = 1<<3;
79 public static final int FINAL = 1<<4;
80 public static final int SYNCHRONIZED = 1<<5;
81 public static final int VOLATILE = 1<<6;
82 public static final int TRANSIENT = 1<<7;
83 public static final int NATIVE = 1<<8;
84 public static final int INTERFACE = 1<<9;
85 public static final int ABSTRACT = 1<<10;
86 public static final int STRICTFP = 1<<11;
87
88 /* Flag that marks a symbol synthetic, added in classfile v49.0. */
89 public static final int SYNTHETIC = 1<<12;
90
91 /** Flag that marks attribute interfaces, added in classfile v49.0. */
92 public static final int ANNOTATION = 1<<13;
93
94 /** An enumeration type or an enumeration constant, added in
95 * classfile v49.0. */
96 public static final int ENUM = 1<<14;
97
98 /** Added in SE8, represents constructs implicitly declared in source. */
99 public static final int MANDATED = 1<<15;
100
101 /** Marks a type as a primitive class. We can't reuse the class file encoding (ACC_PRIMITIVE)
102 * since the latter shares its value (0x800) with ACC_STRICT (javac speak: STRICT_FP) and while
103 * STRICT_FP is not a valid flag for a class in the class file level, javac's ASTs flag a class
104 * as being STRICT_FP so as to propagate the FP strictness to methods of the class thereby causing
105 * a clash */
106 public static final int PRIMITIVE_CLASS = 1<<16;
107
108 public static final int StandardFlags = 0x0fff;
109
110 // Because the following access flags are overloaded with other
111 // bit positions, we translate them when reading and writing class
112 // files into unique bits positions: ACC_SYNTHETIC <-> SYNTHETIC,
113 // for example.
114 public static final int ACC_IDENTITY = 0x0020;
115 public static final int ACC_VALUE = 0x0040;
116 public static final int ACC_BRIDGE = 0x0040;
117 public static final int ACC_VARARGS = 0x0080;
118 public static final int ACC_PRIMITIVE = 0x0800;
119 public static final int ACC_MODULE = 0x8000;
120
121 /*****************************************
122 * Internal compiler flags (no bits in the lower 16).
123 *****************************************/
124
125 /** Flag is set if symbol is deprecated. See also DEPRECATED_REMOVAL.
126 */
127 public static final int DEPRECATED = 1<<17;
128
129 /** Flag is set for a variable symbol if the variable's definition
130 * has an initializer part.
131 */
132 public static final int HASINIT = 1<<18;
133
134 /** Flag is set for a class symbol if it defines one or more non-empty
135 * instance initializer block(s). This is relevenat only for class symbols
136 * that originate from source types. For binary types the instance initializer
137 * blocks are "normalized" into the constructors.
138 */
139 public static final int HASINITBLOCK = 1<<18;
140
141 /** Flag is set for a method symbol if it is an empty no-arg ctor.
142 * i.e. one that simply returns (jlO) or merely chains to a super's
143 * no-arg ctor
144 */
145 public static final int EMPTYNOARGCONSTR = 1<<18;
146
147 /** Flag is set for a class or interface whose instances have identity
148 * i.e. class/interface declarations that are expressly declared with
149 * the modifier `identity' or (b) any concrete class not declared with the
150 * modifier `value' (c) abstract class not declared `value' but meets various
151 * stipulations (d) older class files with ACC_SUPER bit set
152 */
153 public static final int IDENTITY_TYPE = 1<<19;
154
155 /** Flag is set for compiler-generated anonymous method symbols
156 * that `own' an initializer block.
157 */
158 public static final int BLOCK = 1<<20;
159
160 /** Marks a type as a value class */
161 public static final int VALUE_CLASS = 1<<20;
162
163 /** Flag is set for ClassSymbols that are being compiled from source.
164 */
165 public static final int FROM_SOURCE = 1<<21; //ClassSymbols
166
167 /** Flag is set for nested classes that do not access instance members
168 * or `this' of an outer class and therefore don't need to be passed
169 * a this$n reference. This value is currently set only for anonymous
170 * classes in superclass constructor calls.
171 * todo: use this value for optimizing away this$n parameters in
172 * other cases.
173 */
174 public static final int NOOUTERTHIS = 1<<22;
175
176 /** Flag is set for package symbols if a package has a member or
177 * directory and therefore exists.
178 */
179 public static final int EXISTS = 1<<23;
180
181 /** Flag is set for compiler-generated compound classes
182 * representing multiple variable bounds
183 */
184 public static final int COMPOUND = 1<<24;
185
186 /** Flag is set for class symbols if a class file was found for this class.
187 */
188 public static final int CLASS_SEEN = 1<<25;
189
190 /** Flag is set for class symbols if a source file was found for this
191 * class.
192 */
193 public static final int SOURCE_SEEN = 1<<26;
194
195 /* State flags (are reset during compilation).
196 */
197
198 /** Flag for class symbols is set and later re-set as a lock in
199 * Enter to detect cycles in the superclass/superinterface
200 * relations. Similarly for constructor call cycle detection in
201 * Attr.
202 */
203 public static final int LOCKED = 1<<27;
204
205 /** Flag for class symbols is set and later re-set to indicate that a class
206 * has been entered but has not yet been attributed.
207 */
208 public static final int UNATTRIBUTED = 1<<28;
209
210 /** Flag for synthesized default constructors of anonymous classes.
211 */
212 public static final int ANONCONSTR = 1<<29; //non-class members
213
214 /**
215 * Flag to indicate the superclasses of this ClassSymbol has been attributed.
216 */
217 public static final int SUPER_OWNER_ATTRIBUTED = 1<<29; //ClassSymbols
218
219 /** Flag for class symbols to indicate it has been checked and found
220 * acyclic.
221 */
222 public static final int ACYCLIC = 1<<30;
223
224 /** Flag that marks bridge methods.
225 */
226 public static final long BRIDGE = 1L<<31;
227
228 /** Flag that marks formal parameters.
229 */
230 public static final long PARAMETER = 1L<<33;
231
232 /** Flag that marks varargs methods.
233 */
234 public static final long VARARGS = 1L<<34;
235
236 /** Flag for annotation type symbols to indicate it has been
237 * checked and found acyclic.
238 */
239 public static final long ACYCLIC_ANN = 1L<<35;
240
241 /** Flag that marks a generated default constructor.
242 */
243 public static final long GENERATEDCONSTR = 1L<<36;
244
245 /** Flag that marks a hypothetical method that need not really be
246 * generated in the binary, but is present in the symbol table to
247 * simplify checking for erasure clashes - also used for 292 poly sig methods.
248 */
249 public static final long HYPOTHETICAL = 1L<<37;
250
251 /**
252 * Flag that marks an internal proprietary class.
253 */
254 public static final long PROPRIETARY = 1L<<38;
255
256 /**
257 * Flag that marks a multi-catch parameter.
258 */
259 public static final long UNION = 1L<<39;
260
261 /**
262 * Flags an erroneous TypeSymbol as viable for recovery.
263 * TypeSymbols only.
264 */
265 public static final long RECOVERABLE = 1L<<40;
266
267 /**
268 * Flag that marks an 'effectively final' local variable.
269 */
270 public static final long EFFECTIVELY_FINAL = 1L<<41;
271
272 /**
273 * Flag that marks non-override equivalent methods with the same signature,
274 * or a conflicting match binding (BindingSymbol).
275 */
276 public static final long CLASH = 1L<<42;
277
278 /**
279 * Flag that marks either a default method or an interface containing default methods.
280 */
281 public static final long DEFAULT = 1L<<43;
282
283 /**
284 * Flag that marks class as auxiliary, ie a non-public class following
285 * the public class in a source file, that could block implicit compilation.
286 */
287 public static final long AUXILIARY = 1L<<44;
288
289 /**
290 * Flag that marks that a symbol is not available in the current profile
291 */
292 public static final long NOT_IN_PROFILE = 1L<<45;
293
294 /**
295 * Flag that indicates that an override error has been detected by Check.
296 */
297 public static final long BAD_OVERRIDE = 1L<<45;
298
299 /**
300 * Flag that indicates a signature polymorphic method (292).
301 */
302 public static final long SIGNATURE_POLYMORPHIC = 1L<<46;
303
304 /**
305 * Flag that indicates that an inference variable is used in a 'throws' clause.
306 */
307 public static final long THROWS = 1L<<47;
308
309 /**
310 * Flag that marks potentially ambiguous overloads
311 */
312 public static final long POTENTIALLY_AMBIGUOUS = 1L<<48;
313
314 /**
315 * Flag that marks a synthetic method body for a lambda expression
316 */
317 public static final long LAMBDA_METHOD = 1L<<49;
318
319 /**
320 * Flag to control recursion in TransTypes
321 */
322 public static final long TYPE_TRANSLATED = 1L<<50;
323
324 /**
325 * Flag to indicate class symbol is for module-info
326 */
327 public static final long MODULE = 1L<<51;
328
329 /**
330 * Flag to indicate the given ModuleSymbol is an automatic module.
331 */
332 public static final long AUTOMATIC_MODULE = 1L<<52; //ModuleSymbols only
333
334 /**
335 * Flag to indicate the given PackageSymbol contains any non-.java and non-.class resources.
336 */
337 public static final long HAS_RESOURCE = 1L<<52; //PackageSymbols only
338
339 /**
340 * Flag to indicate the given ParamSymbol has a user-friendly name filled.
341 */
342 public static final long NAME_FILLED = 1L<<52; //ParamSymbols only
343
344 /**
345 * Flag to indicate the given ModuleSymbol is a system module.
346 */
347 public static final long SYSTEM_MODULE = 1L<<53; //ModuleSymbols only
348
349 /**
350 * Flag to indicate the given ClassSymbol is a value based.
351 */
352 public static final long VALUE_BASED = 1L<<53; //ClassSymbols only
353
354 /**
355 * Flag to indicate the given symbol has a @Deprecated annotation.
356 */
357 public static final long DEPRECATED_ANNOTATION = 1L<<54;
358
359 /**
360 * Flag to indicate the given symbol has been deprecated and marked for removal.
361 */
362 public static final long DEPRECATED_REMOVAL = 1L<<55;
363
364 /**
365 * Flag to indicate the API element in question is for a preview API.
366 */
367 public static final long PREVIEW_API = 1L<<56; //any Symbol kind
368
369 /**
370 * Flag for synthesized default constructors of anonymous classes that have an enclosing expression.
371 */
372 public static final long ANONCONSTR_BASED = 1L<<57;
373
374 /**
375 * Flag that marks finalize block as body-only, should not be copied into catch clauses.
376 * Used to implement try-with-resources.
377 */
378 public static final long BODY_ONLY_FINALIZE = 1L<<17; //blocks only
379
380 /**
381 * Flag to indicate the API element in question is for a preview API.
382 */
383 public static final long PREVIEW_REFLECTIVE = 1L<<58; //any Symbol kind
384
385 /**
386 * Flag to indicate the given variable is a match binding variable.
387 */
388 public static final long MATCH_BINDING = 1L<<59;
389
390 /**
391 * A flag to indicate a match binding variable whose scope extends after the current statement.
392 */
393 public static final long MATCH_BINDING_TO_OUTER = 1L<<60;
394
395 /**
396 * Flag to indicate that a class is a record. The flag is also used to mark fields that are
397 * part of the state vector of a record and to mark the canonical constructor
398 */
399 public static final long RECORD = 1L<<61; // ClassSymbols, MethodSymbols and VarSymbols
400
401 /**
402 * Flag to mark a record constructor as a compact one
403 */
404 public static final long COMPACT_RECORD_CONSTRUCTOR = 1L<<51; // MethodSymbols only
405
406 /**
407 * Flag to mark a record field that was not initialized in the compact constructor
408 */
409 public static final long UNINITIALIZED_FIELD= 1L<<51; // VarSymbols only
410
411 /** Flag is set for compiler-generated record members, it could be applied to
412 * accessors and fields
413 */
414 public static final int GENERATED_MEMBER = 1<<24; // MethodSymbols and VarSymbols
415
416 /**
417 * Flag to indicate sealed class/interface declaration.
418 */
419 public static final long SEALED = 1L<<62; // ClassSymbols
420
421 /**
422 * Flag to indicate that the class/interface was declared with the non-sealed modifier.
423 */
424 public static final long NON_SEALED = 1L<<63; // ClassSymbols
425
426
427 /** Modifier masks.
428 */
429 public static final int
430 AccessFlags = PUBLIC | PROTECTED | PRIVATE,
431 LocalClassFlags = FINAL | ABSTRACT | STRICTFP | ENUM | SYNTHETIC | ACC_IDENTITY,
432 StaticLocalClassFlags = LocalClassFlags | STATIC | INTERFACE,
433 MemberClassFlags = LocalClassFlags | INTERFACE | AccessFlags,
434 MemberStaticClassFlags = MemberClassFlags | STATIC,
435 ClassFlags = LocalClassFlags | INTERFACE | PUBLIC | ANNOTATION,
436 InterfaceVarFlags = FINAL | STATIC | PUBLIC,
437 VarFlags = AccessFlags | FINAL | STATIC |
438 VOLATILE | TRANSIENT | ENUM,
439 ConstructorFlags = AccessFlags,
440 InterfaceMethodFlags = ABSTRACT | PUBLIC,
441 MethodFlags = AccessFlags | ABSTRACT | STATIC | NATIVE |
442 SYNCHRONIZED | FINAL | STRICTFP,
443 RecordMethodFlags = AccessFlags | ABSTRACT | STATIC |
444 SYNCHRONIZED | FINAL | STRICTFP,
445 AdjustedClassFlags = ClassFlags | ACC_PRIMITIVE | ACC_VALUE;
446 public static final long
447 ExtendedStandardFlags = (long)StandardFlags | DEFAULT | SEALED | NON_SEALED | PRIMITIVE_CLASS | VALUE_CLASS,
448 ExtendedMemberClassFlags = (long)MemberClassFlags | SEALED | NON_SEALED | PRIMITIVE_CLASS | VALUE_CLASS,
449 ExtendedMemberStaticClassFlags = (long) MemberStaticClassFlags | SEALED | NON_SEALED | PRIMITIVE_CLASS | VALUE_CLASS,
450 ExtendedClassFlags = (long)ClassFlags | SEALED | NON_SEALED | PRIMITIVE_CLASS | VALUE_CLASS,
451 ExtendedLocalClassFlags = (long) LocalClassFlags | PRIMITIVE_CLASS | VALUE_CLASS,
452 ExtendedStaticLocalClassFlags = (long) StaticLocalClassFlags | PRIMITIVE_CLASS | VALUE_CLASS,
453 ModifierFlags = ((long)StandardFlags & ~INTERFACE) | DEFAULT | SEALED | NON_SEALED | PRIMITIVE_CLASS | VALUE_CLASS,
454 InterfaceMethodMask = ABSTRACT | PRIVATE | STATIC | PUBLIC | STRICTFP | DEFAULT,
455 AnnotationTypeElementMask = ABSTRACT | PUBLIC,
456 LocalVarFlags = FINAL | PARAMETER,
457 ReceiverParamFlags = PARAMETER;
458
459 public static Set<Modifier> asModifierSet(long flags) {
460 Set<Modifier> modifiers = modifierSets.get(flags);
461 if (modifiers == null) {
462 modifiers = java.util.EnumSet.noneOf(Modifier.class);
463 if (0 != (flags & PUBLIC)) modifiers.add(Modifier.PUBLIC);
464 if (0 != (flags & PROTECTED)) modifiers.add(Modifier.PROTECTED);
465 if (0 != (flags & PRIVATE)) modifiers.add(Modifier.PRIVATE);
466 if (0 != (flags & ABSTRACT)) modifiers.add(Modifier.ABSTRACT);
467 if (0 != (flags & STATIC)) modifiers.add(Modifier.STATIC);
468 if (0 != (flags & SEALED)) modifiers.add(Modifier.SEALED);
469 if (0 != (flags & NON_SEALED))
470 modifiers.add(Modifier.NON_SEALED);
471 if (0 != (flags & FINAL)) modifiers.add(Modifier.FINAL);
472 if (0 != (flags & TRANSIENT)) modifiers.add(Modifier.TRANSIENT);
473 if (0 != (flags & VOLATILE)) modifiers.add(Modifier.VOLATILE);
474 if (0 != (flags & SYNCHRONIZED))
475 modifiers.add(Modifier.SYNCHRONIZED);
476 if (0 != (flags & NATIVE)) modifiers.add(Modifier.NATIVE);
477 if (0 != (flags & STRICTFP)) modifiers.add(Modifier.STRICTFP);
478 if (0 != (flags & DEFAULT)) modifiers.add(Modifier.DEFAULT);
479 if (0 != (flags & PRIMITIVE_CLASS)) modifiers.add(Modifier.PRIMITIVE);
480 if (0 != (flags & VALUE_CLASS)) modifiers.add(Modifier.VALUE);
481 modifiers = Collections.unmodifiableSet(modifiers);
482 modifierSets.put(flags, modifiers);
483 }
484 return modifiers;
485 }
486
487 // Cache of modifier sets.
488 private static final Map<Long, Set<Modifier>> modifierSets = new ConcurrentHashMap<>(64);
489
490 public static boolean isStatic(Symbol symbol) {
491 return (symbol.flags() & STATIC) != 0;
492 }
493
494 public static boolean isEnum(Symbol symbol) {
495 return (symbol.flags() & ENUM) != 0;
496 }
497
498 public static boolean isConstant(Symbol.VarSymbol symbol) {
499 return symbol.getConstValue() != null;
500 }
501
502
503 public enum Flag {
504 PUBLIC(Flags.PUBLIC),
505 PRIVATE(Flags.PRIVATE),
506 PROTECTED(Flags.PROTECTED),
507 STATIC(Flags.STATIC),
508 FINAL(Flags.FINAL),
509 SYNCHRONIZED(Flags.SYNCHRONIZED),
510 VOLATILE(Flags.VOLATILE),
511 TRANSIENT(Flags.TRANSIENT),
512 NATIVE(Flags.NATIVE),
513 INTERFACE(Flags.INTERFACE),
514 ABSTRACT(Flags.ABSTRACT),
515 DEFAULT(Flags.DEFAULT),
516 STRICTFP(Flags.STRICTFP),
517 BRIDGE(Flags.BRIDGE),
518 SYNTHETIC(Flags.SYNTHETIC),
519 ANNOTATION(Flags.ANNOTATION),
520 DEPRECATED(Flags.DEPRECATED),
521 HASINIT(Flags.HASINIT),
522 HASINITBLOCK(Flags.HASINITBLOCK),
523 EMPTYNOARGCONSTR(Flags.EMPTYNOARGCONSTR),
524 IDENTITY_TYPE(Flags.IDENTITY_TYPE) {
525 @Override
526 public String toString() {
527 return "identity";
528 }
529 },
530 BLOCK(Flags.BLOCK),
531 FROM_SOURCE(Flags.FROM_SOURCE),
532 ENUM(Flags.ENUM),
533 MANDATED(Flags.MANDATED),
534 PRIMITIVE(Flags.PRIMITIVE_CLASS),
535 VALUE(Flags.VALUE_CLASS),
536 NOOUTERTHIS(Flags.NOOUTERTHIS),
537 EXISTS(Flags.EXISTS),
538 COMPOUND(Flags.COMPOUND),
539 CLASS_SEEN(Flags.CLASS_SEEN),
540 SOURCE_SEEN(Flags.SOURCE_SEEN),
541 LOCKED(Flags.LOCKED),
542 UNATTRIBUTED(Flags.UNATTRIBUTED),
543 ANONCONSTR(Flags.ANONCONSTR),
544 ACYCLIC(Flags.ACYCLIC),
545 PARAMETER(Flags.PARAMETER),
546 VARARGS(Flags.VARARGS),
547 ACYCLIC_ANN(Flags.ACYCLIC_ANN),
548 GENERATEDCONSTR(Flags.GENERATEDCONSTR),
549 HYPOTHETICAL(Flags.HYPOTHETICAL),
550 PROPRIETARY(Flags.PROPRIETARY),
551 UNION(Flags.UNION),
552 EFFECTIVELY_FINAL(Flags.EFFECTIVELY_FINAL),
553 CLASH(Flags.CLASH),
554 AUXILIARY(Flags.AUXILIARY),
555 NOT_IN_PROFILE(Flags.NOT_IN_PROFILE),
556 BAD_OVERRIDE(Flags.BAD_OVERRIDE),
557 SIGNATURE_POLYMORPHIC(Flags.SIGNATURE_POLYMORPHIC),
558 THROWS(Flags.THROWS),
559 LAMBDA_METHOD(Flags.LAMBDA_METHOD),
560 TYPE_TRANSLATED(Flags.TYPE_TRANSLATED),
561 MODULE(Flags.MODULE),
562 AUTOMATIC_MODULE(Flags.AUTOMATIC_MODULE),
563 SYSTEM_MODULE(Flags.SYSTEM_MODULE),
564 DEPRECATED_ANNOTATION(Flags.DEPRECATED_ANNOTATION),
565 DEPRECATED_REMOVAL(Flags.DEPRECATED_REMOVAL),
566 HAS_RESOURCE(Flags.HAS_RESOURCE),
567 POTENTIALLY_AMBIGUOUS(Flags.POTENTIALLY_AMBIGUOUS),
568 ANONCONSTR_BASED(Flags.ANONCONSTR_BASED),
569 NAME_FILLED(Flags.NAME_FILLED),
570 PREVIEW_API(Flags.PREVIEW_API),
571 PREVIEW_REFLECTIVE(Flags.PREVIEW_REFLECTIVE),
572 MATCH_BINDING(Flags.MATCH_BINDING),
573 MATCH_BINDING_TO_OUTER(Flags.MATCH_BINDING_TO_OUTER),
574 RECORD(Flags.RECORD),
575 RECOVERABLE(Flags.RECOVERABLE),
576 SEALED(Flags.SEALED),
577 NON_SEALED(Flags.NON_SEALED) {
578 @Override
579 public String toString() {
580 return "non-sealed";
581 }
582 };
583
584 Flag(long flag) {
585 this.value = flag;
586 this.lowercaseName = StringUtils.toLowerCase(name());
587 }
588
589 @Override
590 public String toString() {
591 return lowercaseName;
592 }
593
594 final long value;
595 final String lowercaseName;
596 }
597
598 }