public final Class Sneaky

Wrap a org.jooq.lambda.fi.util.function.CheckedBiConsumer in a BiConsumer.

Example:

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

Wrap a org.jooq.lambda.fi.util.function.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;
}));

Wrap a org.jooq.lambda.fi.util.function.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;
}));

Wrap a org.jooq.lambda.fi.util.function.CheckedBiPredicate in a BiPredicate.

Wrap a org.jooq.lambda.fi.util.function.CheckedBooleanSupplier in a BooleanSupplier.

Example:

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

Wrap a CheckedCallable in a Callable.

Example:

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

Wrap a CheckedComparator in a Comparator.

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");
}));

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;
}));

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");
}));

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;
});

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;
}));

Wrap a CheckedDoubleSupplier in a DoubleSupplier.

Example:

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

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;
});

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;
});

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;
}));

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;
}));

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;
}));

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");
}));

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;
});

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;
}));

Wrap a CheckedIntSupplier in a IntSupplier.

Example:

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

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;
});

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;
});

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;
}));

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;
}));

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");
}));

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;
});

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;
}));

Wrap a CheckedLongSupplier in a LongSupplier.

Example:

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

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;
});

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;
});

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;
}));

Wrap a CheckedObjDoubleConsumer in a ObjDoubleConsumer.

Wrap a CheckedObjIntConsumer in a ObjIntConsumer.

Wrap a CheckedObjLongConsumer in a ObjLongConsumer.

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;
}));

Wrap a CheckedRunnable in a Runnable.

Example:

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

Wrap a CheckedSupplier in a Supplier.

Example:

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

"sneaky-throw" a checked exception or throwable.

Wrap a CheckedToDoubleBiFunction in a ToDoubleBiFunction.

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;
}));

Wrap a CheckedToIntBiFunction in a ToIntBiFunction.

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;
}));

Wrap a CheckedToLongBiFunction in a ToLongBiFunction.

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;
}));

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;
}));