From a19acc4a4eb1dccc5a61c3d281fad1fc912da875 Mon Sep 17 00:00:00 2001 From: jimi-21 Date: Tue, 17 Nov 2026 23:07:42 +0800 Subject: [PATCH] 4.x: Add Streamable count operator --- .../io/reactivex/rxjava4/core/Streamable.java | 10 ++++ .../streamable/StreamableIntervalRange.java | 4 +- .../operators/streamable/StreamableRange.java | 4 +- .../streamable/StreamableRangeLong.java | 4 +- .../operators/streamable/StreamableSkip.java | 10 ++-- .../operators/streamable/StreamableTake.java | 10 ++-- .../streamable/StreamableCountTest.java | 51 +++++++++++++++++++ 7 files changed, 77 insertions(+), 16 deletions(-) create mode 100644 src/test/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableCountTest.java diff --git a/src/main/java/io/reactivex/rxjava4/core/Streamable.java b/src/main/java/io/reactivex/rxjava4/core/Streamable.java index 2212f85e67..f4cbdb96dc 100644 --- a/src/main/java/io/reactivex/rxjava4/core/Streamable.java +++ b/src/main/java/io/reactivex/rxjava4/core/Streamable.java @@ -766,6 +766,16 @@ default T blockingLast(@NonNull T defaultItem, @NonNull StreamerCancellation can return StreamableBlocking.blockingLast(this, defaultItem, cancellation); } + /** + * Counts all upstream items and emits the count as a {@code Single}. + * @return the new {@code Single} instance + */ + @CheckReturnValue + @NonNull + default Single count() { + return collect(Collectors.counting()).lastOrError(); + } + /** * Collects all upstream values via the use of a {@link Collector} configuration * and emits its resulting value as a single item of the returned {@code Streamable}. diff --git a/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableIntervalRange.java b/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableIntervalRange.java index 1af73ee6d5..c02fae8927 100644 --- a/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableIntervalRange.java +++ b/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableIntervalRange.java @@ -25,7 +25,7 @@ public record StreamableIntervalRange( long start, - long count, + long itemCount, long initialDelay, long period, TimeUnit unit, @@ -41,7 +41,7 @@ public record StreamableIntervalRange( @Override public @NonNull Streamer stream(@NonNull StreamerCancellation cancellation) { - var streamer = new IntervalStreamer(start, start + count); + var streamer = new IntervalStreamer(start, start + itemCount); if (scheduler != null) { var d = scheduler.schedulePeriodicallyDirect(streamer, initialDelay, period, unit); DisposableHelper.setOnce(streamer, d); diff --git a/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableRange.java b/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableRange.java index 3fbbe488ec..78ac3630c1 100644 --- a/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableRange.java +++ b/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableRange.java @@ -20,11 +20,11 @@ import io.reactivex.rxjava4.disposables.StreamerCancellation; import io.reactivex.rxjava4.operators.*; -public record StreamableRange(int start, int count) implements IsSynchronousStreamable { +public record StreamableRange(int start, int itemCount) implements IsSynchronousStreamable { @Override public @NonNull Streamer<@NonNull Integer> stream(@NonNull StreamerCancellation cancellation) { - return new RangeStreamer<>(start, start + count); + return new RangeStreamer<>(start, start + itemCount); } static final class RangeStreamer diff --git a/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableRangeLong.java b/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableRangeLong.java index 9a9ac9ae58..ffbc23328f 100644 --- a/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableRangeLong.java +++ b/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableRangeLong.java @@ -20,11 +20,11 @@ import io.reactivex.rxjava4.disposables.StreamerCancellation; import io.reactivex.rxjava4.operators.*; -public record StreamableRangeLong(long start, long count) implements IsSynchronousStreamable { +public record StreamableRangeLong(long start, long itemCount) implements IsSynchronousStreamable { @Override public @NonNull Streamer<@NonNull Long> stream(@NonNull StreamerCancellation cancellation) { - return new RangeLongStreamer<>(start, start + count); + return new RangeLongStreamer<>(start, start + itemCount); } static final class RangeLongStreamer diff --git a/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableSkip.java b/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableSkip.java index adfeaaf7a6..813fe806cb 100644 --- a/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableSkip.java +++ b/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableSkip.java @@ -24,22 +24,22 @@ import io.reactivex.rxjava4.disposables.StreamerCancellation; import io.reactivex.rxjava4.operators.*; -public record StreamableSkip(Streamable source, long count) implements Streamable { +public record StreamableSkip(Streamable source, long itemCount) implements Streamable { @SuppressWarnings("unchecked") @Override public @NonNull Streamer<@NonNull T> stream(@NonNull StreamerCancellation cancellation) { var upstream = source.stream(cancellation); if (upstream instanceof IndexableSource isrc) { - return new SkipStreamerIndexed<>(upstream, (IndexableSource)isrc, count); + return new SkipStreamerIndexed<>(upstream, (IndexableSource)isrc, itemCount); } else if (upstream instanceof DeferredEnumerableSource dsrc) { - return new SkipStreamerDeferredEnumerable<>(upstream, (DeferredEnumerableSource)dsrc, count); + return new SkipStreamerDeferredEnumerable<>(upstream, (DeferredEnumerableSource)dsrc, itemCount); } else if (upstream instanceof EnumerableSource esrc) { - return new SkipStreamerEnumerable<>(upstream, (EnumerableSource)esrc, count); + return new SkipStreamerEnumerable<>(upstream, (EnumerableSource)esrc, itemCount); } - return new SkipStreamerBasic<>(upstream, count); + return new SkipStreamerBasic<>(upstream, itemCount); } static abstract class SkipStreamer extends AtomicInteger implements Streamer, BiConsumer { diff --git a/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableTake.java b/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableTake.java index 74563c2479..433606c474 100644 --- a/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableTake.java +++ b/src/main/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableTake.java @@ -21,7 +21,7 @@ import io.reactivex.rxjava4.internal.fuseable.HasUpstreamStreamableSource; import io.reactivex.rxjava4.operators.*; -public record StreamableTake(Streamable source, long count) +public record StreamableTake(Streamable source, long itemCount) implements Streamable, HasUpstreamStreamableSource { @SuppressWarnings("unchecked") @@ -29,15 +29,15 @@ public record StreamableTake(Streamable source, long count) public @NonNull Streamer<@NonNull T> stream(@NonNull StreamerCancellation cancellation) { var upstream = source.stream(cancellation); if (upstream instanceof IndexableSource isrc) { - return new TakeStreamerIndexable<>(upstream, (IndexableSource)isrc, count); + return new TakeStreamerIndexable<>(upstream, (IndexableSource)isrc, itemCount); } else if (upstream instanceof DeferredEnumerableSource dsrc) { - return new TakeStreamerDeferredEnumerable<>(upstream, (DeferredEnumerableSource)dsrc, count); + return new TakeStreamerDeferredEnumerable<>(upstream, (DeferredEnumerableSource)dsrc, itemCount); } else if (upstream instanceof EnumerableSource esrc) { - return new TakeStreamerEnumerable<>(upstream, (EnumerableSource)esrc, count); + return new TakeStreamerEnumerable<>(upstream, (EnumerableSource)esrc, itemCount); } - return new TakeStreamerBasic<>(upstream, count); + return new TakeStreamerBasic<>(upstream, itemCount); } static abstract class TakeStreamerBase implements Streamer { diff --git a/src/test/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableCountTest.java b/src/test/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableCountTest.java new file mode 100644 index 0000000000..b9b7a6b0f5 --- /dev/null +++ b/src/test/java/io/reactivex/rxjava4/internal/operators/streamable/StreamableCountTest.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2016-present, RxJava Contributors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.rxjava4.internal.operators.streamable; + +import java.util.concurrent.TimeUnit; + +import org.junit.jupiter.api.Test; + +import io.reactivex.rxjava4.core.Streamable; +import io.reactivex.rxjava4.exceptions.TestException; + +public class StreamableCountTest extends StreamableBaseTest { + + @Test + public void empty() throws Throwable { + Streamable.empty() + .count() + .test() + .awaitDone(5, TimeUnit.SECONDS) + .assertResult(0L); + } + + @Test + public void multipleItems() throws Throwable { + Streamable.range(1, 5) + .count() + .test() + .awaitDone(5, TimeUnit.SECONDS) + .assertResult(5L); + } + + @Test + public void error() throws Throwable { + Streamable.error(new TestException("error")) + .count() + .test() + .awaitDone(5, TimeUnit.SECONDS) + .assertFailure(TestException.class); + } +}