Refine search
private boolean typeMatchesExpected( TypeMirror returnType, ExecutableElement executableElement) { if (!(returnType instanceof DeclaredType)) { return false; } List<? extends TypeMirror> typeArguments = ((DeclaredType) returnType).getTypeArguments(); if (typeArguments.size() != 1) { return false; } TypeMirror argument = typeArguments.get(0); String expected = getGlideTypeValue(executableElement); return argument.toString().equals(expected); }
private boolean isOptionalType(DeclaredType parametrizedType) { return parametrizedType.asElement().getSimpleName().contentEquals(OPTIONAL_TYPE_SIMPLE_NAME) && parametrizedType.getTypeArguments().size() == 1; } }
private TypeElement visitInterface(DeclaredType t) { if (t.getTypeArguments().isEmpty()) { return (TypeElement) t.asElement(); } else { int count = t.getTypeArguments().size(); if (t.asElement().toString().startsWith("java.util")) { return t.getTypeArguments().get(count - 1).accept(this, null); } else { return (TypeElement) t.asElement(); } } }
private TypeMirror extractViewClass(Element element) { DeclaredType elementType = (DeclaredType) element.asType(); List<? extends TypeMirror> elementTypeArguments = elementType.getTypeArguments(); TypeMirror viewType = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.VIEW).asType(); if (!elementTypeArguments.isEmpty()) { viewType = elementTypeArguments.get(0); } return viewType; }
public boolean isParcelType(TypeMirror typeMirror, boolean root) { if (typeMirror instanceof DeclaredType && getElementUtils().getTypeElement(CanonicalNameConstants.PARCEL_ANNOTATION) != null) { DeclaredType declaredType = (DeclaredType) typeMirror; TypeElement element = (TypeElement) declaredType.asElement(); String name = element.getQualifiedName().toString(); if (isAnnotatedWith(element, CanonicalNameConstants.PARCEL_ANNOTATION)) { return true; } if (SUPPORTED_PARCEL_TYPES.containsKey(name)) { boolean genericsMatch = true; Integer genericsSize = SUPPORTED_PARCEL_TYPES.get(name); if (genericsSize == declaredType.getTypeArguments().size() && (!root || genericsSize > 0)) { for (int i = 0; i < genericsSize; i++) { genericsMatch &= isParcelType(declaredType.getTypeArguments().get(i), false); } return genericsMatch; } } } return false; } }
private void collectIfSimpleType(TypeMirror type, Map<String, TypeMirror> collected) { if (type.getKind() == TypeKind.DECLARED) { DeclaredType declared = (DeclaredType) type; if (declared.getTypeArguments().isEmpty()) { collected.put(declared.asElement().getSimpleName().toString(), declared); } } }
@Override public Boolean visitDeclared( DeclaredType list, Void aVoid ) { List<? extends TypeMirror> typeArguments = list.getTypeArguments(); return typeArguments.size() == 1 && test( typeArguments.get( 0 ) ); } }.visit( typeMirror );
@Override public Void visitDeclared(DeclaredType declaredType, Void v) { TypeElement typeElement = (TypeElement) declaredType.asElement(); rawTypeToString(result, typeElement, innerClassSeparator); List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); if (!typeArguments.isEmpty()) { result.append("<"); for (int i = 0; i < typeArguments.size(); i++) { if (i != 0) { result.append(", "); } typeToString(typeArguments.get(i), result, innerClassSeparator); } result.append(">"); } return null; } @Override public Void visitPrimitive(PrimitiveType primitiveType, Void v) {
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 extendsListOfView(Element element, ElementValidation valid) { DeclaredType elementType = (DeclaredType) element.asType(); List<? extends TypeMirror> elementTypeArguments = elementType.getTypeArguments(); TypeMirror viewType = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.VIEW).asType(); if (!elementType.toString().equals(CanonicalNameConstants.LIST) && elementTypeArguments.size() == 1 && !annotationHelper.isSubtype(elementTypeArguments.get(0), viewType)) { valid.invalidate(); valid.addError("%s can only be used on a " + CanonicalNameConstants.LIST + " of elements extending " + CanonicalNameConstants.VIEW); } }
Element element = ((DeclaredType) typeMirror).asElement(); if (element.getKind().isClass() || element.getKind().isInterface()) { tempTypeElement = (TypeElement) element; collection = !map && find("java.util.Collection", tempTypeElement); aux = ((DeclaredType) typeMirror).getTypeArguments(); actualGenericTypeArguments = new ArrayList<String>(); for (TypeMirror typeMirror : aux) { actualGenericTypeArguments = Arrays.asList(aux.get(0).toString()); } else { actualGenericTypeArguments = Collections.emptyList();
List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); if (typeArguments.size() > 0) { StringBuilder typeString = new StringBuilder(declaredType.asElement().toString()); typeString.append('<'); for (int i = 0; i < typeArguments.size(); i++) { Element element = declaredType.asElement(); if (!(element instanceof TypeElement)) { return false;
private TypeMirror getEntityOrIdType(Element element, int index) { if (isSubtypeOfDao(element.asType())) { DeclaredType declaredType = (DeclaredType) element.asType(); List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); if (typeArguments.size() == 2) { return typeArguments.get(index); } } List<? extends TypeMirror> superTypes = helper.directSupertypes(element.asType()); for (TypeMirror superType : superTypes) { if (superType.getKind() == TypeKind.DECLARED && isSubtypeOfDao(superType)) { DeclaredType superDeclaredType = (DeclaredType) superType; List<? extends TypeMirror> typeArguments = superDeclaredType.getTypeArguments(); if (typeArguments.size() == 2) { return typeArguments.get(index); } } } return null; }
List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); final TypeMirror typeArgument = typeArguments.get(0); TypeMirror typeSecondArgument = typeArguments.get(1); if (typeSecondArgument.getKind() == TypeKind.DECLARED) { TypeElement typeElement = (TypeElement) ((DeclaredType) typeSecondArgument).asElement(); this.containedSecondaryTypeElement = typeElement; TypeElement typeElement = (TypeElement) ((DeclaredType) typeMirror).asElement(); this.containedTypeElement = typeElement;
@Override public TypeName visitDeclared(DeclaredType t, Void p) { ClassName rawType = ClassName.get((TypeElement) t.asElement()); TypeMirror enclosingType = t.getEnclosingType(); TypeName enclosing = (enclosingType.getKind() != TypeKind.NONE) && !t.asElement().getModifiers().contains(Modifier.STATIC) ? enclosingType.accept(this, null) : null; if (t.getTypeArguments().isEmpty() && !(enclosing instanceof ParameterizedTypeName)) { return rawType; } List<TypeName> typeArgumentNames = new ArrayList<>(); for (TypeMirror mirror : t.getTypeArguments()) { typeArgumentNames.add(get(mirror, typeVariables)); } return enclosing instanceof ParameterizedTypeName ? ((ParameterizedTypeName) enclosing).nestedClass( rawType.simpleName(), typeArgumentNames) : new ParameterizedTypeName(null, rawType, typeArgumentNames); }
public AbstractJClass retrieveResponseClass(TypeMirror returnType, RestHolder holder) { String returnTypeString = returnType.toString(); AbstractJClass responseClass; if (returnTypeString.startsWith(RESPONSE_ENTITY)) { DeclaredType declaredReturnType = (DeclaredType) returnType; if (declaredReturnType.getTypeArguments().size() > 0) { responseClass = resolveResponseClass(declaredReturnType.getTypeArguments().get(0), holder, false); } else { responseClass = getEnvironment().getJClass(RESPONSE_ENTITY); } } else { responseClass = resolveResponseClass(returnType, holder, true); } return responseClass; }
return typeMirror.toString().toUpperCase().charAt(0) + typeMirror.toString().substring(1); } else if (typeMirror instanceof DeclaredType) { Element element = ((DeclaredType) typeMirror).asElement(); if (element instanceof TypeElement) { if (isSubtype(element, "java.util.List")) { // ArrayList List<? extends TypeMirror> typeArgs = ((DeclaredType) typeMirror).getTypeArguments(); if (typeArgs != null && !typeArgs.isEmpty()) { TypeMirror argType = typeArgs.get(0); if (isSubtype(argType, "java.lang.Integer")) { return "IntegerArrayList"; return compType.toString().toUpperCase().charAt(0) + compType.toString().substring(1) + "Array"; } else if (compType instanceof DeclaredType) { Element compElement = ((DeclaredType) compType).asElement(); if (compElement instanceof TypeElement) { if (isSubtype(compElement, "java.lang.String")) {
List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); if (typeArguments.size() > 0) { StringBuilder typeString = new StringBuilder(declaredType.asElement().toString()); typeString.append('<'); for (int i = 0; i < typeArguments.size(); i++) { Element element = declaredType.asElement(); if (!(element instanceof TypeElement)) { return false;
private Map<String, TypeMirror> getActualTypes(Types typeUtils, DeclaredType baseClass, TypeMirror annotatedClass) { List<TypeMirror> superTypes = new ArrayList<>(); superTypes.add(annotatedClass); while (!superTypes.isEmpty()) { TypeMirror x = superTypes.remove(0); if (typeUtils.isSameType(typeUtils.erasure(x), typeUtils.erasure(baseClass))) { DeclaredType type = (DeclaredType) x; Map<String, TypeMirror> actualTypes = new HashMap<>(); for (int i = 0; i < type.getTypeArguments().size(); i++) { TypeMirror actualArg = type.getTypeArguments().get(i); TypeMirror formalArg = baseClass.getTypeArguments().get(i); if (!typeUtils.isSameType(actualArg, formalArg)) { actualTypes.put(formalArg.toString(), actualArg); } } return actualTypes; } superTypes.addAll(typeUtils.directSupertypes(x)); } return Collections.emptyMap(); }
@Override public Boolean visitDeclared(DeclaredType t, State state) { if (t.asElement().getKind().equals(ElementKind.ENUM)) { return true; TypeElement proxyElement = (TypeElement) t.asElement(); state.maybeScanProxy(proxyElement); state.requireMapping(proxyElement); if (asId.getTypeArguments().isEmpty()) { return false; return asId.getTypeArguments().get(0).accept(this, state); DeclaredType asCollection = (DeclaredType) State.viewAs(state.findType(Collection.class), t, state); if (asCollection.getTypeArguments().isEmpty()) { return false; return t.getTypeArguments().get(0).accept(this, state); DeclaredType asMap = (DeclaredType) State.viewAs(mapType, t, state); if (asMap.getTypeArguments().isEmpty()) { return false; return t.getTypeArguments().get(0).accept(this, state) && t.getTypeArguments().get(1).accept(this, state);