DATAREDIS-287 - 'setBit' should return boolean value.

christophstrobl · christophstrobl · commit c466b0e83b47 · 2014-03-26T09:05:56.000+01:00
SetBit now returns the original bit value stored at the offset. The result will also be added in pipeline and transaction mode which means that the final result collection may now contain more entries than in prior versions. Original Pull Request: #58
diff --git a/src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java b/src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java
@@ -723,8 +723,8 @@ public void set(byte[] key, byte[] value) {
 		delegate.set(key, value);
 	}
 
-	public void setBit(byte[] key, long offset, boolean value) {
-		delegate.setBit(key, offset, value);
+	public Boolean setBit(byte[] key, long offset, boolean value) {
+		return delegate.setBit(key, offset, value);
 	}
 
 	public void setConfig(String param, String value) {
@@ -1705,8 +1705,8 @@ public void set(String key, String value) {
 		delegate.set(serialize(key), serialize(value));
 	}
 
-	public void setBit(String key, long offset, boolean value) {
-		delegate.setBit(serialize(key), offset, value);
+	public Boolean setBit(String key, long offset, boolean value) {
+		return delegate.setBit(serialize(key), offset, value);
 	}
 
 	public void setEx(String key, long seconds, String value) {
diff --git a/src/main/java/org/springframework/data/redis/connection/RedisStringCommands.java b/src/main/java/org/springframework/data/redis/connection/RedisStringCommands.java
@@ -209,8 +209,9 @@ public enum BitOperation {
 	 * @param key
 	 * @param offset
 	 * @param value
+	 * @return the original bit value stored at {@code offset}.
 	 */
-	void setBit(byte[] key, long offset, boolean value);
+	Boolean setBit(byte[] key, long offset, boolean value);
 
 	/**
 	 * Count the number of set bits (population counting) in value stored at {@code key}.
diff --git a/src/main/java/org/springframework/data/redis/connection/StringRedisConnection.java b/src/main/java/org/springframework/data/redis/connection/StringRedisConnection.java
@@ -127,7 +127,15 @@ public interface StringTuple extends Tuple {
 
 	Boolean getBit(String key, long offset);
 
-	void setBit(String key, long offset, boolean value);
+	/**
+	 * Sets the bit at {@code offset} in value stored at {@code key}.
+	 * 
+	 * @param key
+	 * @param offset
+	 * @param value
+	 * @return the original bit value stored at {@code offset}.
+	 */
+	Boolean setBit(String key, long offset, boolean value);
 
 	Long bitCount(String key);
 
diff --git a/src/main/java/org/springframework/data/redis/connection/jedis/JedisConnection.java b/src/main/java/org/springframework/data/redis/connection/jedis/JedisConnection.java
@@ -1348,17 +1348,18 @@ public Boolean getBit(byte[] key, long offset) {
 		}
 	}
 
-	public void setBit(byte[] key, long offset, boolean value) {
+	public Boolean setBit(byte[] key, long offset, boolean value) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisStatusResult(pipeline.setbit(key, offset, JedisConverters.toBit(value))));
-				return;
+
+				pipeline(new JedisResult(pipeline.setbit(key, offset, JedisConverters.toBit(value))));
+				return null;
 			}
 			if (isQueueing()) {
-				transaction(new JedisStatusResult(transaction.setbit(key, offset, JedisConverters.toBit(value))));
-				return;
+				transaction(new JedisResult(transaction.setbit(key, offset, JedisConverters.toBit(value))));
+				return null;
 			}
-			jedis.setbit(key, offset, JedisConverters.toBit(value));
+			return jedis.setbit(key, offset, JedisConverters.toBit(value));
 		} catch (Exception ex) {
 			throw convertJedisAccessException(ex);
 		}
diff --git a/src/main/java/org/springframework/data/redis/connection/jredis/JredisConnection.java b/src/main/java/org/springframework/data/redis/connection/jredis/JredisConnection.java
@@ -573,9 +573,9 @@ public Boolean getBit(byte[] key, long offset) {
 		}
 	}
 
-	public void setBit(byte[] key, long offset, boolean value) {
+	public Boolean setBit(byte[] key, long offset, boolean value) {
 		try {
-			jredis.setbit(key, (int) offset, value);
+			return jredis.setbit(key, (int) offset, value);
 		} catch (Exception ex) {
 			throw convertJredisAccessException(ex);
 		}
diff --git a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConnection.java b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConnection.java
@@ -1402,17 +1402,20 @@ public Boolean getBit(byte[] key, long offset) {
 		}
 	}
 
-	public void setBit(byte[] key, long offset, boolean value) {
+	public Boolean setBit(byte[] key, long offset, boolean value) {
 		try {
 			if (isPipelined()) {
-				pipeline(new LettuceStatusResult(getAsyncConnection().setbit(key, offset, LettuceConverters.toInt(value))));
-				return;
+				pipeline(new LettuceResult(getAsyncConnection().setbit(key, offset, LettuceConverters.toInt(value)),
+						LettuceConverters.longToBooleanConverter()));
+				return null;
 			}
 			if (isQueueing()) {
-				transaction(new LettuceTxStatusResult(getConnection().setbit(key, offset, LettuceConverters.toInt(value))));
-				return;
+				transaction(new LettuceTxResult(getConnection().setbit(key, offset, LettuceConverters.toInt(value)),
+						LettuceConverters.longToBooleanConverter()));
+				return null;
 			}
-			getConnection().setbit(key, offset, LettuceConverters.toInt(value));
+			return LettuceConverters.longToBooleanConverter().convert(
+					getConnection().setbit(key, offset, LettuceConverters.toInt(value)));
 		} catch (Exception ex) {
 			throw convertLettuceAccessException(ex);
 		}
diff --git a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConverters.java b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConverters.java
@@ -30,6 +30,7 @@
 import org.springframework.data.redis.connection.SortParameters;
 import org.springframework.data.redis.connection.SortParameters.Order;
 import org.springframework.data.redis.connection.convert.Converters;
+import org.springframework.data.redis.connection.convert.LongToBooleanConverter;
 import org.springframework.util.Assert;
 
 import com.lambdaworks.redis.KeyValue;
@@ -52,6 +53,7 @@ abstract public class LettuceConverters extends Converters {
 	private static final Converter<List<ScoredValue<byte[]>>, Set<Tuple>> SCORED_VALUES_TO_TUPLE_SET;
 	private static final Converter<ScoredValue<byte[]>, Tuple> SCORED_VALUE_TO_TUPLE;
 	private static final Converter<Exception, DataAccessException> EXCEPTION_CONVERTER = new LettuceExceptionConverter();
+	private static final Converter<Long, Boolean> LONG_TO_BOOLEAN = new LongToBooleanConverter();
 
 	static {
 		DATE_TO_LONG = new Converter<Date, Long>() {
@@ -100,6 +102,7 @@ public Tuple convert(ScoredValue<byte[]> source) {
 			}
 
 		};
+
 	}
 
 	public static Converter<Date, Long> dateToLong() {
@@ -130,6 +133,14 @@ public static Converter<Exception, DataAccessException> exceptionConverter() {
 		return EXCEPTION_CONVERTER;
 	}
 
+	/**
+	 * @return
+	 * @sice 1.3
+	 */
+	public static Converter<Long, Boolean> longToBooleanConverter() {
+		return LONG_TO_BOOLEAN;
+	}
+
 	public static Long toLong(Date source) {
 		return DATE_TO_LONG.convert(source);
 	}
diff --git a/src/main/java/org/springframework/data/redis/connection/srp/SrpConnection.java b/src/main/java/org/springframework/data/redis/connection/srp/SrpConnection.java
@@ -1047,13 +1047,14 @@ public Boolean getBit(byte[] key, long offset) {
 		}
 	}
 
-	public void setBit(byte[] key, long offset, boolean value) {
+	public Boolean setBit(byte[] key, long offset, boolean value) {
 		try {
 			if (isPipelined()) {
-				pipeline(new SrpStatusResult(pipeline.setbit(key, offset, SrpConverters.toBit(value))));
-				return;
+				pipeline(new SrpGenericResult(pipeline.setbit(key, offset, SrpConverters.toBit(value)),
+						SrpConverters.longToBooleanConverter()));
+				return null;
 			}
-			client.setbit(key, offset, SrpConverters.toBit(value));
+			return SrpConverters.toBoolean(client.setbit(key, offset, SrpConverters.toBit(value)));
 		} catch (Exception ex) {
 			throw convertSrpAccessException(ex);
 		}
diff --git a/src/main/java/org/springframework/data/redis/connection/srp/SrpConverters.java b/src/main/java/org/springframework/data/redis/connection/srp/SrpConverters.java
@@ -34,8 +34,8 @@
 import org.springframework.data.redis.connection.RedisStringCommands.BitOperation;
 import org.springframework.data.redis.connection.RedisZSetCommands.Tuple;
 import org.springframework.data.redis.connection.convert.Converters;
+import org.springframework.data.redis.connection.convert.LongToBooleanConverter;
 import org.springframework.util.Assert;
-import org.springframework.util.NumberUtils;
 
 import redis.client.RedisException;
 import redis.reply.IntegerReply;
@@ -65,6 +65,8 @@ abstract public class SrpConverters extends Converters {
 	private static final Converter<byte[], String> BYTES_TO_STRING;
 	private static final Converter<byte[], Double> BYTES_TO_DOUBLE;
 	private static final Converter<Reply[], Long> REPLIES_TO_TIME_AS_LONG;
+	private static final Converter<IntegerReply, Boolean> INTEGER_REPLY_TO_BOOLEAN;
+	private static final Converter<Long, Boolean> LONG_TO_BOOLEAN = new LongToBooleanConverter();
 
 	static {
 		REPLIES_TO_BYTES_LIST = new Converter<Reply[], List<byte[]>>() {
@@ -171,6 +173,16 @@ public List<String> convert(Reply[] source) {
 				return results;
 			}
 		};
+		INTEGER_REPLY_TO_BOOLEAN = new Converter<IntegerReply, Boolean>() {
+
+			@Override
+			public Boolean convert(IntegerReply source) {
+				if (source == null || source.data() == null) {
+					return false;
+				}
+				return source.data() == 1;
+			}
+		};
 	}
 
 	public static Converter<Reply[], List<byte[]>> repliesToBytesList() {
@@ -213,6 +225,14 @@ public static Converter<Reply[], Long> repliesToTimeAsLong() {
 		return REPLIES_TO_TIME_AS_LONG;
 	}
 
+	/**
+	 * @return
+	 * @since 1.3
+	 */
+	public static Converter<Long, Boolean> longToBooleanConverter() {
+		return LONG_TO_BOOLEAN;
+	}
+
 	public static List<byte[]> toBytesList(Reply[] source) {
 		return REPLIES_TO_BYTES_LIST.convert(source);
 	}
@@ -293,4 +313,15 @@ public static byte[] toBytes(Position source) {
 	public static List<String> toStringList(String source) {
 		return Collections.singletonList(source);
 	}
+
+	/**
+	 * Convert an {@link IntegerReply} to a {@link Boolean} by inspecting {@link IntegerReply#data()}.
+	 * 
+	 * @since 1.3
+	 * @param reply
+	 * @return
+	 */
+	public static Boolean toBoolean(IntegerReply reply) {
+		return INTEGER_REPLY_TO_BOOLEAN.convert(reply);
+	}
 }
diff --git a/src/test/java/org/springframework/data/redis/connection/AbstractConnectionIntegrationTests.java b/src/test/java/org/springframework/data/redis/connection/AbstractConnectionIntegrationTests.java
@@ -416,22 +416,23 @@ public void testPingPong() throws Exception {
 	@Test
 	public void testBitSet() throws Exception {
 		String key = "bitset-test";
-		connection.setBit(key, 0, false);
-		connection.setBit(key, 1, true);
+		actual.add(connection.setBit(key, 0, true));
+		actual.add(connection.setBit(key, 0, false));
+		actual.add(connection.setBit(key, 1, true));
 		actual.add(connection.getBit(key, 0));
 		actual.add(connection.getBit(key, 1));
-		verifyResults(Arrays.asList(new Object[] { false, true }));
+		verifyResults(Arrays.asList(new Object[] { false, true, false, false, true }));
 	}
 
 	@Test
 	@IfProfileValue(name = "redisVersion", value = "2.6")
 	public void testBitCount() {
 		String key = "bitset-test";
-		connection.setBit(key, 0, false);
-		connection.setBit(key, 1, true);
-		connection.setBit(key, 2, true);
+		actual.add(connection.setBit(key, 0, false));
+		actual.add(connection.setBit(key, 1, true));
+		actual.add(connection.setBit(key, 2, true));
 		actual.add(connection.bitCount(key));
-		verifyResults(new ArrayList<Object>(Collections.singletonList(2l)));
+		verifyResults(Arrays.asList(new Object[] { false, false, false, 2L }));
 	}
 
 	@Test

Original file line number	Diff line number	Diff line change
`@@ -723,8 +723,8 @@ public void set(byte[] key, byte[] value) {`
`723`	`723`	`delegate.set(key, value);`
`724`	`724`	`}`
`725`	`725`
`726`		`- public void setBit(byte[] key, long offset, boolean value) {`
`727`		`- delegate.setBit(key, offset, value);`
	`726`	`+ public Boolean setBit(byte[] key, long offset, boolean value) {`
	`727`	`+ return delegate.setBit(key, offset, value);`
`728`	`728`	`}`
`729`	`729`
`730`	`730`	`public void setConfig(String param, String value) {`
`@@ -1705,8 +1705,8 @@ public void set(String key, String value) {`
`1705`	`1705`	`delegate.set(serialize(key), serialize(value));`
`1706`	`1706`	`}`
`1707`	`1707`
`1708`		`- public void setBit(String key, long offset, boolean value) {`
`1709`		`- delegate.setBit(serialize(key), offset, value);`
	`1708`	`+ public Boolean setBit(String key, long offset, boolean value) {`
	`1709`	`+ return delegate.setBit(serialize(key), offset, value);`
`1710`	`1710`	`}`
`1711`	`1711`
`1712`	`1712`	`public void setEx(String key, long seconds, String value) {`
Original file line number	Diff line number	Diff line change
`@@ -1348,17 +1348,18 @@ public Boolean getBit(byte[] key, long offset) {`
`1348`	`1348`	`}`
`1349`	`1349`	`}`
`1350`	`1350`
`1351`		`- public void setBit(byte[] key, long offset, boolean value) {`
	`1351`	`+ public Boolean setBit(byte[] key, long offset, boolean value) {`
`1352`	`1352`	`try {`
`1353`	`1353`	`if (isPipelined()) {`
`1354`		`- pipeline(new JedisStatusResult(pipeline.setbit(key, offset, JedisConverters.toBit(value))));`
`1355`		`- return;`
	`1354`	`+`
	`1355`	`+ pipeline(new JedisResult(pipeline.setbit(key, offset, JedisConverters.toBit(value))));`
	`1356`	`+ return null;`
`1356`	`1357`	`}`
`1357`	`1358`	`if (isQueueing()) {`
`1358`		`- transaction(new JedisStatusResult(transaction.setbit(key, offset, JedisConverters.toBit(value))));`
`1359`		`- return;`
	`1359`	`+ transaction(new JedisResult(transaction.setbit(key, offset, JedisConverters.toBit(value))));`
	`1360`	`+ return null;`
`1360`	`1361`	`}`
`1361`		`- jedis.setbit(key, offset, JedisConverters.toBit(value));`
	`1362`	`+ return jedis.setbit(key, offset, JedisConverters.toBit(value));`
`1362`	`1363`	`} catch (Exception ex) {`
`1363`	`1364`	`throw convertJedisAccessException(ex);`
`1364`	`1365`	`}`
Original file line number	Diff line number	Diff line change
`@@ -573,9 +573,9 @@ public Boolean getBit(byte[] key, long offset) {`
`573`	`573`	`}`
`574`	`574`	`}`
`575`	`575`
`576`		`- public void setBit(byte[] key, long offset, boolean value) {`
	`576`	`+ public Boolean setBit(byte[] key, long offset, boolean value) {`
`577`	`577`	`try {`
`578`		`- jredis.setbit(key, (int) offset, value);`
	`578`	`+ return jredis.setbit(key, (int) offset, value);`
`579`	`579`	`} catch (Exception ex) {`
`580`	`580`	`throw convertJredisAccessException(ex);`
`581`	`581`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1402,17 +1402,20 @@ public Boolean getBit(byte[] key, long offset) {`
`1402`	`1402`	`}`
`1403`	`1403`	`}`
`1404`	`1404`
`1405`		`- public void setBit(byte[] key, long offset, boolean value) {`
	`1405`	`+ public Boolean setBit(byte[] key, long offset, boolean value) {`
`1406`	`1406`	`try {`
`1407`	`1407`	`if (isPipelined()) {`
`1408`		`- pipeline(new LettuceStatusResult(getAsyncConnection().setbit(key, offset, LettuceConverters.toInt(value))));`
`1409`		`- return;`
	`1408`	`+ pipeline(new LettuceResult(getAsyncConnection().setbit(key, offset, LettuceConverters.toInt(value)),`
	`1409`	`+ LettuceConverters.longToBooleanConverter()));`
	`1410`	`+ return null;`
`1410`	`1411`	`}`
`1411`	`1412`	`if (isQueueing()) {`
`1412`		`- transaction(new LettuceTxStatusResult(getConnection().setbit(key, offset, LettuceConverters.toInt(value))));`
`1413`		`- return;`
	`1413`	`+ transaction(new LettuceTxResult(getConnection().setbit(key, offset, LettuceConverters.toInt(value)),`
	`1414`	`+ LettuceConverters.longToBooleanConverter()));`
	`1415`	`+ return null;`
`1414`	`1416`	`}`
`1415`		`- getConnection().setbit(key, offset, LettuceConverters.toInt(value));`
	`1417`	`+ return LettuceConverters.longToBooleanConverter().convert(`
	`1418`	`+ getConnection().setbit(key, offset, LettuceConverters.toInt(value)));`
`1416`	`1419`	`} catch (Exception ex) {`
`1417`	`1420`	`throw convertLettuceAccessException(ex);`
`1418`	`1421`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1047,13 +1047,14 @@ public Boolean getBit(byte[] key, long offset) {`
`1047`	`1047`	`}`
`1048`	`1048`	`}`
`1049`	`1049`
`1050`		`- public void setBit(byte[] key, long offset, boolean value) {`
	`1050`	`+ public Boolean setBit(byte[] key, long offset, boolean value) {`
`1051`	`1051`	`try {`
`1052`	`1052`	`if (isPipelined()) {`
`1053`		`- pipeline(new SrpStatusResult(pipeline.setbit(key, offset, SrpConverters.toBit(value))));`
`1054`		`- return;`
	`1053`	`+ pipeline(new SrpGenericResult(pipeline.setbit(key, offset, SrpConverters.toBit(value)),`
	`1054`	`+ SrpConverters.longToBooleanConverter()));`
	`1055`	`+ return null;`
`1055`	`1056`	`}`
`1056`		`- client.setbit(key, offset, SrpConverters.toBit(value));`
	`1057`	`+ return SrpConverters.toBoolean(client.setbit(key, offset, SrpConverters.toBit(value)));`
`1057`	`1058`	`} catch (Exception ex) {`
`1058`	`1059`	`throw convertSrpAccessException(ex);`
`1059`	`1060`	`}`