record Success()

in commons/src/main/java/org/apache/causeway/commons/functional/Try.java [296:446]
134 lines of code
11 McCabe index (conditional complexity)

    record Success<T>(@Nullable T _value) implements Try<T>, Serializable {

        @Override public boolean isSuccess() { return true; }
        @Override public boolean isFailure() { return false; }

        @Override public Optional<T> getValue() { return Optional.ofNullable(_value); }
        @Override public Optional<Throwable> getFailure() { return Optional.empty(); }

        @Override
        public Try<T> ifSuccess(final @NonNull ThrowingConsumer<Optional<T>> valueConsumer) {
            try {
                valueConsumer.accept(getValue());
                return this;
            } catch (Throwable e) {
                return Try.failure(e);
            }
        }
        @Override
        public Try<T> ifSuccessAsNullable(final @NonNull ThrowingConsumer<T> valueConsumer) {
            try {
                valueConsumer.accept(getValue().orElse(null));
                return this;
            } catch (Throwable e) {
                return Try.failure(e);
            }
        }

        @Override
        public Success<T> ifFailure(final @NonNull ThrowingConsumer<Throwable> exceptionConsumer) {
            return this;
        }

        @Override
        public Success<T> ifFailureFail() {
            return this;
        }

        @Override
        public Success<T> ifAbsentFail() {
            if(_value==null) throw _Exceptions.noSuchElement();
            return this;
        }

        @Override
        public <R> Try<R> mapSuccess(final @NonNull ThrowingFunction<Optional<T>, R> successMapper) {
            return Try.call(()->successMapper.apply(getValue()));
        }
        @Override
        public <R> Try<R> mapSuccessAsNullable(final @NonNull ThrowingFunction<T, R> successMapper) {
            return Try.call(()->successMapper.apply(getValue().orElse(null)));
        }
        @Override
        public <R> Try<R> mapSuccessWhenPresent(final @NonNull ThrowingFunction<T, R> successMapper) {
            return getValue()
                    .map(value->Try.call(()->successMapper.apply(value)))
                    .orElseGet(Try::empty);
        }
        @Override
        public <R> Try<R> flatMapSuccess(final @NonNull ThrowingFunction<Optional<T>, Try<R>> successMapper) {
            try {
                return successMapper.apply(getValue());
            } catch (Throwable ex) {
                return Try.failure(ex);
            }
        }
        @Override
        public <R> Try<R> flatMapSuccessAsNullable(final @NonNull ThrowingFunction<T, Try<R>> successMapper) {
            try {
                return successMapper.apply(getValue().orElse(null));
            } catch (Throwable ex) {
                return Try.failure(ex);
            }
        }
        @Override
        public <R> Try<R> flatMapSuccessWhenPresent(final @NonNull ThrowingFunction<T, Try<R>> successMapper) {
            var value = getValue().orElse(null);
            if(value==null) return Try.empty();
            try {
                return successMapper.apply(value);
            } catch (Throwable ex) {
                return Try.failure(ex);
            }
        }

        @Override
        public Success<T> mapFailure(final @NonNull ThrowingFunction<Throwable, Throwable> failureMapper){
            return this;
        }
        @Override
        public Try<T> mapFailureToSuccess(final @NonNull ThrowingFunction<Throwable, T> recoveryMapper) {
            return this;
        }

        @Override
        public Try<T> mapEmptyToFailure() {
            return _value!=null
                    ? this
                    : Try.failure(_Exceptions.noSuchElement());
        }

        @Override
        public <R> Try<R> thenCall(final @NonNull Callable<R> callable) {
            return Try.call(callable);
        }

        @Override
        public Try<Void> thenRun(final @NonNull ThrowingRunnable runnable) {
            return Try.run(runnable);
        }

        @Override
        public <R> Try<R> then(final @NonNull Callable<? extends Try<R>> next) {
            try {
                return next.call();
            } catch (Throwable e) {
                return Try.failure(e);
            }
        }

        @Override
        public Try<T> orCall(final @NonNull Callable<T> fallback) {
            return this;
        }

        @Override
        public Try<T> accept(
                final @NonNull ThrowingConsumer<Throwable> failureConsumer,
                final @NonNull ThrowingConsumer<Optional<T>> successConsumer) {
            try {
                successConsumer.accept(getValue());
                return this;
            } catch (Throwable e) {
                return Try.failure(e);
            }
        }

        @Override
        public <R> R fold(
                final @NonNull ThrowingFunction<Throwable, R> failureMapper,
                final @NonNull ThrowingFunction<Optional<T>, R> successMapper) {
            return successMapper.apply(getValue());
        }

        @Override
        public <L, R> Either<L, R> mapToEither(
                final @NonNull ThrowingFunction<Throwable, L> failureMapper,
                final @NonNull ThrowingFunction<Optional<T>, R> successMapper) {
            return Either.right(successMapper.apply(getValue()));
        }

    }