github-forks
/
redisson
mirror of https://github.com/redisson/redisson.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

BitSet index range extended to Integer.MAX_VALUE*2

Browse Source
pull/365/head
Nikita 9 years ago
parent 36142c08e5
commit 32ca15c590
5 changed files with 95 additions and 66 deletions
Show Stats Download Patch File Download Diff File

59
src/main/java/org/redisson/RedissonBitSet.java
Unescape Escape View File

@ -35,82 +35,102 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
super(connectionManager, name);
}
@Override
public int length() {
return get(lengthAsync());
}
@Override
public void set(BitSet bs) {
get(setAsync(bs));
}
public boolean get(int bitIndex) {
@Override
public boolean get(long bitIndex) {
return get(getAsync(bitIndex));
}
public Future<Boolean> getAsync(int bitIndex) {
@Override
public Future<Boolean> getAsync(long bitIndex) {
return commandExecutor.readAsync(getName(), codec, RedisCommands.GETBIT, getName(), bitIndex);
}
public void set(int bitIndex) {
@Override
public void set(long bitIndex) {
get(setAsync(bitIndex, true));
}
public void set(int fromIndex, int toIndex, boolean value) {
@Override
public void set(long fromIndex, long toIndex, boolean value) {
get(setAsync(fromIndex, toIndex, value));
}
public void set(int fromIndex, int toIndex) {
@Override
public void set(long fromIndex, long toIndex) {
get(setAsync(fromIndex, toIndex));
}
public void set(int bitIndex, boolean value) {
@Override
public void set(long bitIndex, boolean value) {
get(setAsync(bitIndex, value));
}
public Future<Void> setAsync(int bitIndex, boolean value) {
return commandExecutor.writeAsync(getName(), codec, RedisCommands.SETBIT, getName(), bitIndex, value ? 1 : 0);
@Override
public Future<Void> setAsync(long bitIndex, boolean value) {
return commandExecutor.writeAsync(getName(), codec, RedisCommands.SETBIT_VOID, getName(), bitIndex, value ? 1 : 0);
}
@Override
public byte[] toByteArray() {
return get(toByteArrayAsync());
}
@Override
public Future<byte[]> toByteArrayAsync() {
return commandExecutor.readAsync(getName(), ByteArrayCodec.INSTANCE, RedisCommands.GET, getName());
}
@Override
public int cardinality() {
return get(cardinalityAsync());
}
@Override
public int size() {
return get(sizeAsync());
}
public void clear(int fromIndex, int toIndex) {
@Override
public void clear(long fromIndex, long toIndex) {
get(clearAsync(fromIndex, toIndex));
}
public void clear(int bitIndex) {
@Override
public void clear(long bitIndex) {
get(clearAsync(bitIndex));
}
@Override
public void clear() {
get(clearAsync());
}
@Override
public void or(String... bitSetNames) {
get(orAsync(bitSetNames));
}
@Override
public void and(String... bitSetNames) {
get(andAsync(bitSetNames));
}
@Override
public void xor(String... bitSetNames) {
get(xorAsync(bitSetNames));
}
@Override
public void not() {
get(notAsync());
}
@ -124,6 +144,7 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
return commandExecutor.writeAsync(getName(), codec, RedisCommands.BITOP, params.toArray());
}
@Override
public BitSet asBitSet() {
return fromByteArrayReverse(toByteArray());
}
@ -171,7 +192,7 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
}
@Override
public Future<Void> setAsync(int fromIndex, int toIndex, boolean value) {
public Future<Void> setAsync(long fromIndex, long toIndex, boolean value) {
if (value) {
return setAsync(fromIndex, toIndex);
}
@ -179,10 +200,10 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
}
@Override
public Future<Void> clearAsync(int fromIndex, int toIndex) {
public Future<Void> clearAsync(long fromIndex, long toIndex) {
CommandBatchService executorService = new CommandBatchService(commandExecutor.getConnectionManager());
for (int i = fromIndex; i < toIndex; i++) {
executorService.writeAsync(getName(), codec, RedisCommands.SETBIT, getName(), i, 0);
for (long i = fromIndex; i < toIndex; i++) {
executorService.writeAsync(getName(), codec, RedisCommands.SETBIT_VOID, getName(), i, 0);
}
return executorService.executeAsyncVoid();
}
@ -198,10 +219,10 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
}
@Override
public Future<Void> setAsync(int fromIndex, int toIndex) {
public Future<Void> setAsync(long fromIndex, long toIndex) {
CommandBatchService executorService = new CommandBatchService(commandExecutor.getConnectionManager());
for (int i = fromIndex; i < toIndex; i++) {
executorService.writeAsync(getName(), codec, RedisCommands.SETBIT, getName(), i, 1);
for (long i = fromIndex; i < toIndex; i++) {
executorService.writeAsync(getName(), codec, RedisCommands.SETBIT_VOID, getName(), i, 1);
}
return executorService.executeAsyncVoid();
}
@ -212,7 +233,7 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
}
@Override
public Future<Void> setAsync(int bitIndex) {
public Future<Void> setAsync(long bitIndex) {
return setAsync(bitIndex, true);
}
@ -222,7 +243,7 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
}
@Override
public Future<Void> clearAsync(int bitIndex) {
public Future<Void> clearAsync(long bitIndex) {
return setAsync(bitIndex, false);
}

2
src/main/java/org/redisson/RedissonObject.java
Unescape Escape View File

@ -54,7 +54,7 @@ abstract class RedissonObject implements RObject {
}
protected <V> Future<V> newSucceededFuture(V result) {
return commandExecutor.getConnectionManager().getGroup().next().<V>newSucceededFuture(result);
return commandExecutor.getConnectionManager().<V>newSucceededFuture(result);
}
@Override

14
src/main/java/org/redisson/core/RBitSet.java
Unescape Escape View File

@ -26,29 +26,29 @@ public interface RBitSet extends RExpirable, RBitSetAsync {
int length();
void set(int fromIndex, int toIndex, boolean value);
void set(long fromIndex, long toIndex, boolean value);
void clear(int fromIndex, int toIndex);
void clear(long fromIndex, long toIndex);
void set(BitSet bs);
void not();
void set(int fromIndex, int toIndex);
void set(long fromIndex, long toIndex);
int size();
boolean get(int bitIndex);
boolean get(long bitIndex);
void set(int bitIndex);
void set(long bitIndex);
void set(int bitIndex, boolean value);
void set(long bitIndex, boolean value);
byte[] toByteArray();
int cardinality();
void clear(int bitIndex);
void clear(long bitIndex);
void clear();

14
src/main/java/org/redisson/core/RBitSetAsync.java
Unescape Escape View File

@ -30,27 +30,27 @@ public interface RBitSetAsync extends RExpirableAsync {
Future<Integer> lengthAsync();
Future<Void> setAsync(int fromIndex, int toIndex, boolean value);
Future<Void> setAsync(long fromIndex, long toIndex, boolean value);
Future<Void> clearAsync(int fromIndex, int toIndex);
Future<Void> clearAsync(long fromIndex, long toIndex);
Future<Void> setAsync(BitSet bs);
Future<Void> notAsync();
Future<Void> setAsync(int fromIndex, int toIndex);
Future<Void> setAsync(long fromIndex, long toIndex);
Future<Integer> sizeAsync();
Future<Boolean> getAsync(int bitIndex);
Future<Boolean> getAsync(long bitIndex);
Future<Void> setAsync(int bitIndex);
Future<Void> setAsync(long bitIndex);
Future<Void> setAsync(int bitIndex, boolean value);
Future<Void> setAsync(long bitIndex, boolean value);
Future<Integer> cardinalityAsync();
Future<Void> clearAsync(int bitIndex);
Future<Void> clearAsync(long bitIndex);
Future<Void> clearAsync();

72
src/test/java/org/redisson/RedissonBitSetTest.java
Unescape Escape View File

@ -2,38 +2,47 @@ package org.redisson;
import java.util.BitSet;
import org.junit.Assert;
import static org.assertj.core.api.Assertions.*;
import org.junit.Test;
import org.redisson.core.RBitSet;
public class RedissonBitSetTest extends BaseTest {
@Test
public void testIndexRange() {
RBitSet bs = redisson.getBitSet("testbitset");
long topIndex = Integer.MAX_VALUE*2L;
assertThat(bs.get(topIndex)).isFalse();
bs.set(topIndex);
assertThat(bs.get(topIndex)).isTrue();
}
@Test
public void testLength() {
RBitSet bs = redisson.getBitSet("testbitset");
bs.set(0, 5);
bs.clear(0, 1);
Assert.assertEquals(5, bs.length());
assertThat(bs.length()).isEqualTo(5);
bs.clear();
bs.set(28);
bs.set(31);
Assert.assertEquals(32, bs.length());
assertThat(bs.length()).isEqualTo(32);
bs.clear();
bs.set(3);
bs.set(7);
Assert.assertEquals(8, bs.length());
assertThat(bs.length()).isEqualTo(8);
bs.clear();
bs.set(3);
bs.set(120);
bs.set(121);
Assert.assertEquals(122, bs.length());
assertThat(bs.length()).isEqualTo(122);
bs.clear();
bs.set(0);
Assert.assertEquals(1, bs.length());
assertThat(bs.length()).isEqualTo(1);
}
@Test
@ -41,7 +50,7 @@ public class RedissonBitSetTest extends BaseTest {
RBitSet bs = redisson.getBitSet("testbitset");
bs.set(0, 8);
bs.clear(0, 3);
Assert.assertEquals("{3, 4, 5, 6, 7}", bs.toString());
assertThat(bs.toString()).isEqualTo("{3, 4, 5, 6, 7}");
}
@Test
@ -50,7 +59,7 @@ public class RedissonBitSetTest extends BaseTest {
bs.set(3);
bs.set(5);
bs.not();
Assert.assertEquals("{0, 1, 2, 4, 6, 7}", bs.toString());
assertThat(bs.toString()).isEqualTo("{0, 1, 2, 4, 6, 7}");
}
@Test
@ -58,7 +67,7 @@ public class RedissonBitSetTest extends BaseTest {
RBitSet bs = redisson.getBitSet("testbitset");
bs.set(3);
bs.set(5);
Assert.assertEquals("{3, 5}", bs.toString());
assertThat(bs.toString()).isEqualTo("{3, 5}");
BitSet bs1 = new BitSet();
bs1.set(1);
@ -66,31 +75,30 @@ public class RedissonBitSetTest extends BaseTest {
bs.set(bs1);
bs = redisson.getBitSet("testbitset");
Assert.assertEquals("{1, 10}", bs.toString());
assertThat(bs.toString()).isEqualTo("{1, 10}");
}
@Test
public void testSetGet() {
RBitSet bitset = redisson.getBitSet("testbitset");
Assert.assertEquals(0, bitset.cardinality());
Assert.assertEquals(0, bitset.size());
assertThat(bitset.cardinality()).isZero();
assertThat(bitset.size()).isZero();
bitset.set(10, true);
bitset.set(31, true);
Assert.assertFalse(bitset.get(0));
Assert.assertTrue(bitset.get(31));
Assert.assertTrue(bitset.get(10));
Assert.assertEquals(2, bitset.cardinality());
Assert.assertEquals(32, bitset.size());
assertThat(bitset.get(0)).isFalse();
assertThat(bitset.get(31)).isTrue();
assertThat(bitset.get(10)).isTrue();
assertThat(bitset.cardinality()).isEqualTo(2);
assertThat(bitset.size()).isEqualTo(32);
}
@Test
public void testSetRange() {
RBitSet bs = redisson.getBitSet("testbitset");
bs.set(3, 10);
Assert.assertEquals(7, bs.cardinality());
Assert.assertEquals(16, bs.size());
assertThat(bs.cardinality()).isEqualTo(7);
assertThat(bs.size()).isEqualTo(16);
}
@Test
@ -98,32 +106,32 @@ public class RedissonBitSetTest extends BaseTest {
RBitSet bs = redisson.getBitSet("testbitset");
bs.set(3, true);
bs.set(41, true);
Assert.assertEquals(48, bs.size());
assertThat(bs.size()).isEqualTo(48);
BitSet bitset = bs.asBitSet();
Assert.assertTrue(bitset.get(3));
Assert.assertTrue(bitset.get(41));
Assert.assertEquals(2, bitset.cardinality());
assertThat(bitset.get(3)).isTrue();
assertThat(bitset.get(41)).isTrue();
assertThat(bs.cardinality()).isEqualTo(2);
}
@Test
public void testAnd() {
RBitSet bs1 = redisson.getBitSet("testbitset1");
bs1.set(3, 5);
Assert.assertEquals(2, bs1.cardinality());
Assert.assertEquals(8, bs1.size());
assertThat(bs1.cardinality()).isEqualTo(2);
assertThat(bs1.size()).isEqualTo(8);
RBitSet bs2 = redisson.getBitSet("testbitset2");
bs2.set(4);
bs2.set(10);
bs1.and(bs2.getName());
Assert.assertFalse(bs1.get(3));
Assert.assertTrue(bs1.get(4));
Assert.assertFalse(bs1.get(5));
Assert.assertTrue(bs2.get(10));
assertThat(bs1.get(3)).isFalse();
assertThat(bs1.get(4)).isTrue();
assertThat(bs1.get(5)).isFalse();
assertThat(bs2.get(10)).isTrue();
Assert.assertEquals(1, bs1.cardinality());
Assert.assertEquals(16, bs1.size());
assertThat(bs1.cardinality()).isEqualTo(1);
assertThat(bs1.size()).isEqualTo(16);
}

Write Preview
Loading…
Cancel
Save