Mercurial > hg > openjdk > lambda > jdk
changeset 9538:3db1d8103766
Couple more warnings elimination
author | henryjen |
---|---|
date | Fri, 16 Aug 2013 15:14:39 -0700 |
parents | 068c47d1d7d2 |
children | b96a8477538a |
files | src/share/classes/java/util/stream/AbstractPipeline.java src/share/classes/java/util/stream/Collectors.java src/share/classes/java/util/stream/ReferencePipeline.java src/share/classes/java/util/stream/SliceOps.java src/share/classes/java/util/stream/Stream.java |
diffstat | 5 files changed, 34 insertions(+), 28 deletions(-) [+] |
line wrap: on
line diff
--- a/src/share/classes/java/util/stream/AbstractPipeline.java Thu Aug 15 14:35:12 2013 -0700 +++ b/src/share/classes/java/util/stream/AbstractPipeline.java Fri Aug 16 15:14:39 2013 -0700 @@ -319,6 +319,7 @@ } @Override + @SuppressWarnings("unchecked") public S onClose(Runnable closeHandler) { Runnable existingHandler = sourceStage.sourceCloseAction; sourceStage.sourceCloseAction =
--- a/src/share/classes/java/util/stream/Collectors.java Thu Aug 15 14:35:12 2013 -0700 +++ b/src/share/classes/java/util/stream/Collectors.java Fri Aug 16 15:14:39 2013 -0700 @@ -133,6 +133,11 @@ return (u,v) -> { throw new IllegalStateException(String.format("Duplicate key %s", u)); }; } + @SuppressWarnings("unchecked") + private static <I, R> Function<I, R> castingIdentity() { + return i -> (R) i; + } + /** * Simple implementation class for {@code Collector}. * @@ -162,7 +167,7 @@ BiConsumer<A, T> accumulator, BinaryOperator<A> combiner, Set<Characteristics> characteristics) { - this(supplier, accumulator, combiner, i -> (R) i, characteristics); + this(supplier, accumulator, combiner, castingIdentity(), characteristics); } @Override @@ -205,7 +210,7 @@ */ public static <T, C extends Collection<T>> Collector<T, ?, C> toCollection(Supplier<C> collectionFactory) { - return new CollectorImpl<>(collectionFactory, Collection::add, + return new CollectorImpl<>(collectionFactory, Collection<T>::add, (r1, r2) -> { r1.addAll(r2); return r1; }, CH_ID); } @@ -365,8 +370,8 @@ * @param <A> intermediate accumulation type of the downstream collector * @param <R> result type of the downstream collector * @param <RR> result type of the resulting collector + * @param downstream a collector * @param finisher a function to be applied to the final result of the downstream collector - * @param downstream a collector * @return a collector which performs the action of the downstream collector, * followed by an additional finishing step */ @@ -1045,30 +1050,23 @@ public static <T, D, A> Collector<T, ?, Map<Boolean, D>> partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) { - @SuppressWarnings("unchecked") - BiConsumer<D, ? super T> downstreamAccumulator = (BiConsumer<D, ? super T>) downstream.accumulator(); - BiConsumer<Map<Boolean, A>, T> accumulator = (result, t) -> { - Partition<D> asPartition = ((Partition<D>) result); - downstreamAccumulator.accept(predicate.test(t) ? asPartition.forTrue : asPartition.forFalse, t); - }; + BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator(); + BiConsumer<Partition<A>, T> accumulator = (result, t) -> + downstreamAccumulator.accept(predicate.test(t) ? result.forTrue : result.forFalse, t); BinaryOperator<A> op = downstream.combiner(); - BinaryOperator<Map<Boolean, A>> merger = (m1, m2) -> { - Partition<A> left = (Partition<A>) m1; - Partition<A> right = (Partition<A>) m2; - return new Partition<>(op.apply(left.forTrue, right.forTrue), - op.apply(left.forFalse, right.forFalse)); - }; - Supplier<Map<Boolean, A>> supplier = () -> new Partition<>(downstream.supplier().get(), - downstream.supplier().get()); + BinaryOperator<Partition<A>> merger = (left, right) -> + new Partition<>(op.apply(left.forTrue, right.forTrue), + op.apply(left.forFalse, right.forFalse)); + Supplier<Partition<A>> supplier = () -> + new Partition<>(downstream.supplier().get(), + downstream.supplier().get()); if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) { return new CollectorImpl<>(supplier, accumulator, merger, CH_ID); } else { - Function<Map<Boolean, A>, Map<Boolean, D>> finisher = (Map<Boolean, A> par) -> { - Partition<A> asAPartition = (Partition<A>) par; - return new Partition<>(downstream.finisher().apply(asAPartition.forTrue), - downstream.finisher().apply(asAPartition.forFalse)); - }; + Function<Partition<A>, Map<Boolean, D>> finisher = par -> + new Partition<>(downstream.finisher().apply(par.forTrue), + downstream.finisher().apply(par.forFalse)); return new CollectorImpl<>(supplier, accumulator, merger, finisher, CH_NOID); } }
--- a/src/share/classes/java/util/stream/ReferencePipeline.java Thu Aug 15 14:35:12 2013 -0700 +++ b/src/share/classes/java/util/stream/ReferencePipeline.java Fri Aug 16 15:14:39 2013 -0700 @@ -499,6 +499,7 @@ } @Override + @SuppressWarnings("unchecked") public final <R, A> R collect(Collector<? super P_OUT, A, R> collector) { A container; if (isParallel()
--- a/src/share/classes/java/util/stream/SliceOps.java Thu Aug 15 14:35:12 2013 -0700 +++ b/src/share/classes/java/util/stream/SliceOps.java Fri Aug 16 15:14:39 2013 -0700 @@ -96,6 +96,11 @@ } } + @SuppressWarnings("unchecked") + private static <T> IntFunction<T[]> castingArray() { + return size -> (T[]) new Object[size]; + } + /** * Appends a "slice" operation to the provided stream. The slice operation * may be may be skip-only, limit-only, or skip-and-limit. @@ -107,12 +112,12 @@ * is to be imposed */ public static <T> Stream<T> makeRef(AbstractPipeline<?, T, ?> upstream, - long skip, long limit) { + long skip, long limit) { if (skip < 0) throw new IllegalArgumentException("Skip must be non-negative: " + skip); - return new ReferencePipeline.StatefulOp<T,T>(upstream, StreamShape.REFERENCE, - flags(limit)) { + return new ReferencePipeline.StatefulOp<T, T>(upstream, StreamShape.REFERENCE, + flags(limit)) { Spliterator<T> unorderedSkipLimitSpliterator(Spliterator<T> s, long skip, long limit, long sizeIfKnown) { if (skip <= sizeIfKnown) { @@ -146,7 +151,7 @@ // cancellation will be more aggressive cancelling later tasks // if the target slice size has been reached from a given task, // cancellation should also clear local results if any - return new SliceTask<>(this, helper, spliterator, i -> (T[]) new Object[i], skip, limit). + return new SliceTask<>(this, helper, spliterator, castingArray(), skip, limit). invoke().spliterator(); } } @@ -560,13 +565,13 @@ private volatile boolean completed; - SliceTask(AbstractPipeline<?, P_OUT, ?> op, + SliceTask(AbstractPipeline<P_OUT, P_OUT, ?> op, PipelineHelper<P_OUT> helper, Spliterator<P_IN> spliterator, IntFunction<P_OUT[]> generator, long offset, long size) { super(helper, spliterator); - this.op = (AbstractPipeline<P_OUT, P_OUT, ?>) op; + this.op = op; this.generator = generator; this.targetOffset = offset; this.targetSize = size;
--- a/src/share/classes/java/util/stream/Stream.java Thu Aug 15 14:35:12 2013 -0700 +++ b/src/share/classes/java/util/stream/Stream.java Fri Aug 16 15:14:39 2013 -0700 @@ -873,6 +873,7 @@ * @return the new stream */ @SafeVarargs + @SuppressWarnings("varargs") public static<T> Stream<T> of(T... values) { return Arrays.stream(values); }