protected AbstractJClass getMethodReturnClass(Element element, RestHolder holder) { ExecutableElement executableElement = (ExecutableElement) element; return codeModelHelper.typeMirrorToJClass(executableElement.getReturnType()); }
private List<AbstractJClass> typeBoundsToJClass(List<? extends TypeMirror> bounds, Map<String, TypeMirror> actualTypes) { if (bounds.isEmpty()) { return Collections.singletonList(environment.getClasses().OBJECT); } else { List<AbstractJClass> jClassBounds = new ArrayList<>(); for (TypeMirror bound : bounds) { jClassBounds.add(typeMirrorToJClass(bound, actualTypes)); } return jClassBounds; } }
public AbstractJClass narrowGeneratedClass(AbstractJClass generatedClass, TypeMirror fromTypeArguments) { DeclaredType type = (DeclaredType) fromTypeArguments; for (TypeMirror param : type.getTypeArguments()) { AbstractJClass paramClass = typeMirrorToJClass(param); generatedClass = generatedClass.narrow(paramClass); } return generatedClass; }
@Override public Void visitType(TypeMirror t, String p) { AbstractJClass annotationClass = helper.typeMirrorToJClass(t); use.param(p, annotationClass); return null; }
@Override public Void visitAnnotation(AnnotationMirror a, String p) { AbstractJClass annotationJClass = helper.typeMirrorToJClass(a.getAnnotationType()); use.annotationParam(p, annotationJClass); return null; } };
@Override public Void visitType(TypeMirror t, JAnnotationArrayMember p) { AbstractJClass annotationClass = helper.typeMirrorToJClass(t); p.param(annotationClass); return null; }
protected final IJExpression castArgumentIfNecessary(T holder, String baseType, JVar param, Element element) { IJExpression argument = param; TypeMirror typeMirror = element.asType(); if (!baseType.equals(typeMirror.toString())) { AbstractJClass typeMirrorToJClass = codeModelHelper.typeMirrorToJClass(typeMirror); argument = JExpr.cast(typeMirrorToJClass, param); } return argument; }
@Override public Void visitEnumConstant(VariableElement c, String p) { AbstractJClass annotationClass = helper.typeMirrorToJClass(c.asType()); JEnumConstantRef ref = JExpr.enumConstantRef(annotationClass, c.getSimpleName().toString()); use.param(p, ref); return null; }
@Override public Void visitEnumConstant(VariableElement c, JAnnotationArrayMember p) { AbstractJClass annotationClass = helper.typeMirrorToJClass(c.asType()); JEnumConstantRef ref = JExpr.enumConstantRef(annotationClass, c.getSimpleName().toString()); p.param(ref); return null; }
private AbstractJClass typeMirrorToJClass(DeclaredType declaredType, Map<String, TypeMirror> substitute) { String declaredTypeName = declaredType.asElement().toString(); AbstractJClass declaredClass = environment.getJClass(declaredTypeName); List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); List<AbstractJClass> typeArgumentJClasses = new ArrayList<>(); for (TypeMirror typeArgument : typeArguments) { typeArgumentJClasses.add(typeMirrorToJClass(typeArgument, substitute)); } if (typeArgumentJClasses.size() > 0) { declaredClass = declaredClass.narrow(typeArgumentJClasses); } return declaredClass; }
public void copyAnnotation(IJAnnotatable annotatable, AnnotationMirror annotationMirror) { Map<? extends ExecutableElement, ? extends AnnotationValue> parameters = annotationMirror.getElementValues(); if (!hasAnnotation(annotatable, annotationMirror) || annotatable instanceof JAnnotationArrayMember) { AbstractJClass annotation = typeMirrorToJClass(annotationMirror.getAnnotationType()); JAnnotationUse annotate = annotatable.annotate(annotation); for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> param : parameters.entrySet()) { param.getValue().accept(new AnnotationParamExtractor(annotate, this), param.getKey().getSimpleName().toString()); } } }
public void copyNonAAAnnotations(IJAnnotatable annotatable, List<? extends AnnotationMirror> annotationMirrors) { for (AnnotationMirror annotationMirror : annotationMirrors) { if (annotationMirror.getAnnotationType().asElement().getAnnotation(Inherited.class) == null) { AbstractJClass annotationClass = typeMirrorToJClass(annotationMirror.getAnnotationType()); if (!environment.isAndroidAnnotation(annotationClass.fullName()) && !IGNORED_ANNOTATIONS.contains(annotationClass.fullName())) { copyAnnotation(annotatable, annotationMirror); } } } }
@Override public void process(Element element, EActivityHolder holder) throws JClassAlreadyExistsException { String fieldName = element.getSimpleName().toString(); AbstractJClass fieldType = codeModelHelper.typeMirrorToJClass(element.asType()); NonConfigurationHolder ncHolder = holder.getNonConfigurationHolder(); JFieldVar ncHolderField = ncHolder.createField(fieldName, fieldType); injectInInit(element, holder, fieldName, ncHolderField); retainInOnRetain(holder, fieldName, ncHolderField); }
private void processMethod(Element element, T holder) { ExecutableElement executableElement = (ExecutableElement) element; VariableElement param = executableElement.getParameters().get(0); String methodName = executableElement.getSimpleName().toString(); JBlock block = createBlock(holder, true); AbstractJClass type = codeModelHelper.typeMirrorToJClass(param.asType()); JVar fieldRef = block.decl(type, param.getSimpleName().toString(), getDefault(param.asType())); handler.assignValue(block, fieldRef, holder, element, param); block.add(JExpr.invoke(methodName).arg(fieldRef)); }
public IJExpression getExtraValue(VariableElement parameter, JVar extras, JBlock block, JMethod annotatedMethod, JDefinedClass generatedClass) { String parameterName = parameter.getSimpleName().toString(); AbstractJClass parameterClass = codeModelHelper.typeMirrorToJClass(parameter.asType()); String extraKey = getAnnotationValue(parameter); if (extraKey == null || extraKey.isEmpty()) { extraKey = parameterName; } BundleHelper bundleHelper = new BundleHelper(getEnvironment(), parameter.asType()); IJExpression restoreMethodCall = bundleHelper.getExpressionToRestoreFromBundle(parameterClass, extras, getStaticExtraField(generatedClass, extraKey), annotatedMethod); return block.decl(parameterClass, parameterName, restoreMethodCall); }
private void addParamToMethod(JMethod method, VariableElement parameter, int mod, Map<String, TypeMirror> actualTypes, boolean varParam) { String parameterName = parameter.getSimpleName().toString(); AbstractJClass parameterClass = typeMirrorToJClass(parameter.asType(), actualTypes); JVar param = varParam ? method.varParam(mod, parameterClass.elementType(), parameterName) : method.param(mod, parameterClass, parameterName); copyNonAAAnnotations(param, parameter.getAnnotationMirrors()); }
private IJExpression instantiateArrayList(TypeMirror viewType, EComponentWithViewSupportHolder holder, String name) { TypeElement arrayListTypeElement = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.ARRAYLIST); DeclaredType arrayListType = getProcessingEnvironment().getTypeUtils().getDeclaredType(arrayListTypeElement, viewType); AbstractJClass arrayListClass = codeModelHelper.typeMirrorToJClass(arrayListType); return holder.getOnViewChangedBodyBeforeInjectionBlock().decl(arrayListClass, name, _new(arrayListClass)); }
@Override public void assignValue(JBlock targetBlock, IJAssignmentTarget fieldRef, EComponentWithViewSupportHolder holder, Element element, Element param) { TypeMirror viewType = extractViewClass(param); AbstractJClass viewClass = codeModelHelper.typeMirrorToJClass(viewType); String listName = getListName(element, param); IJExpression arrayList = instantiateArrayList(viewType, holder, "list_" + listName); List<JFieldRef> idsRefs = annotationHelper.extractAnnotationFieldRefs(element, IRClass.Res.ID, true); for (JFieldRef idRef : idsRefs) { addViewToListIfNotNull(arrayList, viewClass, idRef, holder); } targetBlock.add(fieldRef.assign(arrayList)); }
private void listenerFields(Element element, EActivityHolder holder) { List<TypeMirror> listenerTypeMirrors = extractListenerTypeMirrors(element); int i = 1; for (TypeMirror listenerTypeMirror : listenerTypeMirrors) { AbstractJClass listenerClass = codeModelHelper.typeMirrorToJClass(listenerTypeMirror); JFieldVar listener = holder.getGeneratedClass().field(JMod.PRIVATE, listenerClass, "listener" + i + generationSuffix()); codeModelHelper.addSuppressWarnings(listener, "unused"); listener.annotate(getJClass(RoboGuiceClasses.INJECT)); i++; } }
public IJExpression createParameterizedTypeReferenceAnonymousSubclassInstance(TypeMirror returnType) { AbstractJClass narrowedTypeReference = getEnvironment().getJClass(RestSpringClasses.PARAMETERIZED_TYPE_REFERENCE).narrow(codeModelHelper.typeMirrorToJClass(returnType)); JDefinedClass anonymousClass = getEnvironment().getCodeModel().anonymousClass(narrowedTypeReference); return JExpr._new(anonymousClass); }