private static List<String> getComparableParameterNames( ExecutableElement element, boolean skipFirst) { List<? extends VariableElement> parameters = element.getParameters(); if (skipFirst) { parameters = parameters.subList(1, parameters.size()); } List<String> result = new ArrayList<>(parameters.size()); for (VariableElement parameter : parameters) { result.add(parameter.asType().toString()); } return result; }
private static void validateGlideOptionParameters(ExecutableElement executableElement) { if (executableElement.getParameters().isEmpty()) { throw new IllegalArgumentException("@GlideOption methods must take a " + "BaseRequestOptions<?> object as their first parameter, but " + getQualifiedMethodName(executableElement) + " has none"); } VariableElement first = executableElement.getParameters().get(0); TypeMirror expected = first.asType(); if (!isBaseRequestOptions(expected)) { throw new IllegalArgumentException("@GlideOption methods must take a" + " BaseRequestOptions<?> object as their first parameter, but the first parameter in " + getQualifiedMethodName(executableElement) + " is " + expected); } }
@Override protected void processParameters(EComponentWithViewSupportHolder holder, JMethod listenerMethod, JInvocation call, List<? extends VariableElement> parameters) { boolean hasItemParameter = parameters.size() == 1; AbstractJClass narrowAdapterViewClass = getClasses().ADAPTER_VIEW.narrow(getCodeModel().wildcard()); JVar onItemClickParentParam = listenerMethod.param(narrowAdapterViewClass, "parent"); listenerMethod.param(getClasses().VIEW, "view"); JVar onItemClickPositionParam = listenerMethod.param(getCodeModel().INT, "position"); listenerMethod.param(getCodeModel().LONG, "id"); if (hasItemParameter) { VariableElement parameter = parameters.get(0); TypeMirror parameterType = parameter.asType(); if (parameterType.getKind() == TypeKind.INT) { call.arg(onItemClickPositionParam); } else { AbstractJClass parameterClass = codeModelHelper.typeMirrorToJClass(parameterType); call.arg(cast(parameterClass, invoke(onItemClickParentParam, "getAdapter").invoke("getItem").arg(onItemClickPositionParam))); if (parameterClass.isParameterized()) { codeModelHelper.addSuppressWarnings(listenerMethod, "unchecked"); } } } }
public static void validateSwipeTouch(ExecutableElement element) throws IllegalUseException { validateNonPrivateModifier(element); if (element.getParameters().size() != 4) { String msg = "@SwipeTouch must be used on the method with (float, float, float, float) signature"; throw new IllegalUseException(msg); } for (VariableElement variableElement : element.getParameters()) { if (variableElement.asType().getKind() != TypeKind.FLOAT) { String msg = "@SwipeTouch used with method that do not have all 4 float parameters"; throw new IllegalUseException(msg); } } }
@NonNull public Element fromConfigDelegateMethod(@NonNull ExecutableElement method) { return new DelegateMethod.Config(method.getSimpleName().toString(), TypeName.get(method.getReturnType()), getAnnotations(method).getLeft(), method.getParameters().stream().map(p -> ParameterSpec.builder(TypeName.get(p.asType()), p.getSimpleName().toString()).build()).collect(Collectors.toList()), method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()), method.getModifiers(), elements.getDocComment(method)); }
@NonNull @Override public CodeBlock visitEnumConstant(@NonNull VariableElement c, Void v) { return CodeBlock.of("$T.$L", c.asType(), c.getSimpleName()); }
public void hasSeekBarProgressChangeMethodParameters(ExecutableElement executableElement, ElementValidation valid) { List<? extends VariableElement> parameters = executableElement.getParameters(); boolean seekBarParameterFound = false; boolean fromUserParameterFound = false; boolean progressParameterFound = false; for (VariableElement parameter : parameters) { String parameterType = parameter.asType().toString(); if (parameterType.equals(CanonicalNameConstants.SEEKBAR)) { if (seekBarParameterFound) { continue; if (parameter.asType().getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType)) { if (progressParameterFound) { valid.addError("You can have only one parameter of type " + CanonicalNameConstants.INTEGER); continue; if (parameter.asType().getKind() == TypeKind.BOOLEAN || CanonicalNameConstants.BOOLEAN.equals(parameterType)) { if (fromUserParameterFound) { valid.addError("You can have only one parameter of type " + CanonicalNameConstants.BOOLEAN);
protected SortedMap<String, JVar> addMethodParams(ExecutableElement executableElement, RestHolder restHolder, JMethod method) { List<? extends VariableElement> params = executableElement.getParameters(); SortedMap<String, JVar> methodParams = new TreeMap<>(); for (VariableElement parameter : params) { String paramName = parameter.getSimpleName().toString(); String paramType = parameter.asType().toString(); JVar param; if (parameter.asType().getKind().isPrimitive()) { param = method.param(getCodeModel().parseType(paramType), paramName); } else { AbstractJClass parameterClass = codeModelHelper.typeMirrorToJClass(parameter.asType()); param = method.param(parameterClass, paramName); } methodParams.put(paramName, param); } return methodParams; }
/** Create a MethodInfo from AST (an @Implementation method in a shadow class). */ public MethodInfo(ExecutableElement methodElement) { this.name = cleanMethodName(methodElement); for (VariableElement variableElement : methodElement.getParameters()) { TypeMirror varTypeMirror = variableElement.asType(); String paramType = canonicalize(varTypeMirror); String paramTypeWithoutGenerics = typeWithoutGenerics(paramType); paramTypes.add(paramTypeWithoutGenerics); } }
private static void validateGlideTypeParameters(ExecutableElement executableElement) { if (executableElement.getParameters().size() != 1) { throw new IllegalArgumentException("@GlideType methods must take a" + " RequestBuilder object as their first and only parameter, but given multiple for: " + getQualifiedMethodName(executableElement)); } VariableElement first = executableElement.getParameters().get(0); TypeMirror argumentType = first.asType(); if (!argumentType.toString().startsWith("com.bumptech.glide.RequestBuilder")) { throw new IllegalArgumentException("@GlideType methods must take a" + " RequestBuilder object as their first and only parameter, but given: " + argumentType + " for: " + getQualifiedMethodName(executableElement)); } }
@Override protected void processParameters(EComponentWithViewSupportHolder holder, JMethod listenerMethod, JInvocation call, List<? extends VariableElement> parameters) { boolean hasItemParameter = parameters.size() == 1; AbstractJClass narrowAdapterViewClass = getClasses().ADAPTER_VIEW.narrow(getCodeModel().wildcard()); JVar onItemClickParentParam = listenerMethod.param(narrowAdapterViewClass, "parent"); listenerMethod.param(getClasses().VIEW, "view"); JVar onItemClickPositionParam = listenerMethod.param(getCodeModel().INT, "position"); listenerMethod.param(getCodeModel().LONG, "id"); if (hasItemParameter) { VariableElement parameter = parameters.get(0); TypeMirror parameterType = parameter.asType(); if (parameterType.getKind() == TypeKind.INT) { call.arg(onItemClickPositionParam); } else { AbstractJClass parameterClass = codeModelHelper.typeMirrorToJClass(parameterType); call.arg(cast(parameterClass, invoke(onItemClickParentParam, "getAdapter").invoke("getItem").arg(onItemClickPositionParam))); if (parameterClass.isParameterized()) { codeModelHelper.addSuppressWarnings(listenerMethod, "unchecked"); } } } }
@NonNull public Element fromBuilderDelegateMethod(@NonNull ExecutableElement method) { return new DelegateMethod(method.getSimpleName().toString(), TypeName.get(method.getReturnType()), getAnnotations(method).getLeft(), method.getParameters().stream().map(p -> ParameterSpec.builder(TypeName.get(p.asType()), p.getSimpleName().toString()).build()).collect(Collectors.toList()), method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()), method.getModifiers(), elements.getDocComment(method)); }
@Override public Builder visitEnumConstant(VariableElement c, String name) { return builder.addMember(name, "$T.$L", c.asType(), c.getSimpleName()); }
public void hasBeforeTextChangedMethodParameters(ExecutableElement executableElement, ElementValidation valid) { List<? extends VariableElement> parameters = executableElement.getParameters(); boolean charSequenceParameterFound = false; boolean textViewParameterFound = false; for (VariableElement parameter : parameters) { String parameterType = parameter.asType().toString(); if (parameterType.equals(CanonicalNameConstants.CHAR_SEQUENCE)) { if (charSequenceParameterFound) { continue; if (parameter.asType().getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType)) { String parameterName = parameter.toString(); if ("start".equals(parameterName) || "count".equals(parameterName) || "after".equals(parameterName)) {
/** * Verify the annotated method. */ private void validateMethod(ExecutableElement methodElement) { if (methodElement.getModifiers().contains(Modifier.ABSTRACT)) { // no abstract throw new RuntimeException(String.format("The method(%s) annotated by @Route is abstract.", methodElement.getSimpleName())); } List<? extends VariableElement> parameters = methodElement.getParameters(); if (!parameters.isEmpty()) { // params must be annotated by @InjectParam for (VariableElement variableElement : parameters) { // param's type must be String if (!variableElement.asType().toString().equals("java.lang.String")) { throw new RuntimeException(String.format("The method's(%s) parameters must be String.", methodElement.getSimpleName())); } InjectParam injectParam = variableElement.getAnnotation(InjectParam.class); if (injectParam == null) { throw new RuntimeException(String.format("The method's(%s) parameters must be annotated by @InjectParam.", methodElement.getSimpleName())); } if ("".equals(injectParam.key().trim())) { throw new RuntimeException(String.format("The parameter(%s) annotated by @InjectParam must has a non-empty key.", variableElement.getSimpleName())); } } } }
private void collectSimpleUsages(TypeElement type, Map<String, TypeMirror> collected) { for (ExecutableElement method : ElementFilter.methodsIn(elements.getAllMembers(type))) { if (shouldConsideredAsTypeUsage(method)) { collectIfSimpleType(method.getReturnType(), collected); for (VariableElement parameter : method.getParameters()) { collectIfSimpleType(parameter.asType(), collected); } } } }
private boolean hasActivityOptions(TypeElement type, int optionsParamPosition) { if (type == null) { return false; } for (ExecutableElement element : ElementFilter.methodsIn(elementUtils.getAllMembers(type))) { if (element.getSimpleName().contentEquals("startActivity")) { List<? extends VariableElement> parameters = element.getParameters(); if (parameters.size() == optionsParamPosition + 1) { VariableElement parameter = parameters.get(optionsParamPosition); if (parameter.asType().toString().equals(CanonicalNameConstants.BUNDLE)) { return true; } } } } return false; }
private CharSequence appendParameters( ExecutableElement m, StringBuilder signature, DeclaringType declaringType, boolean withTypes, boolean allFinal) { signature.append("("); boolean notFirst = false; for (VariableElement p : m.getParameters()) { if (notFirst) { signature.append(", "); } if (allFinal) { signature.append("final "); } if (withTypes) { signature.append(printType(p, p.asType(), declaringType)); signature.append(" "); } signature.append(p.getSimpleName()); notFirst = true; } return signature.append(")"); }