mockit.asm.fields.FieldVisitor Maven / Gradle / Ivy

Go to download
package mockit.asm.fields;

import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;

import mockit.asm.BaseWriter;
import mockit.asm.SignatureWriter;
import mockit.asm.classes.ClassWriter;
import mockit.asm.jvmConstants.Opcodes;
import mockit.asm.types.JavaType;
import mockit.asm.util.ByteVector;

import org.checkerframework.checker.index.qual.NonNegative;

/**
 * A visitor to visit a Java field, in the following order: ({@link #visitAnnotation})* {@link #visitEnd}.
 */
public final class FieldVisitor extends BaseWriter {
    /**
     * The index of the constant pool item that contains the name of this field.
     */
    @NonNegative
    private final int nameItemIndex;

    /**
     * The index of the constant pool item that contains the descriptor of this field.
     */
    @NonNegative
    private final int descItemIndex;

    @Nullable
    private final SignatureWriter signatureWriter;

    /**
     * The index of the constant pool item that contains the constant value of this field.
     */
    @NonNegative
    private final int valueItemIndex;

    /**
     * Initializes a new field visitor.
     *
     * @param cw
     *            the class writer to which this field must be added
     * @param access
     *            the field's access flags (see {@link Opcodes})
     * @param name
     *            the field's name
     * @param desc
     *            the field's descriptor (see {@link JavaType})
     * @param signature
     *            the field's signature
     * @param value
     *            the field's constant value
     */
    public FieldVisitor(@NonNull ClassWriter cw, int access, @NonNull String name, @NonNull String desc,
            @Nullable String signature, @Nullable Object value) {
        super(cw.getConstantPoolGeneration(), access);

        nameItemIndex = cp.newUTF8(name);
        descItemIndex = cp.newUTF8(desc);
        signatureWriter = signature == null ? null : new SignatureWriter(cp, signature);
        valueItemIndex = value == null ? 0 : cp.newConstItem(value).index;

        createMarkerAttributes(cw.getClassVersion());
    }

    /**
     * Returns the size of this field.
     */
    @NonNegative
    public int getSize() {
        int size = 8 + getMarkerAttributesSize() + getAnnotationsSize();

        if (valueItemIndex != 0) {
            cp.newUTF8("ConstantValue");
            size += 8;
        }

        if (signatureWriter != null) {
            size += signatureWriter.getSize();
        }

        return size;
    }

    /**
     * Puts the content of this field into the given byte vector.
     */
    @Override
    protected void put(@NonNull ByteVector out) {
        putAccess(out, 0);
        out.putShort(nameItemIndex);
        out.putShort(descItemIndex);

        int attributeCount = getAttributeCount();
        out.putShort(attributeCount);

        if (valueItemIndex != 0) {
            out.putShort(cp.newUTF8("ConstantValue"));
            out.putInt(2).putShort(valueItemIndex);
        }

        putMarkerAttributes(out);

        if (signatureWriter != null) {
            signatureWriter.put(out);
        }

        putAnnotations(out);
    }

    @NonNegative
    private int getAttributeCount() {
        int attributeCount = getMarkerAttributeCount();

        if (valueItemIndex != 0) {
            attributeCount++;
        }

        if (signatureWriter != null) {
            attributeCount++;
        }

        if (annotations != null) {
            attributeCount++;
        }

        return attributeCount;
    }
}