user/src/com/google/gwt/i18n/rebind/TypeOracleMessage.java

/*
 * 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.rebind;

import com.google.gwt.core.ext.typeinfo.JArrayType;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JEnumConstant;
import com.google.gwt.core.ext.typeinfo.JEnumType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.JParameterizedType;
import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.i18n.rebind.AbstractResource.ResourceEntry;
import com.google.gwt.i18n.rebind.AbstractResource.ResourceList;
import com.google.gwt.i18n.server.AbstractMessage;
import com.google.gwt.i18n.server.AbstractParameter;
import com.google.gwt.i18n.server.MessageInterface;
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.GwtLocale;
import com.google.gwt.i18n.shared.GwtLocaleFactory;
import com.google.gwt.safehtml.shared.SafeHtml;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * An implementation of the {@link com.google.gwt.i18n.server.Message} API on
 * top of type oracle.
 */
public class TypeOracleMessage extends AbstractMessage {

  /**
   * An implementation of {@link Parameter} on top of type oracle.
   */
  public class TypeOracleParameter extends AbstractParameter {

    private final JParameter param;

    public TypeOracleParameter(int index, JParameter param) {
      super(getLocaleFactory(), index, mapJTypeToType(param.getType()));
      this.param = param;
    }

    @Override
    public <A extends Annotation> A getAnnotation(Class<A> annotClass) {
      return param.getAnnotation(annotClass);
    }

    @Override
    public String getName() {
      return param.getName();
    }

    @Override
    public boolean isAnnotationPresent(Class<? extends Annotation> annotClass) {
      return param.isAnnotationPresent(annotClass);
    }
  }

  /**
   * A single translated message obtained from an {@link AbstractResource}.
   */
  private class ResourceMessageTranslation
      implements MessageTranslation {

    private final ResourceEntry resourceEntry;
    private final GwtLocale matchedLocale;

    public ResourceMessageTranslation(ResourceEntry resourceEntry,
        GwtLocale matchedLocale) {
      this.resourceEntry = resourceEntry;
      this.matchedLocale = matchedLocale;
    }

    public Iterable<AlternateFormMapping> getAllMessageForms() {
      List<AlternateFormMapping> mapping = new ArrayList<AlternateFormMapping>();
      // add the default form
      if (!isStringMap()) {
        mapping.add(new AlternateFormMapping(defaultForms(),
            getDefaultMessage()));
      }

      // add supplied forms
      int numSelectors = getSelectorParameterIndices().length;
      for (String joinedForms : resourceEntry.getForms()) {
        addMapping(mapping, numSelectors, joinedForms,
            resourceEntry.getForm(joinedForms));
      }

      // sort into lexicographic order and return
      Collections.sort(mapping);
      return mapping;
    }

    public String getDefaultMessage() {
      return resourceEntry.getForm(null);
    }

    public GwtLocale getMatchedLocale() {
      return matchedLocale;
    }

    @Override
    public String toString() {
      StringBuilder buf = new StringBuilder();
      buf.append("ResourceMT: ").append(resourceEntry);
      return buf.toString();
    }
  }

  private final JMethod method;

  private final TypeOracle oracle;

  private List<Parameter> parameters;

  private final ResourceList resources;

  public TypeOracleMessage(TypeOracle oracle, GwtLocaleFactory localeFactory,
      MessageInterface msgIntf, JMethod method, ResourceList resources) {
    super(localeFactory, msgIntf);
    this.method = method;
    this.oracle = oracle;
    this.resources = resources;
    init();
  }

  @Override
    public <A extends Annotation> A getAnnotation(Class<A> annotClass) {
      A annot = method.getAnnotation(annotClass);
      if (annot != null) {
        return annot;
      }
      return method.getEnclosingType().findAnnotationInTypeHierarchy(annotClass);
    }

 @Override
public String getMethodName() {
  return method.getName();
}

  @Override
  public List<Parameter> getParameters() {
    if (parameters == null) {
      ensureParameters();
    }
    return parameters;
  }

  @Override
  public Type getReturnType() {
    JType returnType = method.getReturnType();
    return mapJTypeToType(returnType);
  }

  @Override
  public MessageTranslation getTranslation(GwtLocale locale) {
    /*
     * TODO(jat): Note that we don't actually follow the contract here, since
     * the ResourceList we were supplied with has already been filtered
     * according to the locale we should be called with, for the limited use
     * case today of generating translation output files. This will have to be
     * updated when this is used for generating code as well.
     */
    ResourceEntry entry = null;
    if (resources != null) {
      entry = resources.getEntry(getKey());
    }
    if (entry != null) {
      return new ResourceMessageTranslation(entry,
          resources.findLeastDerivedLocale(null, locale));
    }
    return this;
  }

  @Override
  public boolean isAnnotationPresent(Class<? extends Annotation> annotClass) {
    return method.isAnnotationPresent(annotClass);
  }

  public boolean isVarArgs() {
    return method.isVarArgs();
  }

  protected Type mapJTypeToType(JType type) {
    JPrimitiveType primType = type.isPrimitive();
    if (primType != null) {
      if (primType == JPrimitiveType.BOOLEAN) {
        return Type.BOOLEAN;
      }
      if (primType == JPrimitiveType.BYTE) {
        return Type.BYTE;
      }
      if (primType == JPrimitiveType.CHAR) {
        return Type.CHAR;
      }
      if (primType == JPrimitiveType.DOUBLE) {
        return Type.DOUBLE;
      }
      if (primType == JPrimitiveType.FLOAT) {
        return Type.FLOAT;
      }
      if (primType == JPrimitiveType.INT) {
        return Type.INT;
      }
      if (primType == JPrimitiveType.LONG) {
        return Type.LONG;
      }
      if (primType == JPrimitiveType.SHORT) {
        return Type.SHORT;
      }
      throw new RuntimeException("Unexpected primitive type " + primType);
    }
    JArrayType arrayType = type.isArray();
    if (arrayType != null) {
      JType componentType = arrayType.getComponentType();
      return new Type.ArrayType(componentType.getQualifiedSourceName() + "[]",
          mapJTypeToType(componentType));
    }
    JEnumType enumType = type.isEnum();
    String qualSourceName = type.getQualifiedSourceName();
    if (enumType != null) {
      JEnumConstant[] enumConstants = enumType.getEnumConstants();
      int n = enumConstants.length;
      String[] names = new String[n];
      for (int i = 0; i < n; ++i) {
        names[i] = enumConstants[i].getName();
      }
      return new Type.EnumType(qualSourceName, names);
    }
    String stringQualifiedName = String.class.getCanonicalName();
    if (stringQualifiedName.equals(qualSourceName)) {
      return Type.STRING;
    }
    if (SafeHtml.class.getCanonicalName().equals(qualSourceName)) {
      return Type.SAFEHTML;
    }
    JClassType date = oracle.findType(Date.class.getCanonicalName());
    JClassType classType = type.isClassOrInterface();
    if (date != null && classType != null
        && date.isAssignableFrom(classType)) {
      return Type.DATE;
    }
    String listQualifiedName = List.class.getCanonicalName();
    JClassType list = oracle.findType(listQualifiedName);
    JParameterizedType parameterizedType = type.isParameterized();
    if (list != null && classType != null && list.isAssignableFrom(classType)) {
      if (parameterizedType == null) {
        // raw List usage
        return new Type.ListType(listQualifiedName + "<Object>", Type.OBJECT);
      }
      JType componentType = parameterizedType.getTypeArgs()[0];
      return new Type.ListType(listQualifiedName + "<"
          + componentType.getQualifiedSourceName() + ">",
          mapJTypeToType(componentType));
    }
    String mapQualifiedName = Map.class.getCanonicalName();
    JClassType map = oracle.findType(mapQualifiedName);
    if (map != null && classType != null && map.isAssignableFrom(classType)
        && parameterizedType != null) {
      JClassType[] typeArgs = parameterizedType.getTypeArgs();
      if (typeArgs.length == 2
          && stringQualifiedName.equals(typeArgs[0].getQualifiedSourceName())
          && stringQualifiedName.equals(typeArgs[1].getQualifiedSourceName())) {
        return Type.STRING_MAP;
      }
    }
    return new Type(qualSourceName);
  }

  private void ensureParameters() {
    parameters = new ArrayList<Parameter>();
    int i = 0;
    for (JParameter parameter : method.getParameters()) {
      parameters.add(new TypeOracleParameter(i++, parameter));
    }
  }
}