/**
* Checks whether or not a class is suitable to be adapted by TaskAdapter. If the class is of type
* Dispatchable, the check is not performed because the method that will be executed will be
* determined only at runtime of the actual task and not during parse time.
*
* <p>This only checks conditions which are additionally required for tasks adapted by
* TaskAdapter. Thus, this method should be called by Project.checkTaskClass.
*
* <p>Throws a BuildException and logs as Project.MSG_ERR for conditions that will cause the task
* execution to fail. Logs other suspicious conditions with Project.MSG_WARN.
*
* @param taskClass Class to test for suitability. Must not be <code>null</code>.
* @param project Project to log warnings/errors to. Must not be <code>null</code>.
* @see Project#checkTaskClass(Class)
*/
public static void checkTaskClass(final Class<?> taskClass, final Project project) {
if (!Dispatchable.class.isAssignableFrom(taskClass)) {
// don't have to check for interface, since then
// taskClass would be abstract too.
try {
final Method executeM = taskClass.getMethod("execute", (Class[]) null);
// don't have to check for public, since
// getMethod finds public method only.
// don't have to check for abstract, since then
// taskClass would be abstract too.
if (!Void.TYPE.equals(executeM.getReturnType())) {
final String message =
"return type of execute() should be "
+ "void but was \""
+ executeM.getReturnType()
+ "\" in "
+ taskClass;
project.log(message, Project.MSG_WARN);
}
} catch (NoSuchMethodException e) {
final String message = "No public execute() in " + taskClass;
project.log(message, Project.MSG_ERR);
throw new BuildException(message);
} catch (LinkageError e) {
String message = "Could not load " + taskClass + ": " + e;
project.log(message, Project.MSG_ERR);
throw new BuildException(message, e);
}
}
}
/**
* One and only implementation of restore state. Makes all other implementations unnecessary.
*
* @param context FacesContext
* @param state the state to be restored.
*/
public void restoreState(FacesContext context, Object state) {
FacesContext fc = FacesContext.getCurrentInstance();
Object[] savedState = (Object[]) state;
component.initialState = (Boolean) savedState[savedState.length - 1];
int length = (savedState.length - 1) / 2;
for (int i = 0; i < length; i++) {
Object value = savedState[i * 2 + 1];
if (Void.TYPE.equals(value)) {
value = null;
}
Serializable serializable = (Serializable) savedState[i * 2];
if (value != null) {
if (value instanceof Collection) {
value = restoreAttachedState(fc, value);
} else if (value instanceof StateHolderSaver) {
value = ((StateHolderSaver) value).restore(context);
} else {
value = (value instanceof Serializable ? value : restoreAttachedState(fc, value));
}
}
if (value instanceof Map) {
for (Map.Entry<String, Object> entry : ((Map<String, Object>) value).entrySet()) {
this.put(serializable, entry.getKey(), entry.getValue());
}
} else if (value instanceof List) {
for (Object o : ((List<Object>) value)) {
this.add(serializable, o);
}
} else {
put(serializable, value);
}
}
}
@Override
public Object invoke(Object p, Method m, Object[] args) throws Throwable {
if (m_getRecordName.equals(m)) {
return recordName;
}
assert Void.TYPE.equals(m.getReturnType());
for (MetricsRecord rec : subrecs) {
m.invoke(rec, args);
}
return null;
}
/**
* Retieves the type number corresponding to the class of an IN, IN OUT or OUT parameter.
*
* <p>This method extends getTypeNr to return OTHER for primitive arrays, classes that directly
* implement java.io.Serializable and non-primitive arrays whose base component implements
* java.io.Serializable, allowing, for instance, arguments and return types of primitive arrays,
* Serializable objects and arrays, of Serializable objects. Direct primitive types other than
* those mapping directly to the internal wrapper form are not yet handled. That is, HSQLDB cannot
* yet properly deal with CALLs involving methods with primitive byte, short, float or their
* corresponding wrappers, due to the way internal conversion works and lack of detection and
* narrowing code in Function to allow this. In other words, passing in or retrieving any of the
* mentioned types always causes conversion to a wider internal wrapper which is genrally
* incompatible under reflective invocation, resulting in an IllegalArgumentException.
*
* @param c a Class instance
* @return java.sql.Types int value
* @throws HsqlException
*/
static int getParameterTypeNr(Class c) throws HsqlException {
String name;
String msg;
int type;
Trace.doAssert(c != null, "c is null");
if (Void.TYPE.equals(c)) {
return Types.NULL;
}
name = c.getName();
msg = "Unsupported parameter/return value class: ";
if (illegalParameterClasses.contains(c)) {
throw Trace.error(Trace.WRONG_DATA_TYPE, msg + name);
}
type = typeAliases.get(name, Integer.MIN_VALUE);
if (type == Integer.MIN_VALUE) {
// byte[] is already covered as BINARY in typeAliases
if (c.isArray()) {
while (c.isArray()) {
c = c.getComponentType();
}
if (c.isPrimitive() || java.io.Serializable.class.isAssignableFrom(c)) {
type = OTHER;
}
} else if (java.io.Serializable.class.isAssignableFrom(c)) {
type = OTHER;
}
}
Trace.check(type != Integer.MIN_VALUE, Trace.WRONG_DATA_TYPE, msg + name);
return type;
}
/** @see https://github.com/wordnik/swagger-core/wiki/datatypes */
protected static SwaggerDataType convertToSwaggerType(SwaggerModel models, Class<?> type) {
if (Void.TYPE.equals(type)) {
return new SwaggerDataType("void");
} else if (Integer.TYPE.equals(type) || Integer.class.isAssignableFrom(type)) {
return new SwaggerDataType("integer", "int32");
} else if (Long.TYPE.equals(type) || Long.class.isAssignableFrom(type)) {
return new SwaggerDataType("integer", "int64");
} else if (Float.TYPE.equals(type) || Float.class.isAssignableFrom(type)) {
return new SwaggerDataType("number", "float");
} else if (Double.TYPE.equals(type) || Double.class.isAssignableFrom(type)) {
return new SwaggerDataType("number", "double");
} else if (Byte.TYPE.equals(type) || Byte.class.isAssignableFrom(type)) {
return new SwaggerDataType("string", "byte");
} else if (Boolean.TYPE.equals(type) || Boolean.class.isAssignableFrom(type)) {
return new SwaggerDataType("boolean");
} else if (Number.class.isAssignableFrom(type)) {
return new SwaggerDataType("number");
} else if (String.class.equals(type)) {
return new SwaggerDataType("string");
} else if (Date.class.equals(type)) {
return new SwaggerDataType("string", "date-time");
} else if (type.isEnum()) {
return new SwaggerDataType("string");
} else if (type.isArray() || Collection.class.isAssignableFrom(type)) {
return new SwaggerDataType("array");
} else {
// it's a custom type, we need to create a model for it (if it does not already exist)
String typeName = type.getName();
if (!models.containsKey(typeName)) {
// Reserve a spot for this type, avoids circular references to cause a StackOverflow, see
// AMDATUWEB-10...
models.put(typeName, null);
// Overwrite the item with the actual model definition...
models.put(typeName, convertToSwaggerModel(models, type));
}
return new SwaggerDataType(type.getName());
}
}
/**
* Retrieves the SQL data type corrsponding to the Class of the "widest" internal represention in
* which instances of the specified Class can fit without a non-trivial conversion via
* Column.convertObject(Object,int).
*
* <p>By trivial, it is meant converting an Object, o, to a JavaObject holder for o.
*/
static int getWidestTypeNrNoConvert(Class c) {
if (c == null || Void.TYPE.equals(c)) {
return NULL;
}
if (Boolean.class.equals(c)) {
return BIT;
} else if (String.class.equals(c)) {
return LONGVARCHAR;
} else if (Binary.class.equals(c)) {
return LONGVARBINARY;
} else if (Integer.class.equals(c)) {
return INTEGER;
} else if (Long.class.equals(c)) {
return BIGINT;
} else if (Double.class.equals(c)) {
return DOUBLE;
} else if (java.sql.Date.class.isAssignableFrom(c)) {
return DATE;
} else if (java.sql.Time.class.isAssignableFrom(c)) {
return TIME;
} else if (java.sql.Timestamp.class.isAssignableFrom(c)) {
return TIMESTAMP;
} else if (java.math.BigDecimal.class.equals(c)) {
return DECIMAL;
}
// Others, including JavaObject, must be converted.
// We could check for Serializable.class.isAssignableFrom(c)
// here and throw if not, but that will be picked up in the
// conversion, so it's redundant here.
// In other words, please note the NoConvert suffix
// of the method name. It's there for a reason.
return OTHER;
}
public MethodInvokingCorrelationStrategy(Object object, Method method) {
Assert.notNull(object, "'object' must not be null");
Assert.notNull(method, "'method' must not be null");
Assert.isTrue(!Void.TYPE.equals(method.getReturnType()), "Method return type must not be void");
this.processor = new MethodInvokingMessageProcessor<Object>(object, method);
}
public static boolean isVoid(ResolvedType returnType) {
return Void.class.equals(returnType.getErasedType())
|| Void.TYPE.equals(returnType.getErasedType());
}
/** Returns {@code true} if the method return type is void, {@code false} otherwise. */
public boolean isVoid() {
return Void.TYPE.equals(getReturnType().getParameterType());
}
public static boolean isInterceptorMethod(
InterceptionType interceptionType, MethodMetadata method, boolean forTargetClass) {
if (!method.getSupportedInterceptionTypes().contains(interceptionType)) {
return false;
}
if (interceptionType.isLifecycleCallback()) {
if (!Void.TYPE.equals(method.getReturnType())) {
if (LOG.isWarnEnabled()) {
LOG.warn(
getStandardIgnoredMessage(interceptionType, method.getJavaMethod())
+ "does not have a void return type");
}
return false;
}
Class<?>[] parameterTypes = method.getJavaMethod().getParameterTypes();
if (forTargetClass && parameterTypes.length != 0) {
if (LOG.isWarnEnabled()) {
LOG.warn(
getStandardIgnoredMessage(interceptionType, method.getJavaMethod())
+ "is defined on the target class and does not have 0 arguments");
}
return false;
}
if (!forTargetClass && parameterTypes.length != 1) {
if (LOG.isWarnEnabled()) {
LOG.warn(
getStandardIgnoredMessage(interceptionType, method.getJavaMethod())
+ "does not have exactly one parameter");
}
return false;
}
if (parameterTypes.length == 1
&& !InvocationContext.class.isAssignableFrom(parameterTypes[0])) {
if (LOG.isWarnEnabled()) {
LOG.warn(
getStandardIgnoredMessage(interceptionType, method.getJavaMethod())
+ "its single argument is not a "
+ InvocationContext.class.getName());
}
return false;
}
return true;
} else {
if (!Object.class.equals(method.getReturnType())) {
if (LOG.isWarnEnabled()) {
LOG.warn(
getStandardIgnoredMessage(interceptionType, method.getJavaMethod())
+ "does not return a "
+ OBJECT_CLASS_NAME);
}
return false;
}
Class<?>[] parameterTypes = method.getJavaMethod().getParameterTypes();
if (parameterTypes.length != 1) {
if (LOG.isWarnEnabled()) {
LOG.debug(
getStandardIgnoredMessage(interceptionType, method.getJavaMethod())
+ "does not have exactly 1 parameter");
}
return false;
}
if (!InvocationContext.class.isAssignableFrom(parameterTypes[0])) {
if (LOG.isWarnEnabled()) {
LOG.debug(
getStandardIgnoredMessage(interceptionType, method.getJavaMethod())
+ "does not have a "
+ InvocationContext.class.getName()
+ " parameter ");
}
return false;
}
return true;
}
}
/**
* Creates a gateway instance for the given <code>gatewayInterface</code>. The returned instance
* is a Proxy that implements that interface.
*
* @param gatewayInterface The interface declaring the gateway methods
* @param <T> The interface declaring the gateway methods
* @return A Proxy implementation implementing the given interface
*/
@SuppressWarnings("unchecked")
public <T> T createGateway(Class<T> gatewayInterface) {
Map<Method, InvocationHandler> dispatchers = new HashMap<Method, InvocationHandler>();
for (Method gatewayMethod : gatewayInterface.getMethods()) {
MetaDataExtractor[] extractors = extractMetaData(gatewayMethod.getParameterAnnotations());
InvocationHandler dispatcher =
new DispatchOnInvocationHandler(
commandBus, retryScheduler,
dispatchInterceptors, extractors);
final Class<?>[] arguments = gatewayMethod.getParameterTypes();
if (Future.class.equals(gatewayMethod.getReturnType())) {
// no wrapping
} else if (arguments.length >= 3
&& TimeUnit.class.isAssignableFrom(arguments[arguments.length - 1])
&& (long.class.isAssignableFrom(arguments[arguments.length - 2])
|| int.class.isAssignableFrom(arguments[arguments.length - 2]))) {
dispatcher =
wrapToReturnWithTimeoutInArguments(
dispatcher, arguments.length - 2, arguments.length - 1);
} else {
Timeout timeout = gatewayMethod.getAnnotation(Timeout.class);
if (timeout == null) {
timeout = gatewayMethod.getDeclaringClass().getAnnotation(Timeout.class);
}
if (timeout != null) {
dispatcher = wrapToReturnWithFixedTimeout(dispatcher, timeout.value(), timeout.unit());
} else if (!Void.TYPE.equals(gatewayMethod.getReturnType())
|| gatewayMethod.getExceptionTypes().length > 0) {
dispatcher = wrapToWaitForResult(dispatcher);
} else {
dispatcher = wrapToFireAndForget(dispatcher);
}
}
Class<?>[] declaredExceptions = gatewayMethod.getExceptionTypes();
if (!contains(declaredExceptions, TimeoutException.class)) {
dispatcher = wrapToReturnNullOnTimeout(dispatcher);
}
if (!contains(declaredExceptions, InterruptedException.class)) {
dispatcher = wrapToReturnNullOnInterrupted(dispatcher);
}
dispatcher = wrapUndeclaredExceptions(dispatcher, declaredExceptions);
dispatchers.put(gatewayMethod, dispatcher);
}
return gatewayInterface.cast(
Proxy.newProxyInstance(
gatewayInterface.getClassLoader(),
new Class[] {gatewayInterface},
new GatewayInvocationHandler(
dispatchers, commandBus, retryScheduler, dispatchInterceptors)));
}
