#818

Committed 07 Nov 2025 11:24AM UTC coverage: 83.01% (+0.05%) from 82.964%

Build # #818

Build Type

push

Committed by

Commit Message

[release] Release new version.

Run Details

29613 of 35674 relevant lines covered (83.01%)

0.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.67

/byte-buddy-dep/src/main/java/net/bytebuddy/description/ModifierReviewable.java

/*
 * Copyright 2014 - Present Rafael Winterhalter
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package net.bytebuddy.description;

import net.bytebuddy.description.modifier.EnumerationState;
import net.bytebuddy.description.modifier.FieldManifestation;
import net.bytebuddy.description.modifier.FieldPersistence;
import net.bytebuddy.description.modifier.Mandate;
import net.bytebuddy.description.modifier.MethodManifestation;
import net.bytebuddy.description.modifier.MethodStrictness;
import net.bytebuddy.description.modifier.Openness;
import net.bytebuddy.description.modifier.Ownership;
import net.bytebuddy.description.modifier.ParameterManifestation;
import net.bytebuddy.description.modifier.ProvisioningState;
import net.bytebuddy.description.modifier.RequiredPhase;
import net.bytebuddy.description.modifier.SynchronizationState;
import net.bytebuddy.description.modifier.SyntheticState;
import net.bytebuddy.description.modifier.Transitivity;
import net.bytebuddy.description.modifier.TypeManifestation;
import net.bytebuddy.description.modifier.Visibility;
import org.objectweb.asm.Opcodes;

/**
 * Implementations of this interface can be described in terms of a Java modifier.
 */
public interface ModifierReviewable {

    /**
     * Representation of the default modifier.
     */
    int EMPTY_MASK = 0;

    /**
     * Returns the modifier that is described by this object.
     *
     * @return The modifier that is described by this object.
     */
    int getModifiers();

    /**
     * Specifies if the modifier described by this object is {@code final}.
     *
     * @return {@code true} if the modifier described by this object is {@code final}.
     */
    boolean isFinal();

    /**
     * Specifies if the modifier described by this object is synthetic.
     *
     * @return {@code true} if the modifier described by this object is synthetic.
     */
    boolean isSynthetic();

    /**
     * Returns this objects synthetic state.
     *
     * @return This objects synthetic state.
     */
    SyntheticState getSyntheticState();

    /**
     * A modifier reviewable for a {@link ByteCodeElement}, i.e. a type, a field or a method.
     */
    interface OfByteCodeElement extends ModifierReviewable {

        /**
         * Specifies if the modifier described by this object is {@code public}.
         *
         * @return {@code true} if the modifier described by this object is {@code public}.
         */
        boolean isPublic();

        /**
         * Specifies if the modifier described by this object is {@code protected}.
         *
         * @return {@code true} if the modifier described by this object is {@code protected}.
         */
        boolean isProtected();

        /**
         * Specifies if the modifier described by this object is package private.
         *
         * @return {@code true} if the modifier described by this object is package private.
         */
        boolean isPackagePrivate();

        /**
         * Specifies if the modifier described by this object is {@code private}.
         *
         * @return {@code true} if the modifier described by this object is {@code private}.
         */
        boolean isPrivate();

        /**
         * Specifies if the modifier described by this object is {@code static}.
         *
         * @return {@code true} if the modifier described by this object is {@code static}.
         */
        boolean isStatic();

        /**
         * Specifies if the modifier described by this object represents the deprecated flag.
         *
         * @return {@code true} if the modifier described by this object represents the deprecated flag.
         */
        boolean isDeprecated();

        /**
         * Return's this byte code element's ownership.
         *
         * @return This byte code element's ownership.
         */
        Ownership getOwnership();

        /**
         * Returns this byte code element's visibility.
         *
         * @return This byte code element's visibility.
         */
        Visibility getVisibility();
    }

    /**
     * A modifier reviewable for a byte code element that can be abstract, i.e. a {@link net.bytebuddy.description.type.TypeDescription}
     * or a {@link net.bytebuddy.description.method.MethodDescription}.
     */
    interface OfAbstraction extends OfByteCodeElement {

        /**
         * Specifies if the modifier described by this object is {@code abstract}.
         *
         * @return {@code true} if the modifier described by this object is {@code abstract}.
         */
        boolean isAbstract();
    }

    /**
     * A modifier reviewable for a byte code element that can represent an enumeration, i.e. a {@link net.bytebuddy.description.field.FieldDescription}
     * that holds an enumeration value or a {@link net.bytebuddy.description.type.TypeDescription} that represents an enumeration.
     */
    interface OfEnumeration extends OfByteCodeElement {

        /**
         * Specifies if the modifier described by this object represents the enum flag.
         *
         * @return {@code true} if the modifier described by this object represents the enum flag.
         */
        boolean isEnum();

        /**
         * Returns this byte code element's enumeration state.
         *
         * @return This byte code element's enumeration state.
         */
        EnumerationState getEnumerationState();
    }

    /**
     * A modifier reviewable for elements that can be mandated.
     */
    interface OfMandatable extends ModifierReviewable {

        /**
         * Specifies if the modifier described by this object is mandated.
         *
         * @return {@code true} if the modifier described by this object is mandated.
         */
        boolean isMandated();

        /**
         * Returns the mandate of this instance.
         *
         * @return The mandate of this instance.
         */
        Mandate getMandate();
    }

    /**
     * A modifier reviewable for a {@link net.bytebuddy.description.type.TypeDescription}.
     */
    interface ForTypeDefinition extends OfAbstraction, OfEnumeration {

        /**
         * Specifies if the modifier described by this object represents the interface flag.
         *
         * @return {@code true} if the modifier described by this object represents the interface flag.
         */
        boolean isInterface();

        /**
         * Specifies if the modifier described by this object represents the annotation flag.
         *
         * @return {@code true} if the modifier described by this object represents the annotation flag.
         */
        boolean isAnnotation();

        /**
         * Returns this type's manifestation.
         *
         * @return This type's manifestation.
         */
        TypeManifestation getTypeManifestation();
    }

    /**
     * A modifier reviewable for a {@link net.bytebuddy.description.field.FieldDescription}.
     */
    interface ForFieldDescription extends OfEnumeration {

        /**
         * Specifies if the modifier described by this object represents the volatile flag.
         *
         * @return {@code true} if the modifier described by this object represents the volatile flag.
         */
        boolean isVolatile();

        /**
         * Specifies if the modifier described by this object represents the transient flag.
         *
         * @return {@code true} if the modifier described by this object represents the transient flag.
         */
        boolean isTransient();

        /**
         * Returns this field's manifestation.
         *
         * @return This field's manifestation.
         */
        FieldManifestation getFieldManifestation();

        /**
         * Returns this field's persistence.
         *
         * @return This field's persistence.
         */
        FieldPersistence getFieldPersistence();
    }

    /**
     * A modifier reviewable for a {@link net.bytebuddy.description.method.MethodDescription}.
     */
    interface ForMethodDescription extends OfAbstraction {

        /**
         * Specifies if the modifier described by this object is {@code synchronized}.
         *
         * @return {@code true} if the modifier described by this object is {@code synchronized}.
         */
        boolean isSynchronized();

        /**
         * Specifies if the modifier described by this object represents the var args flag.
         *
         * @return {@code true} if the modifier described by this object represents the var args flag.
         */
        boolean isVarArgs();

        /**
         * Specifies if the modifier described by this object is {@code native}.
         *
         * @return {@code true} if the modifier described by this object is {@code native}.
         */
        boolean isNative();

        /**
         * Specifies if the modifier described by this object represents the bridge flag.
         *
         * @return {@code true} if the modifier described by this object represents the bridge flag
         */
        boolean isBridge();

        /**
         * Specifies if the modifier described by this object is {@code strictfp}.
         *
         * @return {@code true} if the modifier described by this object is {@code strictfp}.
         */
        boolean isStrict();

        /**
         * Returns this method's synchronization state.
         *
         * @return This method's synchronization state.
         */
        SynchronizationState getSynchronizationState();

        /**
         * Returns this method's strictness in floating-point computation.
         *
         * @return This method's strictness in floating-point computation.
         */
        MethodStrictness getMethodStrictness();

        /**
         * Returns this method's manifestation.
         *
         * @return This method's manifestation.
         */
        MethodManifestation getMethodManifestation();
    }

    /**
     * A modifier reviewable for a {@link net.bytebuddy.description.method.ParameterDescription}.
     */
    interface ForParameterDescription extends OfMandatable {

        /**
         * Returns this parameter's manifestation.
         *
         * @return This parameter's manifestation.
         */
        ParameterManifestation getParameterManifestation();

        /**
         * Returns this parameter's provisioning state.
         *
         * @return This parameter's provisioning state.
         */
        ProvisioningState getProvisioningState();
    }

    /**
     * Declares modifiers as they can be observed on a Java module.
     */
    interface ForModuleDescription extends ModifierReviewable {

        /**
         * Returns {@code true} if the module is open.
         *
         * @return {@code true} if the module is open.
         */
        boolean isOpen();

        /**
         * Returns the openness of this module.
         *
         * @return A description of the openness of this module.
         */
        Openness getOpenness();
    }

    /**
     * Declares modifiers as they can be observed on a module requirement declaration.
     */
    interface ForModuleRequirement extends OfMandatable {

        /**
         * Returns {@code true} if the module requirement is transitive.
         *
         * @return {@code true} if the module requirement is transitive.
         */
        boolean isTransitive();

        /**
         * Returns {@code true} if the module requirement is during the static phase only.
         *
         * @return {@code true} if the module requirement is during the static phase only.
         */
        boolean isStaticPhase();

        /**
         * Returns the transitivity of this module requirement.
         *
         * @return The transitivity of this module requirement.
         */
        Transitivity getTransitivity();

        /**
         * Returns the phase in which this module requirement is relevant.
         *
         * @return The phase in which this module requirement is relevant.
         */
        RequiredPhase getRequiredPhase();
    }

    /**
     * An abstract base implementation of a {@link ModifierReviewable} class.
     */
    abstract class AbstractBase implements ForTypeDefinition,
            ForFieldDescription,
            ForMethodDescription,
            ForParameterDescription,
            ForModuleDescription,
            ForModuleRequirement {

        /**
         * {@inheritDoc}
         */
        public boolean isAbstract() {
            return matchesMask(Opcodes.ACC_ABSTRACT);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isFinal() {
            return matchesMask(Opcodes.ACC_FINAL);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isStatic() {
            return matchesMask(Opcodes.ACC_STATIC);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isPublic() {
            return matchesMask(Opcodes.ACC_PUBLIC);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isProtected() {
            return matchesMask(Opcodes.ACC_PROTECTED);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isPackagePrivate() {
            return !isPublic() && !isProtected() && !isPrivate();
        }

        /**
         * {@inheritDoc}
         */
        public boolean isPrivate() {
            return matchesMask(Opcodes.ACC_PRIVATE);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isNative() {
            return matchesMask(Opcodes.ACC_NATIVE);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isSynchronized() {
            return matchesMask(Opcodes.ACC_SYNCHRONIZED);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isStrict() {
            return matchesMask(Opcodes.ACC_STRICT);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isMandated() {
            return matchesMask(Opcodes.ACC_MANDATED);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isSynthetic() {
            return matchesMask(Opcodes.ACC_SYNTHETIC);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isBridge() {
            return matchesMask(Opcodes.ACC_BRIDGE);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isDeprecated() {
            return matchesMask(Opcodes.ACC_DEPRECATED);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isAnnotation() {
            return matchesMask(Opcodes.ACC_ANNOTATION);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isEnum() {
            return matchesMask(Opcodes.ACC_ENUM);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isInterface() {
            return matchesMask(Opcodes.ACC_INTERFACE);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isTransient() {
            return matchesMask(Opcodes.ACC_TRANSIENT);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isVolatile() {
            return matchesMask(Opcodes.ACC_VOLATILE);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isVarArgs() {
            return matchesMask(Opcodes.ACC_VARARGS);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isOpen() {
            return matchesMask(Opcodes.ACC_OPEN);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isStaticPhase() {
            return matchesMask(Opcodes.ACC_STATIC_PHASE);
        }

        /**
         * {@inheritDoc}
         */
        public boolean isTransitive() {
            return matchesMask(Opcodes.ACC_TRANSITIVE);
        }

        /**
         * {@inheritDoc}
         */
        public SyntheticState getSyntheticState() {
            return isSynthetic()
                    ? SyntheticState.SYNTHETIC
                    : SyntheticState.PLAIN;
        }

        /**
         * {@inheritDoc}
         */
        public Mandate getMandate() {
            return isMandated()
                    ? Mandate.MANDATED
                    : Mandate.PLAIN;
        }

        /**
         * {@inheritDoc}
         */
        public Visibility getVisibility() {
            int modifiers = getModifiers();
            switch (modifiers & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED | Opcodes.ACC_PRIVATE)) {
                case Opcodes.ACC_PUBLIC:
                    return Visibility.PUBLIC;
                case Opcodes.ACC_PROTECTED:
                    return Visibility.PROTECTED;
                case EMPTY_MASK:
                    return Visibility.PACKAGE_PRIVATE;
                case Opcodes.ACC_PRIVATE:
                    return Visibility.PRIVATE;
                default:
                    throw new IllegalStateException("Unexpected modifiers: " + modifiers);
            }
        }

        /**
         * {@inheritDoc}
         */
        public Ownership getOwnership() {
            return isStatic()
                    ? Ownership.STATIC
                    : Ownership.MEMBER;
        }

        /**
         * {@inheritDoc}
         */
        public EnumerationState getEnumerationState() {
            return isEnum()
                    ? EnumerationState.ENUMERATION
                    : EnumerationState.PLAIN;
        }

        /**
         * {@inheritDoc}
         */
        public TypeManifestation getTypeManifestation() {
            int modifiers = getModifiers();
            switch (modifiers & (Opcodes.ACC_ANNOTATION | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT | Opcodes.ACC_FINAL)) {
                case Opcodes.ACC_FINAL:
                    return TypeManifestation.FINAL;
                case Opcodes.ACC_ABSTRACT:
                    return TypeManifestation.ABSTRACT;
                case Opcodes.ACC_ABSTRACT | Opcodes.ACC_INTERFACE:
                    return TypeManifestation.INTERFACE;
                case Opcodes.ACC_ABSTRACT | Opcodes.ACC_INTERFACE | Opcodes.ACC_ANNOTATION:
                    return TypeManifestation.ANNOTATION;
                case EMPTY_MASK:
                    return TypeManifestation.PLAIN;
                default:
                    throw new IllegalStateException("Unexpected modifiers: " + modifiers);
            }
        }

        /**
         * {@inheritDoc}
         */
        public FieldManifestation getFieldManifestation() {
            int modifiers = getModifiers();
            switch (modifiers & (Opcodes.ACC_VOLATILE | Opcodes.ACC_FINAL)) {
                case Opcodes.ACC_FINAL:
                    return FieldManifestation.FINAL;
                case Opcodes.ACC_VOLATILE:
                    return FieldManifestation.VOLATILE;
                case EMPTY_MASK:
                    return FieldManifestation.PLAIN;
                default:
                    throw new IllegalStateException("Unexpected modifiers: " + modifiers);
            }
        }

        /**
         * {@inheritDoc}
         */
        public FieldPersistence getFieldPersistence() {
            int modifiers = getModifiers();
            switch (modifiers & Opcodes.ACC_TRANSIENT) {
                case Opcodes.ACC_TRANSIENT:
                    return FieldPersistence.TRANSIENT;
                case EMPTY_MASK:
                    return FieldPersistence.PLAIN;
                default:
                    throw new IllegalStateException("Unexpected modifiers: " + modifiers);
            }
        }

        /**
         * {@inheritDoc}
         */
        public SynchronizationState getSynchronizationState() {
            return isSynchronized()
                    ? SynchronizationState.SYNCHRONIZED
                    : SynchronizationState.PLAIN;
        }

        /**
         * {@inheritDoc}
         */
        public MethodManifestation getMethodManifestation() {
            int modifiers = getModifiers();
            switch (modifiers & (Opcodes.ACC_NATIVE | Opcodes.ACC_ABSTRACT | Opcodes.ACC_FINAL | Opcodes.ACC_BRIDGE)) {
                case Opcodes.ACC_NATIVE | Opcodes.ACC_FINAL:
                    return MethodManifestation.FINAL_NATIVE;
                case Opcodes.ACC_NATIVE:
                    return MethodManifestation.NATIVE;
                case Opcodes.ACC_FINAL:
                    return MethodManifestation.FINAL;
                case Opcodes.ACC_BRIDGE:
                    return MethodManifestation.BRIDGE;
                case Opcodes.ACC_BRIDGE | Opcodes.ACC_FINAL:
                    return MethodManifestation.FINAL_BRIDGE;
                case Opcodes.ACC_ABSTRACT:
                    return MethodManifestation.ABSTRACT;
                case EMPTY_MASK:
                    return MethodManifestation.PLAIN;
                default:
                    throw new IllegalStateException("Unexpected modifiers: " + modifiers);
            }
        }

        /**
         * {@inheritDoc}
         */
        public MethodStrictness getMethodStrictness() {
            return isStrict()
                    ? MethodStrictness.STRICT
                    : MethodStrictness.PLAIN;
        }

        /**
         * {@inheritDoc}
         */
        public ParameterManifestation getParameterManifestation() {
            return isFinal()
                    ? ParameterManifestation.FINAL
                    : ParameterManifestation.PLAIN;
        }

        /**
         * {@inheritDoc}
         */
        public ProvisioningState getProvisioningState() {
            return isMandated()
                    ? ProvisioningState.MANDATED
                    : ProvisioningState.PLAIN;
        }

        /**
         * {@inheritDoc}
         */
        public Openness getOpenness() {
            return isOpen()
                    ? Openness.OPEN
                    : Openness.CLOSED;
        }

        /**
         * {@inheritDoc}
         */
        public Transitivity getTransitivity() {
            return isTransitive()
                    ? Transitivity.TRANSITIVE
                    : Transitivity.NONE;
        }

        /**
         * {@inheritDoc}
         */
        public RequiredPhase getRequiredPhase() {
            return isStaticPhase()
                    ? RequiredPhase.STATIC
                    : RequiredPhase.ALWAYS;
        }

        /**
         * Checks if a mask is matched by this instance.
         *
         * @param mask The mask to check.
         * @return {@code true} if the mask is matched.
         */
        private boolean matchesMask(int mask) {
            return (getModifiers() & mask) == mask;
        }
    }
}

1	/*
2	* Copyright 2014 - Present Rafael Winterhalter
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	package net.bytebuddy.description;
17
18	import net.bytebuddy.description.modifier.EnumerationState;
19	import net.bytebuddy.description.modifier.FieldManifestation;
20	import net.bytebuddy.description.modifier.FieldPersistence;
21	import net.bytebuddy.description.modifier.Mandate;
22	import net.bytebuddy.description.modifier.MethodManifestation;
23	import net.bytebuddy.description.modifier.MethodStrictness;
24	import net.bytebuddy.description.modifier.Openness;
25	import net.bytebuddy.description.modifier.Ownership;
26	import net.bytebuddy.description.modifier.ParameterManifestation;
27	import net.bytebuddy.description.modifier.ProvisioningState;
28	import net.bytebuddy.description.modifier.RequiredPhase;
29	import net.bytebuddy.description.modifier.SynchronizationState;
30	import net.bytebuddy.description.modifier.SyntheticState;
31	import net.bytebuddy.description.modifier.Transitivity;
32	import net.bytebuddy.description.modifier.TypeManifestation;
33	import net.bytebuddy.description.modifier.Visibility;
34	import org.objectweb.asm.Opcodes;
35
36	/**
37	* Implementations of this interface can be described in terms of a Java modifier.
38	*/
39	public interface ModifierReviewable {
40
41	/**
42	* Representation of the default modifier.
43	*/
44	int EMPTY_MASK = 0;
45
46	/**
47	* Returns the modifier that is described by this object.
48	*
49	* @return The modifier that is described by this object.
50	*/
51	int getModifiers();
52
53	/**
54	* Specifies if the modifier described by this object is {@code final}.
55	*
56	* @return {@code true} if the modifier described by this object is {@code final}.
57	*/
58	boolean isFinal();
59
60	/**
61	* Specifies if the modifier described by this object is synthetic.
62	*
63	* @return {@code true} if the modifier described by this object is synthetic.
64	*/
65	boolean isSynthetic();
66
67	/**
68	* Returns this objects synthetic state.
69	*
70	* @return This objects synthetic state.
71	*/
72	SyntheticState getSyntheticState();
73
74	/**
75	* A modifier reviewable for a {@link ByteCodeElement}, i.e. a type, a field or a method.
76	*/
77	interface OfByteCodeElement extends ModifierReviewable {
78
79	/**
80	* Specifies if the modifier described by this object is {@code public}.
81	*
82	* @return {@code true} if the modifier described by this object is {@code public}.
83	*/
84	boolean isPublic();
85
86	/**
87	* Specifies if the modifier described by this object is {@code protected}.
88	*
89	* @return {@code true} if the modifier described by this object is {@code protected}.
90	*/
91	boolean isProtected();
92
93	/**
94	* Specifies if the modifier described by this object is package private.
95	*
96	* @return {@code true} if the modifier described by this object is package private.
97	*/
98	boolean isPackagePrivate();
99
100	/**
101	* Specifies if the modifier described by this object is {@code private}.
102	*
103	* @return {@code true} if the modifier described by this object is {@code private}.
104	*/
105	boolean isPrivate();
106
107	/**
108	* Specifies if the modifier described by this object is {@code static}.
109	*
110	* @return {@code true} if the modifier described by this object is {@code static}.
111	*/
112	boolean isStatic();
113
114	/**
115	* Specifies if the modifier described by this object represents the deprecated flag.
116	*
117	* @return {@code true} if the modifier described by this object represents the deprecated flag.
118	*/
119	boolean isDeprecated();
120
121	/**
122	* Return's this byte code element's ownership.
123	*
124	* @return This byte code element's ownership.
125	*/
126	Ownership getOwnership();
127
128	/**
129	* Returns this byte code element's visibility.
130	*
131	* @return This byte code element's visibility.
132	*/
133	Visibility getVisibility();
134	}
135
136	/**
137	* A modifier reviewable for a byte code element that can be abstract, i.e. a {@link net.bytebuddy.description.type.TypeDescription}
138	* or a {@link net.bytebuddy.description.method.MethodDescription}.
139	*/
140	interface OfAbstraction extends OfByteCodeElement {
141
142	/**
143	* Specifies if the modifier described by this object is {@code abstract}.
144	*
145	* @return {@code true} if the modifier described by this object is {@code abstract}.
146	*/
147	boolean isAbstract();
148	}
149
150	/**
151	* A modifier reviewable for a byte code element that can represent an enumeration, i.e. a {@link net.bytebuddy.description.field.FieldDescription}
152	* that holds an enumeration value or a {@link net.bytebuddy.description.type.TypeDescription} that represents an enumeration.
153	*/
154	interface OfEnumeration extends OfByteCodeElement {
155
156	/**
157	* Specifies if the modifier described by this object represents the enum flag.
158	*
159	* @return {@code true} if the modifier described by this object represents the enum flag.
160	*/
161	boolean isEnum();
162
163	/**
164	* Returns this byte code element's enumeration state.
165	*
166	* @return This byte code element's enumeration state.
167	*/
168	EnumerationState getEnumerationState();
169	}
170
171	/**
172	* A modifier reviewable for elements that can be mandated.
173	*/
174	interface OfMandatable extends ModifierReviewable {
175
176	/**
177	* Specifies if the modifier described by this object is mandated.
178	*
179	* @return {@code true} if the modifier described by this object is mandated.
180	*/
181	boolean isMandated();
182
183	/**
184	* Returns the mandate of this instance.
185	*
186	* @return The mandate of this instance.
187	*/
188	Mandate getMandate();
189	}
190
191	/**
192	* A modifier reviewable for a {@link net.bytebuddy.description.type.TypeDescription}.
193	*/
194	interface ForTypeDefinition extends OfAbstraction, OfEnumeration {
195
196	/**
197	* Specifies if the modifier described by this object represents the interface flag.
198	*
199	* @return {@code true} if the modifier described by this object represents the interface flag.
200	*/
201	boolean isInterface();
202
203	/**
204	* Specifies if the modifier described by this object represents the annotation flag.
205	*
206	* @return {@code true} if the modifier described by this object represents the annotation flag.
207	*/
208	boolean isAnnotation();
209
210	/**
211	* Returns this type's manifestation.
212	*
213	* @return This type's manifestation.
214	*/
215	TypeManifestation getTypeManifestation();
216	}
217
218	/**
219	* A modifier reviewable for a {@link net.bytebuddy.description.field.FieldDescription}.
220	*/
221	interface ForFieldDescription extends OfEnumeration {
222
223	/**
224	* Specifies if the modifier described by this object represents the volatile flag.
225	*
226	* @return {@code true} if the modifier described by this object represents the volatile flag.
227	*/
228	boolean isVolatile();
229
230	/**
231	* Specifies if the modifier described by this object represents the transient flag.
232	*
233	* @return {@code true} if the modifier described by this object represents the transient flag.
234	*/
235	boolean isTransient();
236
237	/**
238	* Returns this field's manifestation.
239	*
240	* @return This field's manifestation.
241	*/
242	FieldManifestation getFieldManifestation();
243
244	/**
245	* Returns this field's persistence.
246	*
247	* @return This field's persistence.
248	*/
249	FieldPersistence getFieldPersistence();
250	}
251
252	/**
253	* A modifier reviewable for a {@link net.bytebuddy.description.method.MethodDescription}.
254	*/
255	interface ForMethodDescription extends OfAbstraction {
256
257	/**
258	* Specifies if the modifier described by this object is {@code synchronized}.
259	*
260	* @return {@code true} if the modifier described by this object is {@code synchronized}.
261	*/
262	boolean isSynchronized();
263
264	/**
265	* Specifies if the modifier described by this object represents the var args flag.
266	*
267	* @return {@code true} if the modifier described by this object represents the var args flag.
268	*/
269	boolean isVarArgs();
270
271	/**
272	* Specifies if the modifier described by this object is {@code native}.
273	*
274	* @return {@code true} if the modifier described by this object is {@code native}.
275	*/
276	boolean isNative();
277
278	/**
279	* Specifies if the modifier described by this object represents the bridge flag.
280	*
281	* @return {@code true} if the modifier described by this object represents the bridge flag
282	*/
283	boolean isBridge();
284
285	/**
286	* Specifies if the modifier described by this object is {@code strictfp}.
287	*
288	* @return {@code true} if the modifier described by this object is {@code strictfp}.
289	*/
290	boolean isStrict();
291
292	/**
293	* Returns this method's synchronization state.
294	*
295	* @return This method's synchronization state.
296	*/
297	SynchronizationState getSynchronizationState();
298
299	/**
300	* Returns this method's strictness in floating-point computation.
301	*
302	* @return This method's strictness in floating-point computation.
303	*/
304	MethodStrictness getMethodStrictness();
305
306	/**
307	* Returns this method's manifestation.
308	*
309	* @return This method's manifestation.
310	*/
311	MethodManifestation getMethodManifestation();
312	}
313
314	/**
315	* A modifier reviewable for a {@link net.bytebuddy.description.method.ParameterDescription}.
316	*/
317	interface ForParameterDescription extends OfMandatable {
318
319	/**
320	* Returns this parameter's manifestation.
321	*
322	* @return This parameter's manifestation.
323	*/
324	ParameterManifestation getParameterManifestation();
325
326	/**
327	* Returns this parameter's provisioning state.
328	*
329	* @return This parameter's provisioning state.
330	*/
331	ProvisioningState getProvisioningState();
332	}
333
334	/**
335	* Declares modifiers as they can be observed on a Java module.
336	*/
337	interface ForModuleDescription extends ModifierReviewable {
338
339	/**
340	* Returns {@code true} if the module is open.
341	*
342	* @return {@code true} if the module is open.
343	*/
344	boolean isOpen();
345
346	/**
347	* Returns the openness of this module.
348	*
349	* @return A description of the openness of this module.
350	*/
351	Openness getOpenness();
352	}
353
354	/**
355	* Declares modifiers as they can be observed on a module requirement declaration.
356	*/
357	interface ForModuleRequirement extends OfMandatable {
358
359	/**
360	* Returns {@code true} if the module requirement is transitive.
361	*
362	* @return {@code true} if the module requirement is transitive.
363	*/
364	boolean isTransitive();
365
366	/**
367	* Returns {@code true} if the module requirement is during the static phase only.
368	*
369	* @return {@code true} if the module requirement is during the static phase only.
370	*/
371	boolean isStaticPhase();
372
373	/**
374	* Returns the transitivity of this module requirement.
375	*
376	* @return The transitivity of this module requirement.
377	*/
378	Transitivity getTransitivity();
379
380	/**
381	* Returns the phase in which this module requirement is relevant.
382	*
383	* @return The phase in which this module requirement is relevant.
384	*/
385	RequiredPhase getRequiredPhase();
386	}
387
388	/**
389	* An abstract base implementation of a {@link ModifierReviewable} class.
390	*/
391	abstract class AbstractBase implements ForTypeDefinition,	1✔
392	ForFieldDescription,
393	ForMethodDescription,
394	ForParameterDescription,
395	ForModuleDescription,
396	ForModuleRequirement {
397
398	/**
399	* {@inheritDoc}
400	*/
401	public boolean isAbstract() {
402	return matchesMask(Opcodes.ACC_ABSTRACT);	1✔
403	}
404
405	/**
406	* {@inheritDoc}
407	*/
408	public boolean isFinal() {
409	return matchesMask(Opcodes.ACC_FINAL);	1✔
410	}
411
412	/**
413	* {@inheritDoc}
414	*/
415	public boolean isStatic() {
416	return matchesMask(Opcodes.ACC_STATIC);	1✔
417	}
418
419	/**
420	* {@inheritDoc}
421	*/
422	public boolean isPublic() {
423	return matchesMask(Opcodes.ACC_PUBLIC);	1✔
424	}
425
426	/**
427	* {@inheritDoc}
428	*/
429	public boolean isProtected() {
430	return matchesMask(Opcodes.ACC_PROTECTED);	1✔
431	}
432
433	/**
434	* {@inheritDoc}
435	*/
436	public boolean isPackagePrivate() {
437	return !isPublic() && !isProtected() && !isPrivate();	1✔
438	}
439
440	/**
441	* {@inheritDoc}
442	*/
443	public boolean isPrivate() {
444	return matchesMask(Opcodes.ACC_PRIVATE);	1✔
445	}
446
447	/**
448	* {@inheritDoc}
449	*/
450	public boolean isNative() {
451	return matchesMask(Opcodes.ACC_NATIVE);	1✔
452	}
453
454	/**
455	* {@inheritDoc}
456	*/
457	public boolean isSynchronized() {
458	return matchesMask(Opcodes.ACC_SYNCHRONIZED);	1✔
459	}
460
461	/**
462	* {@inheritDoc}
463	*/
464	public boolean isStrict() {
465	return matchesMask(Opcodes.ACC_STRICT);	1✔
466	}
467
468	/**
469	* {@inheritDoc}
470	*/
471	public boolean isMandated() {
472	return matchesMask(Opcodes.ACC_MANDATED);	1✔
473	}
474
475	/**
476	* {@inheritDoc}
477	*/
478	public boolean isSynthetic() {
479	return matchesMask(Opcodes.ACC_SYNTHETIC);	1✔
480	}
481
482	/**
483	* {@inheritDoc}
484	*/
485	public boolean isBridge() {
486	return matchesMask(Opcodes.ACC_BRIDGE);	1✔
487	}
488
489	/**
490	* {@inheritDoc}
491	*/
492	public boolean isDeprecated() {
493	return matchesMask(Opcodes.ACC_DEPRECATED);	1✔
494	}
495
496	/**
497	* {@inheritDoc}
498	*/
499	public boolean isAnnotation() {
500	return matchesMask(Opcodes.ACC_ANNOTATION);	1✔
501	}
502
503	/**
504	* {@inheritDoc}
505	*/
506	public boolean isEnum() {
507	return matchesMask(Opcodes.ACC_ENUM);	1✔
508	}
509
510	/**
511	* {@inheritDoc}
512	*/
513	public boolean isInterface() {
514	return matchesMask(Opcodes.ACC_INTERFACE);	1✔
515	}
516
517	/**
518	* {@inheritDoc}
519	*/
520	public boolean isTransient() {
521	return matchesMask(Opcodes.ACC_TRANSIENT);	1✔
522	}
523
524	/**
525	* {@inheritDoc}
526	*/
527	public boolean isVolatile() {
528	return matchesMask(Opcodes.ACC_VOLATILE);	1✔
529	}
530
531	/**
532	* {@inheritDoc}
533	*/
534	public boolean isVarArgs() {
535	return matchesMask(Opcodes.ACC_VARARGS);	1✔
536	}
537
538	/**
539	* {@inheritDoc}
540	*/
541	public boolean isOpen() {
542	return matchesMask(Opcodes.ACC_OPEN);	1✔
543	}
544
545	/**
546	* {@inheritDoc}
547	*/
548	public boolean isStaticPhase() {
549	return matchesMask(Opcodes.ACC_STATIC_PHASE);	1✔
550	}
551
552	/**
553	* {@inheritDoc}
554	*/
555	public boolean isTransitive() {
556	return matchesMask(Opcodes.ACC_TRANSITIVE);	1✔
557	}
558
559	/**
560	* {@inheritDoc}
561	*/
562	public SyntheticState getSyntheticState() {
563	return isSynthetic()	1✔
564	? SyntheticState.SYNTHETIC
565	: SyntheticState.PLAIN;
566	}
567
568	/**
569	* {@inheritDoc}
570	*/
571	public Mandate getMandate() {
572	return isMandated()	1✔
573	? Mandate.MANDATED
574	: Mandate.PLAIN;
575	}
576
577	/**
578	* {@inheritDoc}
579	*/
580	public Visibility getVisibility() {
581	int modifiers = getModifiers();	1✔
582	switch (modifiers & (Opcodes.ACC_PUBLIC \| Opcodes.ACC_PROTECTED \| Opcodes.ACC_PRIVATE)) {	1✔
583	case Opcodes.ACC_PUBLIC:
584	return Visibility.PUBLIC;	1✔
585	case Opcodes.ACC_PROTECTED:
586	return Visibility.PROTECTED;	1✔
587	case EMPTY_MASK:
588	return Visibility.PACKAGE_PRIVATE;	1✔
589	case Opcodes.ACC_PRIVATE:
590	return Visibility.PRIVATE;	1✔
591	default:
592	throw new IllegalStateException("Unexpected modifiers: " + modifiers);	×
593	}
594	}
595
596	/**
597	* {@inheritDoc}
598	*/
599	public Ownership getOwnership() {
600	return isStatic()	1✔
601	? Ownership.STATIC
602	: Ownership.MEMBER;
603	}
604
605	/**
606	* {@inheritDoc}
607	*/
608	public EnumerationState getEnumerationState() {
609	return isEnum()	1✔
610	? EnumerationState.ENUMERATION
611	: EnumerationState.PLAIN;
612	}
613
614	/**
615	* {@inheritDoc}
616	*/
617	public TypeManifestation getTypeManifestation() {
618	int modifiers = getModifiers();	1✔
619	switch (modifiers & (Opcodes.ACC_ANNOTATION \| Opcodes.ACC_INTERFACE \| Opcodes.ACC_ABSTRACT \| Opcodes.ACC_FINAL)) {	1✔
620	case Opcodes.ACC_FINAL:
621	return TypeManifestation.FINAL;	1✔
622	case Opcodes.ACC_ABSTRACT:
623	return TypeManifestation.ABSTRACT;	1✔
624	case Opcodes.ACC_ABSTRACT \| Opcodes.ACC_INTERFACE:
625	return TypeManifestation.INTERFACE;	1✔
626	case Opcodes.ACC_ABSTRACT \| Opcodes.ACC_INTERFACE \| Opcodes.ACC_ANNOTATION:
627	return TypeManifestation.ANNOTATION;	1✔
628	case EMPTY_MASK:
629	return TypeManifestation.PLAIN;	1✔
630	default:
631	throw new IllegalStateException("Unexpected modifiers: " + modifiers);	×
632	}
633	}
634
635	/**
636	* {@inheritDoc}
637	*/
638	public FieldManifestation getFieldManifestation() {
639	int modifiers = getModifiers();	1✔
640	switch (modifiers & (Opcodes.ACC_VOLATILE \| Opcodes.ACC_FINAL)) {	1✔
641	case Opcodes.ACC_FINAL:
642	return FieldManifestation.FINAL;	1✔
643	case Opcodes.ACC_VOLATILE:
644	return FieldManifestation.VOLATILE;	1✔
645	case EMPTY_MASK:
646	return FieldManifestation.PLAIN;	×
647	default:
648	throw new IllegalStateException("Unexpected modifiers: " + modifiers);	×
649	}
650	}
651
652	/**
653	* {@inheritDoc}
654	*/
655	public FieldPersistence getFieldPersistence() {
656	int modifiers = getModifiers();	1✔
657	switch (modifiers & Opcodes.ACC_TRANSIENT) {	1✔
658	case Opcodes.ACC_TRANSIENT:
659	return FieldPersistence.TRANSIENT;	1✔
660	case EMPTY_MASK:
661	return FieldPersistence.PLAIN;	1✔
662	default:
663	throw new IllegalStateException("Unexpected modifiers: " + modifiers);	×
664	}
665	}
666
667	/**
668	* {@inheritDoc}
669	*/
670	public SynchronizationState getSynchronizationState() {
671	return isSynchronized()	1✔
672	? SynchronizationState.SYNCHRONIZED
673	: SynchronizationState.PLAIN;
674	}
675
676	/**
677	* {@inheritDoc}
678	*/
679	public MethodManifestation getMethodManifestation() {
680	int modifiers = getModifiers();	1✔
681	switch (modifiers & (Opcodes.ACC_NATIVE \| Opcodes.ACC_ABSTRACT \| Opcodes.ACC_FINAL \| Opcodes.ACC_BRIDGE)) {	1✔
682	case Opcodes.ACC_NATIVE \| Opcodes.ACC_FINAL:
683	return MethodManifestation.FINAL_NATIVE;	1✔
684	case Opcodes.ACC_NATIVE:
685	return MethodManifestation.NATIVE;	1✔
686	case Opcodes.ACC_FINAL:
687	return MethodManifestation.FINAL;	1✔
688	case Opcodes.ACC_BRIDGE:
689	return MethodManifestation.BRIDGE;	1✔
690	case Opcodes.ACC_BRIDGE \| Opcodes.ACC_FINAL:
691	return MethodManifestation.FINAL_BRIDGE;	1✔
692	case Opcodes.ACC_ABSTRACT:
693	return MethodManifestation.ABSTRACT;	1✔
694	case EMPTY_MASK:
695	return MethodManifestation.PLAIN;	1✔
696	default:
697	throw new IllegalStateException("Unexpected modifiers: " + modifiers);	×
698	}
699	}
700
701	/**
702	* {@inheritDoc}
703	*/
704	public MethodStrictness getMethodStrictness() {
705	return isStrict()	1✔
706	? MethodStrictness.STRICT
707	: MethodStrictness.PLAIN;
708	}
709
710	/**
711	* {@inheritDoc}
712	*/
713	public ParameterManifestation getParameterManifestation() {
714	return isFinal()	1✔
715	? ParameterManifestation.FINAL
716	: ParameterManifestation.PLAIN;
717	}
718
719	/**
720	* {@inheritDoc}
721	*/
722	public ProvisioningState getProvisioningState() {
723	return isMandated()	1✔
724	? ProvisioningState.MANDATED
725	: ProvisioningState.PLAIN;
726	}
727
728	/**
729	* {@inheritDoc}
730	*/
731	public Openness getOpenness() {
732	return isOpen()	1✔
733	? Openness.OPEN
734	: Openness.CLOSED;
735	}
736
737	/**
738	* {@inheritDoc}
739	*/
740	public Transitivity getTransitivity() {
741	return isTransitive()	1✔
742	? Transitivity.TRANSITIVE
743	: Transitivity.NONE;
744	}
745
746	/**
747	* {@inheritDoc}
748	*/
749	public RequiredPhase getRequiredPhase() {
750	return isStaticPhase()	1✔
751	? RequiredPhase.STATIC
752	: RequiredPhase.ALWAYS;
753	}
754
755	/**
756	* Checks if a mask is matched by this instance.
757	*
758	* @param mask The mask to check.
759	* @return {@code true} if the mask is matched.
760	*/
761	private boolean matchesMask(int mask) {
762	return (getModifiers() & mask) == mask;	1✔
763	}
764	}
765	}

raphw / byte-buddy / #818

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous