io.vertx.rxjava.ext.web.handler.sockjs

## Class BridgeEvent

- java.lang.Object
- - io.vertx.rxjava.core.Future<Boolean>
  - - io.vertx.rxjava.ext.web.handler.sockjs.BridgeEvent

-     public class BridgeEvent
      extends Future<Boolean>

  Represents an event that occurs on the event bus bridge.

  Please consult the documentation for a full explanation.

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

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `BridgeEvent(BridgeEvent delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `complete(Boolean arg0)` Set the result.
    `Handler<AsyncResult<Boolean>>` | `completer()`
    `<U> Future<U>` | `compose(java.util.function.Function<Boolean,Future<U>> mapper)` Compose this future with a `mapper` function.
    `<U> Future<U>` | `compose(Handler<Boolean> handler, Future<U> next)` Compose this future with a provided `next` future.
    `Object` | `getDelegate()`
    `JsonObject` | `getRawMessage()` Get the raw JSON message for the event.
    `<U> Future<U>` | `map(java.util.function.Function<Boolean,U> mapper)` Apply a `mapper` function on this future.
    `static BridgeEvent` | `newInstance(BridgeEvent arg)`
    `JsonObject` | `rawMessage()` Use `getRawMessage()` instead, will be removed in 3.3
    `Boolean` | `result()` The result of the operation.
    `Future<Boolean>` | `setHandler(Handler<AsyncResult<Boolean>> arg0)` Set a handler for the result.
    `Observable<Boolean>` | `setHandlerObservable()` Set a handler for the result.
    `BridgeEvent` | `setRawMessage(JsonObject message)` Get the raw JSON message for the event.
    `SockJSSocket` | `socket()` Get the SockJSSocket instance corresponding to the event
    `BridgeEventType` | `type()`

    - ### Methods inherited from class io.vertx.rxjava.core.Future

      `cause, complete, fail, fail, failed, failedFuture, future, isComplete, map, newInstance, succeeded, succeededFuture, succeededFuture`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### BridgeEvent

          public BridgeEvent(BridgeEvent delegate)

  - ### Method Detail

    - #### getDelegate

          public Object getDelegate()

      Overrides:
        `getDelegate` in class `Future<Boolean>`

    - #### setHandler

          public Future<Boolean> setHandler(Handler<AsyncResult<Boolean>> arg0)

      Description copied from class: `Future`
      Set a handler for the result.

      If the future has already been completed it will be called immediately. Otherwise it will be called when the future is completed.

      Overrides:
        `setHandler` in class `Future<Boolean>`
      Parameters:
        `arg0` - the Handler that will be called with the result
      Returns:
        a reference to this, so it can be used fluently

    - #### setHandlerObservable

          public Observable<Boolean> setHandlerObservable()

      Description copied from class: `Future`
      Set a handler for the result.

      If the future has already been completed it will be called immediately. Otherwise it will be called when the future is completed.

      Overrides:
        `setHandlerObservable` in class `Future<Boolean>`
      Returns:

    - #### complete

          public void complete(Boolean arg0)

      Description copied from class: `Future`
      Set the result. Any handler will be called, if there is one, and the future will be marked as completed.
      Overrides:
        `complete` in class `Future<Boolean>`
      Parameters:
        `arg0` - the result

    - #### result

          public Boolean result()

      Description copied from class: `Future`
      The result of the operation. This will be null if the operation failed.
      Overrides:
        `result` in class `Future<Boolean>`
      Returns:
        the result or null if the operation failed.

    - #### compose

          public <U> Future<U> compose(Handler<Boolean> handler,
                                       Future<U> next)

      Description copied from class: `Future`
      Compose this future with a provided `next` future.

      When this (the one on which `compose` is called) future succeeds, the `handler` will be called with the completed value, this handler should complete the next future.

      If the `handler` throws an exception, the returned future will be failed with this exception.

      When this future fails, the failure will be propagated to the `next` future and the `handler` will not be called.

      Overrides:
        `compose` in class `Future<Boolean>`
      Parameters:
        `handler` - the handler
        `next` - the next future
      Returns:
        the next future, used for chaining

    - #### compose

          public <U> Future<U> compose(java.util.function.Function<Boolean,Future<U>> mapper)

      Description copied from class: `Future`
      Compose this future with a `mapper` function.

      When this future (the one on which `compose` is called) succeeds, the `mapper` will be called with the completed value and this mapper returns another future object. This returned future completion will complete the future returned by this method call.

      If the `mapper` throws an exception, the returned future will be failed with this exception.

      When this future fails, the failure will be propagated to the returned future and the `mapper` will not be called.

      Overrides:
        `compose` in class `Future<Boolean>`
      Parameters:
        `mapper` - the mapper function
      Returns:
        the composed future

    - #### map

          public <U> Future<U> map(java.util.function.Function<Boolean,U> mapper)

      Description copied from class: `Future`
      Apply a `mapper` function on this future.

      When this future succeeds, the `mapper` will be called with the completed value and this mapper returns a value. This value will complete the future returned by this method call.

      If the `mapper` throws an exception, the returned future will be failed with this exception.

      When this future fails, the failure will be propagated to the returned future and the `mapper` will not be called.

      Overrides:
        `map` in class `Future<Boolean>`
      Parameters:
        `mapper` - the mapper function
      Returns:
        the mapped future

    - #### completer

          public Handler<AsyncResult<Boolean>> completer()

      Overrides:
        `completer` in class `Future<Boolean>`
      Returns:
        an handler completing this future

    - #### type

          public BridgeEventType type()

      Returns:
        the type of the event

    - #### rawMessage

          public JsonObject rawMessage()

      Use `getRawMessage()` instead, will be removed in 3.3
      Returns:

    - #### getRawMessage

          public JsonObject getRawMessage()

      Get the raw JSON message for the event. This will be null for SOCKET_CREATED or SOCKET_CLOSED events as there is no message involved. If the returned message is modified, `setRawMessage(io.vertx.core.json.JsonObject)` should be called with the new message.
      Returns:
        the raw JSON message for the event

    - #### setRawMessage

          public BridgeEvent setRawMessage(JsonObject message)

      Get the raw JSON message for the event. This will be null for SOCKET_CREATED or SOCKET_CLOSED events as there is no message involved.
      Parameters:
        `message` - the raw message
      Returns:
        this reference, so it can be used fluently

    - #### socket

          public SockJSSocket socket()

      Get the SockJSSocket instance corresponding to the event
      Returns:
        the SockJSSocket instance

    - #### newInstance

          public static BridgeEvent newInstance(BridgeEvent arg)

Copyright © 2016. All rights reserved.