1 /*
2 * Copyright (c) 2022, 2025, 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 package java.lang.classfile.attribute;
26
27 import java.lang.classfile.constantpool.ClassEntry;
28 import java.lang.classfile.constantpool.Utf8Entry;
29 import java.lang.constant.ClassDesc;
30 import java.lang.reflect.AccessFlag;
31 import java.util.Optional;
32 import java.util.Set;
33
34 import jdk.internal.classfile.impl.TemporaryConstantPool;
35 import jdk.internal.classfile.impl.UnboundAttribute;
36 import jdk.internal.classfile.impl.Util;
37
38 /**
39 * Models a single entry in the {@link InnerClassesAttribute}.
40 *
41 * @see InnerClassesAttribute#classes()
42 * @jvms 4.7.6 The {@code InnerClasses} Attribute
43 * @since 24
44 */
45 public sealed interface InnerClassInfo
46 permits UnboundAttribute.UnboundInnerClassInfo {
47
48 /**
49 * {@return the nested class described by this entry}
50 */
51 ClassEntry innerClass();
52
53 /**
54 * {@return the class or interface of which this class is a member, if it is
55 * a member of a class or interface} This may be empty if this class is
56 * local or anonymous.
57 *
58 * @see Class#getDeclaringClass()
59 */
60 Optional<ClassEntry> outerClass();
61
62 /**
63 * {@return the simple name of this class, or empty if this class is anonymous}
64 *
65 * @see Class#getSimpleName()
66 */
67 Optional<Utf8Entry> innerName();
68
69 /**
70 * {@return a bit mask of flags denoting access permissions and properties
71 * of the inner class} It is in the range of unsigned short, {@code [0,
72 * 0xFFFF]}.
73 *
74 * @see Class#getModifiers()
75 * @see AccessFlag.Location#INNER_CLASS
76 */
77 int flagsMask();
78
79 /**
80 * {@return a set of flag enums denoting access permissions and properties
81 * of the nested class}
82 *
83 * @throws IllegalArgumentException if the flags mask has any undefined bit set
84 * @see Class#accessFlags()
85 * @see AccessFlag.Location#INNER_CLASS
86 */
87 default Set<AccessFlag> flags() {
88 return AccessFlag.maskToAccessFlags(flagsMask(), AccessFlag.Location.INNER_CLASS);
89 }
90
91 /**
92 * {@return whether a specific access flag is set}
93 *
94 * @param flag the access flag
95 * @see AccessFlag.Location#INNER_CLASS
96 */
97 default boolean has(AccessFlag flag) {
98 return Util.has(AccessFlag.Location.INNER_CLASS, flagsMask(), flag);
99 }
100
101 /**
102 * {@return a nested class description}
103 * @param innerClass the nested class being described
104 * @param outerClass the class that has the nested class as a member, if it exists
105 * @param innerName the simple name of the nested class, if it is not anonymous
106 * @param flags the inner class access flags
107 */
108 static InnerClassInfo of(ClassEntry innerClass, Optional<ClassEntry> outerClass,
109 Optional<Utf8Entry> innerName, int flags) {
110 return new UnboundAttribute.UnboundInnerClassInfo(innerClass, outerClass, innerName, flags);
111 }
112
113 /**
114 * {@return a nested class description}
115 * @param innerClass the nested class being described
116 * @param outerClass the class that has the nested class as a member, if it exists
117 * @param innerName the simple name of the nested class, if it is not anonymous
118 * @param flags the inner class access flags
119 * @throws IllegalArgumentException if {@code innerClass} or {@code outerClass} represents a primitive type
120 */
121 static InnerClassInfo of(ClassDesc innerClass, Optional<ClassDesc> outerClass, Optional<String> innerName, int flags) {
122 return new UnboundAttribute.UnboundInnerClassInfo(TemporaryConstantPool.INSTANCE.classEntry(innerClass),
123 outerClass.map(TemporaryConstantPool.INSTANCE::classEntry),
124 innerName.map(TemporaryConstantPool.INSTANCE::utf8Entry),
125 flags);
126 }
127
128 /**
129 * {@return a nested class description}
130 * @param innerClass the nested class being described
131 * @param outerClass the class that has the nested class as a member, if it exists
132 * @param innerName the name of the nested class, if it is not anonymous
133 * @param flags the inner class access flags
134 * @throws IllegalArgumentException if {@code innerClass} or {@code outerClass}
135 * represents a primitive type, or if any flag cannot be applied to
136 * the {@link AccessFlag.Location#INNER_CLASS} location
137 */
138 static InnerClassInfo of(ClassDesc innerClass, Optional<ClassDesc> outerClass, Optional<String> innerName, AccessFlag... flags) {
139 return of(innerClass, outerClass, innerName, Util.flagsToBits(AccessFlag.Location.INNER_CLASS, flags));
140 }
141 }