org.wildfly.common.context.Contextual Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including
all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and
JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
The newest version!
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016 Red Hat, Inc., and individual contributors
* as indicated by the @author tags.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.wildfly.common.context;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.concurrent.Callable;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.LongFunction;
import java.util.function.Predicate;
import org.wildfly.common.Assert;
import org.wildfly.common._private.CommonMessages;
import org.wildfly.common.annotation.NotNull;
import org.wildfly.common.function.ExceptionBiConsumer;
import org.wildfly.common.function.ExceptionBiFunction;
import org.wildfly.common.function.ExceptionBiPredicate;
import org.wildfly.common.function.ExceptionConsumer;
import org.wildfly.common.function.ExceptionFunction;
import org.wildfly.common.function.ExceptionIntFunction;
import org.wildfly.common.function.ExceptionLongFunction;
import org.wildfly.common.function.ExceptionPredicate;
/**
* A base class for contexts which are activated in a thread-local context.
*
* @param the public type of the contextual object
*
* @author David M. Lloyd
*/
public interface Contextual> {
/**
* Get the context manager for this object. The implementation of this method normally should return a constant
* instance.
*
* @return the context manager (must not be {@code null})
*/
@NotNull
ContextManager getInstanceContextManager();
/**
* Run the given task with this contextual object selected.
*
* @param runnable the task to run (must not be {@code null})
*/
default void run(Runnable runnable) {
Assert.checkNotNullParam("runnable", runnable);
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
runnable.run();
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param action the task to run (must not be {@code null})
* @param the return value type
* @return the action return value
*/
default R runAction(PrivilegedAction action) {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return action.run();
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param action the task to run (must not be {@code null})
* @param the return value type
* @return the action return value
* @throws PrivilegedActionException if the action fails with an exception
*/
default R runExceptionAction(PrivilegedExceptionAction action) throws PrivilegedActionException {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return action.run();
} catch (Exception e) {
throw CommonMessages.msg.privilegedActionFailed(e);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param callable the task to run (must not be {@code null})
* @param the return value type
* @return the action return value
*/
default V runCallable(Callable callable) throws Exception {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return callable.call();
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param consumer 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 the first parameter type
* @param the second parameter type
*/
default void runBiConsumer(BiConsumer consumer, T param1, U param2) {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
consumer.accept(param1, param2);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param consumer 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 the first parameter type
* @param the second parameter type
* @param the exception type
* @throws E if an exception occurs in the task
*/
default void runExBiConsumer(ExceptionBiConsumer consumer, T param1, U param2) throws E {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
consumer.accept(param1, param2);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param consumer the task to run (must not be {@code null})
* @param param the parameter to pass to the task
* @param the parameter type
*/
default void runConsumer(Consumer consumer, T param) {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
consumer.accept(param);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param consumer the task to run (must not be {@code null})
* @param param the parameter to pass to the task
* @param the parameter type
* @param the exception type
* @throws E if an exception occurs in the task
*/
default void runExConsumer(ExceptionConsumer consumer, T param) throws E {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
consumer.accept(param);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* 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 the first parameter type
* @param the second parameter type
* @param the return value type
* @return the action return value
*/
default R runBiFunction(BiFunction function, T param1, U param2) {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return function.apply(param1, param2);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* 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 the first parameter type
* @param the second parameter type
* @param the return value type
* @param the exception type
* @return the action return value
* @throws E if an exception occurs in the task
*/
default R runExBiFunction(ExceptionBiFunction function, T param1, U param2) throws E {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return function.apply(param1, param2);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param function the task to run (must not be {@code null})
* @param param the parameter to pass to the task
* @param the parameter type
* @param the return value type
* @return the action return value
*/
default R runFunction(Function function, T param) {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return function.apply(param);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param function the task to run (must not be {@code null})
* @param param the parameter to pass to the task
* @param the parameter type
* @param the return value type
* @param the exception type
* @return the action return value
* @throws E if an exception occurs in the task
*/
default R runExFunction(ExceptionFunction function, T param) throws E {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return function.apply(param);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param predicate 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 the first parameter type
* @param the second parameter type
* @return the action return value
*/
default boolean runBiPredicate(BiPredicate predicate, T param1, U param2) {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return predicate.test(param1, param2);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param predicate 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 the first parameter type
* @param the second parameter type
* @param the exception type
* @return the action return value
* @throws E if an exception occurs in the task
*/
default boolean runExBiPredicate(ExceptionBiPredicate predicate, T param1, U param2) throws E {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return predicate.test(param1, param2);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param predicate the task to run (must not be {@code null})
* @param param the parameter to pass to the task
* @param the first parameter type
* @return the action return value
*/
default boolean runPredicate(Predicate predicate, T param) {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return predicate.test(param);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param predicate the task to run (must not be {@code null})
* @param param the parameter to pass to the task
* @param the first parameter type
* @param the exception type
* @return the action return value
* @throws E if an exception occurs in the task
*/
default boolean runExPredicate(ExceptionPredicate predicate, T param) throws E {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return predicate.test(param);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param function the task to run (must not be {@code null})
* @param value the parameter to pass to the task
* @param the return value type
* @return the action return value
*/
default T runIntFunction(IntFunction function, int value) {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return function.apply(value);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param function the task to run (must not be {@code null})
* @param value the parameter to pass to the task
* @param the return value type
* @param the exception type
* @return the action return value
* @throws E if an exception occurs in the task
*/
default T runExIntFunction(ExceptionIntFunction function, int value) throws E {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return function.apply(value);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param function the task to run (must not be {@code null})
* @param value the parameter to pass to the task
* @param the return value type
* @return the action return value
*/
default T runLongFunction(LongFunction function, long value) {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return function.apply(value);
} finally {
contextManager.restoreCurrent(old);
}
}
/**
* Run the given task with this contextual object selected.
*
* @param function the task to run (must not be {@code null})
* @param value the parameter to pass to the task
* @param the return value type
* @param the exception type
* @return the action return value
* @throws E if an exception occurs in the task
*/
default T runExLongFunction(ExceptionLongFunction function, long value) throws E {
final ContextManager contextManager = getInstanceContextManager();
final C old = contextManager.getAndSetCurrent(this);
try {
return function.apply(value);
} finally {
contextManager.restoreCurrent(old);
}
}
}