public static <T, U, R, E extends Exception> R applyWithInterruptHandler(InterruptHandler interruptHandler, ExceptionBiFunction<T, U, R, E> function, T param1, U param2) throws E { final JBossThread thread = currentThread(); if (thread == null) { return function.apply(param1, param2); } else { final InterruptHandler old = thread.interruptHandler; thread.interruptHandler = interruptHandler; try { return function.apply(param1, param2); } finally { thread.interruptHandler = old; } } }
public <T, U, R, E extends Exception> R performFunction(ExceptionBiFunction<T, U, R, E> function, T param1, U param2) throws E, SystemException { final ContextTransactionManager tm = ContextTransactionManager.INSTANCE; if (Objects.equals(tm.getStateRef().get().transaction, this)) { return function.apply(param1, param2); } try (SysExTry ignored = whileSuspended()) { try (SysExTry ignored2 = whileResumed(this)) { return function.apply(param1, param2); } } }
public static <T, U, R, E extends Exception> R applyInterruptResumedEx(final ExceptionBiFunction<T, U, R, E> function, T param1, U param2) throws E { final JBossThread thread = currentThread(); if (unregisterDeferral(thread)) try { return function.apply(param1, param2); } finally { registerDeferral(thread); } else { // already resumed return function.apply(param1, param2); } }
public static <T, U, R, E extends Exception> R applyInterruptDeferredEx(final ExceptionBiFunction<T, U, R, E> function, T param1, U param2) throws E { final JBossThread thread = currentThread(); if (registerDeferral(thread)) try { return function.apply(param1, param2); } finally { unregisterDeferral(thread); } else { // already deferred return function.apply(param1, param2); } }
public <T, U, R, E extends Exception> R runAsFunctionEx(final ExceptionBiFunction<T, U, R, E> action, final T parameter1, final U parameter2) throws E { final Supplier<SecurityIdentity> old = securityDomain.getAndSetCurrentSecurityIdentity(this); try { return action.apply(parameter1, parameter2); } finally { securityDomain.setCurrentSecurityIdentity(old); } }
default <R2> ExceptionFunction<T, R2, E> andThen(ExceptionBiFunction<? super T, ? super R, ? extends R2, ? extends E> after) { Assert.checkNotNullParam("after", after); return t -> after.apply(t, apply(t)); }
default <R2> ExceptionBiFunction<T, U, R2, E> andThen(ExceptionFunction<? super R, ? extends R2, ? extends E> after) { Assert.checkNotNullParam("after", after); return (t, u) -> after.apply(apply(t, u)); }
default ExceptionBiConsumer<T, U, E> andThen(ExceptionConsumer<R, ? extends E> after) { Assert.checkNotNullParam("after", after); return (t, u) -> after.accept(apply(t, u)); }
/** * Perform an action under the current naming provider. * * @param function the function to apply (must not be {@code null}) * @param arg1 the first argument * @param arg2 the second argument * @param <T> the first argument type * @param <U> the second argument type * @param <R> the function return type * @param <E> the function exception type * @return the function return value * @throws E if the function throws an exception of the given type */ default <T, U, R, E extends Exception> R performExceptionAction(ExceptionBiFunction<T, U, R, E> function, T arg1, U arg2) throws E { final NamingProvider old = CurrentNamingProvider.getAndSetCurrent(this); try { return function.apply(arg1, arg2); } finally { CurrentNamingProvider.setCurrent(old); } } /**
public static <T, U> JBossEJBProperties fromResource(final String fileName, final ExceptionBiFunction<T, U, InputStream, IOException> streamSupplier, T param1, U param2) throws IOException { Assert.checkNotNullParam("fileName", fileName); Assert.checkNotNullParam("streamSupplier", streamSupplier); final InputStream stream; try { stream = streamSupplier.apply(param1, param2); } catch (FileNotFoundException | NoSuchFileException e) { return null; } if (stream == null) { return null; } return fromResource(fileName, stream); }
default ExceptionSupplier<R, E> compose(ExceptionSupplier<? extends T, ? extends E> before1, ExceptionSupplier<? extends U, ? extends E> before2) { Assert.checkNotNullParam("before1", before1); Assert.checkNotNullParam("before2", before2); return () -> apply(before1.get(), before2.get()); } }
/** * Run the given task with this contextual object selected. * * @param function the task to run (must not be {@code null}) * @param param1 the first parameter to pass to the task * @param param2 the second parameter to pass to the task * @param <T> the first parameter type * @param <U> the second parameter type * @param <R> the return value type * @param <E> the exception type * @return the action return value * @throws E if an exception occurs in the task */ default <T, U, R, E extends Exception> R runExBiFunction(ExceptionBiFunction<T, U, R, E> function, T param1, U param2) throws E { final ContextManager<C> contextManager = getInstanceContextManager(); final C old = contextManager.getAndSetCurrent(this); try { return function.apply(param1, param2); } finally { contextManager.restoreCurrent(old); } }
final SecurityRealm securityRealm = getRealmInfo(realmNestedPrincipal.getRealmName()).getSecurityRealm(); if (realmType.isInstance(securityRealm)) { return fn.apply(realmType.cast(securityRealm), realmNestedPrincipal.getNestedPrincipal()); } else { return nonExistent.get(); return fn.apply(realmType.cast(securityRealm), realmRewrittenPrincipal); } else { return nonExistent.get();
switch (reader.getLocalName()) { case "rule": { rulesList.add(ruleParseFunction.apply(reader, configurations)); break;
/** * Run an action under this identity. * * @param parameter1 the first parameter to pass to the action * @param parameter2 the second parameter to pass to the action * @param action the action to run * @param <R> the action return type * @param <T> the action first parameter type * @param <U> the action second parameter type * @param <E> the action exception type * @return the action result (may be {@code null}) * @throws E if the action throws this exception */ public <T, U, R, E extends Exception> R runAsFunctionEx(ExceptionBiFunction<T, U, R, E> action, T parameter1, U parameter2) throws E { if (action == null) return null; final Supplier<SecurityIdentity>[] oldWithIdentities = establishIdentities(); final Supplier<SecurityIdentity> oldIdentity = securityDomain.getAndSetCurrentSecurityIdentity(this); try { return action.apply(parameter1, parameter2); } finally { securityDomain.setCurrentSecurityIdentity(oldIdentity); restoreIdentities(oldWithIdentities); } }
public static <T, U, R, E extends Exception> R applyWithInterruptHandler(InterruptHandler interruptHandler, ExceptionBiFunction<T, U, R, E> function, T param1, U param2) throws E { final JBossThread thread = currentThread(); if (thread == null) { return function.apply(param1, param2); } else { final InterruptHandler old = thread.interruptHandler; thread.interruptHandler = interruptHandler; try { return function.apply(param1, param2); } finally { thread.interruptHandler = old; } } }
public static <T, U, R, E extends Exception> R applyWithInterruptHandler(InterruptHandler interruptHandler, ExceptionBiFunction<T, U, R, E> function, T param1, U param2) throws E { final JBossThread thread = currentThread(); if (thread == null) { return function.apply(param1, param2); } else { final InterruptHandler old = thread.interruptHandler; thread.interruptHandler = interruptHandler; try { return function.apply(param1, param2); } finally { thread.interruptHandler = old; } } }
public <T, U, R, E extends Exception> R performFunction(ExceptionBiFunction<T, U, R, E> function, T param1, U param2) throws E, SystemException { final ContextTransactionManager tm = ContextTransactionManager.INSTANCE; if (Objects.equals(tm.getStateRef().get().transaction, this)) { return function.apply(param1, param2); } try (SysExTry ignored = whileSuspended()) { try (SysExTry ignored2 = whileResumed(this)) { return function.apply(param1, param2); } } }
public <T, U, R, E extends Exception> R performFunction(ExceptionBiFunction<T, U, R, E> function, T param1, U param2) throws E, SystemException { final ContextTransactionManager tm = ContextTransactionManager.INSTANCE; if (Objects.equals(tm.getStateRef().get().transaction, this)) { return function.apply(param1, param2); } try (SysExTry ignored = whileSuspended()) { try (SysExTry ignored2 = whileResumed(this)) { return function.apply(param1, param2); } } }