first and last methods added. #143

src/main/java/org/redisson/RedissonScoredSortedSet.java

@@ -49,6 +49,22 @@ public class RedissonScoredSortedSet<V> extends RedissonExpirable implements RSc
         return get(addAsync(score, object));
     }
 
+    public V first() {
+        return get(firstAsync());
+    }
+
+    public Future<V> firstAsync() {
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.ZRANGE_SINGLE, getName(), 0, 0);
+    }
+
+    public V last() {
+        return get(lastAsync());
+    }
+
+    public Future<V> lastAsync() {
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.ZRANGE_SINGLE, getName(), -1, -1);
+    }
+
     @Override
     public Future<Boolean> addAsync(double score, V object) {
         return commandExecutor.writeAsync(getName(), codec, RedisCommands.ZADD, getName(), BigDecimal.valueOf(score).toPlainString(), object);

src/main/java/org/redisson/client/protocol/RedisCommands.java

@@ -34,6 +34,7 @@ import org.redisson.client.protocol.decoder.ListScanResultReplayDecoder;
 import org.redisson.client.protocol.decoder.MapScanResult;
 import org.redisson.client.protocol.decoder.MapScanResultReplayDecoder;
 import org.redisson.client.protocol.decoder.NestedMultiDecoder;
+import org.redisson.client.protocol.decoder.ObjectFirstResultReplayDecoder;
 import org.redisson.client.protocol.decoder.ObjectListReplayDecoder;
 import org.redisson.client.protocol.decoder.ObjectMapReplayDecoder;
 import org.redisson.client.protocol.decoder.ObjectSetReplayDecoder;
@@ -55,6 +56,7 @@ public interface RedisCommands {
     RedisCommand<Boolean> ZSCORE_CONTAINS = new RedisCommand<Boolean>("ZSCORE", new BooleanNotNullReplayConvertor(), 2);
     RedisStrictCommand<Double> ZSCORE = new RedisStrictCommand<Double>("ZSCORE", new DoubleReplayConvertor());
     RedisCommand<Integer> ZRANK = new RedisCommand<Integer>("ZRANK", new IntegerReplayConvertor(), 2);
+    RedisCommand<Object> ZRANGE_SINGLE = new RedisCommand<Object>("ZRANGE", new ObjectFirstResultReplayDecoder<Object>());
     RedisCommand<List<Object>> ZRANGE = new RedisCommand<List<Object>>("ZRANGE", new ObjectListReplayDecoder<Object>());
     RedisStrictCommand<Integer> ZREMRANGEBYRANK = new RedisStrictCommand<Integer>("ZREMRANGEBYRANK", new IntegerReplayConvertor());
     RedisStrictCommand<Integer> ZREMRANGEBYSCORE = new RedisStrictCommand<Integer>("ZREMRANGEBYSCORE", new IntegerReplayConvertor());

src/main/java/org/redisson/client/protocol/decoder/ObjectFirstResultReplayDecoder.java

@@ -0,0 +1,41 @@
+/**
+ * Copyright 2014 Nikita Koksharov, Nickolay Borbit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.redisson.client.protocol.decoder;
+
+import java.util.List;
+
+import org.redisson.client.handler.State;
+
+import io.netty.buffer.ByteBuf;
+
+public class ObjectFirstResultReplayDecoder<T> implements MultiDecoder<T> {
+
+    @Override
+    public Object decode(ByteBuf buf, State state) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public T decode(List<Object> parts, State state) {
+        return (T) parts.get(0);
+    }
+
+    @Override
+    public boolean isApplicable(int paramNum, State state) {
+        return false;
+    }
+
+}

src/main/java/org/redisson/core/RScoredSortedSet.java

@@ -21,6 +21,10 @@ import org.redisson.client.protocol.ScoredEntry;
 
 public interface RScoredSortedSet<V> extends RScoredSortedSetAsync<V>, Iterable<V>, RExpirable {
 
+    V first();
+
+    V last();
+
     int removeRangeByScore(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive);
 
     int removeRangeByRank(int startIndex, int endIndex);

src/main/java/org/redisson/core/RScoredSortedSetAsync.java

@@ -23,6 +23,10 @@ import io.netty.util.concurrent.Future;
 
 public interface RScoredSortedSetAsync<V> extends RExpirableAsync {
 
+    Future<V> firstAsync();
+
+    Future<V> lastAsync();
+
     Future<Integer> removeRangeByRankAsync(int startIndex, int endIndex);
 
     Future<Integer> rankAsync(V o);

src/test/java/org/redisson/RedissonScoredSortedSetTest.java

@@ -21,6 +21,19 @@ import io.netty.util.concurrent.Future;
 
 public class RedissonScoredSortedSetTest extends BaseTest {
 
+    @Test
+    public void testFirstLast() {
+        RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");
+        set.add(0.1, "a");
+        set.add(0.2, "b");
+        set.add(0.3, "c");
+        set.add(0.4, "d");
+
+        Assert.assertEquals("a", set.first());
+        Assert.assertEquals("d", set.last());
+    }
+
+
     @Test
     public void testRemoveRangeByScore() {
         RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");