Feature - Atomic class add greaterThanSet and lessThanSet method

modify method name

Signed-off-by: seakider <seakider@gmail.com>

redisson/src/main/java/org/redisson/RedissonAtomicDouble.java

@@ -172,12 +172,12 @@ public class RedissonAtomicDouble extends RedissonExpirable implements RAtomicDo
     }
     
     @Override
-    public boolean lessThanSet(double less, double value) {
-        return get(lessThanSetAsync(less, value));
+    public boolean setIfLessThan(double less, double value) {
+        return get(setIfLessThanAsync(less, value));
     }
     
     @Override
-    public RFuture<Boolean> lessThanSetAsync(double less, double value) {
+    public RFuture<Boolean> setIfLessThanAsync(double less, double value) {
         return commandExecutor.evalWriteAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                 "local currValue = redis.call('get', KEYS[1]); "
                         + "currValue = currValue == false and 0 or tonumber(currValue);"
@@ -190,12 +190,12 @@ public class RedissonAtomicDouble extends RedissonExpirable implements RAtomicDo
     }
     
     @Override
-    public boolean greaterThanSet(double greater, double value) {
-        return get(greaterThanSetAsync(greater, value));
+    public boolean setIfGreaterThan(double greater, double value) {
+        return get(setIfGreaterThanAsync(greater, value));
     }
     
     @Override
-    public RFuture<Boolean> greaterThanSetAsync(double greater, double value) {
+    public RFuture<Boolean> setIfGreaterThanAsync(double greater, double value) {
         return commandExecutor.evalWriteAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                 "local currValue = redis.call('get', KEYS[1]); "
                         + "currValue = currValue == false and 0 or tonumber(currValue);"

redisson/src/main/java/org/redisson/RedissonAtomicLong.java

@@ -170,12 +170,12 @@ public class RedissonAtomicLong extends RedissonExpirable implements RAtomicLong
     }
     
     @Override
-    public boolean lessThanSet(long less, long value) {
-        return get(lessThanSetAsync(less, value));
+    public boolean setIfLessThan(long less, long value) {
+        return get(setIfLessThanAsync(less, value));
     }
     
     @Override
-    public RFuture<Boolean> lessThanSetAsync(long less, long value) {
+    public RFuture<Boolean> setIfLessThanAsync(long less, long value) {
         return commandExecutor.evalWriteAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
         "local currValue = redis.call('get', KEYS[1]); "
                 + "currValue = currValue == false and 0 or tonumber(currValue);"
@@ -188,12 +188,12 @@ public class RedissonAtomicLong extends RedissonExpirable implements RAtomicLong
     }
     
     @Override
-    public boolean greaterThanSet(long greater, long value) {
-        return get(greaterThanSetAsync(greater, value));
+    public boolean setIfGreaterThan(long greater, long value) {
+        return get(setIfGreaterThanAsync(greater, value));
     }
     
     @Override
-    public RFuture<Boolean> greaterThanSetAsync(long greater, long value) {
+    public RFuture<Boolean> setIfGreaterThanAsync(long greater, long value) {
         return commandExecutor.evalWriteAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                 "local currValue = redis.call('get', KEYS[1]); "
                         + "currValue = currValue == false and 0 or tonumber(currValue);"

redisson/src/main/java/org/redisson/api/RAtomicDouble.java

@@ -115,7 +115,7 @@ public interface RAtomicDouble extends RExpirable, RAtomicDoubleAsync {
      * @param value newValue
      * @return true when the value update is successful
      */
-    boolean lessThanSet(double less, double value);
+    boolean setIfLessThan(double less, double value);
     
     /**
      * Atomically sets the given value if current value is greater than
@@ -125,7 +125,7 @@ public interface RAtomicDouble extends RExpirable, RAtomicDoubleAsync {
      * @param value newValue
      * @return true when the value update is successful
      */
-    boolean greaterThanSet(double greater, double value);
+    boolean setIfGreaterThan(double greater, double value);
 
     /**
      * Adds object event listener

redisson/src/main/java/org/redisson/api/RAtomicDoubleAsync.java

@@ -116,7 +116,7 @@ public interface RAtomicDoubleAsync extends RExpirableAsync {
      * @param value newValue
      * @return true when the value update is successful
      */
-    RFuture<Boolean> lessThanSetAsync(double less, double value);
+    RFuture<Boolean> setIfLessThanAsync(double less, double value);
     
     /**
      * Atomically sets the given value if current value is greater than
@@ -126,7 +126,7 @@ public interface RAtomicDoubleAsync extends RExpirableAsync {
      * @param value newValue
      * @return true when the value update is successful
      */
-    RFuture<Boolean> greaterThanSetAsync(double greater, double value);
+    RFuture<Boolean> setIfGreaterThanAsync(double greater, double value);
 
     /**
      * Adds object event listener

redisson/src/main/java/org/redisson/api/RAtomicDoubleReactive.java

@@ -118,7 +118,7 @@ public interface RAtomicDoubleReactive extends RExpirableReactive {
      * @param value newValue
      * @return true when the value update is successful
      */
-    Mono<Boolean> lessThanSet(double less, double value);
+    Mono<Boolean> setIfLessThan(double less, double value);
     
     /**
      * Atomically sets the given value if current value is greater than
@@ -128,6 +128,6 @@ public interface RAtomicDoubleReactive extends RExpirableReactive {
      * @param value newValue
      * @return true when the value update is successful
      */
-    Mono<Boolean> greaterThanSet(double greater, double value);
+    Mono<Boolean> setIfGreaterThan(double greater, double value);
 
 }

redisson/src/main/java/org/redisson/api/RAtomicDoubleRx.java

@@ -119,7 +119,7 @@ public interface RAtomicDoubleRx extends RExpirableRx {
      * @param value newValue
      * @return true when the value update is successful
      */
-    Single<Boolean> lessThanSet(double less, double value);
+    Single<Boolean> setIfLessThan(double less, double value);
     
     /**
      * Atomically sets the given value if current value is greater than
@@ -129,6 +129,6 @@ public interface RAtomicDoubleRx extends RExpirableRx {
      * @param value newValue
      * @return true when the value update is successful
      */
-    Single<Boolean> greaterThanSet(double greater, double value);
+    Single<Boolean> setIfGreaterThan(double greater, double value);
 
 }

redisson/src/main/java/org/redisson/api/RAtomicLong.java

@@ -115,7 +115,7 @@ public interface RAtomicLong extends RExpirable, RAtomicLongAsync {
      * @param value newValue
      * @return true when the value update is successful
      */
-    boolean lessThanSet(long less, long value);
+    boolean setIfLessThan(long less, long value);
     
     /**
      * Atomically sets the given value if current value is greater than
@@ -125,7 +125,7 @@ public interface RAtomicLong extends RExpirable, RAtomicLongAsync {
      * @param value newValue
      * @return true when the value update is successful
      */
-    boolean greaterThanSet(long greater, long value);
+    boolean setIfGreaterThan(long greater, long value);
 
     /**
      * Adds object event listener

redisson/src/main/java/org/redisson/api/RAtomicLongAsync.java

@@ -116,7 +116,7 @@ public interface RAtomicLongAsync extends RExpirableAsync {
      * @param value newValue
      * @return true when the value update is successful
      */
-    RFuture<Boolean> lessThanSetAsync(long less, long value);
+    RFuture<Boolean> setIfLessThanAsync(long less, long value);
     
     /**
      * Atomically sets the given value if current value is greater than
@@ -126,7 +126,7 @@ public interface RAtomicLongAsync extends RExpirableAsync {
      * @param value newValue
      * @return true when the value update is successful
      */
-    RFuture<Boolean> greaterThanSetAsync(long greater, long value);
+    RFuture<Boolean> setIfGreaterThanAsync(long greater, long value);
 
     /**
      * Adds object event listener

redisson/src/main/java/org/redisson/api/RAtomicLongReactive.java

@@ -118,7 +118,7 @@ public interface RAtomicLongReactive extends RExpirableReactive {
      * @param value newValue
      * @return true when the value update is successful
      */
-    Mono<Boolean> lessThanSet(long less, long value);
+    Mono<Boolean> setIfLessThan(long less, long value);
     
     /**
      * Atomically sets the given value if current value is greater than
@@ -128,6 +128,6 @@ public interface RAtomicLongReactive extends RExpirableReactive {
      * @param value newValue
      * @return true when the value update is successful
      */
-    Mono<Boolean> greaterThanSet(long greater, long value);
+    Mono<Boolean> setIfGreaterThan(long greater, long value);
 
 }

redisson/src/main/java/org/redisson/api/RAtomicLongRx.java

@@ -119,7 +119,7 @@ public interface RAtomicLongRx extends RExpirableRx {
      * @param value newValue
      * @return true when the value update is successful
      */
-    Single<Boolean> lessThanSet(long less, long value);
+    Single<Boolean> setIfLessThan(long less, long value);
     
     /**
      * Atomically sets the given value if current value is greater than
@@ -129,6 +129,6 @@ public interface RAtomicLongRx extends RExpirableRx {
      * @param value newValue
      * @return true when the value update is successful
      */
-    Single<Boolean> greaterThanSet(long greater, long value);
+    Single<Boolean> setIfGreaterThan(long greater, long value);
 
 }

redisson/src/test/java/org/redisson/RedissonAtomicDoubleTest.java

@@ -2,7 +2,6 @@ package org.redisson;
 
 import org.junit.jupiter.api.Test;
 import org.redisson.api.RAtomicDouble;
-import org.redisson.api.RAtomicLong;
 
 import java.math.BigDecimal;
 
@@ -11,24 +10,24 @@ import static org.assertj.core.api.Assertions.assertThat;
 public class RedissonAtomicDoubleTest extends RedisDockerTest {
     
     @Test
-    public void testLessThanSet() {
+    public void testSetIfLessThan() {
         RAtomicDouble al = redisson.getAtomicDouble("test");
-        assertThat(al.lessThanSet(0, 1)).isFalse();
+        assertThat(al.setIfLessThan(0, 1)).isFalse();
         assertThat(al.get()).isEqualTo(0);
         
         al.set(12);
-        assertThat(al.lessThanSet(13, 1)).isTrue();
+        assertThat(al.setIfLessThan(13, 1)).isTrue();
         assertThat(al.get()).isEqualTo(1);
     }
     
     @Test
-    public void testGreaterThanSet() {
+    public void testSetIfGreaterThan() {
         RAtomicDouble al = redisson.getAtomicDouble("test");
-        assertThat(al.lessThanSet(0, 1)).isFalse();
+        assertThat(al.setIfLessThan(0, 1)).isFalse();
         assertThat(al.get()).isEqualTo(0);
         
         al.set(12);
-        assertThat(al.greaterThanSet(11, 1)).isTrue();
+        assertThat(al.setIfGreaterThan(11, 1)).isTrue();
         assertThat(al.get()).isEqualTo(1);
     }
     

redisson/src/test/java/org/redisson/RedissonAtomicLongReactiveTest.java

@@ -7,24 +7,24 @@ import org.redisson.api.RAtomicLongReactive;
 public class RedissonAtomicLongReactiveTest extends BaseReactiveTest {
     
     @Test
-    public void testLessThanSet() {
+    public void testSetIfLessThan() {
         RAtomicLongReactive al = redisson.getAtomicLong("test");
-        Assertions.assertFalse(sync(al.lessThanSet(0, 1)));
+        Assertions.assertFalse(sync(al.setIfLessThan(0, 1)));
         Assertions.assertEquals(sync(al.get()).longValue(), 0L);
         
         sync(al.set(12));
-        Assertions.assertTrue(sync(al.lessThanSet(13, 1)));
+        Assertions.assertTrue(sync(al.setIfLessThan(13, 1)));
         Assertions.assertEquals(sync(al.get()).longValue(), 1L);
     }
     
     @Test
-    public void testGreaterThanSet() {
+    public void testSetIfGreaterThan() {
         RAtomicLongReactive al = redisson.getAtomicLong("test");
-        Assertions.assertFalse(sync(al.greaterThanSet(0, 1)));
+        Assertions.assertFalse(sync(al.setIfGreaterThan(0, 1)));
         Assertions.assertEquals(sync(al.get()).longValue(), 0L);
         
         sync(al.set(12));
-        Assertions.assertTrue(sync(al.greaterThanSet(11, 1)));
+        Assertions.assertTrue(sync(al.setIfGreaterThan(11, 1)));
         Assertions.assertEquals(sync(al.get()).longValue(), 1L);
     }
     

redisson/src/test/java/org/redisson/RedissonAtomicLongTest.java

@@ -9,24 +9,24 @@ import static org.assertj.core.api.Assertions.assertThat;
 public class RedissonAtomicLongTest extends RedisDockerTest {
     
     @Test
-    public void testLessThanSet() {
+    public void testSetIfLessThan() {
         RAtomicLong al = redisson.getAtomicLong("test");
-        assertThat(al.lessThanSet(0, 1)).isFalse();
+        assertThat(al.setIfLessThan(0, 1)).isFalse();
         assertThat(al.get()).isEqualTo(0);
         
         al.set(12);
-        assertThat(al.lessThanSet(13, 1)).isTrue();
+        assertThat(al.setIfLessThan(13, 1)).isTrue();
         assertThat(al.get()).isEqualTo(1);
     }
     
     @Test
-    public void testGreaterThanSet() {
+    public void testSetIfGreaterThan() {
         RAtomicLong al = redisson.getAtomicLong("test");
-        assertThat(al.lessThanSet(0, 1)).isFalse();
+        assertThat(al.setIfLessThan(0, 1)).isFalse();
         assertThat(al.get()).isEqualTo(0);
         
         al.set(12);
-        assertThat(al.greaterThanSet(11, 1)).isTrue();
+        assertThat(al.setIfGreaterThan(11, 1)).isTrue();
         assertThat(al.get()).isEqualTo(1);
     }