public static TypeBindings createUnbound(final TypeList genericParameters) { return new TypeBindings( VerifyArgument.noNullElements(genericParameters, "genericParameters"), genericParameters ); }
@Override public Type<?> visitClassType(final Type<?> type, final TypeBindings bindings) { if (bindings.containsGenericParameter(type)) { return bindings.getBoundType(type); } final TypeBindings oldTypeBindings = type.getTypeBindings(); final TypeBindings newTypeBindings = visitTypeBindings(oldTypeBindings, bindings); if (oldTypeBindings != newTypeBindings) { return type.getGenericTypeDefinition().makeGenericType(newTypeBindings.getBoundTypes()); } return type; }
public static Type substitute(final Type type, final TypeList genericParameters, final TypeList typeArguments) { return SubstitutingBinder.visit( type, TypeBindings.create(genericParameters, typeArguments) ); }
public boolean hasBoundParameters() { for (int i = 0, n = size(); i < n; i++) { final Type genericParameter = getGenericParameter(i); final Type parameter = getBoundType(i); if (parameter != genericParameter) { return true; } } return false; }
public TypeBindings withAdditionalBindings(final TypeBindings additionalBindings) { TypeBindings bindings = this; for (final Type parameter : additionalBindings.getGenericParameters()) { bindings = bindings.withAdditionalBinding(parameter, additionalBindings.getBoundType(parameter)); } return bindings; }
public boolean hasConcreteParameters() { for (int i = 0, n = size(); i < n; i++) { final Type parameter = getBoundType(i); if (!parameter.isGenericParameter()) { return true; } } return false; }
for (int i = 0, n = bindings.size(); i < n; i++) { final Type p = bindings.getGenericParameter(i); if (bindings.hasBoundParameter(gp)) { throw new IllegalArgumentException( "ReflectedMethod cannot be used with bound generic method parameters. " + _bindings = TypeBindings.empty(); _bindings = TypeBindings.createUnbound(new TypeList(genericParameters));
genericParameters = TypeBindings.empty(); genericParameters = TypeBindings.createUnbound(Type.list(resolvedTypeParameters)); ); if (!genericParameters.isEmpty()) { for (final Type type : genericParameters.getGenericParameters()) { final GenericParameter genericParameter = (GenericParameter) type;
GenericType(final Type genericTypeDefinition, final TypeList typeArguments) { _genericTypeDefinition = VerifyArgument.notNull(genericTypeDefinition, "genericTypeDefinition"); _typeBindings = TypeBindings.create( genericTypeDefinition.getTypeBindings().getGenericParameters(), VerifyArgument.notNull(typeArguments, "typeArguments") ); }
public TypeList getTypeArguments() { return getTypeBindings().getBoundTypes(); }
void complete() { if (_completed) { return; } _completed = true; if (_genericParameters == null || _genericParameters.isEmpty()) { _typeBindings = TypeBindings.empty(); } else { _typeBindings = TypeBindings.createUnbound(list(_genericParameters)); } }
public MethodInfo makeGenericMethod(final TypeList typeArguments) { if (!isGenericMethodDefinition()) { throw Error.notGenericMethodDefinition(this); } final TypeBindings bindings = TypeBindings.create(getGenericMethodParameters(), typeArguments); if (!bindings.hasBoundParameters()) { throw new IllegalArgumentException("At least one generic parameter must be bound."); } return new GenericMethod(bindings, this); }
@Override public TypeBindings getTypeBindings() { return TypeBindings.empty(); }
public TypeBindings withAdditionalParameter(final Type genericParameter) { if (containsGenericParameter(genericParameter)) { return this; } final Type[] genericParameters; final Type[] boundTypes; final int newParameterCount = _genericParameters.size() + 1; boundTypes = new Type[newParameterCount]; genericParameters = new Type[newParameterCount]; _boundTypes.toArray(boundTypes); _genericParameters.toArray(genericParameters); genericParameters[newParameterCount - 1] = genericParameter; boundTypes[newParameterCount - 1] = genericParameter; return new TypeBindings(Type.list(genericParameters), Type.list(boundTypes)); }
public GenericParameterBuilder<?>[] defineGenericParameters(final String... names) { if (!_typeBindings.isEmpty()) { throw Error.defineGenericParametersAlreadyCalled(); } VerifyArgument.notEmpty(names, "names"); final String[] defensiveCopy = Arrays.copyOf(names, names.length); VerifyArgument.noNullElements(defensiveCopy, "names"); _isGenericTypeDefinition = true; final GenericParameterBuilder<?>[] genericParameters = new GenericParameterBuilder<?>[names.length]; for (int i = 0, n = names.length; i < n; i++) { genericParameters[i] = new GenericParameterBuilder<>( new TypeBuilder(names[i], i, this) ); } _typeBindings = TypeBindings.createUnbound(Type.list(genericParameters)); return genericParameters; }
public TypeBindings bindingsFor(final TypeList genericParameters) { if (VerifyArgument.notNull(genericParameters, "genericParameters").isEmpty()) { return empty(); } final Type[] boundTypes = new Type[genericParameters.size()]; for (int i = 0, n = genericParameters.size(); i < n; i++) { final Type genericParameter = genericParameters.get(i); final int index = _genericParameters.indexOf(genericParameter); if (index == -1) { boundTypes[i] = genericParameters.get(i); } else { boundTypes[i] = _boundTypes.get(index); } } return new TypeBindings(genericParameters, Type.list(boundTypes)); }
protected Type<?> visitTypeParameterCore(final Type<?> type, final TypeBindings bindings) { if (!bindings.containsGenericParameter(type) && Types.Object.equals(type.getExtendsBound())) { return type; if (bindings.containsGenericParameter(type)) { return visit(bindings.getBoundType(type), bindings);
final TypeBindings results = new TypeBindings(genericParameters, Type.list(boundTypes)); return results.withAdditionalBinding(genericParameters.get(i), typeArgument);
public TypeList getGenericMethodParameters() { return getTypeBindings().getGenericParameters(); }
public Type getBoundType(final Type genericParameter) { final int index = _genericParameters.indexOf(genericParameter); if (index == -1) { throw Error.typeParameterNotDefined(genericParameter); } return getBoundType(index); }