RedissonBitSet (Redisson 2.2.1 API)

java.lang.Object
- org.redisson.RedissonBitSet

All Implemented Interfaces:

RBitSet, RBitSetAsync, RExpirable, RExpirableAsync, RObject, RObjectAsync
```
public class RedissonBitSet
extends Object
implements RBitSet
```

Constructor Summary

Constructors
Modifier Constructor and Description

protected RedissonBitSet(CommandAsyncExecutor connectionManager, String name)

Constructors
Modifier	Constructor and Description
`protected`	`RedissonBitSet(CommandAsyncExecutor connectionManager, String name)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`and(String... bitSetNames)`
`io.netty.util.concurrent.Future<Void>`	`andAsync(String... bitSetNames)`
`BitSet`	`asBitSet()`
`int`	`cardinality()`
`io.netty.util.concurrent.Future<Integer>`	`cardinalityAsync()`
`void`	`clear()`
`void`	`clear(int bitIndex)`
`void`	`clear(int fromIndex, int toIndex)`
`io.netty.util.concurrent.Future<Void>`	`clearAsync()`
`io.netty.util.concurrent.Future<Void>`	`clearAsync(int bitIndex)`
`io.netty.util.concurrent.Future<Void>`	`clearAsync(int fromIndex, int toIndex)`
`boolean`	`clearExpire()` Clear an expire timeout or expire date for object.
`io.netty.util.concurrent.Future<Boolean>`	`clearExpireAsync()` Clear an expire timeout or expire date for object in async mode.
`boolean`	`delete()` Deletes the object
`io.netty.util.concurrent.Future<Boolean>`	`deleteAsync()` Delete object in async mode
`boolean`	`expire(long timeToLive, TimeUnit timeUnit)` Set a timeout for object.
`io.netty.util.concurrent.Future<Boolean>`	`expireAsync(long timeToLive, TimeUnit timeUnit)` Set a timeout for object in async mode.
`boolean`	`expireAt(Date timestamp)` Set an expire date for object.
`boolean`	`expireAt(long timestamp)` Set an expire date for object.
`io.netty.util.concurrent.Future<Boolean>`	`expireAtAsync(Date timestamp)` Set an expire date for object in async mode.
`io.netty.util.concurrent.Future<Boolean>`	`expireAtAsync(long timestamp)` Set an expire date for object in async mode.
`protected <V> V`	`get(io.netty.util.concurrent.Future<V> future)`
`boolean`	`get(int bitIndex)`
`io.netty.util.concurrent.Future<Boolean>`	`getAsync(int bitIndex)`
`String`	`getName()` Returns name of object
`boolean`	`isExists()` Check object existence
`io.netty.util.concurrent.Future<Boolean>`	`isExistsAsync()` Check object existence in async mode.
`int`	`length()`
`io.netty.util.concurrent.Future<Integer>`	`lengthAsync()`
`void`	`migrate(String host, int port, int database)` Transfer a object from a source Redis instance to a destination Redis instance
`io.netty.util.concurrent.Future<Void>`	`migrateAsync(String host, int port, int database)` Transfer a object from a source Redis instance to a destination Redis instance in async mode
`boolean`	`move(int database)` Move object to another database
`io.netty.util.concurrent.Future<Boolean>`	`moveAsync(int database)` Move object to another database in async mode
`protected <V> io.netty.util.concurrent.Promise<V>`	`newPromise()`
`protected <V> io.netty.util.concurrent.Future<V>`	`newSucceededFuture(V result)`
`void`	`not()`
`io.netty.util.concurrent.Future<Void>`	`notAsync()`
`void`	`or(String... bitSetNames)`
`io.netty.util.concurrent.Future<Void>`	`orAsync(String... bitSetNames)`
`long`	`remainTimeToLive()` Remaining time to live of Redisson object that has a timeout
`io.netty.util.concurrent.Future<Long>`	`remainTimeToLiveAsync()` Get remaining time to live of object in seconds.
`void`	`rename(String newName)` Rename current object key to `newName`
`io.netty.util.concurrent.Future<Void>`	`renameAsync(String newName)` Rename current object key to `newName` in async mode
`boolean`	`renamenx(String newName)` Rename current object key to `newName` only if new key is not exists
`io.netty.util.concurrent.Future<Boolean>`	`renamenxAsync(String newName)` Rename current object key to `newName` in async mode only if new key is not exists
`void`	`set(BitSet bs)`
`void`	`set(int bitIndex)`
`void`	`set(int bitIndex, boolean value)`
`void`	`set(int fromIndex, int toIndex)`
`void`	`set(int fromIndex, int toIndex, boolean value)`
`io.netty.util.concurrent.Future<Void>`	`setAsync(BitSet bs)`
`io.netty.util.concurrent.Future<Void>`	`setAsync(int bitIndex)`
`io.netty.util.concurrent.Future<Void>`	`setAsync(int bitIndex, boolean value)`
`io.netty.util.concurrent.Future<Void>`	`setAsync(int fromIndex, int toIndex)`
`io.netty.util.concurrent.Future<Void>`	`setAsync(int fromIndex, int toIndex, boolean value)`
`int`	`size()`
`io.netty.util.concurrent.Future<Integer>`	`sizeAsync()`
`byte[]`	`toByteArray()`
`io.netty.util.concurrent.Future<byte[]>`	`toByteArrayAsync()`
`String`	`toString()`
`void`	`xor(String... bitSetNames)`
`io.netty.util.concurrent.Future<Void>`	`xorAsync(String... bitSetNames)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.redisson.core.RExpirable
clearExpire, expire, expireAt, expireAt, remainTimeToLive

Methods inherited from interface org.redisson.core.RObject
delete, getName, isExists, migrate, move, rename, renamenx

Methods inherited from interface org.redisson.core.RExpirableAsync
clearExpireAsync, expireAsync, expireAtAsync, expireAtAsync, remainTimeToLiveAsync

Methods inherited from interface org.redisson.core.RObjectAsync
deleteAsync, isExistsAsync, migrateAsync, moveAsync, renameAsync, renamenxAsync

- Constructor Detail
  - RedissonBitSet
```
protected RedissonBitSet(CommandAsyncExecutor connectionManager,
              String name)
```
- Method Detail
  - length
```
public int length()
```
    Specified by:
    
    length in interface RBitSet
  - set
```
public void set(BitSet bs)
```
    Specified by:
    
    set in interface RBitSet
  - get
```
public boolean get(int bitIndex)
```
    Specified by:
    
    get in interface RBitSet
  - getAsync
```
public io.netty.util.concurrent.Future<Boolean> getAsync(int bitIndex)
```
    Specified by:
    
    getAsync in interface RBitSetAsync
  - set
```
public void set(int bitIndex)
```
    Specified by:
    
    set in interface RBitSet
  - set
```
public void set(int fromIndex,
       int toIndex,
       boolean value)
```
    Specified by:
    
    set in interface RBitSet
  - set
```
public void set(int fromIndex,
       int toIndex)
```
    Specified by:
    
    set in interface RBitSet
  - set
```
public void set(int bitIndex,
       boolean value)
```
    Specified by:
    
    set in interface RBitSet
  - setAsync
```
public io.netty.util.concurrent.Future<Void> setAsync(int bitIndex,
                                             boolean value)
```
    Specified by:
    
    setAsync in interface RBitSetAsync
  - toByteArray
```
public byte[] toByteArray()
```
    Specified by:
    
    toByteArray in interface RBitSet
  - toByteArrayAsync
```
public io.netty.util.concurrent.Future<byte[]> toByteArrayAsync()
```
    Specified by:
    
    toByteArrayAsync in interface RBitSetAsync
  - cardinality
```
public int cardinality()
```
    Specified by:
    
    cardinality in interface RBitSet
  - size
```
public int size()
```
    Specified by:
    
    size in interface RBitSet
  - clear
```
public void clear(int fromIndex,
         int toIndex)
```
    Specified by:
    
    clear in interface RBitSet
  - clear
```
public void clear(int bitIndex)
```
    Specified by:
    
    clear in interface RBitSet
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface RBitSet
  - or
```
public void or(String... bitSetNames)
```
    Specified by:
    
    or in interface RBitSet
  - and
```
public void and(String... bitSetNames)
```
    Specified by:
    
    and in interface RBitSet
  - xor
```
public void xor(String... bitSetNames)
```
    Specified by:
    
    xor in interface RBitSet
  - not
```
public void not()
```
    Specified by:
    
    not in interface RBitSet
  - asBitSet
```
public BitSet asBitSet()
```
    Specified by:
    
    asBitSet in interface RBitSet
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - lengthAsync
```
public io.netty.util.concurrent.Future<Integer> lengthAsync()
```
    Specified by:
    
    lengthAsync in interface RBitSetAsync
  - setAsync
```
public io.netty.util.concurrent.Future<Void> setAsync(int fromIndex,
                                             int toIndex,
                                             boolean value)
```
    Specified by:
    
    setAsync in interface RBitSetAsync
  - clearAsync
```
public io.netty.util.concurrent.Future<Void> clearAsync(int fromIndex,
                                               int toIndex)
```
    Specified by:
    
    clearAsync in interface RBitSetAsync
  - setAsync
```
public io.netty.util.concurrent.Future<Void> setAsync(BitSet bs)
```
    Specified by:
    
    setAsync in interface RBitSetAsync
  - notAsync
```
public io.netty.util.concurrent.Future<Void> notAsync()
```
    Specified by:
    
    notAsync in interface RBitSetAsync
  - setAsync
```
public io.netty.util.concurrent.Future<Void> setAsync(int fromIndex,
                                             int toIndex)
```
    Specified by:
    
    setAsync in interface RBitSetAsync
  - sizeAsync
```
public io.netty.util.concurrent.Future<Integer> sizeAsync()
```
    Specified by:
    
    sizeAsync in interface RBitSetAsync
  - setAsync
```
public io.netty.util.concurrent.Future<Void> setAsync(int bitIndex)
```
    Specified by:
    
    setAsync in interface RBitSetAsync
  - cardinalityAsync
```
public io.netty.util.concurrent.Future<Integer> cardinalityAsync()
```
    Specified by:
    
    cardinalityAsync in interface RBitSetAsync
  - clearAsync
```
public io.netty.util.concurrent.Future<Void> clearAsync(int bitIndex)
```
    Specified by:
    
    clearAsync in interface RBitSetAsync
  - clearAsync
```
public io.netty.util.concurrent.Future<Void> clearAsync()
```
    Specified by:
    
    clearAsync in interface RBitSetAsync
  - orAsync
```
public io.netty.util.concurrent.Future<Void> orAsync(String... bitSetNames)
```
    Specified by:
    
    orAsync in interface RBitSetAsync
  - andAsync
```
public io.netty.util.concurrent.Future<Void> andAsync(String... bitSetNames)
```
    Specified by:
    
    andAsync in interface RBitSetAsync
  - xorAsync
```
public io.netty.util.concurrent.Future<Void> xorAsync(String... bitSetNames)
```
    Specified by:
    
    xorAsync in interface RBitSetAsync
  - expire
```
public boolean expire(long timeToLive,
             TimeUnit timeUnit)
```
    Description copied from interface: RExpirable
    
    Set a timeout for object. After the timeout has expired, the key will automatically be deleted.
    
    Specified by:
    
    expire in interface RExpirable
    
    Parameters:
    timeToLive - - timeout before object will be deleted
    timeUnit - - timeout time unit
    
    Returns:
    true if the timeout was set and false if not
  - expireAsync
```
public io.netty.util.concurrent.Future<Boolean> expireAsync(long timeToLive,
                                                   TimeUnit timeUnit)
```
    Description copied from interface: RExpirableAsync
    
    Set a timeout for object in async mode. After the timeout has expired, the key will automatically be deleted.
    
    Specified by:
    
    expireAsync in interface RExpirableAsync
    
    Parameters:
    timeToLive - - timeout before object will be deleted
    timeUnit - - timeout time unit
    
    Returns:
    true if the timeout was set and false if not
  - expireAt
```
public boolean expireAt(long timestamp)
```
    Description copied from interface: RExpirable
    
    Set an expire date for object. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expireAt in interface RExpirable
    
    Parameters:
    timestamp - - expire date in milliseconds (Unix timestamp)
    
    Returns:
    true if the timeout was set and false if not
  - expireAtAsync
```
public io.netty.util.concurrent.Future<Boolean> expireAtAsync(long timestamp)
```
    Description copied from interface: RExpirableAsync
    
    Set an expire date for object in async mode. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expireAtAsync in interface RExpirableAsync
    
    Parameters:
    timestamp - - expire date in seconds (Unix timestamp)
    
    Returns:
    true if the timeout was set and false if not
  - expireAt
```
public boolean expireAt(Date timestamp)
```
    Description copied from interface: RExpirable
    
    Set an expire date for object. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expireAt in interface RExpirable
    
    Parameters:
    timestamp - - expire date
    
    Returns:
    true if the timeout was set and false if not
  - expireAtAsync
```
public io.netty.util.concurrent.Future<Boolean> expireAtAsync(Date timestamp)
```
    Description copied from interface: RExpirableAsync
    
    Set an expire date for object in async mode. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expireAtAsync in interface RExpirableAsync
    
    Parameters:
    timestamp - - expire date
    
    Returns:
    true if the timeout was set and false if not
  - clearExpire
```
public boolean clearExpire()
```
    Description copied from interface: RExpirable
    
    Clear an expire timeout or expire date for object.
    
    Specified by:
    
    clearExpire in interface RExpirable
    
    Returns:
    true if timeout was removed false if object does not exist or does not have an associated timeout
  - clearExpireAsync
```
public io.netty.util.concurrent.Future<Boolean> clearExpireAsync()
```
    Description copied from interface: RExpirableAsync
    
    Clear an expire timeout or expire date for object in async mode. Object will not be deleted.
    
    Specified by:
    
    clearExpireAsync in interface RExpirableAsync
    
    Returns:
    true if the timeout was cleared and false if not
  - remainTimeToLive
```
public long remainTimeToLive()
```
    Description copied from interface: RExpirable
    
    Remaining time to live of Redisson object that has a timeout
    
    Specified by:
    
    remainTimeToLive in interface RExpirable
    
    Returns:
    time in milliseconds -2 if the key does not exist. -1 if the key exists but has no associated expire.
  - remainTimeToLiveAsync
```
public io.netty.util.concurrent.Future<Long> remainTimeToLiveAsync()
```
    Description copied from interface: RExpirableAsync
    
    Get remaining time to live of object in seconds.
    
    Specified by:
    
    remainTimeToLiveAsync in interface RExpirableAsync
    
    Returns:
    -1 if object does not exist or time in seconds
  - get
```
protected <V> V get(io.netty.util.concurrent.Future<V> future)
```
  - newPromise
```
protected <V> io.netty.util.concurrent.Promise<V> newPromise()
```
  - newSucceededFuture
```
protected <V> io.netty.util.concurrent.Future<V> newSucceededFuture(V result)
```
  - getName
```
public String getName()
```
    Description copied from interface: RObject
    
    Returns name of object
    
    Specified by:
    
    getName in interface RObject
    
    Returns:
    name
  - rename
```
public void rename(String newName)
```
    Description copied from interface: RObject
    
    Rename current object key to newName
    
    Specified by:
    
    rename in interface RObject
  - renameAsync
```
public io.netty.util.concurrent.Future<Void> renameAsync(String newName)
```
    Description copied from interface: RObjectAsync
    
    Rename current object key to newName in async mode
    
    Specified by:
    
    renameAsync in interface RObjectAsync
    
    Returns:
  - migrate
```
public void migrate(String host,
           int port,
           int database)
```
    Description copied from interface: RObject
    
    Transfer a object from a source Redis instance to a destination Redis instance
    
    Specified by:
    
    migrate in interface RObject
    
    Parameters:
    host - - destination host
    port - - destination port
    database - - destination database
  - migrateAsync
```
public io.netty.util.concurrent.Future<Void> migrateAsync(String host,
                                                 int port,
                                                 int database)
```
    Description copied from interface: RObjectAsync
    
    Transfer a object from a source Redis instance to a destination Redis instance in async mode
    
    Specified by:
    
    migrateAsync in interface RObjectAsync
    
    Parameters:
    host - - destination host
    port - - destination port
    database - - destination database
    
    Returns:
  - move
```
public boolean move(int database)
```
    Description copied from interface: RObject
    
    Move object to another database
    
    Specified by:
    
    move in interface RObject
    
    Returns:
    true if key was moved else false
  - moveAsync
```
public io.netty.util.concurrent.Future<Boolean> moveAsync(int database)
```
    Description copied from interface: RObjectAsync
    
    Move object to another database in async mode
    
    Specified by:
    
    moveAsync in interface RObjectAsync
    
    Returns:
    true if key was moved false if not
  - renamenx
```
public boolean renamenx(String newName)
```
    Description copied from interface: RObject
    
    Rename current object key to newName only if new key is not exists
    
    Specified by:
    
    renamenx in interface RObject
    
    Returns:
  - renamenxAsync
```
public io.netty.util.concurrent.Future<Boolean> renamenxAsync(String newName)
```
    Description copied from interface: RObjectAsync
    
    Rename current object key to newName in async mode only if new key is not exists
    
    Specified by:
    
    renamenxAsync in interface RObjectAsync
    
    Returns:
  - delete
```
public boolean delete()
```
    Description copied from interface: RObject
    
    Deletes the object
    
    Specified by:
    
    delete in interface RObject
  - deleteAsync
```
public io.netty.util.concurrent.Future<Boolean> deleteAsync()
```
    Description copied from interface: RObjectAsync
    
    Delete object in async mode
    
    Specified by:
    
    deleteAsync in interface RObjectAsync
    
    Returns:
    true if object was deleted false if not
  - isExists
```
public boolean isExists()
```
    Description copied from interface: RObject
    
    Check object existence
    
    Specified by:
    
    isExists in interface RObject
    
    Returns:
    true if object exists and false otherwise
  - isExistsAsync
```
public io.netty.util.concurrent.Future<Boolean> isExistsAsync()
```
    Description copied from interface: RObjectAsync
    
    Check object existence in async mode.
    
    Specified by:
    
    isExistsAsync in interface RObjectAsync
    
    Returns:
    true if object exists and false otherwise

Class RedissonBitSet

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.redisson.core.RExpirable

Methods inherited from interface org.redisson.core.RObject

Methods inherited from interface org.redisson.core.RExpirableAsync

Methods inherited from interface org.redisson.core.RObjectAsync

Constructor Detail

RedissonBitSet

Method Detail

length

set

get

getAsync

set

set

set

set

setAsync

toByteArray

toByteArrayAsync

cardinality

size

clear

clear

clear

or

and

xor

not

asBitSet

toString

lengthAsync

setAsync

clearAsync

setAsync

notAsync

setAsync

sizeAsync

setAsync

cardinalityAsync

clearAsync

clearAsync

orAsync

andAsync

xorAsync

expire

expireAsync

expireAt

expireAtAsync

expireAt

expireAtAsync

clearExpire

clearExpireAsync

remainTimeToLive

remainTimeToLiveAsync

get

newPromise

newSucceededFuture

getName

rename

renameAsync

migrate

migrateAsync

move

moveAsync

renamenx

renamenxAsync

delete

deleteAsync

isExists

isExistsAsync