/** * {@inheritDoc} */ @Override public String toString() { return TypeUtils.toString(this); }
/** * {@inheritDoc} */ @Override public String toString() { return TypeUtils.toString(this); }
/** * {@inheritDoc} */ @Override public String toString() { return TypeUtils.toString(this); }
private static <T> String toString(final T object) { return object instanceof Type ? toString((Type) object) : object.toString(); }
/** * Format a {@link GenericArrayType} as a {@link String}. * @param g {@code GenericArrayType} to format * @return String * @since 3.2 */ private static String genericArrayTypeToString(final GenericArrayType g) { return String.format("%s[]", toString(g.getGenericComponentType())); }
/** * Helper method to establish the formal parameters for a parameterized type. * @param mappings map containing the assignments * @param variables expected map keys * @return array of map values corresponding to specified keys */ private static Type[] extractTypeArgumentsFrom(final Map<TypeVariable<?>, Type> mappings, final TypeVariable<?>[] variables) { final Type[] result = new Type[variables.length]; int index = 0; for (final TypeVariable<?> var : variables) { Validate.isTrue(mappings.containsKey(var), "missing argument mapping for %s", toString(var)); result[index++] = mappings.get(var); } return result; }
/** * The default constructor. */ protected TypeLiteral() { this.value = Validate.notNull(TypeUtils.getTypeArguments(getClass(), TypeLiteral.class).get(T), "%s does not assign type parameter %s", getClass(), TypeUtils.toLongString(T)); this.toString = String.format("%s<%s>", TypeLiteral.class.getSimpleName(), TypeUtils.toString(value)); }
/** * Append {@code types} to {@code buf} with separator {@code sep}. * @param buf destination * @param sep separator * @param types to append * @return {@code buf} * @since 3.2 */ private static <T> StringBuilder appendAllTo(final StringBuilder buf, final String sep, final T... types) { Validate.notEmpty(Validate.noNullElements(types)); if (types.length > 0) { buf.append(toString(types[0])); for (int i = 1; i < types.length; i++) { buf.append(sep).append(toString(types[i])); } } return buf; }
/** * Format a {@link Class} as a {@link String}. * @param c {@code Class} to format * @return String * @since 3.2 */ private static String classToString(final Class<?> c) { if (c.isArray()) { return toString(c.getComponentType()) + "[]"; } final StringBuilder buf = new StringBuilder(); if (c.getEnclosingClass() != null) { buf.append(classToString(c.getEnclosingClass())).append('.').append(c.getSimpleName()); } else { buf.append(c.getName()); } if (c.getTypeParameters().length > 0) { buf.append('<'); appendAllTo(buf, ", ", c.getTypeParameters()); buf.append('>'); } return buf.toString(); }
/** * Format a {@link TypeVariable} including its {@link GenericDeclaration}. * * @param var the type variable to create a String representation for, not {@code null} * @return String * @since 3.2 */ public static String toLongString(final TypeVariable<?> var) { Validate.notNull(var, "var is null"); final StringBuilder buf = new StringBuilder(); final GenericDeclaration d = var.getGenericDeclaration(); if (d instanceof Class<?>) { Class<?> c = (Class<?>) d; while (true) { if (c.getEnclosingClass() == null) { buf.insert(0, c.getName()); break; } buf.insert(0, c.getSimpleName()).insert(0, '.'); c = c.getEnclosingClass(); } } else if (d instanceof Type) {// not possible as of now buf.append(toString((Type) d)); } else { buf.append(d); } return buf.append(':').append(typeVariableToString(var)).toString(); }
@Test public void testLANG1348() throws Exception { final Method method = Enum.class.getMethod("valueOf", Class.class, String.class); assertEquals("T extends java.lang.Enum<T>", TypeUtils.toString(method.getGenericReturnType())); }
@Test public void testToStringLang1311() { assertEquals("int[]", TypeUtils.toString(int[].class)); assertEquals("java.lang.Integer[]", TypeUtils.toString(Integer[].class)); final Field stringListField = FieldUtils.getDeclaredField(getClass(), "stringListArray"); assertEquals("java.util.List<java.lang.String>[]", TypeUtils.toString(stringListField.getGenericType())); }
@Test public void testLowerBoundedWildcardType() { final WildcardType lowerBounded = TypeUtils.wildcardType().withLowerBounds(java.sql.Date.class).build(); assertEquals(String.format("? super %s", java.sql.Date.class.getName()), TypeUtils.toString(lowerBounded)); assertEquals(String.format("? super %s", java.sql.Date.class.getName()), lowerBounded.toString()); final TypeVariable<Class<Iterable>> iterableT0 = Iterable.class.getTypeParameters()[0]; final WildcardType lowerTypeVariable = TypeUtils.wildcardType().withLowerBounds(iterableT0).build(); assertEquals(String.format("? super %s", iterableT0.getName()), TypeUtils.toString(lowerTypeVariable)); assertEquals(String.format("? super %s", iterableT0.getName()), lowerTypeVariable.toString()); }
@Test public void testWildcardType() throws Exception { final WildcardType simpleWildcard = TypeUtils.wildcardType().withUpperBounds(String.class).build(); final Field cClass = AClass.class.getField("cClass"); assertTrue(TypeUtils.equals(((ParameterizedType) cClass.getGenericType()).getActualTypeArguments()[0], simpleWildcard)); assertEquals(String.format("? extends %s", String.class.getName()), TypeUtils.toString(simpleWildcard)); assertEquals(String.format("? extends %s", String.class.getName()), simpleWildcard.toString()); }
@Test public void testUnboundedWildcardType() { final WildcardType unbounded = TypeUtils.wildcardType().withLowerBounds((Type) null).withUpperBounds().build(); assertTrue(TypeUtils.equals(TypeUtils.WILDCARD_ALL, unbounded)); assertArrayEquals(new Type[] { Object.class }, TypeUtils.getImplicitUpperBounds(unbounded)); assertArrayEquals(new Type[] { null }, TypeUtils.getImplicitLowerBounds(unbounded)); assertEquals("?", TypeUtils.toString(unbounded)); assertEquals("?", unbounded.toString()); }
/** * {@inheritDoc} */ @Override public String toString() { return TypeUtils.toString(this); }
/** * {@inheritDoc} */ @Override public String toString() { return TypeUtils.toString(this); }
/** * Format a {@link GenericArrayType} as a {@link String}. * @param g {@code GenericArrayType} to format * @return String * @since 3.2 */ private static String genericArrayTypeToString(final GenericArrayType g) { return String.format("%s[]", toString(g.getGenericComponentType())); }
/** * The default constructor. */ protected TypeLiteral() { this.value = Validate.notNull(TypeUtils.getTypeArguments(getClass(), TypeLiteral.class).get(T), "%s does not assign type parameter %s", getClass(), TypeUtils.toLongString(T)); this.toString = String.format("%s<%s>", TypeLiteral.class.getSimpleName(), TypeUtils.toString(value)); }
/** * The default constructor. */ protected TypeLiteral() { this.value = Validate.notNull(TypeUtils.getTypeArguments(getClass(), TypeLiteral.class).get(T), "%s does not assign type parameter %s", getClass(), TypeUtils.toLongString(T)); this.toString = String.format("%s<%s>", TypeLiteral.class.getSimpleName(), TypeUtils.toString(value)); }