private static String getBindingKey(ParameterizedType type) { StringBuilder sb = new StringBuilder(); sb.append(type.owner() == null ? "L" + type.name().toString().replace('.', '/') : getGeneralTypeBindingKey(type.owner())); sb.append('<'); for (Type argument : type.arguments()) { sb.append(getGeneralTypeBindingKey(argument)); } sb.append('>'); if (type.owner() == null) { sb.append(';'); } return sb.toString(); }
ParameterizedType copyType(Type[] parameters) { return new ParameterizedType(name(), parameters, owner, annotationArray()); }
public String toString() { StringBuilder builder = new StringBuilder(); if (owner != null) { builder.append(owner); builder.append('.'); appendAnnotations(builder); builder.append(name().local()); } else { appendAnnotations(builder); builder.append(name()); } if (arguments.length > 0) { builder.append('<'); builder.append(arguments[0]); for (int i = 1; i < arguments.length; i++) { builder.append(", ").append(arguments[i]); } builder.append('>'); } return builder.toString(); }
@Override ParameterizedType copyType(AnnotationInstance[] newAnnotations) { return new ParameterizedType(name(), arguments, owner, newAnnotations); }
case PARAMETERIZED_TYPE: ParameterizedType parameterizedType = type.asParameterizedType(); addClassName(parameterizedType.name()); addType(parameterizedType.owner()); addTypeList(parameterizedType.argumentsArray()); break; case PRIMITIVE:
@Override public String name() { return getType().name().toString(); }
private Map<DotName, Type> buildOwnerMap(Type type) { Map<DotName, Type> pTypeTree = new HashMap<DotName, Type>(); Type nextType = type; do { pTypeTree.put(nextType.name(), nextType); nextType = nextType instanceof ParameterizedType ? nextType.asParameterizedType().owner() : null; } while (nextType != null); return pTypeTree; }
last = intern(oType != null ? convertParameterized(oType).copyType(last) : new ParameterizedType(currentName, null, last)); } else if (oType != null) { last = oType;
Type[] arguments = parameterizedType.argumentsArray().clone(); int pos = element.pos; if (pos >= arguments.length) { return intern(parameterizedType.copyType(arguments));
/** * Create a new mock instance. * * @param name the name of this type * @param arguments an array of types representing arguments to this type * @param owner the enclosing type if annotated or parameterized, otherwise null * @return the mock instance * @since 2.1 */ public static ParameterizedType create(DotName name, Type[] arguments, Type owner) { return new ParameterizedType(name, arguments, owner); }
@Override public Stream<IJavaType> arguments() { return getType().arguments().stream().map(Wrappers::wrap); }
private Type searchTypePath(Type type, TypeAnnotationState typeAnnotationState) { PathElementStack elements = typeAnnotationState.pathElements; PathElement element = elements.pop(); if (element == null) { return type; } switch (element.kind) { case ARRAY: { ArrayType arrayType = type.asArrayType(); int dimensions = arrayType.dimensions(); while (--dimensions > 0 && elements.size() > 0 && elements.peek().kind == PathElement.Kind.ARRAY) { elements.pop(); } assert dimensions == 0; return searchTypePath(arrayType.component(), typeAnnotationState); } case PARAMETERIZED: { ParameterizedType parameterizedType = type.asParameterizedType(); return searchTypePath(parameterizedType.argumentsArray()[element.pos], typeAnnotationState); } case WILDCARD_BOUND: { return searchTypePath(type.asWildcardType().bound(), typeAnnotationState); } case NESTED: { int depth = popNestedDepth(elements); return searchNestedType(type, depth, typeAnnotationState); } } throw new IllegalStateException("Unknown path element"); }
case PARAMETERIZED_TYPE: ParameterizedType parameterizedType = type.asParameterizedType(); Type owner = parameterizedType.owner(); stream.writePackedU32(positionOf(parameterizedType.name())); writeReference(stream, owner, true); writeReferenceOrFull(stream, parameterizedType.argumentsArray()); break;
return "L" + ( (ParameterizedType) p ).name().toString().replace('.', '/') + ";"; //$NON-NLS-1$ //$NON-NLS-2$
@Override public IJavaType owner() { return wrap(getType().owner()); }
ParameterizedType toParameterizedType() { return new ParameterizedType(name(), null, null, annotationArray()); } }
ParameterizedType copyType(Type owner) { return new ParameterizedType(name(), arguments, owner, annotationArray()); }
private Type parseClassTypeSignature() { String signature = this.signature; DotName name = parseName(); Type[] types = parseTypeArguments(); Type type = null; if (types.length > 0) { type = new ParameterizedType(name, types, null); } // Suffix while (signature.charAt(pos) == '.') { int mark = ++pos; int suffixEnd = advanceNameEnd(); name = names.wrap(name, signature.substring(mark, suffixEnd), true); types = parseTypeArguments(); // A suffix is a parameterized type if it has typeParameters or it's owner is a parameterized type // The first parameterized type needs a standard class type for the owner if (type == null && types.length > 0) { type = names.intern(new ClassType(name.prefix())); } if (type != null) { type = names.intern(new ParameterizedType(name, types, type)); } } this.pos++; // ; return type != null ? type : names.intern(new ClassType(name)); }
Type[] parameters = readTypeListReference(stream); AnnotationInstance[] annotations = readAnnotations(stream, null); return new ParameterizedType(name, parameters, owner, annotations);