Remove limit(long) from cursor and hint users to stream().limit(...)

Author: christophstrobl

src/main/java/org/springframework/data/redis/core/ConvertingCursor.java

@@ -119,13 +119,4 @@ public Cursor<T> open() {
 	public long getPosition() {
 		return delegate.getPosition();
 	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.redis.core.Cursor#limit(long)
-	 */
-	@Override
-	public Cursor<T> limit(long count) {
-		return new ConvertingCursor<>(delegate.limit(count), converter);
-	}
 }

src/main/java/org/springframework/data/redis/core/Cursor.java

@@ -15,19 +15,25 @@
  */
 package org.springframework.data.redis.core;
 
-import org.springframework.data.redis.util.BoundedIterator;
 import org.springframework.data.util.CloseableIterator;
 
 /**
  * Cursor abstraction to scan over the keyspace or elements within a data structure using a variant of a {@code SCAN}
  * command.
+ * <p />
+ * Using a Java 8 {@link #stream() java.util.stream.Stream} allows to apply additional
+ * {@link java.util.stream.Stream#filter(java.util.function.Predicate) filters} and {@link java.util.stream.Stream#limit(long) limits} to
+ * the underlying {@link Cursor}.
+ * <p />
+ * Make sure to {@link CloseableIterator#close() close} the cursor when done as this allows implementations to clean up
+ * any resources they need to keep open to iterate over elements (eg. by using a try-with-resource statement).
  *
  * @author Christoph Strobl
  * @author Mark Paluch
  * @param <T>
  * @since 1.4
  */
-public interface Cursor<T> extends BoundedIterator<T>, CloseableIterator<T> {
+public interface Cursor<T> extends CloseableIterator<T> {
 
 	/**
 	 * Get the reference cursor. <br>
@@ -56,15 +62,4 @@ public interface Cursor<T> extends BoundedIterator<T>, CloseableIterator<T> {
 	 * @return the current position of the cursor.
 	 */
 	long getPosition();
-
-	/**
-	 * Limit the maximum number of elements to be returned from this cursor. The returned cursor object can be used to
-	 * iterate over the remaining items and to {@link #close() release} associated resources. The returned cursor is not
-	 * attached to the state of {@code this} cursor and this object should be no longer used.
-	 *
-	 * @return a new {@link Cursor} with detached iteration state.
-	 * @since 2.5
-	 */
-	@Override
-	Cursor<T> limit(long count);
 }

src/main/java/org/springframework/data/redis/core/ScanCursor.java

@@ -83,20 +83,6 @@ public ScanCursor(long cursorId, @Nullable ScanOptions options) {
 		this.delegate = Collections.emptyIterator();
 	}
 
-	/**
-	 * Crates a new {@link ScanCursor}.
-	 *
-	 * @param source source cursor.
-	 * @since 2.5
-	 */
-	private ScanCursor(ScanCursor<T> source) {
-
-		this.scanOptions = source.scanOptions;
-		this.cursorId = source.cursorId;
-		this.state = source.state;
-		this.delegate = source.delegate;
-	}
-
 	private void scan(long cursorId) {
 
 		ScanIteration<T> result = doScan(cursorId, this.scanOptions);
@@ -185,10 +171,6 @@ public boolean hasNext() {
 
 		assertCursorIsOpen();
 
-		if (limitReached(getPosition())) {
-			return false;
-		}
-
 		while (!delegate.hasNext() && !CursorState.FINISHED.equals(state)) {
 			scan(cursorId);
 		}
@@ -200,17 +182,6 @@ public boolean hasNext() {
 		return cursorId > 0;
 	}
 
-	/**
-	 * Evaluate if the current cursor position has reached a point where it should stop.
-	 *
-	 * @param currentPosition the current position.
-	 * @return {@literal false} by default.
-	 * @since 2.5
-	 */
-	protected boolean limitReached(long currentPosition) {
-		return false;
-	}
-
 	private void assertCursorIsOpen() {
 
 		if (isReady() || isClosed()) {
@@ -301,81 +272,10 @@ public long getPosition() {
 		return position;
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.redis.core.Cursor#limit(long)
-	 */
-	@Override
-	public ScanCursor<T> limit(long count) {
-
-		Assert.isTrue(count >= 0, "Count must be greater or equal to zero");
-
-		return new LimitingCursor<>(this, count);
-	}
-
 	/**
 	 * @author Thomas Darimont
 	 */
 	enum CursorState {
 		READY, OPEN, FINISHED, CLOSED;
 	}
-
-	/**
-	 * Wrapper for a concrete {@link ScanCursor} forwarding {@link #doScan(long, ScanOptions)}, {@link #doClose()} and
-	 * {@link #isClosed()}.
-	 *
-	 * @param <T>
-	 * @author Mark Paluch
-	 * @author Christoph Strobl
-	 * @since 2.5
-	 */
-	private static class LimitingCursor<T> extends ScanCursor<T> {
-
-		private final ScanCursor<T> delegate;
-		private final long limit;
-
-		LimitingCursor(ScanCursor<T> delegate, long limit) {
-
-			super(delegate);
-
-			this.delegate = delegate;
-			this.limit = limit;
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * @see org.springframework.data.redis.core.ScanCursor#doScan(long, ScanOptions)
-		 */
-		@Override
-		protected ScanIteration<T> doScan(long cursorId, ScanOptions options) {
-			return delegate.doScan(cursorId, options);
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * @see org.springframework.data.redis.core.ScanCursor#doClose()
-		 */
-		@Override
-		protected void doClose() {
-			delegate.close();
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * @see org.springframework.data.redis.core.Cursor#isClosed()
-		 */
-		@Override
-		public boolean isClosed() {
-			return delegate.isClosed();
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * @see org.springframework.data.redis.core.ScanCursor#limitReached(long)
-		 */
-		@Override
-		protected boolean limitReached(long currentPosition) {
-			return delegate.limitReached(currentPosition) || (limit != -1 && currentPosition > limit - 1);
-		}
-	}
 }

src/main/java/org/springframework/data/redis/util/BoundedIterator.java

@@ -24,6 +24,8 @@
 import java.util.List;
 import java.util.NoSuchElementException;
 import java.util.Queue;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.junit.jupiter.api.Test;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
@@ -199,100 +201,36 @@ void hasNextShouldStopCorrectlyWhenWholeScanIterationDoesNotReturnResultsAndStat
 	}
 
 	@Test // GH-1575
-	void limitShouldApplyLimitation() {
+	void streamLimitShouldApplyLimitation() {
 
 		LinkedList<ScanIteration<String>> values = new LinkedList<>();
 		values.add(createIteration(1, "spring"));
 		values.add(createIteration(2, "data"));
 		values.add(createIteration(3, "redis"));
 		values.add(createIteration(0));
-		Cursor<String> cursor = initCursor(values).limit(2);
 
-		List<String> result = new ArrayList<>();
-		while (cursor.hasNext()) {
-			result.add(cursor.next());
-		}
-
-		assertThat(result).hasSize(2).contains("spring", "data");
-	}
-
-	@Test // GH-1575
-	void limitShouldNotLimitOriginalCursor() {
-
-		LinkedList<ScanIteration<String>> values = new LinkedList<>();
-		values.add(createIteration(1, "spring"));
-		values.add(createIteration(2, "data"));
-		values.add(createIteration(3, "redis"));
-		values.add(createIteration(0));
 		Cursor<String> cursor = initCursor(values);
-		cursor.limit(1);
-
-		List<String> result = new ArrayList<>();
-		while (cursor.hasNext()) {
-			result.add(cursor.next());
-		}
-
-		assertThat(result).hasSize(3);
-	}
-
-	@Test // GH-1575
-	void limitAlreadyLimitedCursorToLess() {
-
-		LinkedList<ScanIteration<String>> values = new LinkedList<>();
-		values.add(createIteration(1, "spring"));
-		values.add(createIteration(2, "data"));
-		values.add(createIteration(3, "redis"));
-		values.add(createIteration(0));
-		Cursor<String> cursor = initCursor(values);
-		Cursor<String> limitedTo3 = cursor.limit(3);
-		Cursor<String> limitedTo2 = limitedTo3.limit(2);
-
-		List<String> result = new ArrayList<>();
-		while (limitedTo2.hasNext()) {
-			result.add(limitedTo2.next());
-		}
-
-		assertThat(result).hasSize(2);
-	}
-
-	@Test // GH-1575
-	void limitAlreadyLimitedCursorToMore/*should not work obviously*/() {
-
-		LinkedList<ScanIteration<String>> values = new LinkedList<>();
-		values.add(createIteration(1, "spring"));
-		values.add(createIteration(2, "data"));
-		values.add(createIteration(3, "redis"));
-		values.add(createIteration(0));
-		Cursor<String> cursor = initCursor(values);
-		Cursor<String> limitedTo2 = cursor.limit(2);
-		Cursor<String> limitedTo3 = limitedTo2.limit(3);
-
-		List<String> result = new ArrayList<>();
-		while (limitedTo3.hasNext()) {
-			result.add(limitedTo3.next());
-		}
 
-		assertThat(result).hasSize(2);
+		assertThat(cursor.stream().limit(2).collect(Collectors.toList())).hasSize(2).contains("spring", "data");
 	}
 
 	@Test // GH-1575
-	void decoratedCursorShouldForwardClose() {
+	void streamingCursorShouldForwardClose() {
 
 		LinkedList<ScanIteration<String>> values = new LinkedList<>();
 		values.add(createIteration(1, "spring"));
 		values.add(createIteration(2, "data"));
 		values.add(createIteration(3, "redis"));
 		values.add(createIteration(0));
 		Cursor<String> cursor = initCursor(values);
-		Cursor<String> limited = cursor.limit(1);
 
 		assertThat(cursor.isClosed()).isFalse();
-		assertThat(limited.isClosed()).isFalse();
 
-		limited.close();
+		Stream<String> stream = cursor.stream();
+		stream.collect(Collectors.toList());
+		stream.close();
 
 		assertThat(cursor.isClosed()).isTrue();
-		assertThat(limited.isClosed()).isTrue();
 	}
 
 	private CapturingCursorDummy initCursor(Queue<ScanIteration<String>> values) {