net.bytebuddy.implementation.bytecode.constant.IntegerConstant Java Examples

/**
 * {@inheritDoc}
 */
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext) {
    Size size = IntegerConstant.forValue(stackManipulations.size()).apply(methodVisitor, implementationContext);
    // The array's construction does not alter the stack's size.
    size = size.aggregate(arrayCreator.apply(methodVisitor, implementationContext));
    int index = 0;
    for (StackManipulation stackManipulation : stackManipulations) {
        methodVisitor.visitInsn(Opcodes.DUP);
        size = size.aggregate(StackSize.SINGLE.toIncreasingSize());
        size = size.aggregate(IntegerConstant.forValue(index++).apply(methodVisitor, implementationContext));
        size = size.aggregate(stackManipulation.apply(methodVisitor, implementationContext));
        methodVisitor.visitInsn(arrayCreator.getStorageOpcode());
        size = size.aggregate(sizeDecrease);
    }
    return size;
}
 

/**
 * {@inheritDoc}
 */
public Size apply(MethodVisitor methodVisitor, Context implementationContext, MethodDescription instrumentedMethod) {
    if (instrumentedMethod.isStatic()) {
        throw new IllegalStateException("Hash code method must not be static: " + instrumentedMethod);
    } else if (!instrumentedMethod.getReturnType().represents(int.class)) {
        throw new IllegalStateException("Hash code method does not return primitive integer: " + instrumentedMethod);
    }
    List<StackManipulation> stackManipulations = new ArrayList<StackManipulation>(2 + fieldDescriptions.size() * 8);
    stackManipulations.add(initialValue);
    int padding = 0;
    for (FieldDescription.InDefinedShape fieldDescription : fieldDescriptions) {
        stackManipulations.add(IntegerConstant.forValue(multiplier));
        stackManipulations.add(Multiplication.INTEGER);
        stackManipulations.add(MethodVariableAccess.loadThis());
        stackManipulations.add(FieldAccess.forField(fieldDescription).read());
        NullValueGuard nullValueGuard = fieldDescription.getType().isPrimitive() || fieldDescription.getType().isArray() || nonNullable.matches(fieldDescription)
                ? NullValueGuard.NoOp.INSTANCE
                : new NullValueGuard.UsingJump(instrumentedMethod);
        stackManipulations.add(nullValueGuard.before());
        stackManipulations.add(ValueTransformer.of(fieldDescription.getType()));
        stackManipulations.add(Addition.INTEGER);
        stackManipulations.add(nullValueGuard.after());
        padding = Math.max(padding, nullValueGuard.getRequiredVariablePadding());
    }
    stackManipulations.add(MethodReturn.INTEGER);
    return new Size(new StackManipulation.Compound(stackManipulations).apply(methodVisitor, implementationContext).getMaximalSize(), instrumentedMethod.getStackSize() + padding);
}
 

/**
 * {@inheritDoc}
 */
public Size apply(MethodVisitor methodVisitor, Context implementationContext, MethodDescription instrumentedMethod) {
    if (instrumentedMethod.isStatic()) {
        throw new IllegalStateException("Hash code method must not be static: " + instrumentedMethod);
    } else if (instrumentedMethod.getParameters().size() != 1 || instrumentedMethod.getParameters().getOnly().getType().isPrimitive()) {
        throw new IllegalStateException();
    } else if (!instrumentedMethod.getReturnType().represents(boolean.class)) {
        throw new IllegalStateException("Hash code method does not return primitive boolean: " + instrumentedMethod);
    }
    List<StackManipulation> stackManipulations = new ArrayList<StackManipulation>(3 + fieldDescriptions.size() * 8);
    stackManipulations.add(baseline);
    int padding = 0;
    for (FieldDescription.InDefinedShape fieldDescription : fieldDescriptions) {
        stackManipulations.add(MethodVariableAccess.loadThis());
        stackManipulations.add(FieldAccess.forField(fieldDescription).read());
        stackManipulations.add(MethodVariableAccess.REFERENCE.loadFrom(1));
        stackManipulations.add(TypeCasting.to(instrumentedType));
        stackManipulations.add(FieldAccess.forField(fieldDescription).read());
        NullValueGuard nullValueGuard = fieldDescription.getType().isPrimitive() || fieldDescription.getType().isArray() || nonNullable.matches(fieldDescription)
                ? NullValueGuard.NoOp.INSTANCE
                : new NullValueGuard.UsingJump(instrumentedMethod);
        stackManipulations.add(nullValueGuard.before());
        stackManipulations.add(ValueComparator.of(fieldDescription.getType()));
        stackManipulations.add(nullValueGuard.after());
        padding = Math.max(padding, nullValueGuard.getRequiredVariablePadding());
    }
    stackManipulations.add(IntegerConstant.forValue(true));
    stackManipulations.add(MethodReturn.INTEGER);
    return new Size(new StackManipulation.Compound(stackManipulations).apply(methodVisitor, implementationContext).getMaximalSize(), instrumentedMethod.getStackSize() + padding);
}
 

/**
 * {@inheritDoc}
 */
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext, MethodDescription instrumentedMethod) {
    try {
        return new ByteCodeAppender.Simple(new StackManipulation.Compound(
                MethodInvocation.invoke(new MethodDescription.ForLoadedMethod(ClassLoader.class.getMethod("getSystemClassLoader"))),
                new TextConstant(Nexus.class.getName()),
                MethodInvocation.invoke(new MethodDescription.ForLoadedMethod(ClassLoader.class.getMethod("loadClass", String.class))),
                new TextConstant("initialize"),
                ArrayFactory.forType(TypeDescription.Generic.CLASS)
                        .withValues(Arrays.asList(
                                ClassConstant.of(TypeDescription.CLASS),
                                ClassConstant.of(TypeDescription.ForLoadedType.of(int.class)))),
                MethodInvocation.invoke(new MethodDescription.ForLoadedMethod(Class.class.getMethod("getMethod", String.class, Class[].class))),
                NullConstant.INSTANCE,
                ArrayFactory.forType(TypeDescription.Generic.OBJECT)
                        .withValues(Arrays.asList(
                                ClassConstant.of(instrumentedMethod.getDeclaringType().asErasure()),
                                new StackManipulation.Compound(
                                        IntegerConstant.forValue(identification),
                                        MethodInvocation.invoke(new MethodDescription.ForLoadedMethod(Integer.class.getMethod("valueOf", int.class)))))),
                MethodInvocation.invoke(new MethodDescription.ForLoadedMethod(Method.class.getMethod("invoke", Object.class, Object[].class))),
                Removal.SINGLE
        )).apply(methodVisitor, implementationContext, instrumentedMethod);
    } catch (NoSuchMethodException exception) {
        throw new IllegalStateException("Cannot locate method", exception);
    }
}
 

public Size apply(MethodVisitor methodVisitor,
                  Implementation.Context implementationContext,
                  MethodDescription instrumentedMethod) {
    if (!instrumentedMethod.getReturnType().asErasure().represents(int.class)) {
        throw new IllegalArgumentException(instrumentedMethod + " must return int");
    }
    StackManipulation.Size operandStackSize = new StackManipulation.Compound(
            IntegerConstant.forValue(10),
            IntegerConstant.forValue(50),
            IntegerSum.INSTANCE,
            MethodReturn.INTEGER
    ).apply(methodVisitor, implementationContext);
    return new Size(operandStackSize.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

@Test
public void testForEach() throws Exception {
    StackManipulation stackManipulation = mock(StackManipulation.class);
    assertThat(ArrayAccess.REFERENCE.forEach(Collections.singletonList(stackManipulation)),
            hasPrototype((StackManipulation) new StackManipulation.Compound(new StackManipulation.Compound(Duplication.SINGLE,
                    IntegerConstant.forValue(0),
                    ArrayAccess.REFERENCE.new Loader(),
                    stackManipulation))));
}
 

/**
 * Retrurns a {@link StackManipulation} that checks whether the value in the message is a default
 * value, and if so jumps to after serialization to skip the serialization of the default value.
 * e.g.,
 *
 * <pre>{code
 *   if (message.getFoo() != field.getDefaultValue) {
 *     ...
 *   }
 *   // afterSerializeField
 * }</pre>
 */
private static StackManipulation checkDefaultValue(
    ProtoFieldInfo info,
    LocalVariables<LocalVariable> locals,
    StackManipulation getValue,
    StackManipulation getDefaultInstance,
    Label afterSerializeField) {
  if (info.isInOneof()) {
    // For one-ofs, we can just check the set field number directly.
    return new StackManipulation.Compound(
        locals.load(LocalVariable.message),
        CodeGenUtil.invoke(info.oneOfCaseMethod()),
        EnumLite_getNumber,
        IntegerConstant.forValue(info.descriptor().getNumber()),
        new IfIntsNotEqual(afterSerializeField));
  } else if (!info.isRepeated()) {
    switch (info.valueJavaType()) {
      case INT:
        return checkPrimitiveDefault(
            getValue,
            IntegerConstant.forValue((int) info.descriptor().getDefaultValue()),
            int.class,
            afterSerializeField);
      case LONG:
        return checkPrimitiveDefault(
            getValue,
            LongConstant.forValue((long) info.descriptor().getDefaultValue()),
            long.class,
            afterSerializeField);
      case FLOAT:
        return checkPrimitiveDefault(
            getValue,
            FloatConstant.forValue((float) info.descriptor().getDefaultValue()),
            float.class,
            afterSerializeField);
      case DOUBLE:
        return checkPrimitiveDefault(
            getValue,
            DoubleConstant.forValue((double) info.descriptor().getDefaultValue()),
            double.class,
            afterSerializeField);
      case BOOLEAN:
        return checkPrimitiveDefault(
            getValue,
            IntegerConstant.forValue((boolean) info.descriptor().getDefaultValue()),
            boolean.class,
            afterSerializeField);
      case ENUM:
        return checkPrimitiveDefault(
            getValue,
            IntegerConstant.forValue(
                ((EnumValueDescriptor) info.descriptor().getDefaultValue()).getNumber()),
            int.class,
            afterSerializeField);
      case STRING:
        return new StackManipulation.Compound(
            getValue,
            new TextConstant((String) info.descriptor().getDefaultValue()),
            Object_equals,
            new IfEqual(Object.class, afterSerializeField));
      case BYTE_STRING:
        // We'll use the default instance to get the default value for types that can't be
        // loaded into the constant pool. Since it's a constant, the somewhat indirect reference
        // should get inlined and be the same as a class constant.
        return new StackManipulation.Compound(
            getValue,
            getDefaultInstance,
            invoke(info.getValueMethod()),
            Object_equals,
            new IfEqual(Object.class, afterSerializeField));
      case MESSAGE:
        return new StackManipulation.Compound(
            locals.load(LocalVariable.message),
            invoke(info.hasValueMethod()),
            new IfFalse(afterSerializeField));
      default:
        throw new IllegalStateException("Unknown JavaType: " + info.valueJavaType());
    }
  } else {
    return new StackManipulation.Compound(
        locals.load(LocalVariable.message),
        CodeGenUtil.invoke(info.repeatedValueCountMethod()),
        new IfFalse(afterSerializeField));
  }
}
 

/**
 * Returns the {@link StackManipulation} for setting the value of a normal repeated field.
 *
 * <p>Roughly equivalent to:
 *
 * <pre>{@code
 * ParseSupport.parseArrayStart(parser);
 * while (!ParseSupport.checkArrayEnd(parser)) {
 *   builder.addFoo(readValue());
 * }
 * }</pre>
 */
private StackManipulation setRepeatedFieldValue(
    ProtoFieldInfo info,
    Label beforeReadField,
    LocalVariables<LocalVariable> locals,
    Map<String, FieldDescription> fieldsByName,
    StackManipulation setSingleValue) {
  Label arrayStart = new Label();

  StackManipulation.Compound beforeRead =
      new StackManipulation.Compound(
          locals.load(LocalVariable.parser),
          ParseSupport_parseArrayStart,
          new SetJumpTargetLabel(arrayStart),
          locals.load(LocalVariable.parser),
          ParseSupport_throwIfRepeatedNull,
          locals.load(LocalVariable.parser),
          ParseSupport_checkArrayEnd,
          new IfTrue(beforeReadField));

  Label afterSet = new Label();

  StackManipulation.Compound setValueAndPrepareForNext =
      new StackManipulation.Compound(
          setSingleValue,
          Removal.SINGLE,
          new SetJumpTargetLabel(afterSet),
          locals.load(LocalVariable.parser),
          Parser_nextValue,
          Removal.SINGLE,
          new Goto(arrayStart));

  if (info.valueType() == Type.ENUM) {
    // We special-case enum since we may need to skip unknown values.
    return new StackManipulation.Compound(
        beforeRead,
        locals.load(LocalVariable.parser),
        readValue(info, fieldsByName, locals),
        locals.store(LocalVariable.intvalue),
        locals.load(LocalVariable.intvalue),
        IntegerConstant.forValue(-1),
        new IfEqual(int.class, afterSet),
        locals.load(LocalVariable.builder),
        locals.load(LocalVariable.intvalue),
        setValueAndPrepareForNext);
  } else {
    return new StackManipulation.Compound(
        beforeRead,
        locals.load(LocalVariable.builder),
        locals.load(LocalVariable.parser),
        readValue(info, fieldsByName, locals),
        setValueAndPrepareForNext);
  }
}
 

/**
 * Returns the {@link StackManipulation} for setting the value of a map field.
 *
 * <p>Roughly equivalent to:
 *
 * <pre>{@code
 * ParseSupport.parseObjectStart(parser);
 * while (!ParseSupport.checkObjectEnd(parser.currentToken())) {
 *   builder.putFoo(readKey(), readValue());
 * }
 * }</pre>
 */
private StackManipulation setMapFieldValue(
    ProtoFieldInfo info,
    Label beforeReadField,
    LocalVariables<LocalVariable> locals,
    Map<String, FieldDescription> fieldsByName) {
  final StackManipulation setConcreteValue = invoke(info.setValueMethod());
  final StackManipulation setMapEntry;
  if (info.valueJavaType() == JavaType.MESSAGE) {
    setMapEntry =
        new StackManipulation.Compound(
            TypeCasting.to(new ForLoadedType(info.javaClass())), setConcreteValue);
  } else {
    setMapEntry = setConcreteValue;
  }
  Label mapStart = new Label();
  Label afterSet = new Label();

  StackManipulation.Compound beforeReadKey =
      new StackManipulation.Compound(
          locals.load(LocalVariable.parser),
          ParseSupport_parseObjectStart,
          new SetJumpTargetLabel(mapStart),
          locals.load(LocalVariable.parser),
          Parser_currentToken,
          ParseSupport_checkObjectEnd,
          new IfTrue(beforeReadField));

  StackManipulation.Compound setValueAndPrepareForNext =
      new StackManipulation.Compound(
          setMapEntry,
          Removal.SINGLE,
          new SetJumpTargetLabel(afterSet),
          locals.load(LocalVariable.parser),
          Parser_nextToken,
          Removal.SINGLE,
          new Goto(mapStart));

  if (info.valueType() == Type.ENUM) {
    // We special-case enum since we may need to skip unknown values.
    final LocalVariable keyVar;
    switch (info.mapKeyField().valueJavaType()) {
      case INT:
        keyVar = LocalVariable.intMapKey;
        break;
      case LONG:
        keyVar = LocalVariable.longMapKey;
        break;
      case BOOLEAN:
        keyVar = LocalVariable.boolMapKey;
        break;
      case STRING:
        keyVar = LocalVariable.stringMapKey;
        break;
      default:
        throw new IllegalArgumentException("Invalid map key type");
    }

    return new StackManipulation.Compound(
        beforeReadKey,
        locals.load(LocalVariable.parser),
        readValue(info.mapKeyField(), fieldsByName, locals),
        locals.store(keyVar),
        locals.load(LocalVariable.parser),
        Parser_nextToken,
        Removal.SINGLE,
        locals.load(LocalVariable.parser),
        readValue(info, fieldsByName, locals),
        locals.store(LocalVariable.intvalue),
        locals.load(LocalVariable.intvalue),
        IntegerConstant.forValue(-1),
        new IfEqual(int.class, afterSet),
        locals.load(LocalVariable.builder),
        locals.load(keyVar),
        locals.load(LocalVariable.intvalue),
        setValueAndPrepareForNext);
  } else {
    return new StackManipulation.Compound(
        beforeReadKey,
        locals.load(LocalVariable.builder),
        locals.load(LocalVariable.parser),
        readValue(info.mapKeyField(), fieldsByName, locals),
        locals.load(LocalVariable.parser),
        Parser_nextToken,
        Removal.SINGLE,
        locals.load(LocalVariable.parser),
        readValue(info, fieldsByName, locals),
        setValueAndPrepareForNext);
  }
}
 

/**
 * Returns the {@link StackManipulation} for reading the JSON encoded value for the field. Just
 * dispatches to {@link ParseSupport} based on the field type.
 */
private StackManipulation readValue(
    ProtoFieldInfo field,
    Map<String, FieldDescription> fieldsByName,
    LocalVariables<LocalVariable> locals) {
  switch (field.valueType()) {
    case INT32:
    case SINT32:
    case SFIXED32:
      return ParseSupport_parseInt32;
    case INT64:
    case SINT64:
    case SFIXED64:
      return ParseSupport_parseInt64;
    case BOOL:
      return ParseSupport_parseBool;
    case FLOAT:
      return ParseSupport_parseFloat;
    case DOUBLE:
      return ParseSupport_parseDouble;
    case UINT32:
    case FIXED32:
      return ParseSupport_parseUint32;
    case UINT64:
    case FIXED64:
      return ParseSupport_parseUint64;
    case STRING:
      return ParseSupport_parseString;
    case BYTES:
      return ParseSupport_parseBytes;
    case ENUM:
      return new StackManipulation.Compound(
          CodeGenUtil.getEnumDescriptor(field),
          IntegerConstant.forValue(ignoringUnknownFields),
          ParseSupport_parseEnum);
    case MESSAGE:
    case GROUP:
      return new StackManipulation.Compound(
          FieldAccess.forField(
                  fieldsByName.get(
                      CodeGenUtil.fieldNameForNestedMarshaller(
                          field.valueField().descriptor().getMessageType())))
              .read(),
          locals.load(LocalVariable.currentDepth),
          ParseSupport_parseMessage);
    default:
      throw new IllegalStateException("Unknown field type: " + field.valueType());
  }
}
 

/**
 * {@inheritDoc}
 */
public StackManipulation resolve(TypeDescription instrumentedType) {
    return IntegerConstant.forValue(value);
}