Author: sco...@google.com Date: Tue Mar 31 09:39:25 2009 New Revision: 5120
Modified: changes/scottb/memory/dev/core/src/com/google/gwt/core/ext/typeinfo/AbstractMembers.java changes/scottb/memory/dev/core/src/com/google/gwt/core/ext/typeinfo/DelegateMembers.java changes/scottb/memory/dev/core/src/com/google/gwt/core/ext/typeinfo/Members.java Log: TypeOracle AbstractMembers, Members, DelegatingMembers Modified: changes/scottb/memory/dev/core/src/com/google/gwt/core/ext/typeinfo/AbstractMembers.java ============================================================================== --- changes/scottb/memory/dev/core/src/com/google/gwt/core/ext/typeinfo/AbstractMembers.java (original) +++ changes/scottb/memory/dev/core/src/com/google/gwt/core/ext/typeinfo/AbstractMembers.java Tue Mar 31 09:39:25 2009 @@ -15,9 +15,7 @@ */ package com.google.gwt.core.ext.typeinfo; -import java.util.ArrayList; import java.util.Collection; -import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.TreeMap; @@ -26,7 +24,6 @@ protected final JClassType classType; private JMethod[] cachedOverridableMethods; - private final Map<String, JClassType> nestedTypes = new HashMap<String, JClassType>(); public AbstractMembers(JClassType classType) { this.classType = classType; @@ -43,9 +40,7 @@ return null; } - public JField findField(String name) { - return doGetFields().get(name); - } + public abstract JField findField(String name); public JMethod findMethod(String name, JType[] paramTypes) { JMethod[] overloads = getOverloads(name); @@ -82,9 +77,7 @@ return field; } - public JField[] getFields() { - return doGetFields().values().toArray(TypeOracle.NO_JFIELDS); - } + public abstract JField[] getFields(); public JMethod getMethod(String name, JType[] paramTypes) throws NotFoundException { @@ -95,13 +88,7 @@ return result; } - public JMethod[] getMethods() { - List<JMethod> resultMethods = new ArrayList<JMethod>(); - for (List<JMethod> overloads : doGetMethods().values()) { - resultMethods.addAll(overloads); - } - return resultMethods.toArray(TypeOracle.NO_JMETHODS); - } + public abstract JMethod[] getMethods(); public JClassType getNestedType(String typeName) throws NotFoundException { JClassType result = findNestedType(typeName); @@ -112,17 +99,10 @@ } public JClassType[] getNestedTypes() { - return nestedTypes.values().toArray(TypeOracle.NO_JCLASSES); + return doGetNestedTypes().values().toArray(TypeOracle.NO_JCLASSES); } - public JMethod[] getOverloads(String name) { - List<?> resultMethods = doGetMethods().get(name); - if (resultMethods != null) { - return resultMethods.toArray(TypeOracle.NO_JMETHODS); - } else { - return TypeOracle.NO_JMETHODS; - } - } + public abstract JMethod[] getOverloads(String name); public JMethod[] getOverridableMethods() { if (cachedOverridableMethods == null) { @@ -132,45 +112,28 @@ getOverridableMethodsOnSuperclassesAndThisClass(methodsBySignature); } int size = methodsBySignature.size(); - Collection<JMethod> leafMethods = methodsBySignature.values(); - cachedOverridableMethods = leafMethods.toArray(new JMethod[size]); + if (size == 0) { + cachedOverridableMethods = TypeOracle.NO_JMETHODS; + } else { + Collection<JMethod> leafMethods = methodsBySignature.values(); + cachedOverridableMethods = leafMethods.toArray(new JMethod[size]); + } } return cachedOverridableMethods; } - protected void addConstructor(JConstructor ctor) { - assert (!doGetConstructors().contains(ctor)); - doGetConstructors().add(ctor); - } + protected abstract void addConstructor(JConstructor ctor); - protected void addField(JField field) { - Object existing = doGetFields().put(field.getName(), field); - assert (existing == null); - } + protected abstract void addField(JField field); - protected void addMethod(JMethod method) { - String methodName = method.getName(); - Map<String, List<JMethod>> methods = doGetMethods(); - List<JMethod> overloads = methods.get(methodName); - if (overloads == null) { - overloads = new ArrayList<JMethod>(); - methods.put(methodName, overloads); - } - overloads.add(method); - } - - protected void addNestedType(JClassType type) { - nestedTypes.put(type.getSimpleSourceName(), type); - } + protected abstract void addMethod(JMethod method); protected abstract List<JConstructor> doGetConstructors(); - protected abstract Map<String, JField> doGetFields(); - - protected abstract Map<String, List<JMethod>> doGetMethods(); + protected abstract Map<String, JClassType> doGetNestedTypes(); protected JClassType findNestedTypeImpl(String[] typeName, int index) { - JClassType found = nestedTypes.get(typeName[index]); + JClassType found = doGetNestedTypes().get(typeName[index]); if (found == null) { return null; } else if (index < typeName.length - 1) { Modified: changes/scottb/memory/dev/core/src/com/google/gwt/core/ext/typeinfo/DelegateMembers.java ============================================================================== --- changes/scottb/memory/dev/core/src/com/google/gwt/core/ext/typeinfo/DelegateMembers.java (original) +++ changes/scottb/memory/dev/core/src/com/google/gwt/core/ext/typeinfo/DelegateMembers.java Tue Mar 31 09:39:25 2009 @@ -15,8 +15,11 @@ */ package com.google.gwt.core.ext.typeinfo; +import com.google.gwt.dev.util.collect.HashMap; +import com.google.gwt.dev.util.collect.Lists; +import com.google.gwt.dev.util.collect.Maps; + import java.util.ArrayList; -import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -26,9 +29,11 @@ */ class DelegateMembers extends AbstractMembers { private final JClassType baseType; + private Map<String, JField> fieldMap; + private JField[] fields; private List<JConstructor> lazyConstructors; - private Map<String, JField> lazyFields; - private Map<String, List<JMethod>> lazyMethods; + private Map<String, Object> methodMap; + private JMethod[] methods; private final Substitution substitution; /** @@ -41,6 +46,53 @@ } @Override + public JField findField(String name) { + initFields(); + return fieldMap.get(name); + } + + @Override + public JField[] getFields() { + initFields(); + return fields.length == 0 ? fields : fields.clone(); + } + + @Override + public JMethod[] getMethods() { + initMethods(); + return methods.length == 0 ? methods : methods.clone(); + } + + @SuppressWarnings("unchecked") + @Override + public JMethod[] getOverloads(String name) { + initMethods(); + Object object = methodMap.get(name); + if (object == null) { + return TypeOracle.NO_JMETHODS; + } else if (object instanceof JMethod) { + return new JMethod[] {(JMethod) object}; + } else { + return ((JMethod[]) object).clone(); + } + } + + @Override + protected void addConstructor(JConstructor ctor) { + throw new UnsupportedOperationException(); + } + + @Override + protected void addField(JField field) { + throw new UnsupportedOperationException(); + } + + @Override + protected void addMethod(JMethod method) { + throw new UnsupportedOperationException(); + } + + @Override protected List<JConstructor> doGetConstructors() { if (lazyConstructors != null) { /* @@ -55,52 +107,33 @@ for (JConstructor baseCtor : baseCtors) { JConstructor newCtor = new JConstructor(getParentType(), baseCtor); initializeParams(baseCtor, newCtor); - addConstructor(newCtor); + lazyConstructors.add(newCtor); } - return lazyConstructors; + return lazyConstructors = Lists.normalize(lazyConstructors); } @Override - protected Map<String, JField> doGetFields() { - if (lazyFields != null) { - /* - * Return if the fields are being initialized or have been initialized. - */ - return lazyFields; - } - lazyFields = new LinkedHashMap<String, JField>(); + protected Map<String, JClassType> doGetNestedTypes() { + // TODO: is this correct? + return Maps.create(); + } - JField[] baseFields = baseType.getFields(); - for (JField baseField : baseFields) { + private void initFields() { + if (fields != null) { + return; + } + // Transitively sorted. + fields = baseType.getFields(); + fieldMap = new HashMap<String, JField>(); + for (int i = 0; i < fields.length; ++i) { + JField baseField = fields[i]; JField newField = new JField(getParentType(), baseField); newField.setType(substitution.getSubstitution(baseField.getType())); - addField(newField); - } - - return lazyFields; - } - - @Override - protected Map<String, List<JMethod>> doGetMethods() { - if (lazyMethods != null) { - /* - * Return if the methods are being initialized or have been initialized. - */ - return lazyMethods; - } - lazyMethods = new LinkedHashMap<String, List<JMethod>>(); - - JMethod[] baseMethods = baseType.getMethods(); - for (JMethod baseMethod : baseMethods) { - JMethod newMethod = new JMethod(getParentType(), baseMethod); - initializeParams(baseMethod, newMethod); - newMethod.setReturnType(substitution.getSubstitution(baseMethod.getReturnType())); - initializeExceptions(baseMethod, newMethod); - addMethod(newMethod); + fields[i] = newField; + fieldMap.put(newField.getName(), newField); } - - return lazyMethods; + fieldMap = Maps.normalize(fieldMap); } private void initializeExceptions(JAbstractMethod srcMethod, @@ -118,5 +151,47 @@ newParam.setType(substitution.getSubstitution(srcParam.getType())); newMethod.addParameter(newParam); } + } + + @SuppressWarnings("unchecked") + private void initMethods() { + if (methods != null) { + return; + } + // Transitively sorted. + methods = baseType.getMethods(); + methodMap = new HashMap<String, Object>(); + for (int i = 0; i < methods.length; ++i) { + JMethod baseMethod = methods[i]; + JMethod newMethod = new JMethod(getParentType(), baseMethod); + initializeParams(baseMethod, newMethod); + newMethod.setReturnType(substitution.getSubstitution(baseMethod.getReturnType())); + initializeExceptions(baseMethod, newMethod); + methods[i] = newMethod; + + String methodName = newMethod.getName(); + Object object = methodMap.get(methodName); + if (object == null) { + methodMap.put(methodName, newMethod); + } else if (object instanceof JMethod) { + List<JMethod> list = new ArrayList<JMethod>(2); + list.add((JMethod) object); + list.add(newMethod); + methodMap.put(methodName, list); + } else { + List<JMethod> list = (List<JMethod>) object; + list.add(newMethod); + } + } + + // Replace the ArrayLists with plain arrays. + for (String methodName : methodMap.keySet()) { + Object object = methodMap.get(methodName); + if (object instanceof List) { + List<JMethod> list = (List<JMethod>) object; + methodMap.put(methodName, list.toArray(TypeOracle.NO_JMETHODS)); + } + } + methodMap = Maps.normalize(methodMap); } } Modified: changes/scottb/memory/dev/core/src/com/google/gwt/core/ext/typeinfo/Members.java ============================================================================== --- changes/scottb/memory/dev/core/src/com/google/gwt/core/ext/typeinfo/Members.java (original) +++ changes/scottb/memory/dev/core/src/com/google/gwt/core/ext/typeinfo/Members.java Tue Mar 31 09:39:25 2009 @@ -15,8 +15,10 @@ */ package com.google.gwt.core.ext.typeinfo; +import com.google.gwt.dev.util.collect.Lists; +import com.google.gwt.dev.util.collect.Maps; + import java.util.ArrayList; -import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -24,26 +26,100 @@ * A container for methods and fields. */ class Members extends AbstractMembers { - private final List<JConstructor> constructors = new ArrayList<JConstructor>(); - private final Map<String, JField> fields = new LinkedHashMap<String, JField>(); - private final Map<String, List<JMethod>> methods = new LinkedHashMap<String, List<JMethod>>(); + private List<JConstructor> constructors = Lists.create(); + private Map<String, JField> fieldMap = Maps.create(); + private List<JField> fields = Lists.create(); + private Map<String, Object> methodMap = Maps.create(); + private List<String> methodOrder = Lists.create(); + private Map<String, JClassType> nestedTypes = Maps.create(); public Members(JClassType classType) { super(classType); } @Override + public JField findField(String name) { + return fieldMap.get(name); + } + + @Override + public JField[] getFields() { + return fields.toArray(TypeOracle.NO_JFIELDS); + } + + @SuppressWarnings("unchecked") + @Override + public JMethod[] getMethods() { + List<JMethod> result = new ArrayList<JMethod>(); + for (String methodName : methodOrder) { + Object object = methodMap.get(methodName); + if (object instanceof JMethod) { + result.add((JMethod) object); + } else { + result.addAll((List<JMethod>) object); + } + } + return result.toArray(TypeOracle.NO_JMETHODS); + } + + @SuppressWarnings("unchecked") + @Override + public JMethod[] getOverloads(String name) { + Object object = methodMap.get(name); + if (object == null) { + return TypeOracle.NO_JMETHODS; + } else if (object instanceof JMethod) { + return new JMethod[] {(JMethod) object}; + } else { + List<JMethod> overloads = (List<JMethod>) object; + return overloads.toArray(TypeOracle.NO_JMETHODS); + } + } + + @Override + protected void addConstructor(JConstructor ctor) { + assert (!constructors.contains(ctor)); + constructors = Lists.add(constructors, ctor); + } + + @Override + protected void addField(JField field) { + assert !fieldMap.containsKey(field.getName()); + fieldMap = Maps.put(fieldMap, field.getName(), field); + fields = Lists.add(fields, field); + } + + @SuppressWarnings("unchecked") + @Override + protected void addMethod(JMethod method) { + String methodName = method.getName(); + Object object = methodMap.get(methodName); + if (object == null) { + methodMap = Maps.put(methodMap, methodName, method); + methodOrder = Lists.add(methodOrder, methodName); + } else if (object instanceof JMethod) { + List<JMethod> overloads = new ArrayList<JMethod>(2); + overloads.add((JMethod) object); + overloads.add(method); + methodMap = Maps.put(methodMap, methodName, overloads); + } else { + List<JMethod> overloads = (List<JMethod>) object; + overloads.add(method); + } + } + + @Override protected List<JConstructor> doGetConstructors() { return constructors; } @Override - protected Map<String, JField> doGetFields() { - return fields; + protected Map<String, JClassType> doGetNestedTypes() { + return nestedTypes; } - @Override - protected Map<String, List<JMethod>> doGetMethods() { - return methods; + void addNestedType(JClassType type) { + nestedTypes = Maps.put(nestedTypes, type.getSimpleSourceName(), type); } + } --~--~---------~--~----~------------~-------~--~----~ http://groups.google.com/group/Google-Web-Toolkit-Contributors -~----------~----~----~----~------~----~------~--~---