Introduce ScanCursor limitation check method to.

This commit moves the limit field to the delegating sub class. This way it is possible to override the newly introduced limitReached(long) method without polluting the ScanCursor implementation with the limit check itself.

Author: christophstrobl

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

@@ -43,7 +43,6 @@ public abstract class ScanCursor<T> implements Cursor<T> {
 	private Iterator<T> delegate;
 	private final ScanOptions scanOptions;
 	private long position;
-	private final long limit;
 
 	/**
 	 * Crates new {@link ScanCursor} with {@code id=0} and {@link ScanOptions#NONE}
@@ -82,23 +81,20 @@ public ScanCursor(long cursorId, @Nullable ScanOptions options) {
 		this.cursorId = cursorId;
 		this.state = CursorState.READY;
 		this.delegate = Collections.emptyIterator();
-		this.limit = -1;
 	}
 
 	/**
 	 * Crates a new {@link ScanCursor}.
 	 *
 	 * @param source source cursor.
-	 * @param limit
 	 * @since 2.5
 	 */
-	private ScanCursor(ScanCursor<T> source, long limit) {
+	private ScanCursor(ScanCursor<T> source) {
 
 		this.scanOptions = source.scanOptions;
 		this.cursorId = source.cursorId;
 		this.state = source.state;
 		this.delegate = source.delegate;
-		this.limit = limit;
 	}
 
 	private void scan(long cursorId) {
@@ -189,7 +185,7 @@ public boolean hasNext() {
 
 		assertCursorIsOpen();
 
-		if (limit != -1 && getPosition() > limit - 1) {
+		if (limitReached(getPosition())) {
 			return false;
 		}
 
@@ -204,6 +200,17 @@ 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()) {
@@ -303,7 +310,7 @@ public ScanCursor<T> limit(long count) {
 
 		Assert.isTrue(count >= 0, "Count must be greater or equal to zero");
 
-		return new ScanCursorWrapper<>(this, count);
+		return new LimitingCursor<>(this, count);
 	}
 
 	/**
@@ -318,30 +325,57 @@ enum CursorState {
 	 * {@link #isClosed()}.
 	 *
 	 * @param <T>
+	 * @author Mark Paluch
+	 * @author Christoph Strobl
 	 * @since 2.5
 	 */
-	private static class ScanCursorWrapper<T> extends ScanCursor<T> {
+	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);
 
-		public ScanCursorWrapper(ScanCursor<T> delegate, long limit) {
-			super(delegate, limit);
 			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/test/java/org/springframework/data/redis/core/ScanCursorUnitTests.java

@@ -26,7 +26,6 @@
 import java.util.Queue;
 
 import org.junit.jupiter.api.Test;
-
 import org.springframework.dao.InvalidDataAccessApiUsageException;
 
 /**
@@ -236,6 +235,46 @@ void limitShouldNotLimitOriginalCursor() {
 		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);
+	}
+
 	@Test // GH-1575
 	void decoratedCursorShouldForwardClose() {