| /* |
| * Copyright 2011 Google Inc. |
| * |
| * 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 com.google.gwt.i18n.server.impl; |
| |
| import com.google.gwt.i18n.server.AbstractMessage; |
| import com.google.gwt.i18n.server.AbstractParameter; |
| import com.google.gwt.i18n.server.MessageTranslation; |
| import com.google.gwt.i18n.server.Parameter; |
| import com.google.gwt.i18n.server.Type; |
| import com.google.gwt.i18n.shared.AlternateMessageSelector; |
| import com.google.gwt.i18n.shared.GwtLocale; |
| import com.google.gwt.i18n.shared.GwtLocaleFactory; |
| import com.google.gwt.safehtml.shared.SafeHtml; |
| |
| import java.lang.annotation.Annotation; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.ParameterizedType; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Date; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * Implementation of {@link com.google.gwt.i18n.server.Message Message} |
| * using reflection. |
| * |
| * <p><b>NOTE: THIS CLASS IS CURRENTLY ONLY SUITABLE FOR TESTING OR IF YOU |
| * DON'T CARE ABOUT ACCURATE ARGUMENT NAMES</b> |
| */ |
| public class ReflectionMessage extends AbstractMessage { |
| |
| private class ReflectionParameter extends AbstractParameter { |
| |
| private final Annotation[] annotations; |
| |
| public ReflectionParameter(int idx, java.lang.reflect.Type type, |
| Annotation[] annotations) { |
| super(getLocaleFactory(), idx, mapClassToType(type)); |
| this.annotations = annotations; |
| } |
| |
| @Override |
| public <A extends Annotation> A getAnnotation(Class<A> annotClass) { |
| return ReflectionMessage.findAnnotation(annotations, annotClass); |
| } |
| |
| @Override |
| public String getName() { |
| String[] names = ((ReflectionMessageInterface) getMessageInterface()) |
| .getParameterNames(method); |
| if (names != null) { |
| return names[getIndex()]; |
| } |
| return "arg" + index; |
| } |
| } |
| |
| private static <A> A findAnnotation(Annotation[] annotations, |
| Class<A> annotClass) { |
| for (Annotation annot : annotations) { |
| if (annot.annotationType().equals(annotClass)) { |
| return annotClass.cast(annot); |
| } |
| } |
| return null; |
| } |
| |
| private static <A extends Annotation> A getAnnotation(Method method, |
| Class<A> annotClass) { |
| A result = method.getAnnotation(annotClass); |
| if (result != null) { |
| return result; |
| } |
| return ReflectionUtils.getAnnotation(method.getDeclaringClass(), |
| annotClass, true); |
| } |
| |
| private final Method method; |
| |
| // TODO(jat): some way of fetching messages from property files/etc |
| // not needed for writing translatable messages to output file, but needed |
| // for eventual goal of using this API for the generator itself. |
| public ReflectionMessage(GwtLocaleFactory localeFactory, |
| ReflectionMessageInterface msgIntf, Method method) { |
| super(localeFactory, msgIntf); |
| this.method = method; |
| init(); |
| } |
| |
| public List<AlternateMessageSelector> getAlternateSelectors() { |
| // TODO(jat): implement |
| throw new UnsupportedOperationException(); |
| } |
| |
| @Override |
| public <A extends Annotation> A getAnnotation(Class<A> annotClass) { |
| return getAnnotation(method, annotClass); |
| } |
| |
| @Override |
| public String getMethodName() { |
| return method.getName(); |
| } |
| |
| @Override |
| public List<Parameter> getParameters() { |
| java.lang.reflect.Type[] paramTypes = method.getGenericParameterTypes(); |
| Annotation[][] paramAnnot = method.getParameterAnnotations(); |
| List<Parameter> params = new ArrayList<Parameter>(); |
| int n = paramTypes.length; |
| for (int i = 0; i < n; ++i) { |
| Parameter param = new ReflectionParameter(i, paramTypes[i], paramAnnot[i]); |
| params.add(param); |
| } |
| return Collections.unmodifiableList(params); |
| } |
| |
| @Override |
| public Type getReturnType() { |
| Class<?> type = method.getReturnType(); |
| return mapClassToType(type); |
| } |
| |
| @Override |
| public MessageTranslation getTranslation(GwtLocale locale) { |
| // TODO(jat): implement |
| return this; |
| } |
| |
| @Override |
| public boolean isAnnotationPresent(Class<? extends Annotation> annotClass) { |
| if (method.isAnnotationPresent(annotClass)) { |
| return true; |
| } |
| return ReflectionUtils.getAnnotation(method.getDeclaringClass(), |
| annotClass, true) != null; |
| } |
| |
| public boolean isVarArgs() { |
| return method.isVarArgs(); |
| } |
| |
| @Override |
| public String toString() { |
| return getMessageInterface().toString() + "." + method.getName(); |
| } |
| |
| private Type mapClassToType(java.lang.reflect.Type type) { |
| if (type instanceof Class<?>) { |
| Class<?> clazz = (Class<?>) type; |
| if (clazz.isPrimitive()) { |
| if (clazz == boolean.class) { |
| return Type.BOOLEAN; |
| } |
| if (clazz == byte.class) { |
| return Type.BYTE; |
| } |
| if (clazz == char.class) { |
| return Type.CHAR; |
| } |
| if (clazz == double.class) { |
| return Type.DOUBLE; |
| } |
| if (clazz == float.class) { |
| return Type.FLOAT; |
| } |
| if (clazz == int.class) { |
| return Type.INT; |
| } |
| if (clazz == long.class) { |
| return Type.LONG; |
| } |
| if (clazz == short.class) { |
| return Type.SHORT; |
| } |
| } |
| if (clazz == String.class) { |
| return Type.STRING; |
| } |
| if (Number.class.isAssignableFrom(clazz)) { |
| return Type.NUMBER; |
| } |
| if (SafeHtml.class.isAssignableFrom(clazz)) { |
| return Type.SAFEHTML; |
| } |
| if (Date.class.isAssignableFrom(clazz)) { |
| return Type.DATE; |
| } |
| if (Enum.class.isAssignableFrom(clazz)) { |
| Enum<?>[] enumConstants = (Enum<?>[]) clazz.getEnumConstants(); |
| int n = enumConstants.length; |
| String[] names = new String[n]; |
| for (int i = 0; i < n; ++i) { |
| names[i] = enumConstants[i].name(); |
| } |
| return new Type.EnumType(clazz.getCanonicalName(), names); |
| } |
| if (List.class.isAssignableFrom(clazz)) { |
| // raw list type |
| Type componentType = Type.OBJECT; |
| String sourceName = "java.util.List<java.util.Object>"; |
| return new Type.ListType(sourceName, componentType); |
| } |
| if (clazz.isArray()) { |
| Class<?> componentClass = clazz.getComponentType(); |
| Type componentType = mapClassToType(componentClass); |
| return new Type.ArrayType(componentType.toString() + "[]", |
| componentType); |
| } |
| } |
| if (type instanceof ParameterizedType) { |
| ParameterizedType pType = (ParameterizedType) type; |
| java.lang.reflect.Type rawType = pType.getRawType(); |
| if (rawType instanceof Class<?>) { |
| Class<?> clazz = (Class<?>) rawType; |
| if (List.class.isAssignableFrom(clazz)) { |
| java.lang.reflect.Type[] typeArgs = pType.getActualTypeArguments(); |
| Type componentType = mapClassToType(typeArgs[0]); |
| String sourceName = clazz.getCanonicalName() + "<" |
| + componentType.getSourceName() + ">"; |
| return new Type.ListType(sourceName, componentType); |
| } |
| if (Map.class.isAssignableFrom(clazz)) { |
| if (type instanceof ParameterizedType) { |
| java.lang.reflect.Type[] typeArgs = pType.getActualTypeArguments(); |
| if (typeArgs.length == 2 && typeArgs[0] == String.class |
| && typeArgs[1] == String.class) { |
| return Type.STRING_MAP; |
| } |
| } |
| } |
| } |
| } |
| return new Type(type.toString()); |
| } |
| } |