Java Code Examples for net.bytebuddy.description.method.ParameterDescription#InDefinedShape

@Override
public Advice.OffsetMapping make(ParameterDescription.InDefinedShape target,
                                 AnnotationDescription.Loadable<SimpleMethodSignature> annotation,
                                 AdviceType adviceType) {
    return new Advice.OffsetMapping() {
        @Override
        public Target resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner,
                              Advice.ArgumentHandler argumentHandler, Sort sort) {
            final String className = instrumentedMethod.getDeclaringType().getTypeName();
            String simpleClassName = className.substring(className.lastIndexOf('$') + 1);
            simpleClassName = simpleClassName.substring(simpleClassName.lastIndexOf('.') + 1);
            final String signature = String.format("%s#%s", simpleClassName, instrumentedMethod.getName());
            return Target.ForStackManipulation.of(signature);
        }
    };
}
 

@SuppressWarnings({"rawtypes", "unchecked"})
protected ControllerMethodData(Controller controller, TypeDescription classType, InDefinedShape member, String name, int index)
{
    super(controller, classType, member, name, index);
    if (member.isStatic())
    {
        throw new IllegalStateException("Can't use injections on static methods! (Source: " + member.getDeclaringType().getCanonicalName() + "#" +
                                        member.getName() + " " + member.getDescriptor());
    }
    Map<Class<? extends Annotation>, ? extends Annotation> rawScopeAnnotations = controller.extractRawScopeAnnotations(member);
    Map<Class<? extends Annotation>, ? extends Annotation> rawQualifierAnnotations = controller.extractRawQualifierAnnotations(member);
    this.scopeAnnotations = controller.transformAll(this.classType, name, member, rawScopeAnnotations);
    this.qualifierAnnotations = controller.transformAll(this.classType, name, member, rawQualifierAnnotations);
    ParameterList<ParameterDescription.InDefinedShape> parameters = member.getParameters();
    org.diorite.inject.impl.data.InjectValueData<?, TypeDescription.ForLoadedType.Generic>[] values =
            new org.diorite.inject.impl.data.InjectValueData[parameters.size()];
    int i = 0;
    for (ParameterDescription.InDefinedShape param : parameters)
    {
        values[i] = controller.createValue(i, classType, param.getType(), param, Controller.fixName(param.getType(), param.getName()),
                                           rawScopeAnnotations, rawQualifierAnnotations);
        i++;
    }
    this.values = List.of(values);
}
 

@Override
public Advice.OffsetMapping make(final ParameterDescription.InDefinedShape target,
                                 final AnnotationDescription.Loadable<AnnotationValueExtractor> annotation,
                                 final AdviceType adviceType) {
    return new Advice.OffsetMapping() {
        @Override
        public Target resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Sort sort) {
            return Target.ForStackManipulation.of(getAnnotationValue(instrumentedMethod, annotation.load()));
        }
    };
}
 

@Override
public Advice.OffsetMapping make(ParameterDescription.InDefinedShape target, AnnotationDescription.Loadable<JaxRsPath> annotation, AdviceType adviceType) {
    return new Advice.OffsetMapping() {
        @Override
        public Target resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Sort sort) {
            Object value = null;
            if (useAnnotationValueForTransactionName) {
                value = getTransactionAnnotationValueFromAnnotations(instrumentedMethod, instrumentedType);
            }
            return Target.ForStackManipulation.of(value);
        }
    };
}
 

protected ParameterList<ParameterDescription.InDefinedShape> asList(List<ParameterDescription> elements) {
    List<ParameterDescription.InDefinedShape> parameterDescriptions = new ArrayList<ParameterDescription.InDefinedShape>(elements.size());
    for (ParameterDescription element : elements) {
        parameterDescriptions.add(typePool.describe(Foo.class.getName()).resolve()
                .getDeclaredMethods()
                .filter(is(element.getDeclaringMethod()))
                .getOnly()
                .getParameters()
                .getOnly());
    }
    return new ParameterList.Explicit<ParameterDescription.InDefinedShape>(parameterDescriptions);
}
 

@SuppressWarnings({"unchecked", "rawtypes"})
BinderToConstructor(Controller controller, Class<? extends T> type, Constructor<?> constructor)
{
    this.controller = controller;
    Constructor<? extends T> constructor1 = (Constructor<? extends T>) constructor;
    constructor1.setAccessible(true);

    MethodDescription.ForLoadedConstructor constructorDesc = new MethodDescription.ForLoadedConstructor(constructor);
    Map<Class<? extends Annotation>, ? extends Annotation> scopeMap = controller.extractRawScopeAnnotations(constructorDesc);
    Map<Class<? extends Annotation>, ? extends Annotation> qualifierMap = controller.extractRawQualifierAnnotations(constructorDesc);

    int parameterCount = constructor.getParameterCount();
    ArrayList<ControllerInjectValueData<?>> params = new ArrayList<>(parameterCount);
    ParameterList<ParameterDescription.InDefinedShape> parameters = constructorDesc.getParameters();
    for (int i = 0; i < parameterCount; i++)
    {
        ParameterDescription.InDefinedShape param = parameters.get(i);
        ControllerInjectValueData<Object> value = controller.createValue(- 1, constructorDesc.getDeclaringType(), param.getType(), param,
                                                                         param.getName(), scopeMap, qualifierMap);
        params.add(value);
    }
    this.params = List.of(params.toArray(new ControllerInjectValueData[parameterCount]));

    this.constructor = $this ->
    {
        Object[] args = new Object[parameterCount];
        for (int i = 0; i < parameterCount; i++)
        {
            args[i] = this.params.get(i).tryToGet($this);
        }
        try
        {
            return constructor1.newInstance(args);
        }
        catch (InstantiationException | IllegalAccessException | InvocationTargetException e)
        {
            throw new RuntimeException("Can't bind value to " + constructor1.getDeclaringClass().getName() + " constructor. " +
                                       Arrays.toString(constructor1.getParameterTypes()), e);
        }
    };
}
 

/**
 * {@inheritDoc}
 */
public ParameterList<ParameterDescription.InDefinedShape> getParameters() {
    return new ParameterList.Explicit.ForTypes(this, methodDescription.getParameters().asTypeList().asRawTypes());
}
 

/**
 * {@inheritDoc}
 */
public ParameterList<ParameterDescription.InDefinedShape> getParameters() {
    return new ParameterList.Empty<ParameterDescription.InDefinedShape>();
}
 

/**
 * {@inheritDoc}
 */
public ParameterList<ParameterDescription.InDefinedShape> getParameters() {
    return new ParameterList.Explicit.ForTypes(this, Collections.singletonList(fieldDescription.getType().asRawType()));
}
 

/**
 * {@inheritDoc}
 */
public ParameterList<ParameterDescription.InDefinedShape> getParameters() {
    return new ParameterList.Explicit.ForTypes(this, methodDescription.getParameters().asTypeList().asRawTypes());
}
 

/**
 * {@inheritDoc}
 */
public ParameterList<ParameterDescription.InDefinedShape> getParameters() {
    return new ParameterList.Explicit.ForTypes(this, CompoundList.of(methodDescription.getParameters().asTypeList().asErasures(), placeholderType));
}
 

protected ParameterDescription.InDefinedShape asElement(ParameterDescription element) {
    return element.asDefined();
}
 

/**
 * Exactly matches a given parameter as a {@link ParameterDescription} in its defined shape.
 *
 * @param parameter The parameter to match by its description
 * @param <T>       The type of the matched object.
 * @return An element matcher that exactly matches the given parameter in its defined shape.
 */
public static <T extends ParameterDescription> ElementMatcher.Junction<T> is(ParameterDescription.InDefinedShape parameter) {
    return definedParameter(new EqualityMatcher<ParameterDescription.InDefinedShape>(parameter));
}
 

/**
 * Matches a parameter in its defined shape.
 *
 * @param matcher The matcher to apply to the matched parameter's defined shape.
 * @param <T>     The matched object's type.
 * @return A matcher that matches a matched parameter's defined shape.
 */
public static <T extends ParameterDescription> ElementMatcher.Junction<T> definedParameter(ElementMatcher<? super ParameterDescription.InDefinedShape> matcher) {
    return new DefinedShapeMatcher<T, ParameterDescription.InDefinedShape>(matcher);
}