@Override public boolean accepts(Type containerType) { Class<?> erasedType = getErasedType(containerType); return collectors.containsKey(erasedType) && containerType instanceof ParameterizedType; }
@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<ColumnMapper<?>> build(Type type, ConfigRegistry config) { Class<?> rawType = getErasedType(type); return Optional.ofNullable(mappers.get(rawType)); }
@Override public Optional<ColumnMapper<?>> build(Type type, ConfigRegistry config) { Class<?> rawType = getErasedType(type); return Optional.ofNullable(mappers.get(rawType)); }
@Override public Optional<ColumnMapper<?>> build(Type type, ConfigRegistry config) { Class<?> rawType = getErasedType(type); return Optional.ofNullable(mappers.get(rawType)); }
@Override public Optional<RowMapper<?>> build(Type type, ConfigRegistry config) { Class<?> clazz = getErasedType(type); return clazz.isAnnotationPresent(Entity.class) ? Optional.of(new JpaMapper<>(clazz)) : Optional.empty(); } }
@Override public Collector<?, ?, ?> build(Type containerType) { Class<?> componentType = getErasedType(containerType).getComponentType(); return Collector.of( () -> new ArrayBuilder(componentType), ArrayBuilder::add, (left, right) -> { left.list.addAll(right.list); return left; }, ArrayBuilder::build); }
@Override public Optional<Type> elementType(Type containerType) { Class<?> erasedType = getErasedType(containerType); return findGenericParameter(containerType, erasedType); }
@Override public Optional<ColumnMapper<?>> build(Type type, ConfigRegistry config) { Class<?> rawType = getErasedType(type); if (rawType == Optional.class) { return Optional.of(OptionalMapper.of(type)); } return Optional.ofNullable(mappers.get(rawType)); }
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"); } }
private static Type findOptionalType(Type wrapperType, Object nestedValue) { if (getErasedType(wrapperType).equals(Optional.class)) { Optional<Type> nestedType = findGenericParameter(wrapperType, Optional.class); if (nestedType.isPresent()) { return nestedType.get(); } } return nestedValue == null ? Object.class : nestedValue.getClass(); } }
@Override public Optional<ColumnMapper<?>> build(Type type, ConfigRegistry config) { Class<?> clazz = getErasedType(type); return clazz.isEnum() ? Optional.of(EnumMapper.byName(clazz.asSubclass(Enum.class))) : Optional.empty(); } }
@Override public Optional<Type> elementType(Type containerType) { Class<?> erasedType = getErasedType(containerType); return findGenericParameter(containerType, erasedType); }
@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); }
@Override public Optional<ColumnMapper<?>> build(Type type, ConfigRegistry config) { return ValueType.class.isAssignableFrom(getErasedType(type)) ? Optional.of(new ValueTypeMapper()) : Optional.empty(); } }
@Override protected BeanMapper<?> createNestedMapper(StatementContext ctx, PojoProperty<T> property, String nestedPrefix) { return new BeanMapper<>(GenericTypes.getErasedType(property.getQualifiedType().getType()), nestedPrefix); } }
@Override public Optional<Argument> build(Type expectedType, Object value, ConfigRegistry config) { return getErasedType(expectedType) == Weird.class ? Optional.of(new WeirdArgument()) : Optional.empty(); } }
@Override public Optional<RowMapper<?>> build(Type type, ConfigRegistry config) { Class<?> erasedType = getErasedType(type); MapWith mapWith = erasedType.getAnnotation(MapWith.class); return mapWith == null ? Optional.empty() : Optional.of(Unchecked.supplier(mapWith.value()::newInstance).get()); } }
@SuppressWarnings({ "rawtypes", "unchecked" }) // Type loses <T> protected PojoMapper<?> createNestedMapper(StatementContext ctx, PojoProperty<T> property, String nestedPrefix) { final Type propertyType = property.getQualifiedType().getType(); return new PojoMapper( GenericTypes.getErasedType(propertyType), ctx.getConfig(PojoTypes.class).findFor(type) .orElseThrow(() -> new UnableToProduceResultException("Couldn't find properties for nested type " + propertyType, ctx)), nestedPrefix); }
private <C extends Collection<String>> void testCollectionType(GenericType<C> genericType) { Type containerType = genericType.getType(); Class<?> erasedType = getErasedType(containerType); assertThat(factory.accepts(containerType)).isTrue(); assertThat(factory.accepts(erasedType)).isFalse(); assertThat(factory.elementType(containerType)).contains(String.class); Collector<String, ?, C> collector = (Collector<String, ?, C>) factory.build(containerType); assertThat(Stream.of("foo", "bar", "baz").collect(collector)) .isInstanceOf(erasedType) .containsOnly("foo", "bar", "baz"); } }