io.camunda.operate.util.LambdaExceptionUtil Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of operate-common Show documentation
Operate Common
There is a newer version: 8.6.0-alpha5
/*
 * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH under
 * one or more contributor license agreements. See the NOTICE file distributed
 * with this work for additional information regarding copyright ownership.
 * Licensed under the Camunda License 1.0. You may not use this file
 * except in compliance with the Camunda License 1.0.
 */
package io.camunda.operate.util;

import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/** Helper class to rethrow checked exceptions in lambda expressions. */
public final class LambdaExceptionUtil {

  /**
   * .forEach(rethrowConsumer(name -> System.out.println(Class.forName(name)))); or
   * .forEach(rethrowConsumer(ClassNameUtil::println));
   */
  public static  Consumer rethrowConsumer(
      ConsumerWithExceptions consumer) throws E {
    return t -> {
      try {
        consumer.accept(t);
      } catch (Exception exception) {
        throwAsUnchecked(exception);
      }
    };
  }

  public static  BiConsumer rethrowBiConsumer(
      BiConsumerWithExceptions biConsumer) throws E {
    return (t, u) -> {
      try {
        biConsumer.accept(t, u);
      } catch (Exception exception) {
        throwAsUnchecked(exception);
      }
    };
  }

  /** .map(rethrowFunction(name -> Class.forName(name))) or .map(rethrowFunction(Class::forName)) */
  public static  Function rethrowFunction(
      FunctionWithExceptions function) throws E {
    return t -> {
      try {
        return function.apply(t);
      } catch (Exception exception) {
        throwAsUnchecked(exception);
        return null;
      }
    };
  }

  /** rethrowSupplier(() -> new StringJoiner(new String(new byte[]{77, 97, 114, 107}, "UTF-8"))), */
  public static  Supplier rethrowSupplier(
      SupplierWithExceptions function) throws E {
    return () -> {
      try {
        return function.get();
      } catch (Exception exception) {
        throwAsUnchecked(exception);
        return null;
      }
    };
  }

  /** uncheck(() -> Class.forName("xxx")); */
  public static void uncheck(RunnableWithExceptions t) {
    try {
      t.run();
    } catch (Exception exception) {
      throwAsUnchecked(exception);
    }
  }

  /** uncheck(() -> Class.forName("xxx")); */
  public static  R uncheck(SupplierWithExceptions supplier) {
    try {
      return supplier.get();
    } catch (Exception exception) {
      throwAsUnchecked(exception);
      return null;
    }
  }

  /** uncheck(Class::forName, "xxx"); */
  public static  R uncheck(
      FunctionWithExceptions function, T t) {
    try {
      return function.apply(t);
    } catch (Exception exception) {
      throwAsUnchecked(exception);
      return null;
    }
  }

  @SuppressWarnings("unchecked")
  private static  void throwAsUnchecked(Exception exception) throws E {
    throw (E) exception;
  }

  @FunctionalInterface
  public interface ConsumerWithExceptions {
    void accept(T t) throws E;
  }

  @FunctionalInterface
  public interface BiConsumerWithExceptions {
    void accept(T t, U u) throws E;
  }

  @FunctionalInterface
  public interface FunctionWithExceptions {
    R apply(T t) throws E;
  }

  @FunctionalInterface
  public interface SupplierWithExceptions {
    T get() throws E;
  }

  @FunctionalInterface
  public interface RunnableWithExceptions {
    void run() throws E;
  }
}