io.vertx.reactivex.ext.bridge

## Class BaseBridgeEvent

- java.lang.Object
- - io.vertx.reactivex.core.Future<Boolean>
  - - io.vertx.reactivex.ext.bridge.BaseBridgeEvent

- Direct Known Subclasses:
    BridgeEvent, BridgeEvent

      public class BaseBridgeEvent
      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.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<BaseBridgeEvent>` | `__TYPE_ARG`

    - ### Fields inherited from class io.vertx.reactivex.core.Future

      `__typeArg_0`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `BaseBridgeEvent(BaseBridgeEvent delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `complete(Boolean result)` 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.
    `boolean` | `equals(Object o)`
    `BaseBridgeEvent` | `getDelegate()`
    `JsonObject` | `getRawMessage()` Get the raw JSON message for the event.
    `int` | `hashCode()`
    `<U> Future<U>` | `map(java.util.function.Function<Boolean,U> mapper)` Apply a `mapper` function on this future.
    `static BaseBridgeEvent` | `newInstance(BaseBridgeEvent arg)`
    `Future<Boolean>` | `otherwise(Boolean value)` Map the failure of a future to a specific `value`.
    `Future<Boolean>` | `otherwise(java.util.function.Function<Throwable,Boolean> mapper)` Apply a `mapper` function on this future.
    `Future<Boolean>` | `otherwiseEmpty()` Map the failure of a future to `null`.
    `Future<Boolean>` | `recover(java.util.function.Function<Throwable,Future<Boolean>> mapper)` Handles a failure of this Future by returning the result of another Future.
    `Boolean` | `result()` The result of the operation.
    `Single<Boolean>` | `rxSetHandler()` Set a handler for the result.
    `Future<Boolean>` | `setHandler(Handler<AsyncResult<Boolean>> handler)` Set a handler for the result.
    `BaseBridgeEvent` | `setRawMessage(JsonObject message)` Get the raw JSON message for the event.
    `String` | `toString()`
    `boolean` | `tryComplete(Boolean result)` Set the failure.
    `BridgeEventType` | `type()`

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

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

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

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<BaseBridgeEvent> __TYPE_ARG

  - ### Constructor Detail

    - #### BaseBridgeEvent

          public BaseBridgeEvent(BaseBridgeEvent delegate)

  - ### Method Detail

    - #### toString

          public String toString()

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

    - #### equals

          public boolean equals(Object o)

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

    - #### hashCode

          public int hashCode()

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

    - #### getDelegate

          public BaseBridgeEvent getDelegate()

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

    - #### setHandler

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

      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:
        `handler` - the Handler that will be called with the result
      Returns:
        a reference to this, so it can be used fluently

    - #### rxSetHandler

          public Single<Boolean> rxSetHandler()

      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:
        `rxSetHandler` in class `Future<Boolean>`
      Returns:
        a reference to this, so it can be used fluently

    - #### complete

          public void complete(Boolean result)

      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:
        `result` - the result

    - #### tryComplete

          public boolean tryComplete(Boolean result)

      Set the failure. Any handler will be called, if there is one, and the future will be marked as completed.
      Overrides:
        `tryComplete` in class `Future<Boolean>`
      Parameters:
        `result` - the result
      Returns:
        false when the future is already completed

    - #### result

          public Boolean result()

      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)

      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)

      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)

      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

    - #### recover

          public Future<Boolean> recover(java.util.function.Function<Throwable,Future<Boolean>> mapper)

      Handles a failure of this Future by returning the result of another Future. If the mapper fails, then the returned future will be failed with this failure.
      Overrides:
        `recover` in class `Future<Boolean>`
      Parameters:
        `mapper` - A function which takes the exception of a failure and returns a new future.
      Returns:
        A recovered future

    - #### otherwise

          public Future<Boolean> otherwise(java.util.function.Function<Throwable,Boolean> mapper)

      Apply a `mapper` function on this future.

      When this future fails, 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 succeeds, the result will be propagated to the returned future and the `mapper` will not be called.

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

    - #### otherwise

          public Future<Boolean> otherwise(Boolean value)

      Map the failure of a future to a specific `value`.

      When this future fails, this `value` will complete the future returned by this method call.

      When this future succeeds, the result will be propagated to the returned future.

      Overrides:
        `otherwise` in class `Future<Boolean>`
      Parameters:
        `value` - the value that eventually completes the mapped future
      Returns:
        the mapped future

    - #### otherwiseEmpty

          public Future<Boolean> otherwiseEmpty()

      Map the failure of a future to `null`.

      This is a convenience for `future.otherwise((T) null)`.

      When this future fails, the `null` value will complete the future returned by this method call.

      When this future succeeds, the result will be propagated to the returned future.

      Overrides:
        `otherwiseEmpty` in class `Future<Boolean>`
      Returns:
        the mapped future

    - #### type

          public BridgeEventType type()

      Returns:
        the type of the event

    - #### 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 BaseBridgeEvent 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

    - #### newInstance

          public static BaseBridgeEvent newInstance(BaseBridgeEvent arg)

Copyright © 2019 Eclipse. All rights reserved.