vertx-lang-scala-docs_2.12 3.8.0 API < Back
 

# Packages

-  package root
  Definition Classes
    root
-  package io
  Definition Classes
    root
-  package vertx
  Definition Classes
    io
-  package scala
  Definition Classes
    vertx
-  package redis
  Definition Classes
    scala
-  package client
  Definition Classes
    redis
- Command
- Redis
- RedisAPI
- RedisOptions
- Request
- Response

c

io.vertx.scala.redis.client

# Redis 

###
Companion object Redis

#### class Redis extends ReadStream[Response]

A simple Redis client.

Linear Supertypes
ReadStream[Response], StreamBase, AnyRef, Any
 
Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. Redis
2. ReadStream
3. StreamBase
4. AnyRef
5. Any

1. Hide All
2. Show All

Visibility

1. Public
2. All

### Instance Constructors

1.  new Redis(_asJava: AnyRef)

### Value Members

1.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
2.  final def ##(): Int
   Definition Classes
     AnyRef → Any
3.  final def ==(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
4.  final def asInstanceOf[T0]: T0
   Definition Classes
     Any
5.  def asJava: AnyRef
   Definition Classes
     Redis → ReadStream → StreamBase
6.  def batch(commands: Buffer[Request], handler: Handler[AsyncResult[Buffer[Option[Response]]]]): Redis
7.  def batchFuture(commands: Buffer[Request]): Future[Buffer[Option[Response]]]
8.  def clone(): AnyRef
   Attributes
     protected[java.lang]
   Definition Classes
     AnyRef
   Annotations
     @native() @throws( ... )
9.  def close(): Unit
10.  def connect(handler: Handler[AsyncResult[Redis]]): Redis

    Connects to the redis server.

    Connects to the redis server. * @param handler the async result handler

    returns

      a reference to this, so the API can be used fluently

11.  def connectFuture(): Future[Redis]

    Like connect but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

12.  def endHandler(endHandler: Handler[Unit]): Redis

    Set an end handler.

    Set an end handler. Once the stream has ended, and there is no more data to be read, this handler will be called. * @return a reference to this, so the API can be used fluently

    Definition Classes
      Redis → ReadStream
13.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
14.  def equals(arg0: Any): Boolean
    Definition Classes
      AnyRef → Any
15.  def exceptionHandler(handler: Handler[Throwable]): Redis

    Set an exception handler on the read stream.

    Set an exception handler on the read stream. * @param handler the exception handler

    returns

      a reference to this, so the API can be used fluently

    Definition Classes
      Redis → ReadStream → StreamBase
16.  def fetch(amount: Long): Redis

    Fetch the specified `amount` of elements.

    Fetch the specified `amount` of elements. If the `ReadStream` has been paused, reading will recommence with the specified `amount` of items, otherwise the specified `amount` will be added to the current stream demand. * @return a reference to this, so the API can be used fluently

    Definition Classes
      Redis → ReadStream
17.  def finalize(): Unit
    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )
18.  final def getClass(): Class[_]
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
19.  def handler(handler: Handler[Response]): Redis

    Set a data handler.

    Set a data handler. As data is read, the handler will be called with the data. * @return a reference to this, so the API can be used fluently

    Definition Classes
      Redis → ReadStream
20.  def hashCode(): Int
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
21.  final def isInstanceOf[T0]: Boolean
    Definition Classes
      Any
22.  final def ne(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
23.  final def notify(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
24.  final def notifyAll(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
25.  def pause(): Redis

    Pause the `ReadStream`, it sets the buffer in `fetch` mode and clears the actual demand.

    Pause the `ReadStream`, it sets the buffer in `fetch` mode and clears the actual demand.

    While it's paused, no data will be sent to the data `handler`. * @return a reference to this, so the API can be used fluently

    Definition Classes
      Redis → ReadStream
26.  def pipe(): Pipe[Response]

    Pause this stream and return a io.vertx.scala.core.streams.Pipe to transfer the elements of this stream to a destination io.vertx.scala.core.streams.WriteStream.

    Pause this stream and return a io.vertx.scala.core.streams.Pipe to transfer the elements of this stream to a destination io.vertx.scala.core.streams.WriteStream.

    The stream will be resumed when the pipe will be wired to a `WriteStream`. * @return a pipe

    Definition Classes
      Redis → ReadStream
27.  def pipeTo(dst: WriteStream[Response], handler: Handler[AsyncResult[Unit]]): Unit

    Pipe this `ReadStream` to the `WriteStream`.

    Pipe this `ReadStream` to the `WriteStream`.

    Elements emitted by this stream will be written to the write stream until this stream ends or fails.

    Once this stream has ended or failed, the write stream will be ended and the `handler` will be called with the result. * @param dst the destination write stream

    Definition Classes
      Redis → ReadStream
28.  def pipeTo(dst: WriteStream[Response]): Unit

    Like io.vertx.scala.core.streams.ReadStream#pipeTo but with no completion handler.

    Like io.vertx.scala.core.streams.ReadStream#pipeTo but with no completion handler.

    Definition Classes
      Redis → ReadStream
29.  def pipeToFuture(dst: WriteStream[Response]): Future[Unit]

    Like pipeTo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

    Like pipeTo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

    Definition Classes
      Redis → ReadStream
30.  def resume(): Redis

    Resume reading, and sets the buffer in `flowing` mode.

    Resume reading, and sets the buffer in `flowing` mode.

    If the `ReadStream` has been paused, reading will recommence on it. * @return a reference to this, so the API can be used fluently

    Definition Classes
      Redis → ReadStream
31.  def send(command: Request, onSend: Handler[AsyncResult[Option[Response]]]): Redis
32.  def sendFuture(command: Request): Future[Option[Response]]
33.  def socketAddress(): SocketAddress

    Returns the address associated with this client.

    Returns the address associated with this client. * @return the address.

34.  final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
      AnyRef
35.  def toString(): String
    Definition Classes
      AnyRef → Any
36.  final def wait(): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
37.  final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
38.  final def wait(arg0: Long): Unit
    Definition Classes
      AnyRef
    Annotations
      @native() @throws( ... )

### Inherited from ReadStream[Response]

### Inherited from StreamBase

### Inherited from AnyRef

### Inherited from Any

### Ungrouped