• Home
• io.smallrye.reactive
• smallrye-reactive-messaging-api
• 4.26.0
• source code
• Message.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.eclipse.microprofile.reactive.messaging.Message Maven / Gradle / Ivy

/**
 * Copyright (c) 2018-2019 Contributors to the Eclipse Foundation
 * 

 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 * 

 * Licensed under the Apache License, Version 2.0 (the "License");
 * You may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 

 * http://www.apache.org/licenses/LICENSE-2.0
 * 

 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.eclipse.microprofile.reactive.messaging;

import static java.util.Objects.requireNonNullElse;

import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.logging.Logger;

import io.smallrye.common.annotation.Experimental;

/**
 * A message envelope.
 * 

 * A message contains a non-{@code null} payload, an acknowledgement function and a set of metadata.
 * Metadata are indexed using the class name of the values.
 * 
 *
 * @param  The type of the message payload.
 */
public interface Message {

    Logger LOGGER = Logger.getLogger(Message.class.getName());

    Function> EMPTY_ACK = m -> CompletableFuture.completedFuture(null);
    BiFunction> EMPTY_NACK = (t, m) -> CompletableFuture.completedFuture(null);

    private static Function> validateAck(Function> ackM) {
        return (ackM != null) ? ackM : EMPTY_ACK;
    }

    private static Function> validateAck(Supplier> ack) {
        return (ack != null) ? m -> ack.get() : EMPTY_ACK;
    }

    private static BiFunction> validateNack(
            BiFunction> nackM) {
        return (nackM != null) ? nackM : EMPTY_NACK;
    }

    private static BiFunction> validateNack(
            Function> nack) {
        return (nack != null) ? (t, m) -> nack.apply(t) : EMPTY_NACK;
    }

    private static Function> wrapAck(Message message) {
        var ackM = message.getAckWithMetadata();
        return ackM != null ? ackM : validateAck(message.getAck());
    }

    private static BiFunction> wrapNack(Message message) {
        var nackM = message.getNackWithMetadata();
        return nackM != null ? nackM : validateNack(message.getNack());
    }

    private static  Message newMessage(T payload, Metadata metadata) {
        return new Message<>() {
            @Override
            public T getPayload() {
                return payload;
            }

            @Override
            public Metadata getMetadata() {
                return metadata;
            }
        };
    }

    private static  Message newMessage(T payload,
            Function> actualAck) {
        return new Message<>() {
            @Override
            public T getPayload() {
                return payload;
            }

            @Override
            public Function> getAckWithMetadata() {
                return actualAck;
            }

        };
    }

    private static  Message newMessage(T payload,
            Metadata metadata,
            Function> actualAck) {
        return new Message<>() {
            @Override
            public T getPayload() {
                return payload;
            }

            @Override
            public Metadata getMetadata() {
                return metadata;
            }

            @Override
            public Function> getAckWithMetadata() {
                return actualAck;
            }

        };
    }

    private static  Message newMessage(T payload,
            Function> actualAck,
            BiFunction> actualNack) {
        return new Message<>() {
            @Override
            public T getPayload() {
                return payload;
            }

            @Override
            public Function> getAckWithMetadata() {
                return actualAck;
            }

            @Override
            public BiFunction> getNackWithMetadata() {
                return actualNack;
            }
        };
    }

    private static  Message newMessage(T payload,
            Metadata metadata,
            Function> actualAck,
            BiFunction> actualNack) {
        return new Message<>() {
            @Override
            public T getPayload() {
                return payload;
            }

            @Override
            public Metadata getMetadata() {
                return metadata;
            }

            @Override
            public Function> getAckWithMetadata() {
                return actualAck;
            }

            @Override
            public BiFunction> getNackWithMetadata() {
                return actualNack;
            }
        };
    }

    /**
     * Create a message with the given payload.
     * No metadata are associated with the message, the acknowledgement and negative acknowledgement are immediate.
     *
     * @param payload The payload.
     * @param  The type of payload
     * @return A message with the given payload, no metadata, and no-op ack and nack functions.
     */
    static  Message of(T payload) {
        return () -> payload;
    }

    /**
     * Create a message with the given payload and metadata.
     * The acknowledgement and negative-acknowledgement are immediate.
     *
     * @param payload The payload.
     * @param metadata The metadata, if {@code null} an empty set of metadata is used.
     * @param  The type of payload
     * @return A message with the given payload, metadata and no-op ack and nack functions.
     */
    static  Message of(T payload, Metadata metadata) {
        return newMessage(payload, metadata == null ? Metadata.empty() : metadata);
    }

    /**
     * Create a message with the given payload and metadata.
     * The acknowledgement and negative-acknowledgement are immediate.
     *
     * @param payload The payload.
     * @param metadata The metadata, must not be {@code null}, must not contain {@code null} values, can be empty
     * @param  The type of payload
     * @return A message with the given payload, metadata and no-op ack and nack functions.
     */
    static  Message of(T payload, Iterable