user/src/com/google/gwt/i18n/rebind/ConstantsWithLookupImplCreator.java - gwt - Git at Google

 /*
  * 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<String, LookupMethodCreator> namesToMethodCreators = new HashMap<>();

   private final Map<JMethod, List<List<JMethod>>> neededPartitionLookups = new HashMap<>();

   private final int partitionsSize;

   /**
    * Constructor for <code>ConstantsWithLookupImplCreator</code>. The default partition size of
    * {@value #DEFAULT_PARTITIONS_SIZE} is used.
    *
    * @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
    *
    * @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 <code>ConstantsWithLookupImplCreator</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
    */
   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<List<JMethod>> methodToCreatePartitionLookups) {
     neededPartitionLookups.put(targetMethod, methodToCreatePartitionLookups);
   }

   void createMethodWithPartitionCheckFor(LookupMethodCreator methodCreator, JMethod targetMethod) {
     List<List<JMethod>> methodPartitions = findMethodsToCreateWithPartitionSize(targetMethod,
         methodCreator.getReturnType());

     String nextPartitionMethod = null;
     final List<List<JMethod>> methodToCreatePartitionLookups;
     final List<JMethod> methodsToCreate;
     if (methodPartitions.size() > 1) {
       nextPartitionMethod = createPartitionMethodName(targetMethod, 0);
       methodsToCreate = methodPartitions.get(0);
       methodToCreatePartitionLookups = methodPartitions.subList(1, methodPartitions.size());
     } else {
       methodsToCreate = methodPartitions.isEmpty() ? Collections.<JMethod> 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<JMethod> findAllMethodsToCreate(JMethod targetMethod, JType methodReturnType) {
     JMethod[] allMethods = allInterfaceMethods;
     JType erasedType = methodReturnType.getErasedType();
     List<JMethod> methodsToCreate = new ArrayList<>();
     for (JMethod methodToCheck : allMethods) {
       if (methodToCheck.getReturnType().getErasedType().equals(erasedType)
           && methodToCheck != targetMethod) {
         methodsToCreate.add(methodToCheck);
       }
     }
     return methodsToCreate;
   }

   List<List<JMethod>> findMethodsToCreateWithPartitionSize(JMethod targetMethod,
       JType methodReturnType) {
     List<JMethod> allMethodsToCreate = findAllMethodsToCreate(targetMethod, methodReturnType);
     return Lists.partition(allMethodsToCreate, partitionsSize);
   }

   LookupMethodCreator getLookupMethodCreator(String name) {
     return namesToMethodCreators.get(name);
   }

   /**
    * Visible for testing only.
    */
   Map<JMethod, List<List<JMethod>>> getNeededPartitionLookups() {
     return neededPartitionLookups;
   }

   /**
    * Checks that the method has the right structure to implement
    * <code>Constant</code>.
    *
    * @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<JMethod, List<List<JMethod>>> neededPartitionLookup :
       neededPartitionLookups.entrySet()) {
       JMethod targetMethod = neededPartitionLookup.getKey();
       LookupMethodCreator lookupMethodCreator = getLookupMethodCreator(targetMethod.getName());
       List<List<JMethod>> methodForPartitionLookups = neededPartitionLookup.getValue();
       int partitionStartIndex = 0;
       Iterator<List<JMethod>> neededPartitionIterator = methodForPartitionLookups.iterator();
       while (neededPartitionIterator.hasNext()) {
         String currentPartitionLookupMethodName = createPartitionMethodName(targetMethod,
             partitionStartIndex++);
         List<JMethod> methodsToCreate = neededPartitionIterator.next();
         String nextPartitionMethod = null;
         if (neededPartitionIterator.hasNext()) {
           nextPartitionMethod = createPartitionMethodName(targetMethod, partitionStartIndex);
         }
         lookupMethodCreator.createPartitionLookup(currentPartitionLookupMethodName, targetMethod,
             methodsToCreate, nextPartitionMethod);
       }
     }
   }
 }
	/*
	* 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<String, LookupMethodCreator> namesToMethodCreators = new HashMap<>();

	private final Map<JMethod, List<List<JMethod>>> neededPartitionLookups = new HashMap<>();

	private final int partitionsSize;

	/**
	* Constructor for <code>ConstantsWithLookupImplCreator</code>. The default partition size of
	* {@value #DEFAULT_PARTITIONS_SIZE} is used.
	*
	* @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
	*
	* @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 <code>ConstantsWithLookupImplCreator</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
	*/
	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<List<JMethod>> methodToCreatePartitionLookups) {
	neededPartitionLookups.put(targetMethod, methodToCreatePartitionLookups);
	}

	void createMethodWithPartitionCheckFor(LookupMethodCreator methodCreator, JMethod targetMethod) {
	List<List<JMethod>> methodPartitions = findMethodsToCreateWithPartitionSize(targetMethod,
	methodCreator.getReturnType());

	String nextPartitionMethod = null;
	final List<List<JMethod>> methodToCreatePartitionLookups;
	final List<JMethod> methodsToCreate;
	if (methodPartitions.size() > 1) {
	nextPartitionMethod = createPartitionMethodName(targetMethod, 0);
	methodsToCreate = methodPartitions.get(0);
	methodToCreatePartitionLookups = methodPartitions.subList(1, methodPartitions.size());
	} else {
	methodsToCreate = methodPartitions.isEmpty() ? Collections.<JMethod> 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<JMethod> findAllMethodsToCreate(JMethod targetMethod, JType methodReturnType) {
	JMethod[] allMethods = allInterfaceMethods;
	JType erasedType = methodReturnType.getErasedType();
	List<JMethod> methodsToCreate = new ArrayList<>();
	for (JMethod methodToCheck : allMethods) {
	if (methodToCheck.getReturnType().getErasedType().equals(erasedType)
	&& methodToCheck != targetMethod) {
	methodsToCreate.add(methodToCheck);
	}
	}
	return methodsToCreate;
	}

	List<List<JMethod>> findMethodsToCreateWithPartitionSize(JMethod targetMethod,
	JType methodReturnType) {
	List<JMethod> allMethodsToCreate = findAllMethodsToCreate(targetMethod, methodReturnType);
	return Lists.partition(allMethodsToCreate, partitionsSize);
	}

	LookupMethodCreator getLookupMethodCreator(String name) {
	return namesToMethodCreators.get(name);
	}

	/**
	* Visible for testing only.
	*/
	Map<JMethod, List<List<JMethod>>> getNeededPartitionLookups() {
	return neededPartitionLookups;
	}

	/**
	* Checks that the method has the right structure to implement
	* <code>Constant</code>.
	*
	* @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<JMethod, List<List<JMethod>>> neededPartitionLookup :
	neededPartitionLookups.entrySet()) {
	JMethod targetMethod = neededPartitionLookup.getKey();
	LookupMethodCreator lookupMethodCreator = getLookupMethodCreator(targetMethod.getName());
	List<List<JMethod>> methodForPartitionLookups = neededPartitionLookup.getValue();
	int partitionStartIndex = 0;
	Iterator<List<JMethod>> neededPartitionIterator = methodForPartitionLookups.iterator();
	while (neededPartitionIterator.hasNext()) {
	String currentPartitionLookupMethodName = createPartitionMethodName(targetMethod,
	partitionStartIndex++);
	List<JMethod> methodsToCreate = neededPartitionIterator.next();
	String nextPartitionMethod = null;
	if (neededPartitionIterator.hasNext()) {
	nextPartitionMethod = createPartitionMethodName(targetMethod, partitionStartIndex);
	}
	lookupMethodCreator.createPartitionLookup(currentPartitionLookupMethodName, targetMethod,
	methodsToCreate, nextPartitionMethod);
	}
	}
	}
	}