| /* | |
| * Copyright 2008 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.TreeLogger; | |
| import com.google.gwt.core.ext.UnableToCompleteException; | |
| import com.google.gwt.core.ext.typeinfo.JArrayType; | |
| import com.google.gwt.core.ext.typeinfo.JClassType; | |
| import com.google.gwt.core.ext.typeinfo.JMethod; | |
| 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.NotFoundException; | |
| import com.google.gwt.core.ext.typeinfo.TypeOracle; | |
| import com.google.gwt.core.ext.typeinfo.TypeOracleException; | |
| import com.google.gwt.i18n.rebind.AbstractResource.ResourceList; | |
| import com.google.gwt.i18n.shared.GwtLocale; | |
| import com.google.gwt.user.rebind.SourceWriter; | |
| import java.util.Map; | |
| /** | |
| * Creates the class implementation for a given resource bundle using the | |
| * standard <code>AbstractGeneratorClassCreator</code>. | |
| */ | |
| class ConstantsImplCreator extends AbstractLocalizableImplCreator { | |
| /** | |
| * Does a Map need to be generated in order to store complex results? | |
| */ | |
| private boolean needCache = false; | |
| /** | |
| * Constructor for <code>ConstantsImplCreator</code>. | |
| * | |
| * @param logger logger to print errors | |
| * @param writer <code>Writer</code> to print to | |
| * @param localizableClass class/interface to conform to | |
| * @param resourceList resource bundle used to generate the class | |
| * @param oracle types | |
| * @throws UnableToCompleteException | |
| */ | |
| public ConstantsImplCreator(TreeLogger logger, SourceWriter writer, | |
| JClassType localizableClass, ResourceList resourceList, TypeOracle oracle) | |
| throws UnableToCompleteException { | |
| super(logger, writer, localizableClass, resourceList, true); | |
| try { | |
| JClassType stringClass = oracle.getType(String.class.getName()); | |
| JClassType mapClass = oracle.getType(Map.class.getName()); | |
| JType stringArrayClass = oracle.getArrayType(stringClass); | |
| JType intClass = oracle.parse(int.class.getName()); | |
| JType doubleClass = oracle.parse(double.class.getName()); | |
| JType floatClass = oracle.parse(float.class.getName()); | |
| JType booleanClass = oracle.parse(boolean.class.getName()); | |
| register(stringClass, new SimpleValueMethodCreator(this, | |
| SimpleValueMethodCreator.STRING)); | |
| register(mapClass, new ConstantsMapMethodCreator(this)); | |
| register(intClass, new SimpleValueMethodCreator(this, | |
| SimpleValueMethodCreator.INT)); | |
| register(doubleClass, new SimpleValueMethodCreator(this, | |
| SimpleValueMethodCreator.DOUBLE)); | |
| register(floatClass, new SimpleValueMethodCreator(this, | |
| SimpleValueMethodCreator.FLOAT)); | |
| register(booleanClass, new SimpleValueMethodCreator(this, | |
| SimpleValueMethodCreator.BOOLEAN)); | |
| register(stringArrayClass, new ConstantsStringArrayMethodCreator(this)); | |
| } catch (NotFoundException e) { | |
| throw error(logger, e); | |
| } catch (TypeOracleException e) { | |
| throw error(logger, e); | |
| } | |
| } | |
| /** | |
| * Checks that the method has the right structure to implement | |
| * <code>Constant</code>. | |
| * | |
| * @param method method to check | |
| */ | |
| protected void checkConstantMethod(TreeLogger logger, JMethod method) | |
| throws UnableToCompleteException { | |
| if (method.getParameters().length > 0) { | |
| throw error(logger, | |
| "Methods in interfaces extending Constant must have no parameters"); | |
| } | |
| checkReturnType(logger, method); | |
| } | |
| /** | |
| * @param logger | |
| * @param method | |
| * @throws UnableToCompleteException | |
| */ | |
| protected void checkReturnType(TreeLogger logger, JMethod method) | |
| throws UnableToCompleteException { | |
| JType returnType = method.getReturnType(); | |
| JPrimitiveType primitive = returnType.isPrimitive(); | |
| if (primitive != null | |
| && (primitive == JPrimitiveType.BOOLEAN | |
| || primitive == JPrimitiveType.DOUBLE | |
| || primitive == JPrimitiveType.FLOAT || primitive == JPrimitiveType.INT)) { | |
| return; | |
| } | |
| JArrayType arrayType = returnType.isArray(); | |
| if (arrayType != null) { | |
| String arrayComponent = arrayType.getComponentType().getQualifiedSourceName(); | |
| if (!arrayComponent.equals("java.lang.String")) { | |
| throw error(logger, | |
| "Methods in interfaces extending Constant only support arrays of Strings"); | |
| } | |
| return; | |
| } | |
| String returnTypeName = returnType.getQualifiedSourceName(); | |
| if (returnTypeName.equals("java.lang.String")) { | |
| return; | |
| } | |
| if (returnTypeName.equals("java.util.Map")) { | |
| JParameterizedType paramType = returnType.isParameterized(); | |
| if (paramType != null) { | |
| JClassType[] typeArgs = paramType.getTypeArgs(); | |
| if (typeArgs.length != 2 | |
| || !typeArgs[0].getQualifiedSourceName().equals("java.lang.String") | |
| || !typeArgs[1].getQualifiedSourceName().equals("java.lang.String")) { | |
| throw error(logger, | |
| "Map Methods in interfaces extending Constant must be raw or <String, String>"); | |
| } | |
| } | |
| return; | |
| } | |
| throw error(logger, | |
| "Methods in interfaces extending Constant must have a return type of " | |
| + "String/int/float/boolean/double/String[]/Map"); | |
| } | |
| @Override | |
| protected void classEpilog() { | |
| if (isNeedCache()) { | |
| getWriter().println("java.util.Map cache = new java.util.HashMap();"); | |
| } | |
| } | |
| /** | |
| * Create the method body associated with the given method. Arguments are | |
| * arg0...argN. | |
| */ | |
| @Override | |
| protected void emitMethodBody(TreeLogger logger, JMethod method, | |
| GwtLocale locale) throws UnableToCompleteException { | |
| checkConstantMethod(logger, method); | |
| delegateToCreator(logger, method, locale); | |
| } | |
| boolean isNeedCache() { | |
| return needCache; | |
| } | |
| void setNeedCache(boolean needCache) { | |
| this.needCache = needCache; | |
| } | |
| } |