/** * Return a String representation of this type in its fully resolved form * (including any generic parameters). */ @Override public String toString() { if (isArray()) { return getComponentType() + "[]"; } if (this.resolved == null) { return "?"; } if (this.type instanceof TypeVariable) { TypeVariable<?> variable = (TypeVariable<?>) this.type; if (this.variableResolver == null || this.variableResolver.resolveVariable(variable) == null) { // Don't bother with variable boundaries for toString()... // Can cause infinite recursions in case of self-references return "?"; } } StringBuilder result = new StringBuilder(this.resolved.getName()); if (hasGenerics()) { result.append('<'); result.append(StringUtils.arrayToDelimitedString(getGenerics(), ", ")); result.append('>'); } return result.toString(); }
@Nullable private ResolvableType resolveVariable(TypeVariable<?> variable) { if (this.type instanceof TypeVariable) { return resolveType().resolveVariable(variable); } if (this.type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) this.type; Class<?> resolved = resolve(); if (resolved == null) { return null; } TypeVariable<?>[] variables = resolved.getTypeParameters(); for (int i = 0; i < variables.length; i++) { if (ObjectUtils.nullSafeEquals(variables[i].getName(), variable.getName())) { Type actualType = parameterizedType.getActualTypeArguments()[i]; return forType(actualType, this.variableResolver); } } Type ownerType = parameterizedType.getOwnerType(); if (ownerType != null) { return forType(ownerType, this.variableResolver).resolveVariable(variable); } } if (this.variableResolver != null) { return this.variableResolver.resolveVariable(variable); } return null; }
/** * Resolve this type by a single level, returning the resolved value or {@link #NONE}. * <p>Note: The returned {@link ResolvableType} should only be used as an intermediary * as it cannot be serialized. */ ResolvableType resolveType() { if (this.type instanceof ParameterizedType) { return forType(((ParameterizedType) this.type).getRawType(), this.variableResolver); } if (this.type instanceof WildcardType) { Type resolved = resolveBounds(((WildcardType) this.type).getUpperBounds()); if (resolved == null) { resolved = resolveBounds(((WildcardType) this.type).getLowerBounds()); } return forType(resolved, this.variableResolver); } if (this.type instanceof TypeVariable) { TypeVariable<?> variable = (TypeVariable<?>) this.type; // Try default variable resolution if (this.variableResolver != null) { ResolvableType resolved = this.variableResolver.resolveVariable(variable); if (resolved != null) { return resolved; } } // Fallback to bounds return forType(resolveBounds(variable.getBounds()), this.variableResolver); } return NONE; }
ResolvableType resolved = this.variableResolver.resolveVariable(variable); if (resolved != null) { ourResolved = resolved.resolve(); ResolvableType resolved = other.variableResolver.resolveVariable(variable); if (resolved != null) { ourResolved = resolved.resolve();
ResolvableType resolved = this.variableResolver.resolveVariable(variable); if (resolved != null) { ourResolved = resolved.resolve(); ResolvableType resolved = other.variableResolver.resolveVariable(variable); if (resolved != null) { ourResolved = resolved.resolve();
/** * Return a String representation of this type in its fully resolved form * (including any generic parameters). */ @Override public String toString() { if (isArray()) { return getComponentType() + "[]"; } if (this.resolved == null) { return "?"; } if (this.type instanceof TypeVariable) { TypeVariable<?> variable = (TypeVariable<?>) this.type; if (this.variableResolver == null || this.variableResolver.resolveVariable(variable) == null) { // Don't bother with variable boundaries for toString()... // Can cause infinite recursions in case of self-references return "?"; } } StringBuilder result = new StringBuilder(this.resolved.getName()); if (hasGenerics()) { result.append('<'); result.append(StringUtils.arrayToDelimitedString(getGenerics(), ", ")); result.append('>'); } return result.toString(); }
@Nullable private ResolvableType resolveVariable(TypeVariable<?> variable) { if (this.type instanceof TypeVariable) { return resolveType().resolveVariable(variable); } if (this.type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) this.type; Class<?> resolved = resolve(); if (resolved == null) { return null; } TypeVariable<?>[] variables = resolved.getTypeParameters(); for (int i = 0; i < variables.length; i++) { if (ObjectUtils.nullSafeEquals(variables[i].getName(), variable.getName())) { Type actualType = parameterizedType.getActualTypeArguments()[i]; return forType(actualType, this.variableResolver); } } Type ownerType = parameterizedType.getOwnerType(); if (ownerType != null) { return forType(ownerType, this.variableResolver).resolveVariable(variable); } } if (this.variableResolver != null) { return this.variableResolver.resolveVariable(variable); } return null; }
ResolvableType resolved = this.variableResolver.resolveVariable(variable); if (resolved != null) { return resolved;
/** * Resolve this type by a single level, returning the resolved value or {@link #NONE}. * <p>Note: The returned {@link ResolvableType} should only be used as an intermediary * as it cannot be serialized. */ ResolvableType resolveType() { if (this.type instanceof ParameterizedType) { return forType(((ParameterizedType) this.type).getRawType(), this.variableResolver); } if (this.type instanceof WildcardType) { Type resolved = resolveBounds(((WildcardType) this.type).getUpperBounds()); if (resolved == null) { resolved = resolveBounds(((WildcardType) this.type).getLowerBounds()); } return forType(resolved, this.variableResolver); } if (this.type instanceof TypeVariable) { TypeVariable<?> variable = (TypeVariable<?>) this.type; // Try default variable resolution if (this.variableResolver != null) { ResolvableType resolved = this.variableResolver.resolveVariable(variable); if (resolved != null) { return resolved; } } // Fallback to bounds return forType(resolveBounds(variable.getBounds()), this.variableResolver); } return NONE; }
/** * Return a String representation of this type in its fully resolved form (including any generic * parameters). */ @Override public String toString() { if (isArray()) { return getComponentType() + "[]"; } if (this.resolved == null) { return "?"; } if (this.type instanceof TypeVariable) { TypeVariable<?> variable = (TypeVariable<?>) this.type; if (this.variableResolver == null || this.variableResolver.resolveVariable(variable) == null) { // Don't bother with variable boundaries for toString()... // Can cause infinite recursions in case of self-references return "?"; } } StringBuilder result = new StringBuilder(this.resolved.getName()); if (hasGenerics()) { result.append('<'); result.append(StringUtils.arrayToDelimitedString(getGenerics(), ", ")); result.append('>'); } return result.toString(); }
@Nullable private ResolvableType resolveVariable(TypeVariable<?> variable) { if (this.type instanceof TypeVariable) { return resolveType().resolveVariable(variable); } if (this.type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) this.type; Class<?> resolved = resolve(); if (resolved == null) { return null; } TypeVariable<?>[] variables = resolved.getTypeParameters(); for (int i = 0; i < variables.length; i++) { if (ObjectUtils.nullSafeEquals(variables[i].getName(), variable.getName())) { Type actualType = parameterizedType.getActualTypeArguments()[i]; return forType(actualType, this.variableResolver); } } Type ownerType = parameterizedType.getOwnerType(); if (ownerType != null) { return forType(ownerType, this.variableResolver).resolveVariable(variable); } } if (this.variableResolver != null) { return this.variableResolver.resolveVariable(variable); } return null; }
/** * Determine whether the underlying type is a type variable that * cannot be resolved through the associated variable resolver. */ private boolean isUnresolvableTypeVariable() { if (this.type instanceof TypeVariable) { if (this.variableResolver == null) { return true; } TypeVariable<?> variable = (TypeVariable<?>) this.type; ResolvableType resolved = this.variableResolver.resolveVariable(variable); if (resolved == null || resolved.isUnresolvableTypeVariable()) { return true; } } return false; }
ResolvableType resolved = this.variableResolver.resolveVariable(variable); if (resolved != null) { ourResolved = resolved.resolve(); ResolvableType resolved = other.variableResolver.resolveVariable(variable); if (resolved != null) { ourResolved = resolved.resolve();
/** * Resolve this type by a single level, returning the resolved value or {@link #NONE}. * <p>Note: The returned {@link ResolvableType} should only be used as an intermediary * as it cannot be serialized. */ ResolvableType resolveType() { if (this.type instanceof ParameterizedType) { return forType(((ParameterizedType) this.type).getRawType(), this.variableResolver); } if (this.type instanceof WildcardType) { Type resolved = resolveBounds(((WildcardType) this.type).getUpperBounds()); if (resolved == null) { resolved = resolveBounds(((WildcardType) this.type).getLowerBounds()); } return forType(resolved, this.variableResolver); } if (this.type instanceof TypeVariable) { TypeVariable<?> variable = (TypeVariable<?>) this.type; // Try default variable resolution if (this.variableResolver != null) { ResolvableType resolved = this.variableResolver.resolveVariable(variable); if (resolved != null) { return resolved; } } // Fallback to bounds return forType(resolveBounds(variable.getBounds()), this.variableResolver); } return NONE; }
@Nullable private ResolvableType resolveVariable(TypeVariable<?> variable) { if (this.type instanceof TypeVariable) { return resolveType().resolveVariable(variable); } if (this.type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) this.type; Class<?> resolved = resolve(); if (resolved == null) { return null; } TypeVariable<?>[] variables = resolved.getTypeParameters(); for (int i = 0; i < variables.length; i++) { if (ObjectUtils.nullSafeEquals(variables[i].getName(), variable.getName())) { Type actualType = parameterizedType.getActualTypeArguments()[i]; return forType(actualType, this.variableResolver); } } Type ownerType = parameterizedType.getOwnerType(); if (ownerType != null) { return forType(ownerType, this.variableResolver).resolveVariable(variable); } } if (this.variableResolver != null) { return this.variableResolver.resolveVariable(variable); } return null; }
/** * Return a String representation of this type in its fully resolved form * (including any generic parameters). */ @Override public String toString() { if (isArray()) { return getComponentType() + "[]"; } if (this.resolved == null) { return "?"; } if (this.type instanceof TypeVariable) { TypeVariable<?> variable = (TypeVariable<?>) this.type; if (this.variableResolver == null || this.variableResolver.resolveVariable(variable) == null) { // Don't bother with variable boundaries for toString()... // Can cause infinite recursions in case of self-references return "?"; } } StringBuilder result = new StringBuilder(this.resolved.getName()); if (hasGenerics()) { result.append('<'); result.append(StringUtils.arrayToDelimitedString(getGenerics(), ", ")); result.append('>'); } return result.toString(); }
ResolvableType resolved = this.variableResolver.resolveVariable(variable); if (resolved != null) { ourResolved = resolved.resolve(); ResolvableType resolved = other.variableResolver.resolveVariable(variable); if (resolved != null) { ourResolved = resolved.resolve();
/** * Determine whether the underlying type is a type variable that * cannot be resolved through the associated variable resolver. */ private boolean isUnresolvableTypeVariable() { if (this.type instanceof TypeVariable) { if (this.variableResolver == null) { return true; } TypeVariable<?> variable = (TypeVariable<?>) this.type; ResolvableType resolved = this.variableResolver.resolveVariable(variable); if (resolved == null || resolved.isUnresolvableTypeVariable()) { return true; } } return false; }
@Test public void resolveTypeWithCustomVariableResolver() throws Exception { VariableResolver variableResolver = mock(VariableResolver.class); given(variableResolver.getSource()).willReturn(this); ResolvableType longType = ResolvableType.forClass(Long.class); given(variableResolver.resolveVariable(any())).willReturn(longType); ResolvableType variable = ResolvableType.forType( Fields.class.getField("typeVariableType").getGenericType(), variableResolver); ResolvableType parameterized = ResolvableType.forType( Fields.class.getField("parameterizedType").getGenericType(), variableResolver); assertThat(variable.resolve(), equalTo((Class) Long.class)); assertThat(parameterized.resolve(), equalTo((Class) List.class)); assertThat(parameterized.resolveGeneric(), equalTo((Class) Long.class)); verify(variableResolver, atLeastOnce()).resolveVariable(this.typeVariableCaptor.capture()); assertThat(this.typeVariableCaptor.getValue().getName(), equalTo("T")); }
/** * Determine whether the underlying type is a type variable that * cannot be resolved through the associated variable resolver. */ private boolean isUnresolvableTypeVariable() { if (this.type instanceof TypeVariable) { if (this.variableResolver == null) { return true; } TypeVariable<?> variable = (TypeVariable<?>) this.type; ResolvableType resolved = this.variableResolver.resolveVariable(variable); if (resolved == null || resolved.isUnresolvableTypeVariable()) { return true; } } return false; }