@Override public Void visitArray(ArrayType arrayType, Void v) { TypeMirror type = arrayType.getComponentType(); if (type instanceof PrimitiveType) { result.append(type.toString()); // Don't box, since this is an array. } else { typeToString(arrayType.getComponentType(), result, innerClassSeparator); } result.append("[]"); return null; } @Override public Void visitTypeVariable(TypeVariable typeVariable, Void v) {
private boolean checkIfParameterizedTypeReferenceShouldBeUsed(TypeMirror returnType) { switch (returnType.getKind()) { case DECLARED: return !((DeclaredType) returnType).getTypeArguments().isEmpty(); case ARRAY: ArrayType arrayType = (ArrayType) returnType; TypeMirror componentType = arrayType.getComponentType(); return checkIfParameterizedTypeReferenceShouldBeUsed(componentType); } return false; }
/** * Returns a method name from the {@code android.content.res.Resources} class for array resource * binding, null if the element type is not supported. */ private static @Nullable FieldResourceBinding.Type getArrayResourceMethodName(Element element) { TypeMirror typeMirror = element.asType(); if (TYPED_ARRAY_TYPE.equals(typeMirror.toString())) { return FieldResourceBinding.Type.TYPED_ARRAY; } if (TypeKind.ARRAY.equals(typeMirror.getKind())) { ArrayType arrayType = (ArrayType) typeMirror; String componentType = arrayType.getComponentType().toString(); if (STRING_TYPE.equals(componentType)) { return FieldResourceBinding.Type.STRING_ARRAY; } else if ("int".equals(componentType)) { return FieldResourceBinding.Type.INT_ARRAY; } else if ("java.lang.CharSequence".equals(componentType)) { return FieldResourceBinding.Type.TEXT_ARRAY; } } return null; }
private static boolean isArrayOfStrings(TypeMirror type) { return type.getKind() == TypeKind.ARRAY && ((ArrayType) type).getComponentType().toString().equals(String.class.getName()); }
@Override public Boolean visitArray(ArrayType t, Element element) { TypeMirror componentMirror = t.getComponentType(); TypeElement componentElement = (TypeElement) context.getTypeUtils().asElement( componentMirror ); return Constants.BASIC_ARRAY_TYPES.contains( componentElement.getQualifiedName().toString() ); }
@Override public String visitArray(ArrayType t, Builder builder) { return t.getComponentType().accept(this, builder) + "[]"; }
@Override public List<String> visitArray(ArrayType t, Boolean p) { List<String> rv = new ArrayList<String>(visit(t.getComponentType())); rv.add("[]"); return rv; }
@Override public TypeElement visitArray(ArrayType t, Void p) { return visit(t.getComponentType()); }
private void validateArrayType(ArrayType mirror) throws EpoxyProcessorException { // Check that the type of the array implements hashCode TypeMirror arrayType = mirror.getComponentType(); try { validateImplementsHashCode(arrayType); } catch (EpoxyProcessorException e) { throwError("Type in array does not implement hashCode. Type: %s", arrayType.toString()); } }
AttributeModel(ExecutableElement element) { this.element = element; this.name = element.getSimpleName().toString(); TypeMirror type = element.getReturnType(); this.isArray = type.getKind() == TypeKind.ARRAY; this.type = this.isArray ? ((ArrayType) type).getComponentType() : type; this.kind = AttributeTypeKind.from(this.type); this.suffix = this.isArray ? "[]" : ""; this.mirrorModel = getMirrorModelIfAnnotation(); }
private AbstractJClass typeMirrorToJClass(ArrayType arrayType, Map<String, TypeMirror> substitute) { AbstractJClass refClass = typeMirrorToJClass(arrayType.getComponentType(), substitute); return refClass.array(); }
@Override public Type visitArray(ArrayType arrayType, Boolean p) { if (arrayType.getComponentType() instanceof PrimitiveType) { Type type = getPrimitive((PrimitiveType) arrayType.getComponentType()); if (type != null) { return type.asArrayType(); } } return visit(arrayType.getComponentType(), p).asArrayType(); }
static ArrayTypeName get( ArrayType mirror, Map<TypeParameterElement, TypeVariableName> typeVariables) { return new ArrayTypeName(get(mirror.getComponentType(), typeVariables)); }
@Override public Type visitArray(ArrayType t, Type.Parameters p) { return factory.array(t.getComponentType().accept(this, p)); }
public void canBePutInABundle(Element element, ElementValidation valid) { TypeMirror typeMirror = element.asType(); String typeString = element.asType().toString(); if (!isKnownBundleCompatibleType(typeString)) { if (typeMirror instanceof ArrayType) { ArrayType arrayType = (ArrayType) element.asType(); typeMirror = arrayType.getComponentType(); } if (typeMirror.getKind() != TypeKind.NONE) { TypeMirror parcelableType = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.PARCELABLE).asType(); TypeMirror serializableType = annotationHelper.typeElementFromQualifiedName("java.io.Serializable").asType(); if (typeString.startsWith(CanonicalNameConstants.SPARSE_ARRAY)) { DeclaredType declaredType = (DeclaredType) typeMirror; List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); if (typeArguments.size() != 1 || !annotationHelper.isSubtype(typeArguments.get(0), parcelableType)) { valid.addError("Unrecognized type. The type argument of SparseArray should implement Parcelable."); } } else if (!annotationHelper.isSubtype(typeMirror, parcelableType) && !annotationHelper.isSubtype(typeMirror, serializableType) && !parcelerHelper.isParcelType(typeMirror)) { valid.addError("Unrecognized type. Please let your attribute be primitive or implement Serializable or Parcelable or an annotated Parceler bean."); } } } }
public static String toArrayTypeString(ArrayType type, Context context) { TypeMirror componentType = type.getComponentType(); if ( componentType.getKind().isPrimitive() ) { return PRIMITIVES.get( componentType.getKind() ) + "[]"; } // When an ArrayType is annotated with an annotation which uses TYPE_USE targets, // we cannot simply take the TypeMirror returned by #getComponentType because it // itself is an AnnotatedType. // // The simplest approach here to get the TypeMirror for both ArrayType use cases // is to use the visitor to retrieve the underlying TypeMirror. TypeMirror component = componentType.accept( new SimpleTypeVisitor6<TypeMirror, Void>() { @Override protected TypeMirror defaultAction(TypeMirror e, Void aVoid) { return e; } }, null ); return extractClosestRealTypeAsString( component, context ) + "[]"; }
@Nullable private TypeMirror inferContainedType(TypeMirror type) { if (type.getKind() == TypeKind.DECLARED) { DeclaredType declaredType = (DeclaredType) type; if (isIterableType(declaredType) || isOptionalType(declaredType)) { // TBD wrong logic to unpack, need to create super utility for introspecting type // hierarchy. Need to be fixed. List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); return typeArguments.size() == 1 ? upperBound(typeArguments.get(0)) : objectType; } } if (type instanceof ArrayType) { return upperBound(((ArrayType) type).getComponentType()); } return null; }
if (elementType.getKind() == TypeKind.ARRAY) { ArrayType arrayType = (ArrayType) elementType; viewType = arrayType.getComponentType(); kind = FieldCollectionViewBinding.Kind.ARRAY; } else if (LIST_TYPE.equals(erasedType)) {
public static Type typeFor(TypeMirror typeMirror, TypeMirror typeConverterType, Elements elements, Types types) { TypeMirror genericClassTypeMirror = types.erasure(typeMirror); boolean hasTypeConverter = typeConverterType != null && !typeConverterType.toString().equals("void"); Type type; if (!hasTypeConverter && typeMirror instanceof ArrayType) { TypeMirror arrayTypeMirror = ((ArrayType)typeMirror).getComponentType(); type = new ArrayCollectionType(Type.typeFor(arrayTypeMirror, null, elements, types)); } else if (!hasTypeConverter && !genericClassTypeMirror.toString().equals(typeMirror.toString())) { type = CollectionType.collectionTypeFor(typeMirror, genericClassTypeMirror, elements, types); if (type == null) { if (typeMirror.toString().contains("?")) { throw new RuntimeException("Generic types with wildcards are currently not supported by LoganSquare."); } try { type = new ParameterizedTypeField(TypeName.get(typeMirror)); } catch (Exception ignored) { } } } else { type = FieldType.fieldTypeFor(typeMirror, typeConverterType, elements, types); } return type; }
} else if (expectedType.getKind() == TypeKind.ARRAY) { ArrayType arrayType = (ArrayType) expectedType; TypeMirror componentType = arrayType.getComponentType(); return resolveResponseClass(componentType, holder, false).array();