Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.google.gwt.i18n.rebind.ConstantsWithLookupImplCreator Maven / Gradle / Ivy
/*
* 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.JClassType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.JType;
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.thirdparty.guava.common.collect.Lists;
import com.google.gwt.user.rebind.SourceWriter;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
class ConstantsWithLookupImplCreator extends ConstantsImplCreator {
/**
* Used partition size if no one is specified.
*
* Used in constructor without a partition size.
*/
private static final int DEFAULT_PARTITIONS_SIZE = 500;
final JMethod[] allInterfaceMethods;
private final Map namesToMethodCreators = new HashMap<>();
private final Map>> neededPartitionLookups = new HashMap<>();
private final int partitionsSize;
/**
* Constructor for ConstantsWithLookupImplCreator. The default partition size of
* {@value #DEFAULT_PARTITIONS_SIZE} is used.
*
* @param logger logger to print errors
* @param writer Writer to print to
* @param localizableClass class/interface to conform to
* @param resourceList resource bundle used to generate the class
* @param oracle types
* @throws UnableToCompleteException
*
* @see LookupMethodCreator#DEFAULT_PARTITIONS_SIZE
*/
ConstantsWithLookupImplCreator(TreeLogger logger, SourceWriter writer,
JClassType localizableClass, ResourceList resourceList, TypeOracle oracle)
throws UnableToCompleteException {
this(logger, writer, localizableClass, resourceList, oracle, DEFAULT_PARTITIONS_SIZE);
}
/**
* Constructor for ConstantsWithLookupImplCreator.
*
* @param logger logger to print errors
* @param writer Writer to print to
* @param localizableClass class/interface to conform to
* @param resourceList resource bundle used to generate the class
* @param oracle types
* @throws UnableToCompleteException
*/
ConstantsWithLookupImplCreator(TreeLogger logger, SourceWriter writer,
JClassType localizableClass, ResourceList resourceList, TypeOracle oracle,
int partitionsSize) throws UnableToCompleteException {
super(logger, writer, localizableClass, resourceList, oracle);
this.partitionsSize = partitionsSize;
try {
// Boolean
JType booleanType = oracle.parse(boolean.class.getName());
LookupMethodCreator booleanMethod = new LookupMethodCreator(this,
booleanType) {
@Override
public void printReturnTarget() {
println("return target.booleanValue();");
}
@Override
public String returnTemplate() {
return "boolean answer = {0}();\n"
+ "cache.put(\"{0}\",new Boolean(answer));\n"
+ "return answer;";
}
};
namesToMethodCreators.put("getBoolean", booleanMethod);
// Double
JType doubleType = oracle.parse(double.class.getName());
LookupMethodCreator doubleMethod = new LookupMethodCreator(this,
doubleType) {
@Override
public void printReturnTarget() {
println("return target.doubleValue();");
}
@Override
public String returnTemplate() {
return "double answer = {0}();\n"
+ "cache.put(\"{0}\",new Double(answer));\n"
+ "return answer;";
}
};
namesToMethodCreators.put("getDouble", doubleMethod);
// Int
JType intType = oracle.parse(int.class.getName());
LookupMethodCreator intMethod = new LookupMethodCreator(this, intType) {
@Override
public void printReturnTarget() {
println("return target.intValue();");
}
@Override
public String returnTemplate() {
return "int answer = {0}();\n"
+ "cache.put(\"{0}\",new Integer(answer));\n"
+ "return answer;";
}
};
namesToMethodCreators.put("getInt", intMethod);
// Float
JType floatType = oracle.parse(float.class.getName());
LookupMethodCreator floatMethod = new LookupMethodCreator(this, floatType) {
@Override
public String returnTemplate() {
String val = "float answer = {0}();\n"
+ "cache.put(\"{0}\", new Float(answer));\n"
+ "return answer;";
return val;
}
@Override
protected void printReturnTarget() {
println("return target.floatValue();");
}
};
namesToMethodCreators.put("getFloat", floatMethod);
// Map - use erased type for matching
JType mapType = oracle.parse(Map.class.getName()).getErasedType();
namesToMethodCreators.put("getMap",
new LookupMethodCreator(this, mapType) {
@Override
public String getReturnTypeName() {
return ConstantsMapMethodCreator.GENERIC_STRING_MAP_TYPE;
}
});
// String
JType stringType = oracle.parse(String.class.getName());
LookupMethodCreator stringMethod = new LookupMethodCreator(this,
stringType) {
@Override
public String returnTemplate() {
return "String answer = {0}();\n"
+ "cache.put(\"{0}\",answer);\n"
+ "return answer;";
}
};
namesToMethodCreators.put("getString", stringMethod);
// String Array
JType stringArray = oracle.getArrayType(stringType);
namesToMethodCreators.put("getStringArray", new LookupMethodCreator(this,
stringArray));
setNeedCache(true);
allInterfaceMethods = getAllInterfaceMethods(localizableClass);
} catch (TypeOracleException e) {
throw error(logger, e);
}
}
@Override
protected void classEpilog() {
createNeededPartitionLookups();
super.classEpilog();
}
/**
* 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 {
checkMethod(logger, method);
if (method.getParameters().length == 1) {
String name = method.getName();
LookupMethodCreator c = getLookupMethodCreator(name);
if (c != null) {
createMethodWithPartitionCheckFor(c, method);
return;
}
}
// fall through
super.emitMethodBody(logger, method, locale);
}
void addNeededPartitionLookups(JMethod targetMethod,
List> methodToCreatePartitionLookups) {
neededPartitionLookups.put(targetMethod, methodToCreatePartitionLookups);
}
void createMethodWithPartitionCheckFor(LookupMethodCreator methodCreator, JMethod targetMethod) {
List> methodPartitions = findMethodsToCreateWithPartitionSize(targetMethod,
methodCreator.getReturnType());
String nextPartitionMethod = null;
final List> methodToCreatePartitionLookups;
final List methodsToCreate;
if (methodPartitions.size() > 1) {
nextPartitionMethod = createPartitionMethodName(targetMethod, 0);
methodsToCreate = methodPartitions.get(0);
methodToCreatePartitionLookups = methodPartitions.subList(1, methodPartitions.size());
} else {
methodsToCreate = methodPartitions.isEmpty() ? Collections. emptyList()
: methodPartitions.get(0);
methodToCreatePartitionLookups = Collections.emptyList();
}
addNeededPartitionLookups(targetMethod, methodToCreatePartitionLookups);
methodCreator.createCacheLookupFor();
methodCreator.createMethodFor(targetMethod, methodsToCreate, nextPartitionMethod);
}
String createPartitionMethodName(JMethod targetMethod, int partitionIndex) {
final String templatePartitionMethodName = "{0}FromPartition{1}";
return MessageFormat.format(templatePartitionMethodName, new Object[] {
targetMethod.getName(), partitionIndex});
}
List findAllMethodsToCreate(JMethod targetMethod, JType methodReturnType) {
JMethod[] allMethods = allInterfaceMethods;
JType erasedType = methodReturnType.getErasedType();
List methodsToCreate = new ArrayList<>();
for (JMethod methodToCheck : allMethods) {
if (methodToCheck.getReturnType().getErasedType().equals(erasedType)
&& methodToCheck != targetMethod) {
methodsToCreate.add(methodToCheck);
}
}
return methodsToCreate;
}
List> findMethodsToCreateWithPartitionSize(JMethod targetMethod,
JType methodReturnType) {
List allMethodsToCreate = findAllMethodsToCreate(targetMethod, methodReturnType);
return Lists.partition(allMethodsToCreate, partitionsSize);
}
LookupMethodCreator getLookupMethodCreator(String name) {
return namesToMethodCreators.get(name);
}
/**
* Visible for testing only.
*/
Map>> getNeededPartitionLookups() {
return neededPartitionLookups;
}
/**
* Checks that the method has the right structure to implement
* Constant.
*
* @param method method to check
*/
private void checkMethod(TreeLogger logger, JMethod method)
throws UnableToCompleteException {
if (getLookupMethodCreator(method.getName()) != null) {
JParameter[] params = method.getParameters();
// user may have specified a method named getInt/etc with no parameters
// this isn't a conflict, so treat them like any other Constant methods
if (params.length == 0) {
checkConstantMethod(logger, method);
} else {
if (params.length != 1
|| !params[0].getType().getQualifiedSourceName().equals(
"java.lang.String")) {
throw error(logger, method + " must have a single String argument.");
}
checkReturnType(logger, method);
}
} else {
checkConstantMethod(logger, method);
}
}
private void createNeededPartitionLookups() {
for (Entry>> neededPartitionLookup :
neededPartitionLookups.entrySet()) {
JMethod targetMethod = neededPartitionLookup.getKey();
LookupMethodCreator lookupMethodCreator = getLookupMethodCreator(targetMethod.getName());
List> methodForPartitionLookups = neededPartitionLookup.getValue();
int partitionStartIndex = 0;
Iterator> neededPartitionIterator = methodForPartitionLookups.iterator();
while (neededPartitionIterator.hasNext()) {
String currentPartitionLookupMethodName = createPartitionMethodName(targetMethod,
partitionStartIndex++);
List methodsToCreate = neededPartitionIterator.next();
String nextPartitionMethod = null;
if (neededPartitionIterator.hasNext()) {
nextPartitionMethod = createPartitionMethodName(targetMethod, partitionStartIndex);
}
lookupMethodCreator.createPartitionLookup(currentPartitionLookupMethodName, targetMethod,
methodsToCreate, nextPartitionMethod);
}
}
}
}
