org.eclipse.microprofile.reactive.messaging

## Interface Message<T>

Type Parameters:
  `T` - The type of the message payload.

    public interface Message<T>

A message envelope.

Messaging providers may provide their own sub classes of this type, in order to allow messaging provider specific information to be passed to and from applications.

### Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
`default CompletionStage<Void>` `ack()` Acknowledge this message.
`default Supplier<CompletionStage<Void>>` `getAck()`
`default Function<Throwable,CompletionStage<Void>>` `getNack()`
`T` `getPayload()`
`default CompletionStage<Void>` `nack(Throwable reason)` Acknowledge negatively this message.
`static <T> Message<T>` `of(T payload)` Create a message with the given payload.
`static <T> Message<T>` `of(T payload, Supplier<CompletionStage<Void>> ack)` Create a message with the given payload and ack function.
`static <T> Message<T>` `of(T payload, Supplier<CompletionStage<Void>> ack, Function<Throwable,CompletionStage<Void>> nack)` Create a message with the given payload, ack and nack functions.
`default <C> C` `unwrap(Class<C> unwrapType)` Returns an object of the specified type to allow access to the connector-specific `Message` implementation, and other classes.
`default Message<T>` `withAck(Supplier<CompletionStage<Void>> ack)` Creates a new instance of `Message` with the given acknowledgement supplier.
`default Message<T>` `withNack(Function<Throwable,CompletionStage<Void>> nack)` Creates a new instance of `Message` with the given negative-acknowledgement function.
`default <P> Message<P>` `withPayload(P payload)` Creates a new instance of `Message` with the specified payload.

### Method Detail

#### of

    static <T> Message<T> of(T payload)

Create a message with the given payload.

Type Parameters:
  `T` - The type of payload
Parameters:
  `payload` - The payload.
Returns:
  A message with the given payload, and a no-op ack function.

#### of

    static <T> Message<T> of(T payload,
                             Supplier<CompletionStage<Void>> ack)

Create a message with the given payload and ack function.

Type Parameters:
  `T` - the type of payload
Parameters:
  `payload` - The payload.
  `ack` - The ack function, this will be invoked when the returned messages `ack()` method is invoked.
Returns:
  A message with the given payload and ack function.

#### of

    static <T> Message<T> of(T payload,
                             Supplier<CompletionStage<Void>> ack,
                             Function<Throwable,CompletionStage<Void>> nack)

Create a message with the given payload, ack and nack functions.

Type Parameters:
  `T` - the type of payload
Parameters:
  `payload` - The payload.
  `ack` - The ack function, this will be invoked when the returned messages `ack()` method is invoked.
  `nack` - The negative-ack function, this will be invoked when the returned messages `nack(Throwable)` method is invoked.
Returns:
  A message with the given payload, ack and nack functions.

#### withPayload

    default <P> Message<P> withPayload(P payload)

Creates a new instance of `Message` with the specified payload. The ack/nack functions are taken from the current `Message`.

Type Parameters:
  `P` - the type of the new payload
Parameters:
  `payload` - the new payload.
Returns:
  the new instance of `Message`

#### withAck

    default Message<T> withAck(Supplier<CompletionStage<Void>> ack)

Creates a new instance of `Message` with the given acknowledgement supplier. The payload, and nack function are taken from the current `Message`.

Parameters:
  `ack` - the positive-acknowledgement function
Returns:
  the new instance of `Message`

#### withNack

    default Message<T> withNack(Function<Throwable,CompletionStage<Void>> nack)

Creates a new instance of `Message` with the given negative-acknowledgement function. The payload and acknowledgment are taken from the current `Message`.

Parameters:
  `nack` - the negative-acknowledgement function
Returns:
  the new instance of `Message`

#### getPayload

    T getPayload()

Returns:
  The payload for this message.

#### ack

    default CompletionStage<Void> ack()

Acknowledge this message.

Returns:
  a completion stage completed when the message is acknowledged. If the acknowledgement fails, the completion stage propagates the failure.

#### getAck

    default Supplier<CompletionStage<Void>> getAck()

Returns:
  the supplier used to retrieve the acknowledgement `CompletionStage`.

#### getNack

    default Function<Throwable,CompletionStage<Void>> getNack()

Returns:
  the function used to retrieve the negative-acknowledgement asynchronous function.

#### nack

    default CompletionStage<Void> nack(Throwable reason)

Acknowledge negatively this message. `nack` is used to indicate that the processing of a message failed with the reason passed as the parameter.

Parameters:
  `reason` - the reason of the nack, must not be `null`
Returns:
  a completion stage completed when the message is negative-acknowledgement has completed. If the negative acknowledgement fails, the completion stage propagates the failure.

#### unwrap

    default <C> C unwrap(Class<C> unwrapType)

Returns an object of the specified type to allow access to the connector-specific `Message` implementation, and other classes. For example, a Kafka connector could implement this method to allow unwrapping to a specific Kafka message implementation, or to `ConsumerRecord` and `ProducerRecord`. If the `Message` implementation does not support the target class, an `IllegalArgumentException` should be raised. The default implementation tries to cast the current `Message` instance to the target class. When a connector provides its own `Message` implementation, it should override this method to support specific types.

Type Parameters:
  `C` - the target type
Parameters:
  `unwrapType` - the class of the object to be returned, must not be `null`
Returns:
  an instance of the specified class
Throws:
  `IllegalArgumentException` - if the current `Message` instance does not support the call