RedisSetMethods (TORO Martini 1.5.2 API)

java.lang.Object
- io.toro.martini.redis.RedisBaseMethods
- - io.toro.martini.redis.RedisSetMethods

public class RedisSetMethods
extends io.toro.martini.redis.RedisBaseMethods

Methods for Sets.

Constructor Summary

Constructors
Constructor and Description

RedisSetMethods(DataSourceManager dataSourceManager)

Constructors
Constructor and Description
`RedisSetMethods(DataSourceManager dataSourceManager)`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Long`	`sadd(String connectionName, Object key, GloopExecutionContext context, Object... members)` Add one or more members to a set.
`static Future<Long>`	`saddAsync(String connectionName, Object key, GloopExecutionContext context, Object... members)` Asynchronously add one or more members to a set.
`static Long`	`scard(String connectionName, Object key, GloopExecutionContext context)` Get the number of members in a set.
`static Future<Long>`	`scardAsync(String connectionName, Object key, GloopExecutionContext context)` Asynchronously get the number of members in a set.
`static Set<Object>`	`sdiff(String connectionName, GloopExecutionContext context, Object... keys)` Subtract multiple sets.
`static Long`	`sdiff(String connectionName, ValueStreamingChannel<Object> channel, GloopExecutionContext context, Object... keys)` Subtract multiple sets.
`static Future<Set<Object>>`	`sdiffAsync(String connectionName, GloopExecutionContext context, Object... keys)` Asynchronously subtract multiple sets.
`static Future<Long>`	`sdiffAsync(String connectionName, ValueStreamingChannel<Object> channel, GloopExecutionContext context, Object... keys)` Asynchronously subtract multiple sets.
`static Long`	`sdiffstore(String connectionName, Object destination, GloopExecutionContext context, Object... keys)` Subtract multiple sets and store the resulting set in a key.
`static Future<Long>`	`sdiffstoreAsync(String connectionName, Object destination, GloopExecutionContext context, Object... keys)` Asynchronously subtract multiple sets and store the resulting set in a key.
`static Set<Object>`	`sinter(String connectionName, GloopExecutionContext context, Object... keys)` Intersect multiple sets.
`static Long`	`sinter(String connectionName, ValueStreamingChannel<Object> channel, GloopExecutionContext context, Object... keys)` Intersect multiple sets.
`static Future<Set<Object>>`	`sinterAsync(String connectionName, GloopExecutionContext context, Object... keys)` Asynchronously intersect multiple sets.
`static Future<Long>`	`sinterAsync(String connectionName, ValueStreamingChannel<Object> channel, GloopExecutionContext context, Object... keys)` Asynchronously intersect multiple sets.
`static Long`	`sinterstore(String connectionName, Object destination, GloopExecutionContext context, Object... keys)` Intersect multiple sets and store the resulting set in a key.
`static Future<Long>`	`sinterstoreAsync(String connectionName, Object destination, GloopExecutionContext context, Object... keys)` Asynchronously intersect multiple sets and store the resulting set in a key.
`static Boolean`	`sismember(String connectionName, Object key, Object member, GloopExecutionContext context)` Determine if a given value is a member of a set.
`static Future<Boolean>`	`sismemberAsync(String connectionName, Object key, Object member, GloopExecutionContext context)` Asynchronously determine if a given value is a member of a set.
`static Set<Object>`	`smembers(String connectionName, Object key, GloopExecutionContext context)` Get all the members in a set.
`static Long`	`smembers(String connectionName, ValueStreamingChannel<Object> channel, Object key, GloopExecutionContext context)` Get all the members in a set.
`static Future<Set<Object>>`	`smembersAsync(String connectionName, Object key, GloopExecutionContext context)` Asynchronously get all the members in a set.
`static Future<Long>`	`smembersAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, GloopExecutionContext context)` Asynchronously get all the members in a set.
`static Boolean`	`smove(String connectionName, Object source, Object destination, Object member, GloopExecutionContext context)` Move a member from one set to another.
`static Future<Boolean>`	`smoveAsync(String connectionName, Object source, Object destination, Object member, GloopExecutionContext context)` Asynchronously move a member from one set to another.
`static Object`	`spop(String connectionName, Object key, GloopExecutionContext context)` Remove and return a random member from a set.
`static Set<Object>`	`spop(String connectionName, Object key, long count, GloopExecutionContext context)` Remove and return one or multiple random members from a set.
`static Future<Object>`	`spopAsync(String connectionName, Object key, GloopExecutionContext context)` Asynchronously remove and return a random member from a set.
`static Future<Set<Object>>`	`spopAsync(String connectionName, Object key, long count, GloopExecutionContext context)` Asynchronously remove and return one or multiple random members from a set.
`static Object`	`srandmember(String connectionName, Object key, GloopExecutionContext context)` Get one random member from a set.
`static List<Object>`	`srandmember(String connectionName, Object key, long count, GloopExecutionContext context)` Get one or multiple random members from a set.
`static Long`	`srandmember(String connectionName, ValueStreamingChannel<Object> channel, Object key, long count, GloopExecutionContext context)` Get one or multiple random members from a set.
`static Future<Object>`	`srandmemberAsync(String connectionName, Object key, GloopExecutionContext context)` Asynchronously get one random member from a set.
`static Future<List<Object>>`	`srandmemberAsync(String connectionName, Object key, long count, GloopExecutionContext context)` Asynchronously get one or multiple random members from a set.
`static Future<Long>`	`srandmemberAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, long count, GloopExecutionContext context)` Asynchronously get one or multiple random members from a set.
`static Long`	`srem(String connectionName, Object key, GloopExecutionContext context, Object... members)` Remove one or more members from a set.
`static Future<Long>`	`sremAsync(String connectionName, Object key, GloopExecutionContext context, Object... members)` Asynchronously remove one or more members from a set.
`static ValueScanCursor<Object>`	`sscan(String connectionName, Object key, GloopExecutionContext context)` Incrementally iterate Set elements.
`static ValueScanCursor<Object>`	`sscan(String connectionName, Object key, GloopModel scanArgs, GloopExecutionContext context)` Incrementally iterate Set elements.
`static ValueScanCursor<Object>`	`sscan(String connectionName, Object key, ScanCursor scanCursor, GloopExecutionContext context)` Incrementally iterate Set elements.
`static ValueScanCursor<Object>`	`sscan(String connectionName, Object key, ScanCursor scanCursor, GloopModel scanArgs, GloopExecutionContext context)` Incrementally iterate Set elements.
`static StreamScanCursor`	`sscan(String connectionName, ValueStreamingChannel<Object> channel, Object key, GloopExecutionContext context)` Incrementally iterate Set elements.
`static StreamScanCursor`	`sscan(String connectionName, ValueStreamingChannel<Object> channel, Object key, GloopModel scanArgs, GloopExecutionContext context)` Incrementally iterate Set elements.
`static StreamScanCursor`	`sscan(String connectionName, ValueStreamingChannel<Object> channel, Object key, ScanCursor scanCursor, GloopExecutionContext context)` Incrementally iterate Set elements.
`static StreamScanCursor`	`sscan(String connectionName, ValueStreamingChannel<Object> channel, Object key, ScanCursor scanCursor, GloopModel scanArgs, GloopExecutionContext context)` Incrementally iterate Set elements.
`static Future<ValueScanCursor<Object>>`	`sscanAsync(String connectionName, Object key, GloopExecutionContext context)` Asynchronously incrementally iterate set elements.
`static Future<ValueScanCursor<Object>>`	`sscanAsync(String connectionName, Object key, GloopModel scanArgs, GloopExecutionContext context)` Asynchronously incrementally iterate set elements.
`static Future<ValueScanCursor<Object>>`	`sscanAsync(String connectionName, Object key, ScanCursor scanCursor, GloopExecutionContext context)` Asynchronously incrementally iterate set elements.
`static Future<ValueScanCursor<Object>>`	`sscanAsync(String connectionName, Object key, ScanCursor scanCursor, GloopModel scanArgs, GloopExecutionContext context)` Asynchronously incrementally iterate set elements.
`static Future<StreamScanCursor>`	`sscanAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, GloopExecutionContext context)` Asynchronously incrementally iterate set elements.
`static Future<StreamScanCursor>`	`sscanAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, GloopModel scanArgs, GloopExecutionContext context)` Asynchronously incrementally iterate set elements.
`static Future<StreamScanCursor>`	`sscanAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, ScanCursor scanCursor, GloopExecutionContext context)` Asynchronously incrementally iterate set elements.
`static Future<StreamScanCursor>`	`sscanAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, ScanCursor scanCursor, GloopModel scanArgs, GloopExecutionContext context)` Asynchronously incrementally iterate set elements.
`static Set<Object>`	`sunion(String connectionName, GloopExecutionContext context, Object... keys)` Add multiple sets.
`static Long`	`sunion(String connectionName, ValueStreamingChannel<Object> channel, GloopExecutionContext context, Object... keys)` Add multiple sets.
`static Future<Set<Object>>`	`sunionAsync(String connectionName, GloopExecutionContext context, Object... keys)` Asynchronously add multiple sets.
`static Future<Long>`	`sunionAsync(String connectionName, ValueStreamingChannel<Object> channel, GloopExecutionContext context, Object... keys)` Asynchronously add multiple sets.
`static Long`	`sunionstore(String connectionName, Object destination, GloopExecutionContext context, Object... keys)` Add multiple sets and store the resulting set in a key.
`static Future<Long>`	`sunionstoreAsync(String connectionName, Object destination, GloopExecutionContext context, Object... keys)` Asynchronously add multiple sets and store the resulting set in a key.

Methods inherited from class io.toro.martini.redis.RedisBaseMethods
getDataSourceManager, getRedisConnection, getRedisConnection

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

Constructor Detail

RedisSetMethods

@Autowired
RedisSetMethods(DataSourceManager dataSourceManager)

Method Detail

sadd

@GloopParameter(name="redisSaddOutput")
public static Long sadd(@GloopParameter(allowNull=false)
                                                                String connectionName,
                                                                @GloopParameter(allowNull=false)
                                                                Object key,
                                                                GloopExecutionContext context,
                                                                @GloopParameter(allowNull=false)
                                                                Object... members)

Add one or more members to a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; members - the member type: value
Returns:: Long integer-reply the number of elements that were added to the set, not including all the elements already present into the set.

saddAsync

@GloopParameter(name="redisFutureSaddOutput")
public static Future<Long> saddAsync(@GloopParameter(allowNull=false)
                                                                                   String connectionName,
                                                                                   @GloopParameter(allowNull=false)
                                                                                   Object key,
                                                                                   GloopExecutionContext context,
                                                                                   @GloopParameter(allowNull=false)
                                                                                   Object... members)

Asynchronously add one or more members to a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; members - the member type: value
Returns:: long integer-reply the number of elements that were added to the set, not including all the elements already present into the set.

scard

@GloopParameter(name="redisScardOutput")
public static Long scard(@GloopParameter(allowNull=false)
                                                                  String connectionName,
                                                                  @GloopParameter(allowNull=false)
                                                                  Object key,
                                                                  GloopExecutionContext context)

Get the number of members in a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: Long integer-reply the cardinality (number of elements) of the set, or false if key does not exist.

scardAsync

@GloopParameter(name="redisFutureScardOutput")
public static Future<Long> scardAsync(@GloopParameter(allowNull=false)
                                                                                     String connectionName,
                                                                                     @GloopParameter(allowNull=false)
                                                                                     Object key,
                                                                                     GloopExecutionContext context)

Asynchronously get the number of members in a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: long integer-reply the cardinality (number of elements) of the set, or false if key does not exist.

sdiff

@GloopParameter(name="redisSdiffOutput")
public static Set<Object> sdiff(@GloopParameter(allowNull=false)
                                                                         String connectionName,
                                                                         GloopExecutionContext context,
                                                                         @GloopParameter(allowNull=false)
                                                                         Object... keys)

Subtract multiple sets.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the key
Returns:: Set<V> array-reply list with members of the resulting set.

sdiff

@GloopParameter(name="redisSdiffOutput")
public static Long sdiff(@GloopParameter(allowNull=false)
                                                                  String connectionName,
                                                                  @GloopParameter(allowNull=false)
                                                                  ValueStreamingChannel<Object> channel,
                                                                  GloopExecutionContext context,
                                                                  @GloopParameter(allowNull=false)
                                                                  Object... keys)

Subtract multiple sets.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - the channel; keys - the keys
Returns:: Long count of members of the resulting set.

sdiffAsync

@GloopParameter(name="redisFutureSdiffOutput")
public static Future<Set<Object>> sdiffAsync(@GloopParameter(allowNull=false)
                                                                                            String connectionName,
                                                                                            GloopExecutionContext context,
                                                                                            @GloopParameter(allowNull=false)
                                                                                            Object... keys)

Asynchronously subtract multiple sets.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the key
Returns:: set<V> array-reply list with members of the resulting set.

sdiffAsync

@GloopParameter(name="redisFutureSdiffOutput")
public static Future<Long> sdiffAsync(@GloopParameter(allowNull=false)
                                                                                     String connectionName,
                                                                                     @GloopParameter(allowNull=false)
                                                                                     ValueStreamingChannel<Object> channel,
                                                                                     GloopExecutionContext context,
                                                                                     @GloopParameter(allowNull=false)
                                                                                     Object... keys)

Asynchronously subtract multiple sets.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - the channel; keys - the keys
Returns:: long count of members of the resulting set.

sdiffstore

@GloopParameter(name="redisSdiffstoreOutput")
public static Long sdiffstore(@GloopParameter(allowNull=false)
                                                                            String connectionName,
                                                                            @GloopParameter(allowNull=false)
                                                                            Object destination,
                                                                            GloopExecutionContext context,
                                                                            @GloopParameter(allowNull=false)
                                                                            Object... keys)

Subtract multiple sets and store the resulting set in a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; destination - the destination type: key; keys - the key
Returns:: Long integer-reply the number of elements in the resulting set.

sdiffstoreAsync

@GloopParameter(name="redisFutureSdiffstoreOutput")
public static Future<Long> sdiffstoreAsync(@GloopParameter(allowNull=false)
                                                                                               String connectionName,
                                                                                               @GloopParameter(allowNull=false)
                                                                                               Object destination,
                                                                                               GloopExecutionContext context,
                                                                                               @GloopParameter(allowNull=false)
                                                                                               Object... keys)

Asynchronously subtract multiple sets and store the resulting set in a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; destination - the destination type: key; keys - the key
Returns:: long integer-reply the number of elements in the resulting set.

sinter

@GloopParameter(name="redisSinterOutput")
public static Set<Object> sinter(@GloopParameter(allowNull=false)
                                                                           String connectionName,
                                                                           GloopExecutionContext context,
                                                                           @GloopParameter(allowNull=false)
                                                                           Object... keys)

Intersect multiple sets.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the key
Returns:: Set<V> array-reply list with members of the resulting set.

sinter

@GloopParameter(name="redisSinterOutput")
public static Long sinter(@GloopParameter(allowNull=false)
                                                                    String connectionName,
                                                                    @GloopParameter(allowNull=false)
                                                                    ValueStreamingChannel<Object> channel,
                                                                    GloopExecutionContext context,
                                                                    @GloopParameter(allowNull=false)
                                                                    Object... keys)

Intersect multiple sets.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - the channel; keys - the keys
Returns:: Long count of members of the resulting set.

sinterAsync

@GloopParameter(name="redisFutureSinterOutput")
public static Future<Set<Object>> sinterAsync(@GloopParameter(allowNull=false)
                                                                                              String connectionName,
                                                                                              GloopExecutionContext context,
                                                                                              @GloopParameter(allowNull=false)
                                                                                              Object... keys)

Asynchronously intersect multiple sets.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the key
Returns:: set<V> array-reply list with members of the resulting set.

sinterAsync

@GloopParameter(name="redisFutureSinterOutput")
public static Future<Long> sinterAsync(@GloopParameter(allowNull=false)
                                                                                       String connectionName,
                                                                                       @GloopParameter(allowNull=false)
                                                                                       ValueStreamingChannel<Object> channel,
                                                                                       GloopExecutionContext context,
                                                                                       @GloopParameter(allowNull=false)
                                                                                       Object... keys)

Asynchronously intersect multiple sets.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - the channel; keys - the keys
Returns:: long count of members of the resulting set.

sinterstore

@GloopParameter(name="redisSinterstoreOutput")
public static Long sinterstore(@GloopParameter(allowNull=false)
                                                                              String connectionName,
                                                                              @GloopParameter(allowNull=false)
                                                                              Object destination,
                                                                              GloopExecutionContext context,
                                                                              @GloopParameter(allowNull=false)
                                                                              Object... keys)

Intersect multiple sets and store the resulting set in a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; destination - the destination type: key; keys - the key
Returns:: Long integer-reply the number of elements in the resulting set.

sinterstoreAsync

@GloopParameter(name="redisFutureSinterstoreOutput")
public static Future<Long> sinterstoreAsync(@GloopParameter(allowNull=false)
                                                                                                 String connectionName,
                                                                                                 @GloopParameter(allowNull=false)
                                                                                                 Object destination,
                                                                                                 GloopExecutionContext context,
                                                                                                 @GloopParameter(allowNull=false)
                                                                                                 Object... keys)

Asynchronously intersect multiple sets and store the resulting set in a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; destination - the destination type: key; keys - the key
Returns:: long integer-reply the number of elements in the resulting set.

sismember

@GloopParameter(name="redisSismemberOutput")
public static Boolean sismember(@GloopParameter(allowNull=false)
                                                                             String connectionName,
                                                                             @GloopParameter(allowNull=false)
                                                                             Object key,
                                                                             @GloopParameter(allowNull=false)
                                                                             Object member,
                                                                             GloopExecutionContext context)

Determine if a given value is a member of a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; member - the member type: value
Returns:: Boolean integer-reply specifically: true if the element is a member of the set. false if the element is not a member of the set, or if key does not exist.

sismemberAsync

@GloopParameter(name="redisFutureSismemberOutput")
public static Future<Boolean> sismemberAsync(@GloopParameter(allowNull=false)
                                                                                                String connectionName,
                                                                                                @GloopParameter(allowNull=false)
                                                                                                Object key,
                                                                                                @GloopParameter(allowNull=false)
                                                                                                Object member,
                                                                                                GloopExecutionContext context)

Asynchronously determine if a given value is a member of a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; member - the member type: value
Returns:: boolean integer-reply specifically: true if the element is a member of the set. false if the element is not a member of the set, or if key does not exist.

smove

@GloopParameter(name="redisSmoveOutput")
public static Boolean smove(@GloopParameter(allowNull=false)
                                                                     String connectionName,
                                                                     @GloopParameter(allowNull=false)
                                                                     Object source,
                                                                     @GloopParameter(allowNull=false)
                                                                     Object destination,
                                                                     @GloopParameter(allowNull=false)
                                                                     Object member,
                                                                     GloopExecutionContext context)

Move a member from one set to another.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; source - the source key; destination - the destination type: key; member - the member type: value
Returns:: Boolean integer-reply specifically: true if the element is moved. false if the element is not a member of source and no operation was performed.

smoveAsync

@GloopParameter(name="redisFutureSmoveOutput")
public static Future<Boolean> smoveAsync(@GloopParameter(allowNull=false)
                                                                                        String connectionName,
                                                                                        @GloopParameter(allowNull=false)
                                                                                        Object source,
                                                                                        @GloopParameter(allowNull=false)
                                                                                        Object destination,
                                                                                        @GloopParameter(allowNull=false)
                                                                                        Object member,
                                                                                        GloopExecutionContext context)

Asynchronously move a member from one set to another.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; source - the source key; destination - the destination type: key; member - the member type: value
Returns:: boolean integer-reply specifically: true if the element is moved. false if the element is not a member of source and no operation was performed.

smembers

@GloopParameter(name="redisSmembersOutput")
public static Set<Object> smembers(@GloopParameter(allowNull=false)
                                                                               String connectionName,
                                                                               @GloopParameter(allowNull=false)
                                                                               Object key,
                                                                               GloopExecutionContext context)

Get all the members in a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: Set<V> array-reply all elements of the set.

smembers

@GloopParameter(name="redisSmembersOutput")
public static Long smembers(@GloopParameter(allowNull=false)
                                                                        String connectionName,
                                                                        @GloopParameter(allowNull=false)
                                                                        ValueStreamingChannel<Object> channel,
                                                                        @GloopParameter(allowNull=false)
                                                                        Object key,
                                                                        GloopExecutionContext context)

Get all the members in a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - the channel; key - the keys
Returns:: Long count of members of the resulting set.

smembersAsync

@GloopParameter(name="redisFutureSmembersOutput")
public static Future<Set<Object>> smembersAsync(@GloopParameter(allowNull=false)
                                                                                                  String connectionName,
                                                                                                  @GloopParameter(allowNull=false)
                                                                                                  Object key,
                                                                                                  GloopExecutionContext context)

Asynchronously get all the members in a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: set<V> array-reply all elements of the set.

smembersAsync

@GloopParameter(name="redisFutureSmembersOutput")
public static Future<Long> smembersAsync(@GloopParameter(allowNull=false)
                                                                                           String connectionName,
                                                                                           @GloopParameter(allowNull=false)
                                                                                           ValueStreamingChannel<Object> channel,
                                                                                           @GloopParameter(allowNull=false)
                                                                                           Object key,
                                                                                           GloopExecutionContext context)

Asynchronously get all the members in a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - the channel; key - the keys
Returns:: long count of members of the resulting set.

spop

@GloopParameter(name="redisSpopOutput")
public static Object spop(@GloopParameter(allowNull=false)
                                                                  String connectionName,
                                                                  @GloopParameter(allowNull=false)
                                                                  Object key,
                                                                  GloopExecutionContext context)

Remove and return a random member from a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: V bulk-string-reply the removed element, or null when key does not exist.

spop

@GloopParameter(name="redisSpopOutput")
public static Set<Object> spop(@GloopParameter(allowNull=false)
                                                                       String connectionName,
                                                                       @GloopParameter(allowNull=false)
                                                                       Object key,
                                                                       @GloopParameter(allowNull=false)
                                                                       long count,
                                                                       GloopExecutionContext context)

Remove and return one or multiple random members from a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; count - number of members to pop
Returns:: V bulk-string-reply the removed element, or null when key does not exist.

spopAsync

@GloopParameter(name="redisFutureSpopOutput")
public static Future<Object> spopAsync(@GloopParameter(allowNull=false)
                                                                                     String connectionName,
                                                                                     @GloopParameter(allowNull=false)
                                                                                     Object key,
                                                                                     GloopExecutionContext context)

Asynchronously remove and return a random member from a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: v bulk-string-reply the removed element, or null when key does not exist.

spopAsync

@GloopParameter(name="redisFutureSpopOutput")
public static Future<Set<Object>> spopAsync(@GloopParameter(allowNull=false)
                                                                                          String connectionName,
                                                                                          @GloopParameter(allowNull=false)
                                                                                          Object key,
                                                                                          @GloopParameter(allowNull=false)
                                                                                          long count,
                                                                                          GloopExecutionContext context)

Asynchronously remove and return one or multiple random members from a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; count - number of members to pop
Returns:: v bulk-string-reply the removed element, or null when key does not exist.

srandmember

@GloopParameter(name="redisSrandmemberOutput")
public static Object srandmember(@GloopParameter(allowNull=false)
                                                                                String connectionName,
                                                                                @GloopParameter(allowNull=false)
                                                                                Object key,
                                                                                GloopExecutionContext context)

Get one random member from a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: V bulk-string-reply without the additional count argument the command returns a Bulk Reply with the randomly selected element, or null when key does not exist.

srandmember

@GloopParameter(name="redisSrandmemberOutput")
public static List<Object> srandmember(@GloopParameter(allowNull=false)
                                                                                      String connectionName,
                                                                                      @GloopParameter(allowNull=false)
                                                                                      Object key,
                                                                                      @GloopParameter(allowNull=false)
                                                                                      long count,
                                                                                      GloopExecutionContext context)

Get one or multiple random members from a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; count - the count type: long
Returns:: Set<V> bulk-string-reply without the additional count argument the command returns a Bulk Reply with the randomly selected element, or null when key does not exist.

srandmember

@GloopParameter(name="redisSrandmemberOutput")
public static Long srandmember(@GloopParameter(allowNull=false)
                                                                              String connectionName,
                                                                              @GloopParameter(allowNull=false)
                                                                              ValueStreamingChannel<Object> channel,
                                                                              @GloopParameter(allowNull=false)
                                                                              Object key,
                                                                              @GloopParameter(allowNull=false)
                                                                              long count,
                                                                              GloopExecutionContext context)

Get one or multiple random members from a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every value; key - the key; count - the count
Returns:: Long count of members of the resulting set.

srandmemberAsync

@GloopParameter(name="redisFutureSrandmemberOutput")
public static Future<Object> srandmemberAsync(@GloopParameter(allowNull=false)
                                                                                                   String connectionName,
                                                                                                   @GloopParameter(allowNull=false)
                                                                                                   Object key,
                                                                                                   GloopExecutionContext context)

Asynchronously get one random member from a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: v bulk-string-reply without the additional count argument the command returns a bulk reply with the randomly selected element, or null when key does not exist.

srandmemberAsync

@GloopParameter(name="redisFutureSrandmemberOutput")
public static Future<List<Object>> srandmemberAsync(@GloopParameter(allowNull=false)
                                                                                                         String connectionName,
                                                                                                         @GloopParameter(allowNull=false)
                                                                                                         Object key,
                                                                                                         @GloopParameter(allowNull=false)
                                                                                                         long count,
                                                                                                         GloopExecutionContext context)

Asynchronously get one or multiple random members from a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; count - the count type: long
Returns:: set<V> bulk-string-reply without the additional count argument the command returns a bulk reply with the randomly selected element, or null when key does not exist.

srandmemberAsync

@GloopParameter(name="redisFutureSrandmemberOutput")
public static Future<Long> srandmemberAsync(@GloopParameter(allowNull=false)
                                                                                                 String connectionName,
                                                                                                 @GloopParameter(allowNull=false)
                                                                                                 ValueStreamingChannel<Object> channel,
                                                                                                 @GloopParameter(allowNull=false)
                                                                                                 Object key,
                                                                                                 @GloopParameter(allowNull=false)
                                                                                                 long count,
                                                                                                 GloopExecutionContext context)

Asynchronously get one or multiple random members from a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every value; key - the key; count - the count
Returns:: long count of members of the resulting set.

srem

@GloopParameter(name="redisSremOutput")
public static Long srem(@GloopParameter(allowNull=false)
                                                                String connectionName,
                                                                @GloopParameter(allowNull=false)
                                                                Object key,
                                                                GloopExecutionContext context,
                                                                @GloopParameter(allowNull=false)
                                                                Object... members)

Remove one or more members from a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; members - the member type: value
Returns:: Long integer-reply the number of members that were removed from the set, not including non existing members.

sremAsync

@GloopParameter(name="redisFutureSremOutput")
public static Future<Long> sremAsync(@GloopParameter(allowNull=false)
                                                                                   String connectionName,
                                                                                   @GloopParameter(allowNull=false)
                                                                                   Object key,
                                                                                   GloopExecutionContext context,
                                                                                   @GloopParameter(allowNull=false)
                                                                                   Object... members)

Asynchronously remove one or more members from a set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; members - the member type: value
Returns:: long integer-reply the number of members that were removed from the set, not including non existing members.

sunion

@GloopParameter(name="redisSunionOutput")
public static Set<Object> sunion(@GloopParameter(allowNull=false)
                                                                           String connectionName,
                                                                           GloopExecutionContext context,
                                                                           @GloopParameter(allowNull=false)
                                                                           Object... keys)

Add multiple sets.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the key
Returns:: Set<V> array-reply list with members of the resulting set.

sunion

@GloopParameter(name="redisSunionOutput")
public static Long sunion(@GloopParameter(allowNull=false)
                                                                    String connectionName,
                                                                    @GloopParameter(allowNull=false)
                                                                    ValueStreamingChannel<Object> channel,
                                                                    GloopExecutionContext context,
                                                                    @GloopParameter(allowNull=false)
                                                                    Object... keys)

Add multiple sets.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every value; keys - the keys
Returns:: Long count of members of the resulting set.

sunionAsync

@GloopParameter(name="redisFutureSunionOutput")
public static Future<Set<Object>> sunionAsync(@GloopParameter(allowNull=false)
                                                                                              String connectionName,
                                                                                              GloopExecutionContext context,
                                                                                              @GloopParameter(allowNull=false)
                                                                                              Object... keys)

Asynchronously add multiple sets.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the key
Returns:: set<V> array-reply list with members of the resulting set.

sunionAsync

@GloopParameter(name="redisFutureSunionOutput")
public static Future<Long> sunionAsync(@GloopParameter(allowNull=false)
                                                                                       String connectionName,
                                                                                       @GloopParameter(allowNull=false)
                                                                                       ValueStreamingChannel<Object> channel,
                                                                                       GloopExecutionContext context,
                                                                                       @GloopParameter(allowNull=false)
                                                                                       Object... keys)

Asynchronously add multiple sets.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every value; keys - the keys
Returns:: long count of members of the resulting set.

sunionstore

@GloopParameter(name="redisSunionstoreOutput")
public static Long sunionstore(@GloopParameter(allowNull=false)
                                                                              String connectionName,
                                                                              @GloopParameter(allowNull=false)
                                                                              Object destination,
                                                                              GloopExecutionContext context,
                                                                              @GloopParameter(allowNull=false)
                                                                              Object... keys)

Add multiple sets and store the resulting set in a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; destination - the destination type: key; keys - the key
Returns:: Long integer-reply the number of elements in the resulting set.

sunionstoreAsync

@GloopParameter(name="redisFutureSunionstoreOutput")
public static Future<Long> sunionstoreAsync(@GloopParameter(allowNull=false)
                                                                                                 String connectionName,
                                                                                                 @GloopParameter(allowNull=false)
                                                                                                 Object destination,
                                                                                                 GloopExecutionContext context,
                                                                                                 @GloopParameter(allowNull=false)
                                                                                                 Object... keys)

Asynchronously add multiple sets and store the resulting set in a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; destination - the destination type: key; keys - the key
Returns:: long integer-reply the number of elements in the resulting set.

sscan

@GloopParameter(name="redisSscanOutput")
public static ValueScanCursor<Object> sscan(@GloopParameter(allowNull=false)
                                                                                     String connectionName,
                                                                                     @GloopParameter(allowNull=false)
                                                                                     Object key,
                                                                                     GloopExecutionContext context)

Incrementally iterate Set elements.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: ValueScanCursor<V> scan cursor.

sscan

@GloopParameter(name="redisSscanOutput")
public static ValueScanCursor<Object> sscan(@GloopParameter(allowNull=false)
                                                                                     String connectionName,
                                                                                     @GloopParameter(allowNull=false)
                                                                                     Object key,
                                                                                     @GloopObjectParameter(value="scanArgs{\n  limit:long:Limit the scan by count:false\n match::Set the match filter:false\n}\n")
                                                                                     GloopModel scanArgs,
                                                                                     GloopExecutionContext context)

Incrementally iterate Set elements.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; scanArgs - scan arguments
Returns:: ValueScanCursor<V> scan cursor.

sscan

@GloopParameter(name="redisSscanOutput")
public static ValueScanCursor<Object> sscan(@GloopParameter(allowNull=false)
                                                                                     String connectionName,
                                                                                     @GloopParameter(allowNull=false)
                                                                                     Object key,
                                                                                     @GloopParameter(allowNull=false)
                                                                                     ScanCursor scanCursor,
                                                                                     @GloopObjectParameter(value="scanArgs{\n  limit:long:Limit the scan by count:false\n match::Set the match filter:false\n}\n")
                                                                                     GloopModel scanArgs,
                                                                                     GloopExecutionContext context)

Incrementally iterate Set elements.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; scanCursor - cursor to resume from a previous scan, must not be null; scanArgs - scan arguments
Returns:: ValueScanCursor<V> scan cursor.

sscan

@GloopParameter(name="redisSscanOutput")
public static ValueScanCursor<Object> sscan(@GloopParameter(allowNull=false)
                                                                                     String connectionName,
                                                                                     @GloopParameter(allowNull=false)
                                                                                     Object key,
                                                                                     @GloopParameter(allowNull=false)
                                                                                     ScanCursor scanCursor,
                                                                                     GloopExecutionContext context)

Incrementally iterate Set elements.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; scanCursor - cursor to resume from a previous scan, must not be null
Returns:: ValueScanCursor<V> scan cursor.

sscan

@GloopParameter(name="redisSscanOutput")
public static StreamScanCursor sscan(@GloopParameter(allowNull=false)
                                                                              String connectionName,
                                                                              @GloopParameter(allowNull=false)
                                                                              ValueStreamingChannel<Object> channel,
                                                                              @GloopParameter(allowNull=false)
                                                                              Object key,
                                                                              GloopExecutionContext context)

Incrementally iterate Set elements.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every value; key - the key
Returns:: StreamScanCursor scan cursor.

sscan

@GloopParameter(name="redisSscanOutput")
public static StreamScanCursor sscan(@GloopParameter(allowNull=false)
                                                                              String connectionName,
                                                                              @GloopParameter(allowNull=false)
                                                                              ValueStreamingChannel<Object> channel,
                                                                              @GloopParameter(allowNull=false)
                                                                              Object key,
                                                                              @GloopObjectParameter(value="scanArgs{\n  limit:long:Limit the scan by count:false\n match::Set the match filter:false\n}\n")
                                                                              GloopModel scanArgs,
                                                                              GloopExecutionContext context)

Incrementally iterate Set elements.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every value; key - the key; scanArgs - scan arguments
Returns:: StreamScanCursor scan cursor.

sscan

@GloopParameter(name="redisSscanOutput")
public static StreamScanCursor sscan(@GloopParameter(allowNull=false)
                                                                              String connectionName,
                                                                              @GloopParameter(allowNull=false)
                                                                              ValueStreamingChannel<Object> channel,
                                                                              @GloopParameter(allowNull=false)
                                                                              Object key,
                                                                              @GloopParameter(allowNull=false)
                                                                              ScanCursor scanCursor,
                                                                              @GloopObjectParameter(value="scanArgs{\n  limit:long:Limit the scan by count:false\n match::Set the match filter:false\n}\n")
                                                                              GloopModel scanArgs,
                                                                              GloopExecutionContext context)

Incrementally iterate Set elements.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every value; key - the key; scanCursor - cursor to resume from a previous scan, must not be null; scanArgs - scan arguments
Returns:: StreamScanCursor scan cursor.

sscan

@GloopParameter(name="redisSscanOutput")
public static StreamScanCursor sscan(@GloopParameter(allowNull=false)
                                                                              String connectionName,
                                                                              @GloopParameter(allowNull=false)
                                                                              ValueStreamingChannel<Object> channel,
                                                                              @GloopParameter(allowNull=false)
                                                                              Object key,
                                                                              @GloopParameter(allowNull=false)
                                                                              ScanCursor scanCursor,
                                                                              GloopExecutionContext context)

Incrementally iterate Set elements.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every value; key - the key; scanCursor - cursor to resume from a previous scan, must not be null
Returns:: StreamScanCursor scan cursor.