Class RedisAPI


  • public class RedisAPI
    extends Object
    Auto generated Redis API client wrapper.

    NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

    • Constructor Detail

      • RedisAPI

        public RedisAPI​(io.vertx.redis.client.RedisAPI delegate)
      • RedisAPI

        public RedisAPI​(Object delegate)
    • Method Detail

      • getDelegate

        public io.vertx.redis.client.RedisAPI getDelegate()
      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object
      • close

        public void close()
      • acl

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> acl​(List<String> args)
        Redis command acl.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • aclAndAwait

        public Response aclAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#acl(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • aclAndForget

        public RedisAPI aclAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#acl(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#acl(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#acl(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • append

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> append​(String arg0,
                                                       String arg1)
        Redis command append.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • appendAndAwait

        public Response appendAndAwait​(String arg0,
                                       String arg1)
        Blocking variant of append(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • appendAndForget

        public RedisAPI appendAndForget​(String arg0,
                                        String arg1)
        Variant of append(String,String) that ignores the result of the operation.

        This method subscribes on the result of append(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from append(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • asking

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> asking()
        Redis command asking.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • askingAndAwait

        public Response askingAndAwait()
        Blocking variant of asking().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • askingAndForget

        public RedisAPI askingAndForget()
        Variant of asking() that ignores the result of the operation.

        This method subscribes on the result of asking(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from asking() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • auth

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> auth​(List<String> args)
        Redis command auth.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • authAndAwait

        public Response authAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#auth(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • authAndForget

        public RedisAPI authAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#auth(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#auth(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#auth(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • bgrewriteaof

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> bgrewriteaof()
        Redis command bgrewriteaof.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • bgrewriteaofAndAwait

        public Response bgrewriteaofAndAwait()
        Blocking variant of bgrewriteaof().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • bgrewriteaofAndForget

        public RedisAPI bgrewriteaofAndForget()
        Variant of bgrewriteaof() that ignores the result of the operation.

        This method subscribes on the result of bgrewriteaof(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bgrewriteaof() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • bgsave

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> bgsave​(List<String> args)
        Redis command bgsave.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • bgsaveAndAwait

        public Response bgsaveAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bgsave(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • bgsaveAndForget

        public RedisAPI bgsaveAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#bgsave(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bgsave(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bgsave(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • bitcount

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> bitcount​(List<String> args)
        Redis command bitcount.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • bitcountAndAwait

        public Response bitcountAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bitcount(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • bitcountAndForget

        public RedisAPI bitcountAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#bitcount(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bitcount(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bitcount(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • bitfield

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> bitfield​(List<String> args)
        Redis command bitfield.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • bitfieldAndAwait

        public Response bitfieldAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bitfield(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • bitfieldAndForget

        public RedisAPI bitfieldAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#bitfield(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bitfield(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bitfield(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • bitfieldRo

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> bitfieldRo​(List<String> args)
        Redis command bitfieldRo.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • bitfieldRoAndAwait

        public Response bitfieldRoAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bitfieldRo(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • bitfieldRoAndForget

        public RedisAPI bitfieldRoAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#bitfieldRo(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bitfieldRo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bitfieldRo(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • bitop

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> bitop​(List<String> args)
        Redis command bitop.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • bitopAndAwait

        public Response bitopAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bitop(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • bitopAndForget

        public RedisAPI bitopAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#bitop(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bitop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bitop(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • bitpos

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> bitpos​(List<String> args)
        Redis command bitpos.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • bitposAndAwait

        public Response bitposAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bitpos(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • bitposAndForget

        public RedisAPI bitposAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#bitpos(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bitpos(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bitpos(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • blmove

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> blmove​(String arg0,
                                                       String arg1,
                                                       String arg2,
                                                       String arg3,
                                                       String arg4)
        Redis command blmove.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        arg3 -
        arg4 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • blmoveAndAwait

        public Response blmoveAndAwait​(String arg0,
                                       String arg1,
                                       String arg2,
                                       String arg3,
                                       String arg4)
        Blocking variant of blmove(String,String,String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        arg3 -
        arg4 -
        Returns:
        the Response instance produced by the operation.
      • blpop

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> blpop​(List<String> args)
        Redis command blpop.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • blpopAndAwait

        public Response blpopAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#blpop(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • blpopAndForget

        public RedisAPI blpopAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#blpop(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#blpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#blpop(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • brpop

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> brpop​(List<String> args)
        Redis command brpop.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • brpopAndAwait

        public Response brpopAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#brpop(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • brpopAndForget

        public RedisAPI brpopAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#brpop(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#brpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#brpop(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • brpoplpush

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> brpoplpush​(String arg0,
                                                           String arg1,
                                                           String arg2)
        Redis command brpoplpush.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • brpoplpushAndAwait

        public Response brpoplpushAndAwait​(String arg0,
                                           String arg1,
                                           String arg2)
        Blocking variant of brpoplpush(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • bzpopmax

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> bzpopmax​(List<String> args)
        Redis command bzpopmax.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • bzpopmaxAndAwait

        public Response bzpopmaxAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bzpopmax(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • bzpopmaxAndForget

        public RedisAPI bzpopmaxAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#bzpopmax(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bzpopmax(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bzpopmax(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • bzpopmin

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> bzpopmin​(List<String> args)
        Redis command bzpopmin.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • bzpopminAndAwait

        public Response bzpopminAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bzpopmin(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • bzpopminAndForget

        public RedisAPI bzpopminAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#bzpopmin(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bzpopmin(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bzpopmin(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • client

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> client​(List<String> args)
        Redis command client.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • clientAndAwait

        public Response clientAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#client(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • clientAndForget

        public RedisAPI clientAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#client(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#client(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#client(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • cluster

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> cluster​(List<String> args)
        Redis command cluster.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • clusterAndAwait

        public Response clusterAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#cluster(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • clusterAndForget

        public RedisAPI clusterAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#cluster(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#cluster(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#cluster(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • command

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> command​(List<String> args)
        Redis command command.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • commandAndAwait

        public Response commandAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#command(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • commandAndForget

        public RedisAPI commandAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#command(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#command(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#command(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • config

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> config​(List<String> args)
        Redis command config.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • configAndAwait

        public Response configAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#config(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • configAndForget

        public RedisAPI configAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#config(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#config(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#config(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • copy

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> copy​(List<String> args)
        Redis command copy.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • copyAndAwait

        public Response copyAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#copy(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • copyAndForget

        public RedisAPI copyAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#copy(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#copy(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#copy(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • dbsize

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> dbsize()
        Redis command dbsize.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • dbsizeAndAwait

        public Response dbsizeAndAwait()
        Blocking variant of dbsize().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • dbsizeAndForget

        public RedisAPI dbsizeAndForget()
        Variant of dbsize() that ignores the result of the operation.

        This method subscribes on the result of dbsize(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from dbsize() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • debug

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> debug​(List<String> args)
        Redis command debug.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • debugAndAwait

        public Response debugAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#debug(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • debugAndForget

        public RedisAPI debugAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#debug(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#debug(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#debug(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • decr

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> decr​(String arg0)
        Redis command decr.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • decrAndAwait

        public Response decrAndAwait​(String arg0)
        Blocking variant of decr(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • decrAndForget

        public RedisAPI decrAndForget​(String arg0)
        Variant of decr(String) that ignores the result of the operation.

        This method subscribes on the result of decr(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from decr(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • decrby

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> decrby​(String arg0,
                                                       String arg1)
        Redis command decrby.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • decrbyAndAwait

        public Response decrbyAndAwait​(String arg0,
                                       String arg1)
        Blocking variant of decrby(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • decrbyAndForget

        public RedisAPI decrbyAndForget​(String arg0,
                                        String arg1)
        Variant of decrby(String,String) that ignores the result of the operation.

        This method subscribes on the result of decrby(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from decrby(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • del

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> del​(List<String> args)
        Redis command del.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • delAndAwait

        public Response delAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#del(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • delAndForget

        public RedisAPI delAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#del(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#del(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#del(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • discard

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> discard()
        Redis command discard.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • discardAndAwait

        public Response discardAndAwait()
        Blocking variant of discard().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • discardAndForget

        public RedisAPI discardAndForget()
        Variant of discard() that ignores the result of the operation.

        This method subscribes on the result of discard(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from discard() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • dump

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> dump​(String arg0)
        Redis command dump.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • dumpAndAwait

        public Response dumpAndAwait​(String arg0)
        Blocking variant of dump(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • dumpAndForget

        public RedisAPI dumpAndForget​(String arg0)
        Variant of dump(String) that ignores the result of the operation.

        This method subscribes on the result of dump(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from dump(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • echo

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> echo​(String arg0)
        Redis command echo.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • echoAndAwait

        public Response echoAndAwait​(String arg0)
        Blocking variant of echo(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • echoAndForget

        public RedisAPI echoAndForget​(String arg0)
        Variant of echo(String) that ignores the result of the operation.

        This method subscribes on the result of echo(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from echo(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • eval

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> eval​(List<String> args)
        Redis command eval.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • evalAndAwait

        public Response evalAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#eval(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • evalAndForget

        public RedisAPI evalAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#eval(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#eval(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#eval(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • evalsha

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> evalsha​(List<String> args)
        Redis command evalsha.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • evalshaAndAwait

        public Response evalshaAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#evalsha(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • evalshaAndForget

        public RedisAPI evalshaAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#evalsha(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#evalsha(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#evalsha(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • exec

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> exec()
        Redis command exec.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • execAndAwait

        public Response execAndAwait()
        Blocking variant of exec().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • execAndForget

        public RedisAPI execAndForget()
        Variant of exec() that ignores the result of the operation.

        This method subscribes on the result of exec(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from exec() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • exists

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> exists​(List<String> args)
        Redis command exists.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • existsAndAwait

        public Response existsAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#exists(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • existsAndForget

        public RedisAPI existsAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#exists(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#exists(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#exists(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • expire

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> expire​(String arg0,
                                                       String arg1)
        Redis command expire.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • expireAndAwait

        public Response expireAndAwait​(String arg0,
                                       String arg1)
        Blocking variant of expire(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • expireAndForget

        public RedisAPI expireAndForget​(String arg0,
                                        String arg1)
        Variant of expire(String,String) that ignores the result of the operation.

        This method subscribes on the result of expire(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from expire(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • expireat

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> expireat​(String arg0,
                                                         String arg1)
        Redis command expireat.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • expireatAndAwait

        public Response expireatAndAwait​(String arg0,
                                         String arg1)
        Blocking variant of expireat(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • expireatAndForget

        public RedisAPI expireatAndForget​(String arg0,
                                          String arg1)
        Variant of expireat(String,String) that ignores the result of the operation.

        This method subscribes on the result of expireat(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from expireat(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • failover

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> failover​(List<String> args)
        Redis command failover.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • failoverAndAwait

        public Response failoverAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#failover(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • failoverAndForget

        public RedisAPI failoverAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#failover(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#failover(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#failover(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • flushall

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> flushall​(List<String> args)
        Redis command flushall.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • flushallAndAwait

        public Response flushallAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#flushall(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • flushallAndForget

        public RedisAPI flushallAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#flushall(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#flushall(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#flushall(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • flushdb

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> flushdb​(List<String> args)
        Redis command flushdb.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • flushdbAndAwait

        public Response flushdbAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#flushdb(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • flushdbAndForget

        public RedisAPI flushdbAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#flushdb(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#flushdb(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#flushdb(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • geoadd

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> geoadd​(List<String> args)
        Redis command geoadd.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • geoaddAndAwait

        public Response geoaddAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#geoadd(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • geoaddAndForget

        public RedisAPI geoaddAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#geoadd(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#geoadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#geoadd(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • geodist

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> geodist​(List<String> args)
        Redis command geodist.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • geodistAndAwait

        public Response geodistAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#geodist(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • geodistAndForget

        public RedisAPI geodistAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#geodist(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#geodist(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#geodist(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • geohash

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> geohash​(List<String> args)
        Redis command geohash.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • geohashAndAwait

        public Response geohashAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#geohash(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • geohashAndForget

        public RedisAPI geohashAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#geohash(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#geohash(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#geohash(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • geopos

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> geopos​(List<String> args)
        Redis command geopos.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • geoposAndAwait

        public Response geoposAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#geopos(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • geoposAndForget

        public RedisAPI geoposAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#geopos(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#geopos(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#geopos(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • georadius

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> georadius​(List<String> args)
        Redis command georadius.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • georadiusAndAwait

        public Response georadiusAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#georadius(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • georadiusAndForget

        public RedisAPI georadiusAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#georadius(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#georadius(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#georadius(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • georadiusRo

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> georadiusRo​(List<String> args)
        Redis command georadiusRo.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • georadiusRoAndAwait

        public Response georadiusRoAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#georadiusRo(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • georadiusRoAndForget

        public RedisAPI georadiusRoAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#georadiusRo(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#georadiusRo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#georadiusRo(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • georadiusbymember

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> georadiusbymember​(List<String> args)
        Redis command georadiusbymember.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • georadiusbymemberAndAwait

        public Response georadiusbymemberAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#georadiusbymember(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • georadiusbymemberAndForget

        public RedisAPI georadiusbymemberAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#georadiusbymember(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#georadiusbymember(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#georadiusbymember(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • georadiusbymemberRo

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> georadiusbymemberRo​(List<String> args)
        Redis command georadiusbymemberRo.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • georadiusbymemberRoAndAwait

        public Response georadiusbymemberRoAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#georadiusbymemberRo(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • georadiusbymemberRoAndForget

        public RedisAPI georadiusbymemberRoAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#georadiusbymemberRo(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#georadiusbymemberRo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#georadiusbymemberRo(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • geosearch

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> geosearch​(List<String> args)
        Redis command geosearch.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • geosearchAndAwait

        public Response geosearchAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#geosearch(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • geosearchAndForget

        public RedisAPI geosearchAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#geosearch(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#geosearch(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#geosearch(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • geosearchstore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> geosearchstore​(List<String> args)
        Redis command geosearchstore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • geosearchstoreAndAwait

        public Response geosearchstoreAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#geosearchstore(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • geosearchstoreAndForget

        public RedisAPI geosearchstoreAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#geosearchstore(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#geosearchstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#geosearchstore(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • get

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> get​(String arg0)
        Redis command get.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • getAndAwait

        public Response getAndAwait​(String arg0)
        Blocking variant of get(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • getAndForget

        public RedisAPI getAndForget​(String arg0)
        Variant of get(String) that ignores the result of the operation.

        This method subscribes on the result of get(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from get(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • getbit

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> getbit​(String arg0,
                                                       String arg1)
        Redis command getbit.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • getbitAndAwait

        public Response getbitAndAwait​(String arg0,
                                       String arg1)
        Blocking variant of getbit(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • getbitAndForget

        public RedisAPI getbitAndForget​(String arg0,
                                        String arg1)
        Variant of getbit(String,String) that ignores the result of the operation.

        This method subscribes on the result of getbit(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getbit(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • getdel

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> getdel​(String arg0)
        Redis command getdel.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • getdelAndAwait

        public Response getdelAndAwait​(String arg0)
        Blocking variant of getdel(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • getdelAndForget

        public RedisAPI getdelAndForget​(String arg0)
        Variant of getdel(String) that ignores the result of the operation.

        This method subscribes on the result of getdel(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getdel(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • getex

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> getex​(List<String> args)
        Redis command getex.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • getexAndAwait

        public Response getexAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#getex(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • getexAndForget

        public RedisAPI getexAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#getex(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#getex(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#getex(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • getrange

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> getrange​(String arg0,
                                                         String arg1,
                                                         String arg2)
        Redis command getrange.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • getrangeAndAwait

        public Response getrangeAndAwait​(String arg0,
                                         String arg1,
                                         String arg2)
        Blocking variant of getrange(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • getset

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> getset​(String arg0,
                                                       String arg1)
        Redis command getset.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • getsetAndAwait

        public Response getsetAndAwait​(String arg0,
                                       String arg1)
        Blocking variant of getset(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • getsetAndForget

        public RedisAPI getsetAndForget​(String arg0,
                                        String arg1)
        Variant of getset(String,String) that ignores the result of the operation.

        This method subscribes on the result of getset(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getset(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hdel

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hdel​(List<String> args)
        Redis command hdel.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hdelAndAwait

        public Response hdelAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#hdel(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • hdelAndForget

        public RedisAPI hdelAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#hdel(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#hdel(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#hdel(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hello

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hello​(List<String> args)
        Redis command hello.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • helloAndAwait

        public Response helloAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#hello(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • helloAndForget

        public RedisAPI helloAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#hello(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#hello(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#hello(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hexists

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hexists​(String arg0,
                                                        String arg1)
        Redis command hexists.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hexistsAndAwait

        public Response hexistsAndAwait​(String arg0,
                                        String arg1)
        Blocking variant of hexists(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • hexistsAndForget

        public RedisAPI hexistsAndForget​(String arg0,
                                         String arg1)
        Variant of hexists(String,String) that ignores the result of the operation.

        This method subscribes on the result of hexists(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hexists(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hget

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hget​(String arg0,
                                                     String arg1)
        Redis command hget.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hgetAndAwait

        public Response hgetAndAwait​(String arg0,
                                     String arg1)
        Blocking variant of hget(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • hgetAndForget

        public RedisAPI hgetAndForget​(String arg0,
                                      String arg1)
        Variant of hget(String,String) that ignores the result of the operation.

        This method subscribes on the result of hget(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hget(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hgetall

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hgetall​(String arg0)
        Redis command hgetall.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hgetallAndAwait

        public Response hgetallAndAwait​(String arg0)
        Blocking variant of hgetall(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • hgetallAndForget

        public RedisAPI hgetallAndForget​(String arg0)
        Variant of hgetall(String) that ignores the result of the operation.

        This method subscribes on the result of hgetall(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hgetall(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hincrby

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hincrby​(String arg0,
                                                        String arg1,
                                                        String arg2)
        Redis command hincrby.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hincrbyAndAwait

        public Response hincrbyAndAwait​(String arg0,
                                        String arg1,
                                        String arg2)
        Blocking variant of hincrby(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • hincrbyfloat

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hincrbyfloat​(String arg0,
                                                             String arg1,
                                                             String arg2)
        Redis command hincrbyfloat.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hincrbyfloatAndAwait

        public Response hincrbyfloatAndAwait​(String arg0,
                                             String arg1,
                                             String arg2)
        Blocking variant of hincrbyfloat(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • hkeys

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hkeys​(String arg0)
        Redis command hkeys.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hkeysAndAwait

        public Response hkeysAndAwait​(String arg0)
        Blocking variant of hkeys(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • hkeysAndForget

        public RedisAPI hkeysAndForget​(String arg0)
        Variant of hkeys(String) that ignores the result of the operation.

        This method subscribes on the result of hkeys(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hkeys(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hlen

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hlen​(String arg0)
        Redis command hlen.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hlenAndAwait

        public Response hlenAndAwait​(String arg0)
        Blocking variant of hlen(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • hlenAndForget

        public RedisAPI hlenAndForget​(String arg0)
        Variant of hlen(String) that ignores the result of the operation.

        This method subscribes on the result of hlen(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hlen(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hmget

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hmget​(List<String> args)
        Redis command hmget.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hmgetAndAwait

        public Response hmgetAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#hmget(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • hmgetAndForget

        public RedisAPI hmgetAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#hmget(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#hmget(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#hmget(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hmset

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hmset​(List<String> args)
        Redis command hmset.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hmsetAndAwait

        public Response hmsetAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#hmset(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • hmsetAndForget

        public RedisAPI hmsetAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#hmset(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#hmset(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#hmset(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • host

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> host​(List<String> args)
        Redis command host.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hostAndAwait

        public Response hostAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#host(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • hostAndForget

        public RedisAPI hostAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#host(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#host(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#host(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hrandfield

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hrandfield​(List<String> args)
        Redis command hrandfield.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hrandfieldAndAwait

        public Response hrandfieldAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#hrandfield(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • hrandfieldAndForget

        public RedisAPI hrandfieldAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#hrandfield(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#hrandfield(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#hrandfield(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hscan

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hscan​(List<String> args)
        Redis command hscan.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hscanAndAwait

        public Response hscanAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#hscan(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • hscanAndForget

        public RedisAPI hscanAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#hscan(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#hscan(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#hscan(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hset

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hset​(List<String> args)
        Redis command hset.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hsetAndAwait

        public Response hsetAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#hset(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • hsetAndForget

        public RedisAPI hsetAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#hset(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#hset(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#hset(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hsetnx

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hsetnx​(String arg0,
                                                       String arg1,
                                                       String arg2)
        Redis command hsetnx.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hsetnxAndAwait

        public Response hsetnxAndAwait​(String arg0,
                                       String arg1,
                                       String arg2)
        Blocking variant of hsetnx(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • hstrlen

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hstrlen​(String arg0,
                                                        String arg1)
        Redis command hstrlen.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hstrlenAndAwait

        public Response hstrlenAndAwait​(String arg0,
                                        String arg1)
        Blocking variant of hstrlen(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • hstrlenAndForget

        public RedisAPI hstrlenAndForget​(String arg0,
                                         String arg1)
        Variant of hstrlen(String,String) that ignores the result of the operation.

        This method subscribes on the result of hstrlen(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hstrlen(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • hvals

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> hvals​(String arg0)
        Redis command hvals.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • hvalsAndAwait

        public Response hvalsAndAwait​(String arg0)
        Blocking variant of hvals(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • hvalsAndForget

        public RedisAPI hvalsAndForget​(String arg0)
        Variant of hvals(String) that ignores the result of the operation.

        This method subscribes on the result of hvals(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hvals(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • incr

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> incr​(String arg0)
        Redis command incr.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • incrAndAwait

        public Response incrAndAwait​(String arg0)
        Blocking variant of incr(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • incrAndForget

        public RedisAPI incrAndForget​(String arg0)
        Variant of incr(String) that ignores the result of the operation.

        This method subscribes on the result of incr(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from incr(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • incrby

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> incrby​(String arg0,
                                                       String arg1)
        Redis command incrby.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • incrbyAndAwait

        public Response incrbyAndAwait​(String arg0,
                                       String arg1)
        Blocking variant of incrby(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • incrbyAndForget

        public RedisAPI incrbyAndForget​(String arg0,
                                        String arg1)
        Variant of incrby(String,String) that ignores the result of the operation.

        This method subscribes on the result of incrby(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from incrby(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • incrbyfloat

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> incrbyfloat​(String arg0,
                                                            String arg1)
        Redis command incrbyfloat.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • incrbyfloatAndAwait

        public Response incrbyfloatAndAwait​(String arg0,
                                            String arg1)
        Blocking variant of incrbyfloat(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • incrbyfloatAndForget

        public RedisAPI incrbyfloatAndForget​(String arg0,
                                             String arg1)
        Variant of incrbyfloat(String,String) that ignores the result of the operation.

        This method subscribes on the result of incrbyfloat(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from incrbyfloat(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • info

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> info​(List<String> args)
        Redis command info.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • infoAndAwait

        public Response infoAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#info(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • infoAndForget

        public RedisAPI infoAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#info(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#info(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#info(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • keys

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> keys​(String arg0)
        Redis command keys.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • keysAndAwait

        public Response keysAndAwait​(String arg0)
        Blocking variant of keys(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • keysAndForget

        public RedisAPI keysAndForget​(String arg0)
        Variant of keys(String) that ignores the result of the operation.

        This method subscribes on the result of keys(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from keys(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • lastsave

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> lastsave()
        Redis command lastsave.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • lastsaveAndAwait

        public Response lastsaveAndAwait()
        Blocking variant of lastsave().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • lastsaveAndForget

        public RedisAPI lastsaveAndForget()
        Variant of lastsave() that ignores the result of the operation.

        This method subscribes on the result of lastsave(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lastsave() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • latency

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> latency​(List<String> args)
        Redis command latency.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • latencyAndAwait

        public Response latencyAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#latency(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • latencyAndForget

        public RedisAPI latencyAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#latency(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#latency(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#latency(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • lindex

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> lindex​(String arg0,
                                                       String arg1)
        Redis command lindex.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • lindexAndAwait

        public Response lindexAndAwait​(String arg0,
                                       String arg1)
        Blocking variant of lindex(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • lindexAndForget

        public RedisAPI lindexAndForget​(String arg0,
                                        String arg1)
        Variant of lindex(String,String) that ignores the result of the operation.

        This method subscribes on the result of lindex(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lindex(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • linsert

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> linsert​(String arg0,
                                                        String arg1,
                                                        String arg2,
                                                        String arg3)
        Redis command linsert.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        arg3 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • linsertAndAwait

        public Response linsertAndAwait​(String arg0,
                                        String arg1,
                                        String arg2,
                                        String arg3)
        Blocking variant of linsert(String,String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        arg3 -
        Returns:
        the Response instance produced by the operation.
      • llen

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> llen​(String arg0)
        Redis command llen.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • llenAndAwait

        public Response llenAndAwait​(String arg0)
        Blocking variant of llen(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • llenAndForget

        public RedisAPI llenAndForget​(String arg0)
        Variant of llen(String) that ignores the result of the operation.

        This method subscribes on the result of llen(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from llen(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • lmove

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> lmove​(String arg0,
                                                      String arg1,
                                                      String arg2,
                                                      String arg3)
        Redis command lmove.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        arg3 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • lmoveAndAwait

        public Response lmoveAndAwait​(String arg0,
                                      String arg1,
                                      String arg2,
                                      String arg3)
        Blocking variant of lmove(String,String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        arg3 -
        Returns:
        the Response instance produced by the operation.
      • lolwut

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> lolwut​(List<String> args)
        Redis command lolwut.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • lolwutAndAwait

        public Response lolwutAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#lolwut(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • lolwutAndForget

        public RedisAPI lolwutAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#lolwut(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#lolwut(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#lolwut(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • lpop

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> lpop​(List<String> args)
        Redis command lpop.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • lpopAndAwait

        public Response lpopAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#lpop(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • lpopAndForget

        public RedisAPI lpopAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#lpop(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#lpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#lpop(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • lpos

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> lpos​(List<String> args)
        Redis command lpos.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • lposAndAwait

        public Response lposAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#lpos(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • lposAndForget

        public RedisAPI lposAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#lpos(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#lpos(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#lpos(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • lpush

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> lpush​(List<String> args)
        Redis command lpush.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • lpushAndAwait

        public Response lpushAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#lpush(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • lpushAndForget

        public RedisAPI lpushAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#lpush(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#lpush(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#lpush(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • lpushx

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> lpushx​(List<String> args)
        Redis command lpushx.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • lpushxAndAwait

        public Response lpushxAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#lpushx(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • lpushxAndForget

        public RedisAPI lpushxAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#lpushx(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#lpushx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#lpushx(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • lrange

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> lrange​(String arg0,
                                                       String arg1,
                                                       String arg2)
        Redis command lrange.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • lrangeAndAwait

        public Response lrangeAndAwait​(String arg0,
                                       String arg1,
                                       String arg2)
        Blocking variant of lrange(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • lrem

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> lrem​(String arg0,
                                                     String arg1,
                                                     String arg2)
        Redis command lrem.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • lremAndAwait

        public Response lremAndAwait​(String arg0,
                                     String arg1,
                                     String arg2)
        Blocking variant of lrem(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • lremAndForget

        public RedisAPI lremAndForget​(String arg0,
                                      String arg1,
                                      String arg2)
        Variant of lrem(String,String,String) that ignores the result of the operation.

        This method subscribes on the result of lrem(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lrem(String,String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • lset

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> lset​(String arg0,
                                                     String arg1,
                                                     String arg2)
        Redis command lset.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • lsetAndAwait

        public Response lsetAndAwait​(String arg0,
                                     String arg1,
                                     String arg2)
        Blocking variant of lset(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • lsetAndForget

        public RedisAPI lsetAndForget​(String arg0,
                                      String arg1,
                                      String arg2)
        Variant of lset(String,String,String) that ignores the result of the operation.

        This method subscribes on the result of lset(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lset(String,String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • ltrim

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> ltrim​(String arg0,
                                                      String arg1,
                                                      String arg2)
        Redis command ltrim.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • ltrimAndAwait

        public Response ltrimAndAwait​(String arg0,
                                      String arg1,
                                      String arg2)
        Blocking variant of ltrim(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • memory

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> memory​(List<String> args)
        Redis command memory.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • memoryAndAwait

        public Response memoryAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#memory(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • memoryAndForget

        public RedisAPI memoryAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#memory(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#memory(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#memory(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • mget

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> mget​(List<String> args)
        Redis command mget.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • mgetAndAwait

        public Response mgetAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#mget(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • mgetAndForget

        public RedisAPI mgetAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#mget(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#mget(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#mget(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • migrate

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> migrate​(List<String> args)
        Redis command migrate.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • migrateAndAwait

        public Response migrateAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#migrate(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • migrateAndForget

        public RedisAPI migrateAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#migrate(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#migrate(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#migrate(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • module

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> module​(List<String> args)
        Redis command module.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • moduleAndAwait

        public Response moduleAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#module(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • moduleAndForget

        public RedisAPI moduleAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#module(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#module(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#module(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • monitor

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> monitor()
        Redis command monitor.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • monitorAndAwait

        public Response monitorAndAwait()
        Blocking variant of monitor().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • monitorAndForget

        public RedisAPI monitorAndForget()
        Variant of monitor() that ignores the result of the operation.

        This method subscribes on the result of monitor(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from monitor() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • move

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> move​(String arg0,
                                                     String arg1)
        Redis command move.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • moveAndAwait

        public Response moveAndAwait​(String arg0,
                                     String arg1)
        Blocking variant of move(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • moveAndForget

        public RedisAPI moveAndForget​(String arg0,
                                      String arg1)
        Variant of move(String,String) that ignores the result of the operation.

        This method subscribes on the result of move(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from move(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • mset

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> mset​(List<String> args)
        Redis command mset.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • msetAndAwait

        public Response msetAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#mset(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • msetAndForget

        public RedisAPI msetAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#mset(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#mset(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#mset(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • msetnx

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> msetnx​(List<String> args)
        Redis command msetnx.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • msetnxAndAwait

        public Response msetnxAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#msetnx(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • msetnxAndForget

        public RedisAPI msetnxAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#msetnx(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#msetnx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#msetnx(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • multi

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> multi()
        Redis command multi.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • multiAndAwait

        public Response multiAndAwait()
        Blocking variant of multi().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • multiAndForget

        public RedisAPI multiAndForget()
        Variant of multi() that ignores the result of the operation.

        This method subscribes on the result of multi(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from multi() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • object

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> object​(List<String> args)
        Redis command object.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • objectAndAwait

        public Response objectAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#object(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • objectAndForget

        public RedisAPI objectAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#object(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#object(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#object(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • persist

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> persist​(String arg0)
        Redis command persist.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • persistAndAwait

        public Response persistAndAwait​(String arg0)
        Blocking variant of persist(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • persistAndForget

        public RedisAPI persistAndForget​(String arg0)
        Variant of persist(String) that ignores the result of the operation.

        This method subscribes on the result of persist(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from persist(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • pexpire

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> pexpire​(String arg0,
                                                        String arg1)
        Redis command pexpire.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • pexpireAndAwait

        public Response pexpireAndAwait​(String arg0,
                                        String arg1)
        Blocking variant of pexpire(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • pexpireAndForget

        public RedisAPI pexpireAndForget​(String arg0,
                                         String arg1)
        Variant of pexpire(String,String) that ignores the result of the operation.

        This method subscribes on the result of pexpire(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from pexpire(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • pexpireat

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> pexpireat​(String arg0,
                                                          String arg1)
        Redis command pexpireat.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • pexpireatAndAwait

        public Response pexpireatAndAwait​(String arg0,
                                          String arg1)
        Blocking variant of pexpireat(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • pexpireatAndForget

        public RedisAPI pexpireatAndForget​(String arg0,
                                           String arg1)
        Variant of pexpireat(String,String) that ignores the result of the operation.

        This method subscribes on the result of pexpireat(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from pexpireat(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • pfadd

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> pfadd​(List<String> args)
        Redis command pfadd.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • pfaddAndAwait

        public Response pfaddAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#pfadd(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • pfaddAndForget

        public RedisAPI pfaddAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#pfadd(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#pfadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#pfadd(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • pfcount

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> pfcount​(List<String> args)
        Redis command pfcount.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • pfcountAndAwait

        public Response pfcountAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#pfcount(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • pfcountAndForget

        public RedisAPI pfcountAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#pfcount(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#pfcount(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#pfcount(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • pfdebug

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> pfdebug​(List<String> args)
        Redis command pfdebug.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • pfdebugAndAwait

        public Response pfdebugAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#pfdebug(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • pfdebugAndForget

        public RedisAPI pfdebugAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#pfdebug(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#pfdebug(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#pfdebug(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • pfmerge

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> pfmerge​(List<String> args)
        Redis command pfmerge.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • pfmergeAndAwait

        public Response pfmergeAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#pfmerge(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • pfmergeAndForget

        public RedisAPI pfmergeAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#pfmerge(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#pfmerge(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#pfmerge(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • pfselftest

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> pfselftest()
        Redis command pfselftest.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • pfselftestAndAwait

        public Response pfselftestAndAwait()
        Blocking variant of pfselftest().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • pfselftestAndForget

        public RedisAPI pfselftestAndForget()
        Variant of pfselftest() that ignores the result of the operation.

        This method subscribes on the result of pfselftest(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from pfselftest() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • ping

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> ping​(List<String> args)
        Redis command ping.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • pingAndAwait

        public Response pingAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#ping(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • pingAndForget

        public RedisAPI pingAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#ping(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#ping(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#ping(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • post

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> post​(List<String> args)
        Redis command post.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • postAndAwait

        public Response postAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#post(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • postAndForget

        public RedisAPI postAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#post(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#post(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#post(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • psetex

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> psetex​(String arg0,
                                                       String arg1,
                                                       String arg2)
        Redis command psetex.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • psetexAndAwait

        public Response psetexAndAwait​(String arg0,
                                       String arg1,
                                       String arg2)
        Blocking variant of psetex(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • psubscribe

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> psubscribe​(List<String> args)
        Redis command psubscribe.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • psubscribeAndAwait

        public Response psubscribeAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#psubscribe(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • psubscribeAndForget

        public RedisAPI psubscribeAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#psubscribe(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#psubscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#psubscribe(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • psync

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> psync​(List<String> args)
        Redis command psync.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • psyncAndAwait

        public Response psyncAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#psync(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • psyncAndForget

        public RedisAPI psyncAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#psync(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#psync(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#psync(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • pttl

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> pttl​(String arg0)
        Redis command pttl.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • pttlAndAwait

        public Response pttlAndAwait​(String arg0)
        Blocking variant of pttl(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • pttlAndForget

        public RedisAPI pttlAndForget​(String arg0)
        Variant of pttl(String) that ignores the result of the operation.

        This method subscribes on the result of pttl(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from pttl(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • publish

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> publish​(String arg0,
                                                        String arg1)
        Redis command publish.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • publishAndAwait

        public Response publishAndAwait​(String arg0,
                                        String arg1)
        Blocking variant of publish(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • publishAndForget

        public RedisAPI publishAndForget​(String arg0,
                                         String arg1)
        Variant of publish(String,String) that ignores the result of the operation.

        This method subscribes on the result of publish(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from publish(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • pubsub

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> pubsub​(List<String> args)
        Redis command pubsub.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • pubsubAndAwait

        public Response pubsubAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#pubsub(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • pubsubAndForget

        public RedisAPI pubsubAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#pubsub(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#pubsub(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#pubsub(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • punsubscribe

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> punsubscribe​(List<String> args)
        Redis command punsubscribe.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • punsubscribeAndAwait

        public Response punsubscribeAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#punsubscribe(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • punsubscribeAndForget

        public RedisAPI punsubscribeAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#punsubscribe(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#punsubscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#punsubscribe(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • randomkey

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> randomkey()
        Redis command randomkey.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • randomkeyAndAwait

        public Response randomkeyAndAwait()
        Blocking variant of randomkey().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • randomkeyAndForget

        public RedisAPI randomkeyAndForget()
        Variant of randomkey() that ignores the result of the operation.

        This method subscribes on the result of randomkey(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from randomkey() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • readonly

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> readonly()
        Redis command readonly.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • readonlyAndAwait

        public Response readonlyAndAwait()
        Blocking variant of readonly().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • readonlyAndForget

        public RedisAPI readonlyAndForget()
        Variant of readonly() that ignores the result of the operation.

        This method subscribes on the result of readonly(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from readonly() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • readwrite

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> readwrite()
        Redis command readwrite.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • readwriteAndAwait

        public Response readwriteAndAwait()
        Blocking variant of readwrite().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • readwriteAndForget

        public RedisAPI readwriteAndForget()
        Variant of readwrite() that ignores the result of the operation.

        This method subscribes on the result of readwrite(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from readwrite() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • rename

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> rename​(String arg0,
                                                       String arg1)
        Redis command rename.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • renameAndAwait

        public Response renameAndAwait​(String arg0,
                                       String arg1)
        Blocking variant of rename(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • renameAndForget

        public RedisAPI renameAndForget​(String arg0,
                                        String arg1)
        Variant of rename(String,String) that ignores the result of the operation.

        This method subscribes on the result of rename(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from rename(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • renamenx

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> renamenx​(String arg0,
                                                         String arg1)
        Redis command renamenx.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • renamenxAndAwait

        public Response renamenxAndAwait​(String arg0,
                                         String arg1)
        Blocking variant of renamenx(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • renamenxAndForget

        public RedisAPI renamenxAndForget​(String arg0,
                                          String arg1)
        Variant of renamenx(String,String) that ignores the result of the operation.

        This method subscribes on the result of renamenx(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from renamenx(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • replconf

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> replconf​(List<String> args)
        Redis command replconf.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • replconfAndAwait

        public Response replconfAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#replconf(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • replconfAndForget

        public RedisAPI replconfAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#replconf(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#replconf(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#replconf(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • replicaof

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> replicaof​(String arg0,
                                                          String arg1)
        Redis command replicaof.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • replicaofAndAwait

        public Response replicaofAndAwait​(String arg0,
                                          String arg1)
        Blocking variant of replicaof(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • replicaofAndForget

        public RedisAPI replicaofAndForget​(String arg0,
                                           String arg1)
        Variant of replicaof(String,String) that ignores the result of the operation.

        This method subscribes on the result of replicaof(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from replicaof(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • reset

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> reset()
        Redis command reset.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • resetAndAwait

        public Response resetAndAwait()
        Blocking variant of reset().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • resetAndForget

        public RedisAPI resetAndForget()
        Variant of reset() that ignores the result of the operation.

        This method subscribes on the result of reset(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from reset() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • restore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> restore​(List<String> args)
        Redis command restore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • restoreAndAwait

        public Response restoreAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#restore(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • restoreAndForget

        public RedisAPI restoreAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#restore(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#restore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#restore(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • restoreAsking

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> restoreAsking​(List<String> args)
        Redis command restoreAsking.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • restoreAskingAndAwait

        public Response restoreAskingAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#restoreAsking(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • restoreAskingAndForget

        public RedisAPI restoreAskingAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#restoreAsking(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#restoreAsking(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#restoreAsking(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • role

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> role()
        Redis command role.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • roleAndAwait

        public Response roleAndAwait()
        Blocking variant of role().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • roleAndForget

        public RedisAPI roleAndForget()
        Variant of role() that ignores the result of the operation.

        This method subscribes on the result of role(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from role() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • rpop

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> rpop​(List<String> args)
        Redis command rpop.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • rpopAndAwait

        public Response rpopAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#rpop(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • rpopAndForget

        public RedisAPI rpopAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#rpop(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#rpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#rpop(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • rpoplpush

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> rpoplpush​(String arg0,
                                                          String arg1)
        Redis command rpoplpush.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • rpoplpushAndAwait

        public Response rpoplpushAndAwait​(String arg0,
                                          String arg1)
        Blocking variant of rpoplpush(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • rpoplpushAndForget

        public RedisAPI rpoplpushAndForget​(String arg0,
                                           String arg1)
        Variant of rpoplpush(String,String) that ignores the result of the operation.

        This method subscribes on the result of rpoplpush(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from rpoplpush(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • rpush

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> rpush​(List<String> args)
        Redis command rpush.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • rpushAndAwait

        public Response rpushAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#rpush(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • rpushAndForget

        public RedisAPI rpushAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#rpush(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#rpush(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#rpush(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • rpushx

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> rpushx​(List<String> args)
        Redis command rpushx.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • rpushxAndAwait

        public Response rpushxAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#rpushx(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • rpushxAndForget

        public RedisAPI rpushxAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#rpushx(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#rpushx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#rpushx(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • sadd

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> sadd​(List<String> args)
        Redis command sadd.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • saddAndAwait

        public Response saddAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sadd(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • saddAndForget

        public RedisAPI saddAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#sadd(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sadd(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • save

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> save()
        Redis command save.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • saveAndAwait

        public Response saveAndAwait()
        Blocking variant of save().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • saveAndForget

        public RedisAPI saveAndForget()
        Variant of save() that ignores the result of the operation.

        This method subscribes on the result of save(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from save() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • scan

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> scan​(List<String> args)
        Redis command scan.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • scanAndAwait

        public Response scanAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#scan(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • scanAndForget

        public RedisAPI scanAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#scan(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#scan(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#scan(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • scard

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> scard​(String arg0)
        Redis command scard.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • scardAndAwait

        public Response scardAndAwait​(String arg0)
        Blocking variant of scard(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • scardAndForget

        public RedisAPI scardAndForget​(String arg0)
        Variant of scard(String) that ignores the result of the operation.

        This method subscribes on the result of scard(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from scard(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • script

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> script​(List<String> args)
        Redis command script.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • scriptAndAwait

        public Response scriptAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#script(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • scriptAndForget

        public RedisAPI scriptAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#script(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#script(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#script(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • sdiff

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> sdiff​(List<String> args)
        Redis command sdiff.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • sdiffAndAwait

        public Response sdiffAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sdiff(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • sdiffAndForget

        public RedisAPI sdiffAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#sdiff(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sdiff(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sdiff(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • sdiffstore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> sdiffstore​(List<String> args)
        Redis command sdiffstore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • sdiffstoreAndAwait

        public Response sdiffstoreAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sdiffstore(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • sdiffstoreAndForget

        public RedisAPI sdiffstoreAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#sdiffstore(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sdiffstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sdiffstore(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • select

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> select​(String arg0)
        Redis command select.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • selectAndAwait

        public Response selectAndAwait​(String arg0)
        Blocking variant of select(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • selectAndForget

        public RedisAPI selectAndForget​(String arg0)
        Variant of select(String) that ignores the result of the operation.

        This method subscribes on the result of select(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from select(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • set

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> set​(List<String> args)
        Redis command set.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • setAndAwait

        public Response setAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#set(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • setAndForget

        public RedisAPI setAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#set(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#set(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#set(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • setbit

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> setbit​(String arg0,
                                                       String arg1,
                                                       String arg2)
        Redis command setbit.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • setbitAndAwait

        public Response setbitAndAwait​(String arg0,
                                       String arg1,
                                       String arg2)
        Blocking variant of setbit(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • setex

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> setex​(String arg0,
                                                      String arg1,
                                                      String arg2)
        Redis command setex.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • setexAndAwait

        public Response setexAndAwait​(String arg0,
                                      String arg1,
                                      String arg2)
        Blocking variant of setex(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • setnx

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> setnx​(String arg0,
                                                      String arg1)
        Redis command setnx.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • setnxAndAwait

        public Response setnxAndAwait​(String arg0,
                                      String arg1)
        Blocking variant of setnx(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • setnxAndForget

        public RedisAPI setnxAndForget​(String arg0,
                                       String arg1)
        Variant of setnx(String,String) that ignores the result of the operation.

        This method subscribes on the result of setnx(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from setnx(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • setrange

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> setrange​(String arg0,
                                                         String arg1,
                                                         String arg2)
        Redis command setrange.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • setrangeAndAwait

        public Response setrangeAndAwait​(String arg0,
                                         String arg1,
                                         String arg2)
        Blocking variant of setrange(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • shutdown

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> shutdown​(List<String> args)
        Redis command shutdown.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • shutdownAndAwait

        public Response shutdownAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#shutdown(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • shutdownAndForget

        public RedisAPI shutdownAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#shutdown(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#shutdown(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#shutdown(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • sinter

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> sinter​(List<String> args)
        Redis command sinter.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • sinterAndAwait

        public Response sinterAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sinter(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • sinterAndForget

        public RedisAPI sinterAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#sinter(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sinter(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sinter(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • sinterstore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> sinterstore​(List<String> args)
        Redis command sinterstore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • sinterstoreAndAwait

        public Response sinterstoreAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sinterstore(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • sinterstoreAndForget

        public RedisAPI sinterstoreAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#sinterstore(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sinterstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sinterstore(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • sismember

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> sismember​(String arg0,
                                                          String arg1)
        Redis command sismember.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • sismemberAndAwait

        public Response sismemberAndAwait​(String arg0,
                                          String arg1)
        Blocking variant of sismember(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • sismemberAndForget

        public RedisAPI sismemberAndForget​(String arg0,
                                           String arg1)
        Variant of sismember(String,String) that ignores the result of the operation.

        This method subscribes on the result of sismember(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from sismember(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • slaveof

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> slaveof​(String arg0,
                                                        String arg1)
        Redis command slaveof.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • slaveofAndAwait

        public Response slaveofAndAwait​(String arg0,
                                        String arg1)
        Blocking variant of slaveof(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • slaveofAndForget

        public RedisAPI slaveofAndForget​(String arg0,
                                         String arg1)
        Variant of slaveof(String,String) that ignores the result of the operation.

        This method subscribes on the result of slaveof(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from slaveof(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • slowlog

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> slowlog​(List<String> args)
        Redis command slowlog.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • slowlogAndAwait

        public Response slowlogAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#slowlog(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • slowlogAndForget

        public RedisAPI slowlogAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#slowlog(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#slowlog(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#slowlog(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • smembers

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> smembers​(String arg0)
        Redis command smembers.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • smembersAndAwait

        public Response smembersAndAwait​(String arg0)
        Blocking variant of smembers(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • smembersAndForget

        public RedisAPI smembersAndForget​(String arg0)
        Variant of smembers(String) that ignores the result of the operation.

        This method subscribes on the result of smembers(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from smembers(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • smismember

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> smismember​(List<String> args)
        Redis command smismember.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • smismemberAndAwait

        public Response smismemberAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#smismember(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • smismemberAndForget

        public RedisAPI smismemberAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#smismember(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#smismember(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#smismember(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • smove

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> smove​(String arg0,
                                                      String arg1,
                                                      String arg2)
        Redis command smove.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • smoveAndAwait

        public Response smoveAndAwait​(String arg0,
                                      String arg1,
                                      String arg2)
        Blocking variant of smove(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • sort

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> sort​(List<String> args)
        Redis command sort.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • sortAndAwait

        public Response sortAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sort(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • sortAndForget

        public RedisAPI sortAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#sort(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sort(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sort(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • spop

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> spop​(List<String> args)
        Redis command spop.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • spopAndAwait

        public Response spopAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#spop(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • spopAndForget

        public RedisAPI spopAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#spop(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#spop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#spop(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • srandmember

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> srandmember​(List<String> args)
        Redis command srandmember.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • srandmemberAndAwait

        public Response srandmemberAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#srandmember(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • srandmemberAndForget

        public RedisAPI srandmemberAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#srandmember(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#srandmember(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#srandmember(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • srem

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> srem​(List<String> args)
        Redis command srem.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • sremAndAwait

        public Response sremAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#srem(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • sremAndForget

        public RedisAPI sremAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#srem(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#srem(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#srem(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • sscan

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> sscan​(List<String> args)
        Redis command sscan.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • sscanAndAwait

        public Response sscanAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sscan(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • sscanAndForget

        public RedisAPI sscanAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#sscan(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sscan(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sscan(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • stralgo

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> stralgo​(List<String> args)
        Redis command stralgo.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • stralgoAndAwait

        public Response stralgoAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#stralgo(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • stralgoAndForget

        public RedisAPI stralgoAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#stralgo(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#stralgo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#stralgo(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • strlen

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> strlen​(String arg0)
        Redis command strlen.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • strlenAndAwait

        public Response strlenAndAwait​(String arg0)
        Blocking variant of strlen(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • strlenAndForget

        public RedisAPI strlenAndForget​(String arg0)
        Variant of strlen(String) that ignores the result of the operation.

        This method subscribes on the result of strlen(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from strlen(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • subscribe

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> subscribe​(List<String> args)
        Redis command subscribe.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • subscribeAndAwait

        public Response subscribeAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#subscribe(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • subscribeAndForget

        public RedisAPI subscribeAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#subscribe(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#subscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#subscribe(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • substr

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> substr​(String arg0,
                                                       String arg1,
                                                       String arg2)
        Redis command substr.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • substrAndAwait

        public Response substrAndAwait​(String arg0,
                                       String arg1,
                                       String arg2)
        Blocking variant of substr(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • sunion

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> sunion​(List<String> args)
        Redis command sunion.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • sunionAndAwait

        public Response sunionAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sunion(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • sunionAndForget

        public RedisAPI sunionAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#sunion(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sunion(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sunion(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • sunionstore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> sunionstore​(List<String> args)
        Redis command sunionstore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • sunionstoreAndAwait

        public Response sunionstoreAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sunionstore(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • sunionstoreAndForget

        public RedisAPI sunionstoreAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#sunionstore(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sunionstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sunionstore(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • swapdb

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> swapdb​(String arg0,
                                                       String arg1)
        Redis command swapdb.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • swapdbAndAwait

        public Response swapdbAndAwait​(String arg0,
                                       String arg1)
        Blocking variant of swapdb(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • swapdbAndForget

        public RedisAPI swapdbAndForget​(String arg0,
                                        String arg1)
        Variant of swapdb(String,String) that ignores the result of the operation.

        This method subscribes on the result of swapdb(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from swapdb(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • sync

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> sync()
        Redis command sync.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • syncAndAwait

        public Response syncAndAwait()
        Blocking variant of sync().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • syncAndForget

        public RedisAPI syncAndForget()
        Variant of sync() that ignores the result of the operation.

        This method subscribes on the result of sync(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from sync() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • time

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> time()
        Redis command time.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • timeAndAwait

        public Response timeAndAwait()
        Blocking variant of time().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • timeAndForget

        public RedisAPI timeAndForget()
        Variant of time() that ignores the result of the operation.

        This method subscribes on the result of time(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from time() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • touch

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> touch​(List<String> args)
        Redis command touch.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • touchAndAwait

        public Response touchAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#touch(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • touchAndForget

        public RedisAPI touchAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#touch(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#touch(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#touch(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • ttl

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> ttl​(String arg0)
        Redis command ttl.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • ttlAndAwait

        public Response ttlAndAwait​(String arg0)
        Blocking variant of ttl(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • ttlAndForget

        public RedisAPI ttlAndForget​(String arg0)
        Variant of ttl(String) that ignores the result of the operation.

        This method subscribes on the result of ttl(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ttl(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • type

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> type​(String arg0)
        Redis command type.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • typeAndAwait

        public Response typeAndAwait​(String arg0)
        Blocking variant of type(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • typeAndForget

        public RedisAPI typeAndForget​(String arg0)
        Variant of type(String) that ignores the result of the operation.

        This method subscribes on the result of type(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from type(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • unlink

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> unlink​(List<String> args)
        Redis command unlink.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • unlinkAndAwait

        public Response unlinkAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#unlink(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • unlinkAndForget

        public RedisAPI unlinkAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#unlink(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#unlink(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#unlink(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • unsubscribe

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> unsubscribe​(List<String> args)
        Redis command unsubscribe.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • unsubscribeAndAwait

        public Response unsubscribeAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#unsubscribe(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • unsubscribeAndForget

        public RedisAPI unsubscribeAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#unsubscribe(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#unsubscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#unsubscribe(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • unwatch

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> unwatch()
        Redis command unwatch.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • unwatchAndAwait

        public Response unwatchAndAwait()
        Blocking variant of unwatch().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Response instance produced by the operation.
      • unwatchAndForget

        public RedisAPI unwatchAndForget()
        Variant of unwatch() that ignores the result of the operation.

        This method subscribes on the result of unwatch(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from unwatch() but you don't need to compose it with other operations.

        Returns:
        the instance of RedisAPI to chain method calls.
      • wait

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> wait​(String arg0,
                                                     String arg1)
        Redis command wait.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • waitAndAwait

        public Response waitAndAwait​(String arg0,
                                     String arg1)
        Blocking variant of wait(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • waitAndForget

        public RedisAPI waitAndForget​(String arg0,
                                      String arg1)
        Variant of wait(String,String) that ignores the result of the operation.

        This method subscribes on the result of wait(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from wait(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • watch

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> watch​(List<String> args)
        Redis command watch.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • watchAndAwait

        public Response watchAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#watch(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • watchAndForget

        public RedisAPI watchAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#watch(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#watch(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#watch(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xack

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xack​(List<String> args)
        Redis command xack.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xackAndAwait

        public Response xackAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xack(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • xackAndForget

        public RedisAPI xackAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#xack(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xack(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xack(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xadd

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xadd​(List<String> args)
        Redis command xadd.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xaddAndAwait

        public Response xaddAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xadd(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • xaddAndForget

        public RedisAPI xaddAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#xadd(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xadd(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xautoclaim

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xautoclaim​(List<String> args)
        Redis command xautoclaim.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xautoclaimAndAwait

        public Response xautoclaimAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xautoclaim(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • xautoclaimAndForget

        public RedisAPI xautoclaimAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#xautoclaim(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xautoclaim(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xautoclaim(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xclaim

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xclaim​(List<String> args)
        Redis command xclaim.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xclaimAndAwait

        public Response xclaimAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xclaim(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • xclaimAndForget

        public RedisAPI xclaimAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#xclaim(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xclaim(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xclaim(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xdel

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xdel​(List<String> args)
        Redis command xdel.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xdelAndAwait

        public Response xdelAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xdel(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • xdelAndForget

        public RedisAPI xdelAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#xdel(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xdel(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xdel(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xgroup

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xgroup​(List<String> args)
        Redis command xgroup.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xgroupAndAwait

        public Response xgroupAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xgroup(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • xgroupAndForget

        public RedisAPI xgroupAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#xgroup(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xgroup(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xgroup(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xinfo

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xinfo​(List<String> args)
        Redis command xinfo.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xinfoAndAwait

        public Response xinfoAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xinfo(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • xinfoAndForget

        public RedisAPI xinfoAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#xinfo(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xinfo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xinfo(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xlen

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xlen​(String arg0)
        Redis command xlen.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xlenAndAwait

        public Response xlenAndAwait​(String arg0)
        Blocking variant of xlen(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • xlenAndForget

        public RedisAPI xlenAndForget​(String arg0)
        Variant of xlen(String) that ignores the result of the operation.

        This method subscribes on the result of xlen(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from xlen(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xpending

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xpending​(List<String> args)
        Redis command xpending.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xpendingAndAwait

        public Response xpendingAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xpending(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • xpendingAndForget

        public RedisAPI xpendingAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#xpending(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xpending(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xpending(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xrange

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xrange​(List<String> args)
        Redis command xrange.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xrangeAndAwait

        public Response xrangeAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xrange(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • xrangeAndForget

        public RedisAPI xrangeAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#xrange(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xrange(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xread

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xread​(List<String> args)
        Redis command xread.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xreadAndAwait

        public Response xreadAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xread(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • xreadAndForget

        public RedisAPI xreadAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#xread(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xread(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xread(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xreadgroup

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xreadgroup​(List<String> args)
        Redis command xreadgroup.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xreadgroupAndAwait

        public Response xreadgroupAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xreadgroup(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • xreadgroupAndForget

        public RedisAPI xreadgroupAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#xreadgroup(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xreadgroup(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xreadgroup(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xrevrange

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xrevrange​(List<String> args)
        Redis command xrevrange.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xrevrangeAndAwait

        public Response xrevrangeAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xrevrange(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • xrevrangeAndForget

        public RedisAPI xrevrangeAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#xrevrange(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xrevrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xrevrange(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xsetid

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xsetid​(String arg0,
                                                       String arg1)
        Redis command xsetid.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xsetidAndAwait

        public Response xsetidAndAwait​(String arg0,
                                       String arg1)
        Blocking variant of xsetid(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • xsetidAndForget

        public RedisAPI xsetidAndForget​(String arg0,
                                        String arg1)
        Variant of xsetid(String,String) that ignores the result of the operation.

        This method subscribes on the result of xsetid(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from xsetid(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • xtrim

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> xtrim​(List<String> args)
        Redis command xtrim.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • xtrimAndAwait

        public Response xtrimAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xtrim(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • xtrimAndForget

        public RedisAPI xtrimAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#xtrim(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xtrim(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xtrim(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zadd

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zadd​(List<String> args)
        Redis command zadd.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zaddAndAwait

        public Response zaddAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zadd(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zaddAndForget

        public RedisAPI zaddAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zadd(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zadd(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zcard

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zcard​(String arg0)
        Redis command zcard.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zcardAndAwait

        public Response zcardAndAwait​(String arg0)
        Blocking variant of zcard(String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        Returns:
        the Response instance produced by the operation.
      • zcardAndForget

        public RedisAPI zcardAndForget​(String arg0)
        Variant of zcard(String) that ignores the result of the operation.

        This method subscribes on the result of zcard(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zcard(String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zcount

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zcount​(String arg0,
                                                       String arg1,
                                                       String arg2)
        Redis command zcount.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zcountAndAwait

        public Response zcountAndAwait​(String arg0,
                                       String arg1,
                                       String arg2)
        Blocking variant of zcount(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • zdiff

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zdiff​(List<String> args)
        Redis command zdiff.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zdiffAndAwait

        public Response zdiffAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zdiff(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zdiffAndForget

        public RedisAPI zdiffAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zdiff(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zdiff(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zdiff(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zdiffstore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zdiffstore​(List<String> args)
        Redis command zdiffstore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zdiffstoreAndAwait

        public Response zdiffstoreAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zdiffstore(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zdiffstoreAndForget

        public RedisAPI zdiffstoreAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zdiffstore(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zdiffstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zdiffstore(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zincrby

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zincrby​(String arg0,
                                                        String arg1,
                                                        String arg2)
        Redis command zincrby.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zincrbyAndAwait

        public Response zincrbyAndAwait​(String arg0,
                                        String arg1,
                                        String arg2)
        Blocking variant of zincrby(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • zinter

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zinter​(List<String> args)
        Redis command zinter.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zinterAndAwait

        public Response zinterAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zinter(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zinterAndForget

        public RedisAPI zinterAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zinter(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zinter(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zinter(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zinterstore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zinterstore​(List<String> args)
        Redis command zinterstore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zinterstoreAndAwait

        public Response zinterstoreAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zinterstore(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zinterstoreAndForget

        public RedisAPI zinterstoreAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zinterstore(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zinterstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zinterstore(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zlexcount

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zlexcount​(String arg0,
                                                          String arg1,
                                                          String arg2)
        Redis command zlexcount.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zlexcountAndAwait

        public Response zlexcountAndAwait​(String arg0,
                                          String arg1,
                                          String arg2)
        Blocking variant of zlexcount(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • zmscore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zmscore​(List<String> args)
        Redis command zmscore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zmscoreAndAwait

        public Response zmscoreAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zmscore(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zmscoreAndForget

        public RedisAPI zmscoreAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zmscore(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zmscore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zmscore(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zpopmax

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zpopmax​(List<String> args)
        Redis command zpopmax.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zpopmaxAndAwait

        public Response zpopmaxAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zpopmax(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zpopmaxAndForget

        public RedisAPI zpopmaxAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zpopmax(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zpopmax(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zpopmax(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zpopmin

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zpopmin​(List<String> args)
        Redis command zpopmin.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zpopminAndAwait

        public Response zpopminAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zpopmin(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zpopminAndForget

        public RedisAPI zpopminAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zpopmin(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zpopmin(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zpopmin(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zrandmember

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zrandmember​(List<String> args)
        Redis command zrandmember.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zrandmemberAndAwait

        public Response zrandmemberAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrandmember(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zrandmemberAndForget

        public RedisAPI zrandmemberAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zrandmember(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrandmember(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrandmember(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zrange

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zrange​(List<String> args)
        Redis command zrange.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zrangeAndAwait

        public Response zrangeAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrange(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zrangeAndForget

        public RedisAPI zrangeAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zrange(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrange(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zrangebylex

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zrangebylex​(List<String> args)
        Redis command zrangebylex.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zrangebylexAndAwait

        public Response zrangebylexAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrangebylex(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zrangebylexAndForget

        public RedisAPI zrangebylexAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zrangebylex(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrangebylex(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrangebylex(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zrangebyscore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zrangebyscore​(List<String> args)
        Redis command zrangebyscore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zrangebyscoreAndAwait

        public Response zrangebyscoreAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrangebyscore(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zrangebyscoreAndForget

        public RedisAPI zrangebyscoreAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zrangebyscore(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrangebyscore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrangebyscore(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zrangestore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zrangestore​(List<String> args)
        Redis command zrangestore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zrangestoreAndAwait

        public Response zrangestoreAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrangestore(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zrangestoreAndForget

        public RedisAPI zrangestoreAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zrangestore(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrangestore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrangestore(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zrank

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zrank​(String arg0,
                                                      String arg1)
        Redis command zrank.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zrankAndAwait

        public Response zrankAndAwait​(String arg0,
                                      String arg1)
        Blocking variant of zrank(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • zrankAndForget

        public RedisAPI zrankAndForget​(String arg0,
                                       String arg1)
        Variant of zrank(String,String) that ignores the result of the operation.

        This method subscribes on the result of zrank(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zrank(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zrem

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zrem​(List<String> args)
        Redis command zrem.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zremAndAwait

        public Response zremAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrem(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zremAndForget

        public RedisAPI zremAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zrem(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrem(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrem(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zremrangebylex

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zremrangebylex​(String arg0,
                                                               String arg1,
                                                               String arg2)
        Redis command zremrangebylex.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zremrangebylexAndAwait

        public Response zremrangebylexAndAwait​(String arg0,
                                               String arg1,
                                               String arg2)
        Blocking variant of zremrangebylex(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • zremrangebyrank

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zremrangebyrank​(String arg0,
                                                                String arg1,
                                                                String arg2)
        Redis command zremrangebyrank.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zremrangebyrankAndAwait

        public Response zremrangebyrankAndAwait​(String arg0,
                                                String arg1,
                                                String arg2)
        Blocking variant of zremrangebyrank(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • zremrangebyscore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zremrangebyscore​(String arg0,
                                                                 String arg1,
                                                                 String arg2)
        Redis command zremrangebyscore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zremrangebyscoreAndAwait

        public Response zremrangebyscoreAndAwait​(String arg0,
                                                 String arg1,
                                                 String arg2)
        Blocking variant of zremrangebyscore(String,String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        arg2 -
        Returns:
        the Response instance produced by the operation.
      • zrevrange

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zrevrange​(List<String> args)
        Redis command zrevrange.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zrevrangeAndAwait

        public Response zrevrangeAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrevrange(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zrevrangeAndForget

        public RedisAPI zrevrangeAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zrevrange(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrevrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrevrange(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zrevrangebylex

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zrevrangebylex​(List<String> args)
        Redis command zrevrangebylex.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zrevrangebylexAndAwait

        public Response zrevrangebylexAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrevrangebylex(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zrevrangebylexAndForget

        public RedisAPI zrevrangebylexAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zrevrangebylex(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrevrangebylex(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrevrangebylex(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zrevrangebyscore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zrevrangebyscore​(List<String> args)
        Redis command zrevrangebyscore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zrevrangebyscoreAndAwait

        public Response zrevrangebyscoreAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrevrangebyscore(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zrevrangebyscoreAndForget

        public RedisAPI zrevrangebyscoreAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zrevrangebyscore(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrevrangebyscore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrevrangebyscore(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zrevrank

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zrevrank​(String arg0,
                                                         String arg1)
        Redis command zrevrank.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zrevrankAndAwait

        public Response zrevrankAndAwait​(String arg0,
                                         String arg1)
        Blocking variant of zrevrank(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • zrevrankAndForget

        public RedisAPI zrevrankAndForget​(String arg0,
                                          String arg1)
        Variant of zrevrank(String,String) that ignores the result of the operation.

        This method subscribes on the result of zrevrank(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zrevrank(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zscan

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zscan​(List<String> args)
        Redis command zscan.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zscanAndAwait

        public Response zscanAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zscan(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zscanAndForget

        public RedisAPI zscanAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zscan(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zscan(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zscan(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zscore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zscore​(String arg0,
                                                       String arg1)
        Redis command zscore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zscoreAndAwait

        public Response zscoreAndAwait​(String arg0,
                                       String arg1)
        Blocking variant of zscore(String,String).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the Response instance produced by the operation.
      • zscoreAndForget

        public RedisAPI zscoreAndForget​(String arg0,
                                        String arg1)
        Variant of zscore(String,String) that ignores the result of the operation.

        This method subscribes on the result of zscore(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zscore(String,String) but you don't need to compose it with other operations.

        Parameters:
        arg0 -
        arg1 -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zunion

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zunion​(List<String> args)
        Redis command zunion.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zunionAndAwait

        public Response zunionAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zunion(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zunionAndForget

        public RedisAPI zunionAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zunion(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zunion(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zunion(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • zunionstore

        @CheckReturnValue
        public io.smallrye.mutiny.Uni<Response> zunionstore​(List<String> args)
        Redis command zunionstore.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        args -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.
      • zunionstoreAndAwait

        public Response zunionstoreAndAwait​(List<String> args)
        Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zunionstore(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        args -
        Returns:
        the Response instance produced by the operation.
      • zunionstoreAndForget

        public RedisAPI zunionstoreAndForget​(List<String> args)
        Variant of io.vertx.mutiny.redis.client.RedisAPI#zunionstore(List) that ignores the result of the operation.

        This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zunionstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zunionstore(List) but you don't need to compose it with other operations.

        Parameters:
        args -
        Returns:
        the instance of RedisAPI to chain method calls.
      • newInstance

        public static RedisAPI newInstance​(io.vertx.redis.client.RedisAPI arg)