org.eclipse.edc.spi.result.Result Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of boot-spi Show documentation
edc :: boot-spi
The newest version!
/*
 *  Copyright (c) 2021 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
 *
 *  This program and the accompanying materials are made available under the
 *  terms of the Apache License, Version 2.0 which is available at
 *  https://www.apache.org/licenses/LICENSE-2.0
 *
 *  SPDX-License-Identifier: Apache-2.0
 *
 *  Contributors:
 *       Bayerische Motoren Werke Aktiengesellschaft (BMW AG) - initial API and implementation
 *
 */

package org.eclipse.edc.spi.result;

import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * A generic result type.
 */
public class Result extends AbstractResult> {

    private Result(T content, Failure failure) {
        super(content, failure);
    }

    public static Result success() {
        return new Result<>(null, null);
    }

    public static  Result success(T content) {
        return new Result<>(content, null);
    }

    public static  Result failure(String failure) {
        return new Result<>(null, new Failure(List.of(failure)));
    }

    public static  Result failure(List failures) {
        return new Result<>(null, new Failure(failures));
    }


    /**
     * Runs the block provided by the {@link Supplier} and wrap the return into a Result
     *
     * @param supplier The block to execute
     * @return The Result of the supplier call. Success if no {@link Exception} were thrown. Failure otherwise
     */
    public static  Result ofThrowable(Supplier supplier) {
        try {
            return Result.success(supplier.get());
        } catch (Exception e) {
            return Result.failure(e.getMessage());
        }
    }

    /**
     * Converts a {@link Optional} into a result, interpreting the Optional's value as content.
     *
     * @return {@link Result#failure(String)} if the Optional is empty, {@link Result#success(Object)} using the Optional's value otherwise.
     */
    @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
    public static  Result from(Optional opt) {
        return opt.map(Result::success).orElse(Result.failure("Empty optional"));
    }

    /**
     * Merges this result with another one. If both Results are successful, a new one is created with no content. If
     * either this result or {@code other} is a failure, the merged result will be a {@code failure()} and will contain
     * all failure messages, no content. If both results are failures, the merged result will contain failure messages
     * of {@code this} result, then the failure messages of {@code other}.
     */
    public  Result merge(Result other) {
        if (succeeded() && other.succeeded()) {
            return new Result<>(null, null);
        } else {
            var messages = new ArrayList();
            messages.addAll(Optional.ofNullable(getFailure()).map(Failure::getMessages).orElse(Collections.emptyList()));
            messages.addAll(Optional.ofNullable(other.getFailure()).map(Failure::getMessages).orElse(Collections.emptyList()));
            return Result.failure(messages);
        }
    }

    /**
     * Maps this {@link Result} into another, maintaining the basic semantics (failed vs success). If this
     * {@link Result} is successful, the content is discarded. If this {@link Result} failed, the failures are carried
     * over. This method is intended for use when the return type is implicit, for example:
     *      *   public Result<Void> someMethod() {
     *      Result<String> result = getStringResult();
     *      return result.mapTo();
     *   }
     * 
     *
     * @see Result#map(Function)
     * @see Result#mapTo(Class)
     * @deprecated please use {@link #mapEmpty()} or {@link #mapFailure()}.
     */
    @Deprecated(since = "0.6.4")
    public  Result mapTo() {
        return mapEmpty();
    }

    /**
     * Maps this {@link Result} into another, maintaining the basic semantics (failed vs success). If this
     * {@link Result} is successful, the content is discarded. If this {@link Result} failed, the failures are carried
     * over. This method is intended for use when an explicit return type is needed, for example when using var:
     *      *      Result<String> result = getStringResult();
     *      var voidResult = result.mapTo(Void.class);
     * 
     *
     * @param clazz type of the result, with which the resulting {@link Result} should be parameterized
     * @see Result#map(Function)
     * @see Result#mapTo()
     * @deprecated please use {@link #mapEmpty()} or {@link #mapFailure()}.
     */
    @Deprecated(since = "0.6.4")
    public  Result mapTo(Class clazz) {
        return mapEmpty();
    }

    /**
     * Converts this result into an {@link Optional}. When this result is failed, or there is no content,
     * {@link Optional#isEmpty()} is returned, otherwise the content is the {@link Optional}'s value
     *
     * @return {@link Optional#empty()} if failed, or no content, {@link Optional#of(Object)} otherwise.
     */
    public Optional asOptional() {
        return succeeded() && getContent() != null ? Optional.of(getContent()) : Optional.empty();
    }

    @Override
    @SuppressWarnings("unchecked")
    @NotNull
    protected , C1> R1 newInstance(@Nullable C1 content, @Nullable Failure failure) {
        return (R1) new Result<>(content, failure);
    }

}