DATAREDIS-1196 - Add support for LPOS command.

Original pull request: #563.

Author: christophstrobl

src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java

@@ -702,6 +702,15 @@ public byte[] lPop(byte[] key) {
 		return convertAndReturn(delegate.lPop(key), identityConverter);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.RedisListCommands#lPos(byte[], byte[], java.lang.Integer, java.lang.Integer)
+	 */
+	@Override
+	public List<Long> lPos(byte[] key, byte[] element, @Nullable Integer rank, @Nullable Integer count) {
+		return convertAndReturn(delegate.lPos(key, element, rank, count), identityConverter);
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.redis.connection.RedisListCommands#lPush(byte[], byte[][])
@@ -2138,6 +2147,15 @@ public String lPop(String key) {
 		return convertAndReturn(delegate.lPop(serialize(key)), bytesToString);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.StringRedisConnection#lPos(java.lang.String, java.lang.String, java.lang.Integer, java.lang.Integer)
+	 */
+	@Override
+	public List<Long> lPos(String key, String element, @Nullable Integer rank, @Nullable Integer count) {
+		return lPos(serialize(key), serialize(element), rank, count);
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.redis.connection.StringRedisConnection#lPush(java.lang.String, java.lang.String[])

src/main/java/org/springframework/data/redis/connection/DefaultedRedisConnection.java

@@ -621,6 +621,13 @@ default Long rPush(byte[] key, byte[]... values) {
 		return listCommands().rPush(key, values);
 	}
 
+	/** @deprecated in favor of {@link RedisConnection#listCommands()}}. */
+	@Override
+	@Deprecated
+	default List<Long> lPos(byte[] key, byte[] element, @Nullable Integer rank, @Nullable Integer count) {
+		return listCommands().lPos(key, element, rank, count);
+	}
+
 	/** @deprecated in favor of {@link RedisConnection#listCommands()}}. */
 	@Override
 	@Deprecated

src/main/java/org/springframework/data/redis/connection/ReactiveListCommands.java

@@ -312,6 +312,125 @@ default Mono<Boolean> lTrim(ByteBuffer key, long start, long end) {
 	 */
 	Flux<BooleanResponse<RangeCommand>> lTrim(Publisher<RangeCommand> commands);
 
+	/**
+	 * {@code LPOS} command parameters.
+	 * 
+	 * @author Christoph Strobl
+	 * @since 2.4
+	 * @see <a href="https://redis.io/commands/lpos">Redis Documentation: LPOS</a>
+	 */
+	class LPosCommand extends KeyCommand {
+
+		private final ByteBuffer element;
+		private final @Nullable Integer count;
+		private final @Nullable Integer rank;
+
+		private LPosCommand(@Nullable ByteBuffer key, ByteBuffer element, @Nullable Integer count, @Nullable Integer rank) {
+
+			super(key);
+			this.element = element;
+			this.count = count;
+			this.rank = rank;
+		}
+
+		/**
+		 * Creates a new {@link LPosCommand} for given {@literal element}.
+		 *
+		 * @param element
+		 * @return a new {@link LPosCommand} for {@literal element}.
+		 */
+		public static LPosCommand lPosOf(ByteBuffer element) {
+			return new LPosCommand(null, element, null, null);
+		}
+
+		/**
+		 * Applies the {@literal key}. Constructs a new command instance with all previously configured properties.
+		 *
+		 * @param key must not be {@literal null}.
+		 * @return a new {@link LPosCommand} with {@literal key} applied.
+		 */
+		public LPosCommand from(ByteBuffer key) {
+
+			Assert.notNull(key, "Key must not be null!");
+			return new LPosCommand(key, element, count, rank);
+		}
+
+		/**
+		 * Applies the {@literal count} parameter specifying the number of matches to return. Constructs a new command
+		 * instance with all previously configured properties.
+		 *
+		 * @param count can be {@literal null}.
+		 * @return a new {@link LPosCommand} with {@literal count} applied.
+		 */
+		public LPosCommand count(Integer count) {
+			return new LPosCommand(getKey(), element, count, rank);
+		}
+
+		/**
+		 * Applies the {@literal rank} parameter specifying the "rank" of the first element to return. Constructs a new
+		 * command instance with all previously configured properties.
+		 *
+		 * @param rank can be {@literal null}.
+		 * @return a new {@link LPosCommand} with {@literal count} applied.
+		 */
+		public LPosCommand rank(Integer rank) {
+			return new LPosCommand(getKey(), element, count, rank);
+		}
+
+		@Nullable
+		public Integer getCount() {
+			return count;
+		}
+
+		@Nullable
+		public Integer getRank() {
+			return rank;
+		}
+
+		@Nullable
+		public ByteBuffer getElement() {
+			return element;
+		}
+	}
+
+	/**
+	 * Get first index of the {@literal element} from list at {@literal key}.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param element
+	 * @return a {@link Mono} emitting the elements index.
+	 * @since 2.4
+	 * @see <a href="https://redis.io/commands/lindex">Redis Documentation: LINDEX</a>
+	 */
+	default Mono<Long> lPos(ByteBuffer key, ByteBuffer element) {
+
+		Assert.notNull(key, "Key must not be null!");
+
+		return lPos(LPosCommand.lPosOf(element).from(key)).next();
+	}
+
+	/**
+	 * Get indices of the {@literal element} from list at {@link LPosCommand#getKey()}.
+	 *
+	 * @param command must not be {@literal null}.
+	 * @return a {@link Flux} emitting the elements indices one by one.
+	 * @since 2.4
+	 * @see <a href="https://redis.io/commands/lindex">Redis Documentation: LINDEX</a>
+	 */
+	default Flux<Long> lPos(LPosCommand command) {
+		return lPos(Mono.just(command)).map(NumericResponse::getOutput);
+	}
+
+	/**
+	 * Get indices of the {@literal element} from list at {@link LPosCommand#getKey()}.
+	 *
+	 * @param commands must not be {@literal null}.
+	 * @return a {@link Flux} emitting the elements indices one by one.
+	 * @since 2.4
+	 * @see <a href="https://redis.io/commands/lindex">Redis Documentation: LINDEX</a>
+	 */
+	Flux<NumericResponse<LPosCommand, Long>> lPos(Publisher<LPosCommand> commands);
+
 	/**
 	 * {@code LINDEX} command parameters.
 	 *

src/main/java/org/springframework/data/redis/connection/RedisListCommands.java

@@ -18,6 +18,7 @@
 import java.util.List;
 
 import org.springframework.lang.Nullable;
+import org.springframework.util.CollectionUtils;
 
 /**
  * List-specific commands supported by Redis.
@@ -46,6 +47,36 @@ enum Position {
 	@Nullable
 	Long rPush(byte[] key, byte[]... values);
 
+	/**
+	 * Returns the index of matching elements inside the list stored at given {@literal key}. <br />
+	 * Requires Redis 6.0.6.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param element must not be {@literal null}.
+	 * @return {@literal null} when used in pipeline / transaction.
+	 * @see <a href="https://redis.io/commands/lpos">Redis Documentation: LPOS</a>
+	 * @since 2.4
+	 */
+	@Nullable
+	default Long lPos(byte[] key, byte[] element) {
+		return CollectionUtils.firstElement(lPos(key, element, null, null));
+	}
+
+	/**
+	 * Returns the index of matching elements inside the list stored at given {@literal key}. <br />
+	 * Requires Redis 6.0.6.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param element must not be {@literal null}.
+	 * @param rank specifies the "rank" of the first element to return, in case there are multiple matches. A rank of 1
+	 *          means to return the first match, 2 to return the second match, and so forth.
+	 * @param count number of matches to return.
+	 * @return {@literal null} when used in pipeline / transaction.
+	 * @see <a href="https://redis.io/commands/lpos">Redis Documentation: LPOS</a>
+	 * @since 2.4
+	 */
+	List<Long> lPos(byte[] key, byte[] element, @Nullable Integer rank, @Nullable Integer count);
+
 	/**
 	 * Prepend {@code values} to {@code key}.
 	 *

src/main/java/org/springframework/data/redis/connection/StringRedisConnection.java

@@ -49,6 +49,7 @@
 import org.springframework.data.redis.core.types.RedisClientInfo;
 import org.springframework.data.redis.serializer.RedisSerializer;
 import org.springframework.lang.Nullable;
+import org.springframework.util.CollectionUtils;
 
 /**
  * Convenience extension of {@link RedisConnection} that accepts and returns {@link String}s instead of byte arrays.
@@ -685,6 +686,36 @@ default Long bitPos(String key, boolean bit) {
 	 */
 	Long rPush(String key, String... values);
 
+	/**
+	 * Returns the index of matching elements inside the list stored at given {@literal key}. <br />
+	 * Requires Redis 6.0.6.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param element must not be {@literal null}.
+	 * @return {@literal null} when used in pipeline / transaction.
+	 * @see <a href="https://redis.io/commands/lpos">Redis Documentation: LPOS</a>
+	 * @since 2.4
+	 */
+	@Nullable
+	default Long lPos(String key, String element) {
+		return CollectionUtils.firstElement(lPos(key, element, null, null));
+	}
+
+	/**
+	 * Returns the index of matching elements inside the list stored at given {@literal key}. <br />
+	 * Requires Redis 6.0.6.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param element must not be {@literal null}.
+	 * @param rank specifies the "rank" of the first element to return, in case there are multiple matches. A rank of 1
+	 *          means to return the first match, 2 to return the second match, and so forth.
+	 * @param count number of matches to return.
+	 * @return {@literal null} when used in pipeline / transaction.
+	 * @see <a href="https://redis.io/commands/lpos">Redis Documentation: LPOS</a>
+	 * @since 2.4
+	 */
+	List<Long> lPos(String key, String element, @Nullable Integer rank, @Nullable Integer count);
+
 	/**
 	 * Prepend {@code values} to {@code key}.
 	 *

src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterListCommands.java

@@ -20,9 +20,11 @@
 import java.util.List;
 
 import org.springframework.dao.DataAccessException;
+import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.data.redis.connection.ClusterSlotHashUtil;
 import org.springframework.data.redis.connection.RedisListCommands;
 import org.springframework.data.redis.connection.jedis.JedisClusterConnection.JedisMultiKeyClusterCommandCallback;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.CollectionUtils;
 
@@ -55,6 +57,19 @@ public Long rPush(byte[] key, byte[]... values) {
 		}
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.RedisListCommands#l{lPos(byte[], byte[], java.lang.Integer, java.lang.Integer)
+	 */
+	@Override
+	public List<Long> lPos(byte[] key, byte[] element, @Nullable Integer rank, @Nullable Integer count) {
+
+		Assert.notNull(key, "Key must not be null!");
+		Assert.notNull(element, "Element must not be null!");
+
+		throw new InvalidDataAccessApiUsageException("LPOS is not supported by jedis.");
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.redis.connection.RedisListCommands#lPush(byte[], byte[][])

src/main/java/org/springframework/data/redis/connection/jedis/JedisListCommands.java

@@ -20,7 +20,9 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.data.redis.connection.RedisListCommands;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
@@ -60,6 +62,19 @@ public Long rPush(byte[] key, byte[]... values) {
 		}
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.RedisListCommands#l{lPos(byte[], byte[], java.lang.Integer, java.lang.Integer)
+	 */
+	@Override
+	public List<Long> lPos(byte[] key, byte[] element, @Nullable Integer rank, @Nullable Integer count) {
+
+		Assert.notNull(key, "Key must not be null!");
+		Assert.notNull(element, "Element must not be null!");
+
+		throw new InvalidDataAccessApiUsageException("LPOS is not supported by jedis.");
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.redis.connection.RedisListCommands#lPush(byte[], byte[][])

src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConnection.java

@@ -1136,6 +1136,7 @@ static class TypeHints {
 			COMMAND_OUTPUT_TYPE_MAPPING.put(LINSERT, IntegerOutput.class);
 			COMMAND_OUTPUT_TYPE_MAPPING.put(LLEN, IntegerOutput.class);
 			COMMAND_OUTPUT_TYPE_MAPPING.put(LPUSH, IntegerOutput.class);
+			COMMAND_OUTPUT_TYPE_MAPPING.put(LPOS, IntegerOutput.class);
 			COMMAND_OUTPUT_TYPE_MAPPING.put(LPUSHX, IntegerOutput.class);
 			COMMAND_OUTPUT_TYPE_MAPPING.put(LREM, IntegerOutput.class);
 			COMMAND_OUTPUT_TYPE_MAPPING.put(PTTL, IntegerOutput.class);

src/main/java/org/springframework/data/redis/connection/lettuce/LettuceListCommands.java

@@ -15,13 +15,16 @@
  */
 package org.springframework.data.redis.connection.lettuce;
 
+import io.lettuce.core.LPosArgs;
 import io.lettuce.core.cluster.api.async.RedisClusterAsyncCommands;
 import io.lettuce.core.cluster.api.sync.RedisClusterCommands;
 
+import java.util.Collections;
 import java.util.List;
 
 import org.springframework.dao.DataAccessException;
 import org.springframework.data.redis.connection.RedisListCommands;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
@@ -61,6 +64,47 @@ public Long rPush(byte[] key, byte[]... values) {
 		}
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.RedisListCommands#l{lPos(byte[], byte[], java.lang.Integer, java.lang.Integer)
+	 */
+	@Override
+	public List<Long> lPos(byte[] key, byte[] element, @Nullable Integer rank, @Nullable Integer count) {
+
+		Assert.notNull(key, "Key must not be null!");
+		Assert.notNull(element, "Element must not be null!");
+
+		LPosArgs args = new LPosArgs();
+		if (rank != null) {
+			args.rank(rank);
+		}
+		try {
+			if (isPipelined()) {
+				if (count != null) {
+					pipeline(connection.newLettuceResult(getAsyncConnection().lpos(key, element, count, args)));
+				} else {
+					pipeline(connection.newLettuceResult(getAsyncConnection().lpos(key, element, args)));
+				}
+				return null;
+			}
+			if (isQueueing()) {
+				if (count != null) {
+					transaction(connection.newLettuceResult(getAsyncConnection().lpos(key, element, count, args)));
+				} else {
+					transaction(connection.newLettuceResult(getAsyncConnection().lpos(key, element, args)));
+				}
+				return null;
+			}
+			if (count != null) {
+				return getConnection().lpos(key, element, count, args);
+			}
+
+			return Collections.singletonList(getConnection().lpos(key, element, args));
+		} catch (Exception ex) {
+			throw convertLettuceAccessException(ex);
+		}
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.redis.connection.RedisListCommands#lPush(byte[], byte[][])