Module org.jooq.jool
Package org.jooq.lambda

Class Sneaky

  • public final class Sneaky
extends java.lang.Object
    Improved interoperability between checked exceptions and Java 8.

    Similar to Unchecked, except that Unchecked.RETHROW_ALL is used as the default way to re-throw checked exceptions.

    • Constructor Detail

      • Sneaky

        private Sneaky()
        No instances

    • Method Detail

      • throwChecked

        public static void throwChecked​(java.lang.Throwable t)
        "sneaky-throw" a checked exception or throwable.

      • runnable

        public static java.lang.Runnable runnable​(CheckedRunnable runnable)
        Wrap a CheckedRunnable in a Runnable.

        Example: 

        
 new Thread(Unchecked.runnable(() -> {
     throw new Exception("Cannot run this thread");
 })).start();

      • callable

        public static <T> java.util.concurrent.Callable<T> callable​(CheckedCallable<T> callable)
        Wrap a CheckedCallable in a Callable.

        Example: 

        
 Executors.newFixedThreadPool(1).submit(Unchecked.callable(() -> {
     throw new Exception("Cannot execute this task");
 })).get();

      • biConsumer

        public static <T,​U> java.util.function.BiConsumer<T,​U> biConsumer​(CheckedBiConsumer<T,​U> consumer)
        Wrap a CheckedBiConsumer in a BiConsumer.

        Example: 

        
 map.forEach(Unchecked.biConsumer((k, v) -> {
     if (k == null || v == null)
         throw new Exception("No nulls allowed in map");
 }));

      • biFunction

        public static <T,​U,​R> java.util.function.BiFunction<T,​U,​R> biFunction​(CheckedBiFunction<T,​U,​R> function)
        Wrap a CheckedBiFunction in a BiFunction.

        Example: 

        
 map.computeIfPresent("key", Unchecked.biFunction((k, v) -> {
     if (k == null || v == null)
         throw new Exception("No nulls allowed in map");

     return 42;
 }));

      • binaryOperator

        public static <T> java.util.function.BinaryOperator<T> binaryOperator​(CheckedBinaryOperator<T> operator)
        Wrap a CheckedBinaryOperator in a BinaryOperator.

        Example: 

        
 Stream.of("a", "b", "c").reduce(Unchecked.binaryOperator((s1, s2) -> {
     if (s2.length() > 10)
         throw new Exception("Only short strings allowed");

     return s1 + s2;
 }));

      • intBinaryOperator

        public static java.util.function.IntBinaryOperator intBinaryOperator​(CheckedIntBinaryOperator operator)
        Wrap a CheckedIntBinaryOperator in a IntBinaryOperator.

        Example: 

        
 IntStream.of(1, 2, 3).reduce(Unchecked.intBinaryOperator((i1, i2) -> {
     if (i2 < 0)
         throw new Exception("Only positive numbers allowed");

     return i1 + i2;
 }));

      • longBinaryOperator

        public static java.util.function.LongBinaryOperator longBinaryOperator​(CheckedLongBinaryOperator operator)
        Wrap a CheckedLongBinaryOperator in a LongBinaryOperator.

        Example: 

        
 LongStream.of(1L, 2L, 3L).reduce(Unchecked.longBinaryOperator((l1, l2) -> {
     if (l2 < 0L)
         throw new Exception("Only positive numbers allowed");

     return l1 + l2;
 }));

      • doubleBinaryOperator

        public static java.util.function.DoubleBinaryOperator doubleBinaryOperator​(CheckedDoubleBinaryOperator operator)
        Wrap a CheckedDoubleBinaryOperator in a DoubleBinaryOperator.

        Example: 

        
 DoubleStream.of(1.0, 2.0, 3.0).reduce(Unchecked.doubleBinaryOperator((d1, d2) -> {
     if (d2 < 0.0)
         throw new Exception("Only positive numbers allowed");

     return d1 + d2;
 }));

      • consumer

        public static <T> java.util.function.Consumer<T> consumer​(CheckedConsumer<T> consumer)
        Wrap a CheckedConsumer in a Consumer.

        Example: 

        
 Arrays.asList("a", "b").stream().forEach(Unchecked.consumer(s -> {
     if (s.length() > 10)
         throw new Exception("Only short strings allowed");
 }));

      • intConsumer

        public static java.util.function.IntConsumer intConsumer​(CheckedIntConsumer consumer)
        Wrap a CheckedIntConsumer in a IntConsumer.

        Example: 

        
 Arrays.stream(new int[] { 1, 2 }).forEach(Unchecked.intConsumer(i -> {
     if (i < 0)
         throw new Exception("Only positive numbers allowed");
 }));

      • longConsumer

        public static java.util.function.LongConsumer longConsumer​(CheckedLongConsumer consumer)
        Wrap a CheckedLongConsumer in a LongConsumer.

        Example: 

        
 Arrays.stream(new long[] { 1L, 2L }).forEach(Unchecked.longConsumer(l -> {
     if (l < 0)
         throw new Exception("Only positive numbers allowed");
 }));

      • doubleConsumer

        public static java.util.function.DoubleConsumer doubleConsumer​(CheckedDoubleConsumer consumer)
        Wrap a CheckedDoubleConsumer in a DoubleConsumer.

        Example: 

        
 Arrays.stream(new double[] { 1.0, 2.0 }).forEach(Unchecked.doubleConsumer(d -> {
     if (d < 0.0)
         throw new Exception("Only positive numbers allowed");
 }));

      • function

        public static <T,​R> java.util.function.Function<T,​R> function​(CheckedFunction<T,​R> function)
        Wrap a CheckedFunction in a Function.

        Example: 

        
 map.computeIfAbsent("key", Unchecked.function(k -> {
     if (k.length() > 10)
         throw new Exception("Only short strings allowed");

     return 42;
 }));

      • toIntFunction

        public static <T> java.util.function.ToIntFunction<T> toIntFunction​(CheckedToIntFunction<T> function)
        Wrap a CheckedToIntFunction in a ToIntFunction.

        Example: 

        
 map.computeIfAbsent("key", Unchecked.toIntFunction(k -> {
     if (k.length() > 10)
         throw new Exception("Only short strings allowed");

     return 42;
 }));

      • toLongFunction

        public static <T> java.util.function.ToLongFunction<T> toLongFunction​(CheckedToLongFunction<T> function)
        Wrap a CheckedToLongFunction in a ToLongFunction.

        Example: 

        
 map.computeIfAbsent("key", Unchecked.toLongFunction(k -> {
     if (k.length() > 10)
         throw new Exception("Only short strings allowed");

     return 42L;
 }));

      • toDoubleFunction

        public static <T> java.util.function.ToDoubleFunction<T> toDoubleFunction​(CheckedToDoubleFunction<T> function)
        Wrap a CheckedToDoubleFunction in a ToDoubleFunction.

        Example: 

        
 map.computeIfAbsent("key", Unchecked.toDoubleFunction(k -> {
     if (k.length() > 10)
         throw new Exception("Only short strings allowed");

     return 42.0;
 }));

      • intFunction

        public static <R> java.util.function.IntFunction<R> intFunction​(CheckedIntFunction<R> function)
        Wrap a CheckedIntFunction in a IntFunction.

        Example: 

        
 IntStream.of(1, 2, 3).mapToObj(Unchecked.intFunction(i -> {
     if (i < 0)
         throw new Exception("Only positive numbers allowed");

     return "" + i;
 });

      • intToLongFunction

        public static java.util.function.IntToLongFunction intToLongFunction​(CheckedIntToLongFunction function)
        Wrap a CheckedIntToLongFunction in a IntToLongFunction.

        Example: 

        
 IntStream.of(1, 2, 3).mapToLong(Unchecked.intToLongFunction(i -> {
     if (i < 0)
         throw new Exception("Only positive numbers allowed");

     return (long) i;
 });

      • intToDoubleFunction

        public static java.util.function.IntToDoubleFunction intToDoubleFunction​(CheckedIntToDoubleFunction function)
        Wrap a CheckedIntToDoubleFunction in a IntToDoubleFunction.

        Example: 

        
 IntStream.of(1, 2, 3).mapToDouble(Unchecked.intToDoubleFunction(i -> {
     if (i < 0)
         throw new Exception("Only positive numbers allowed");

     return (double) i;
 });

      • longFunction

        public static <R> java.util.function.LongFunction<R> longFunction​(CheckedLongFunction<R> function)
        Wrap a CheckedLongFunction in a LongFunction.

        Example: 

        
 LongStream.of(1L, 2L, 3L).mapToObj(Unchecked.longFunction(l -> {
     if (l < 0L)
         throw new Exception("Only positive numbers allowed");

     return "" + l;
 });

      • longToIntFunction

        public static java.util.function.LongToIntFunction longToIntFunction​(CheckedLongToIntFunction function)
        Wrap a CheckedLongToIntFunction in a LongToIntFunction.

        Example: 

        
 LongStream.of(1L, 2L, 3L).mapToInt(Unchecked.longToIntFunction(l -> {
     if (l < 0L)
         throw new Exception("Only positive numbers allowed");

     return (int) l;
 });

      • longToDoubleFunction

        public static java.util.function.LongToDoubleFunction longToDoubleFunction​(CheckedLongToDoubleFunction function)
        Wrap a CheckedLongToDoubleFunction in a LongToDoubleFunction.

        Example: 

        
 LongStream.of(1L, 2L, 3L).mapToInt(Unchecked.longToDoubleFunction(l -> {
     if (l < 0L)
         throw new Exception("Only positive numbers allowed");

     return (double) l;
 });

      • doubleFunction

        public static <R> java.util.function.DoubleFunction<R> doubleFunction​(CheckedDoubleFunction<R> function)
        Wrap a CheckedDoubleFunction in a DoubleFunction.

        Example: 

        
 DoubleStream.of(1.0, 2.0, 3.0).mapToObj(Unchecked.doubleFunction(d -> {
     if (d < 0.0)
         throw new Exception("Only positive numbers allowed");

     return "" + d;
 });

      • doubleToIntFunction

        public static java.util.function.DoubleToIntFunction doubleToIntFunction​(CheckedDoubleToIntFunction function)
        Wrap a CheckedDoubleToIntFunction in a DoubleToIntFunction.

        Example: 

        
 DoubleStream.of(1.0, 2.0, 3.0).mapToInt(Unchecked.doubleToIntFunction(d -> {
     if (d < 0.0)
         throw new Exception("Only positive numbers allowed");

     return (int) d;
 });

      • doubleToLongFunction

        public static java.util.function.DoubleToLongFunction doubleToLongFunction​(CheckedDoubleToLongFunction function)
        Wrap a CheckedDoubleToLongFunction in a DoubleToLongFunction.

        Example: 

        
 DoubleStream.of(1.0, 2.0, 3.0).mapToLong(Unchecked.doubleToLongFunction(d -> {
     if (d < 0.0)
         throw new Exception("Only positive numbers allowed");

     return (long) d;
 });

      • predicate

        public static <T> java.util.function.Predicate<T> predicate​(CheckedPredicate<T> predicate)
        Wrap a CheckedPredicate in a Predicate.

        Example: 

        
 Stream.of("a", "b", "c").filter(Unchecked.predicate(s -> {
     if (s.length() > 10)
         throw new Exception("Only short strings allowed");

     return true;
 }));

      • intPredicate

        public static java.util.function.IntPredicate intPredicate​(CheckedIntPredicate predicate)
        Wrap a CheckedPredicate in a IntPredicate.

        Example: 

        
 IntStream.of(1, 2, 3).filter(Unchecked.intPredicate(i -> {
     if (i < 0)
         throw new Exception("Only positive numbers allowed");

     return true;
 }));

      • longPredicate

        public static java.util.function.LongPredicate longPredicate​(CheckedLongPredicate predicate)
        Wrap a CheckedLongPredicate in a LongPredicate.

        Example: 

        
 LongStream.of(1L, 2L, 3L).filter(Unchecked.longPredicate(l -> {
     if (l < 0L)
         throw new Exception("Only positive numbers allowed");

     return true;
 }));

      • doublePredicate

        public static java.util.function.DoublePredicate doublePredicate​(CheckedDoublePredicate predicate)
        Wrap a CheckedDoublePredicate in a DoublePredicate.

        Example: 

        
 DoubleStream.of(1.0, 2.0, 3.0).filter(Unchecked.doublePredicate(d -> {
     if (d < 0.0)
         throw new Exception("Only positive numbers allowed");

     return true;
 }));

      • supplier

        public static <T> java.util.function.Supplier<T> supplier​(CheckedSupplier<T> supplier)
        Wrap a CheckedSupplier in a Supplier.

        Example: 

        
 ResultSet rs = statement.executeQuery();
 Stream.generate(Unchecked.supplier(() -> rs.getObject(1)));

      • intSupplier

        public static java.util.function.IntSupplier intSupplier​(CheckedIntSupplier supplier)
        Wrap a CheckedIntSupplier in a IntSupplier.

        Example: 

        
 ResultSet rs = statement.executeQuery();
 Stream.generate(Unchecked.intSupplier(() -> rs.getInt(1)));

      • longSupplier

        public static java.util.function.LongSupplier longSupplier​(CheckedLongSupplier supplier)
        Wrap a CheckedLongSupplier in a LongSupplier.

        Example: 

        
 ResultSet rs = statement.executeQuery();
 Stream.generate(Unchecked.longSupplier(() -> rs.getLong(1)));

      • doubleSupplier

        public static java.util.function.DoubleSupplier doubleSupplier​(CheckedDoubleSupplier supplier)
        Wrap a CheckedDoubleSupplier in a DoubleSupplier.

        Example: 

        
 ResultSet rs = statement.executeQuery();
 Stream.generate(Unchecked.doubleSupplier(() -> rs.getDouble(1)));

      • booleanSupplier

        public static java.util.function.BooleanSupplier booleanSupplier​(CheckedBooleanSupplier supplier)
        Wrap a CheckedBooleanSupplier in a BooleanSupplier.

        Example: 

        
 ResultSet rs = statement.executeQuery();
 Stream.generate(Unchecked.booleanSupplier(() -> rs.getBoolean(1)));

      • unaryOperator

        public static <T> java.util.function.UnaryOperator<T> unaryOperator​(CheckedUnaryOperator<T> operator)
        Wrap a CheckedUnaryOperator in a UnaryOperator.

        Example: 

        
 Stream.of("a", "b", "c").map(Unchecked.unaryOperator(s -> {
     if (s.length() > 10)
         throw new Exception("Only short strings allowed");

     return s;
 }));

      • intUnaryOperator

        public static java.util.function.IntUnaryOperator intUnaryOperator​(CheckedIntUnaryOperator operator)
        Wrap a CheckedIntUnaryOperator in a IntUnaryOperator.

        Example: 

        
 IntStream.of(1, 2, 3).map(Unchecked.intUnaryOperator(i -> {
     if (i < 0)
         throw new Exception("Only positive numbers allowed");

     return i;
 }));

      • longUnaryOperator

        public static java.util.function.LongUnaryOperator longUnaryOperator​(CheckedLongUnaryOperator operator)
        Wrap a CheckedLongUnaryOperator in a LongUnaryOperator.

        Example: 

        
 LongStream.of(1L, 2L, 3L).map(Unchecked.longUnaryOperator(l -> {
     if (l < 0L)
         throw new Exception("Only positive numbers allowed");

     return l;
 }));

      • doubleUnaryOperator

        public static java.util.function.DoubleUnaryOperator doubleUnaryOperator​(CheckedDoubleUnaryOperator operator)
        Wrap a CheckedDoubleUnaryOperator in a DoubleUnaryOperator.

        Example: 

        
 LongStream.of(1.0, 2.0, 3.0).map(Unchecked.doubleUnaryOperator(d -> {
     if (d < 0.0)
         throw new Exception("Only positive numbers allowed");

     return d;
 }));