@Override public Optional<Type> elementType(Type containerType) { Class<?> erasedType = getErasedType(containerType); return findGenericParameter(containerType, erasedType); }
public SqlCallHandler(Class<?> sqlObjectType, Method method) { super(sqlObjectType, method); Type returnType = GenericTypes.resolveType(method.getGenericReturnType(), sqlObjectType); Class<?> returnClass = GenericTypes.getErasedType(returnType); if (Void.TYPE.equals(returnClass)) { returnOutParams = false; } else if (OutParameters.class.isAssignableFrom(returnClass)) { returnOutParams = true; } else { throw new IllegalArgumentException("@SqlCall methods may only return null or OutParameters at present"); } }
@Override public java.util.Optional<Type> elementType(Type containerType) { Class<?> erasedType = getErasedType(containerType); if (Multimap.class.isAssignableFrom(erasedType)) { Type keyType = resolveType(multimapKey, containerType); Type valueType = resolveType(multimapValue, containerType); return java.util.Optional.of(resolveMapEntryType(keyType, valueType)); } else if (Map.class.isAssignableFrom(erasedType)) { return java.util.Optional.of(resolveMapEntryType(containerType)); } return findGenericParameter(containerType, erasedType); }
/** * Given a subtype of {@code Map<K,V>}, returns the corresponding map entry type {@code Map.Entry<K,V>}. * @param mapType the map subtype * @return the map entry type */ public static Type resolveMapEntryType(Type mapType) { Type keyType = resolveType(KEY, mapType); Type valueType = resolveType(VALUE, mapType); return resolveMapEntryType(keyType, valueType); }
@Override public boolean accepts(Type containerType) { Class<?> erasedType = getErasedType(containerType); return collectors.containsKey(erasedType) && containerType instanceof ParameterizedType; }
/** * Same as {@link #findGenericParameter(Type, Class, int)} with n = 0. * * @param type the type * @param parameterizedSupertype the parameterized supertype * @return the first parameter type * @see #findGenericParameter(Type, Class, int) */ public static Optional<Type> findGenericParameter(Type type, Class<?> parameterizedSupertype) { return findGenericParameter(type, parameterizedSupertype, 0); }
@Override Type getParameterType(Parameter parameter) { Type type = super.getParameterType(parameter); if (!parameter.isAnnotationPresent(SingleValue.class)) { Class<?> erasedType = GenericTypes.getErasedType(type); if (Iterable.class.isAssignableFrom(erasedType)) { return GenericTypes.findGenericParameter(type, Iterable.class).get(); } else if (Iterator.class.isAssignableFrom(erasedType)) { return GenericTypes.findGenericParameter(type, Iterator.class).get(); } else if (GenericTypes.isArray(type)) { return ((Class<?>) type).getComponentType(); } } return type; }
@Override public java.util.Optional<Type> elementType(Type containerType) { Class<?> erasedType = getErasedType(containerType); if (Map.class.isAssignableFrom(erasedType)) { return Optional.of(GenericTypes.resolveMapEntryType(containerType)); } return findGenericParameter(containerType, erasedType); }
@Override public Optional<Type> elementType(Type containerType) { Class<?> erasedType = getErasedType(containerType); return Map.class.isAssignableFrom(erasedType) ? Optional.of(GenericTypes.resolveMapEntryType(containerType)) : Optional.empty(); }
private static Type resolveMaplikeEntryType(Type maplikeType, Type keyParam, Type valueParam) { Type keyType = GenericTypes.resolveType(keyParam, maplikeType); Type valueType = GenericTypes.resolveType(valueParam, maplikeType); return resolveMapEntryType(keyType, valueType); }
/** * Given a key and value type, returns the map entry type {@code Map.Entry<keyType,valueType>}. * @param keyType the key type * @param valueType the value type * @return the map entry type */ public static Type resolveMapEntryType(Type keyType, Type valueType) { return resolveMapEntryType(TypeToken.of(keyType), TypeToken.of(valueType)); }
@Override public boolean accepts(Type containerType) { // compiler ensures that elements of EnumSet<E extends Enum<E>> are always enums return EnumSet.class.isAssignableFrom(getErasedType(containerType)) && containerType instanceof ParameterizedType; }
@Override public Optional<Type> elementType(Type containerType) { return findGenericParameter(containerType, EnumSet.class); }
private <M extends Map<Long, String>> void testMapType(GenericType<M> genericType) { Type containerType = genericType.getType(); Class<?> erasedType = getErasedType(containerType); assertThat(factory.accepts(containerType)).isTrue(); assertThat(factory.accepts(erasedType)).isFalse(); assertThat(factory.elementType(containerType)).contains(resolveMapEntryType(Long.class, String.class)); Collector<Map.Entry<Long, String>, ?, M> collector = (Collector<Map.Entry<Long, String>, ?, M>) factory.build(containerType); assertThat(Stream.of(entry(1L, "foo"), entry(2L, "bar"), entry(3L, "baz")).collect(collector)) .isInstanceOf(erasedType) .containsOnly(entry(1L, "foo"), entry(2L, "bar"), entry(3L, "baz")); assertThatThrownBy(() -> Stream.of(entry(1L, "foo"), entry(1L, "bar")).collect(collector)) .isInstanceOf(IllegalStateException.class) .hasMessageContaining("Multiple values"); } }
Type parameterType = resolveType(parameterizedSupertype.getTypeParameters()[n], type); return parameterType instanceof Class || parameterType instanceof ParameterizedType ? Optional.of(parameterType)
/** * Given a subtype of {@code Map<K,V>}, returns the corresponding map entry type {@code Map.Entry<K,V>}. * @param mapType the map subtype * @return the map entry type */ public static Type resolveMapEntryType(Type mapType) { Type keyType = resolveType(KEY, mapType); Type valueType = resolveType(VALUE, mapType); return resolveMapEntryType(keyType, valueType); }
/** * Given a key and value type, returns the map entry type {@code Map.Entry<keyType,valueType>}. * @param keyType the key type * @param valueType the value type * @return the map entry type */ public static Type resolveMapEntryType(Type keyType, Type valueType) { return resolveMapEntryType(TypeToken.of(keyType), TypeToken.of(valueType)); }
@Override public Optional<Type> elementType(Type containerType) { Class<?> erasedType = getErasedType(containerType); return findGenericParameter(containerType, erasedType); }
@Override public boolean accepts(Type containerType) { Class<?> erasedType = getErasedType(containerType); return containerType instanceof ParameterizedType && collectors.containsKey(erasedType); }
@SuppressWarnings("unchecked") static RowMapperFactory factory() { return (type, config) -> { if (type instanceof ParameterizedType && getErasedType(type).equals(Map.Entry.class)) { Type keyType = resolveType(KEY_PARAM, type); Type valueType = resolveType(VALUE_PARAM, type); RowMapper<?> keyMapper = getKeyMapper(keyType, config); RowMapper<?> valueMapper = getValueMapper(valueType, config); return Optional.of(new MapEntryMapper(keyMapper, valueMapper)); } return Optional.empty(); }; }