@SuppressWarnings("rawtypes") private static String key(final Executable exec) { if (exec instanceof Method) { return exec.getName() + Type.getMethodDescriptor((Method) exec); } else { return "<init>" + Type.getConstructorDescriptor((Constructor) exec); } } }
/** * Takes given parameters references and returns reference set for given method or constructor. */ public BeanReferences[] resolveReferenceFromValues(final Executable methodOrCtor, final String... parameterReferences) { BeanReferences[] references = convertRefToReferences(parameterReferences); if (references == null || references.length == 0) { references = buildDefaultReferences(methodOrCtor); } if (methodOrCtor.getParameterTypes().length != references.length) { throw new PetiteException("Different number of method parameters and references for: " + methodOrCtor.getDeclaringClass().getName() + '#' + methodOrCtor.getName()); } removeAllDuplicateNames(references); return references; }
private BeanReferences[] updateReferencesWithDefaultsIfNeeded(final Executable methodOrCtor, BeanReferences[] references) { BeanReferences[] defaultReferences = buildDefaultReferences(methodOrCtor); if (references == null || references.length == 0) { references = defaultReferences; } if (methodOrCtor.getParameterTypes().length != references.length) { throw new PetiteException( "Different number of parameters and references for: " + methodOrCtor.getName()); } // apply default parameters for (int i = 0; i < references.length; i++) { BeanReferences parameterReferences = references[i]; if (parameterReferenceIsNotSet(parameterReferences)) { references[i] = defaultReferences[i]; } } return references; }
private static String declarerName(Parameter p) { Executable exec = p.getDeclaringExecutable(); return exec.getDeclaringClass().getName() + '.' + exec.getName(); } }
@Override public Generator<?> parameter(Parameter parameter) { return produceGenerator( new ParameterTypeContext( parameter.getName(), parameter.getAnnotatedType(), parameter.getDeclaringExecutable().getName() ).annotate(parameter)); }
protected String getName() { return executable.getName(); }
public TypeMappingException(Executable executable, Parameter parameter, Exception cause) { super("Parameter \"" + parameter.getName() + "\" of method \"" + executable.getName() + "\" is missing generic type parameters and can not be mapped." + " For details and possible solutions see " + Urls.Errors.AMBIGUOUS_PARAMETER_TYPE, cause); }
@Override public String getName() { return getReflectionMethod().getName(); }
@Override public String getName() { return getReflectionMethod().getName(); }
public static String getSimpleName(Executable executable) { return executable instanceof Constructor ? executable.getDeclaringClass().getSimpleName() : executable.getName(); }
ParameterNameClassVisitor(Executable executable) { super(Opcodes.ASM5); methodName = executable instanceof Constructor ? "<init>" : executable.getName(); parameterTypes = Arrays.stream(executable.getParameterTypes()) .map(Type::getType) .collect(toList()); this.methodVisitor = new ParameterNameMethodVisitor(isStatic(executable.getModifiers()), parameterTypes); }
private static String declarerName(Parameter p) { Executable exec = p.getDeclaringExecutable(); return exec.getDeclaringClass().getName() + '.' + exec.getName(); } }
@Override public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException { boolean result = false; for (Class<? extends Annotation> annotationClass : annotationClasses()) { log.trace("Checking if {} is annotated with {}.", parameterContext.getDeclaringExecutable().getName(), annotationClass.getName()); if (parameterContext.getParameter().isAnnotationPresent(annotationClass)) { log.trace("Found {} on {}.", annotationClass.getName(), parameterContext.getDeclaringExecutable().getName()); result = true; break; } } return result; }
@SuppressWarnings("rawtypes") private static String key(final Executable exec) { if (exec instanceof Method) { return exec.getName() + Type.getMethodDescriptor((Method) exec); } else { return "<init>" + Type.getConstructorDescriptor((Constructor) exec); } } }
public static Signature of(Executable x) { return new Signature(x.getName(), x.getParameterTypes()); }
public static Signature of(Executable x) { return new Signature(x.getName(), x.getParameterTypes()); }
private ParameterTypeContext createParameterTypeContext(Parameter parameter) { Executable exec = parameter.getDeclaringExecutable(); String declarerName = exec.getDeclaringClass().getName() + '.' + exec.getName(); return new ParameterTypeContext( parameter.getName(), parameter.getAnnotatedType(), declarerName, typeVariables) .allowMixedTypes(true).annotate(parameter); }
private ParameterTypeContext createParameterTypeContext(Parameter parameter) { Executable exec = parameter.getDeclaringExecutable(); String declarerName = exec.getDeclaringClass().getName() + '.' + exec.getName(); return new ParameterTypeContext( parameter.getName(), parameter.getAnnotatedType(), declarerName, typeVariables) .allowMixedTypes(true).annotate(parameter); }
@Override public Generator<?> parameter(Parameter parameter) { return produceGenerator( new ParameterTypeContext( parameter.getName(), parameter.getAnnotatedType(), parameter.getDeclaringExecutable().getName() ).annotate(parameter)); }
/** * Takes given parameters references and returns reference set for given method or constructor. */ public BeanReferences[] resolveReferenceFromValues(final Executable methodOrCtor, final String... parameterReferences) { BeanReferences[] references = convertRefToReferences(parameterReferences); if (references == null || references.length == 0) { references = buildDefaultReferences(methodOrCtor); } if (methodOrCtor.getParameterTypes().length != references.length) { throw new PetiteException("Different number of method parameters and references for: " + methodOrCtor.getDeclaringClass().getName() + '#' + methodOrCtor.getName()); } removeAllDuplicateNames(references); return references; }