| // Copyright 2006, 2007, 2008, 2009, 2010, 2011 The Apache Software Foundation |
| // |
| // 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 org.apache.tapestry5.internal.services; |
| |
| import java.lang.annotation.Annotation; |
| import java.lang.annotation.Inherited; |
| import java.lang.reflect.Modifier; |
| import java.util.Arrays; |
| import java.util.Formatter; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import javassist.*; |
| import javassist.expr.ExprEditor; |
| import javassist.expr.FieldAccess; |
| |
| import org.apache.tapestry5.ComponentResources; |
| import org.apache.tapestry5.func.Predicate; |
| import org.apache.tapestry5.internal.InternalComponentResources; |
| import org.apache.tapestry5.ioc.internal.services.CtClassSource; |
| import org.apache.tapestry5.ioc.internal.util.CollectionFactory; |
| import org.apache.tapestry5.ioc.internal.util.InternalUtils; |
| import org.apache.tapestry5.ioc.services.ClassFab; |
| import org.apache.tapestry5.ioc.services.ClassFabUtils; |
| import org.apache.tapestry5.ioc.services.ClassFactory; |
| import org.apache.tapestry5.ioc.services.FieldValueConduit; |
| import org.apache.tapestry5.ioc.services.MethodSignature; |
| import org.apache.tapestry5.ioc.util.BodyBuilder; |
| import org.apache.tapestry5.ioc.util.IdAllocator; |
| import org.apache.tapestry5.model.ComponentModel; |
| import org.apache.tapestry5.model.MutableComponentModel; |
| import org.apache.tapestry5.runtime.Component; |
| import org.apache.tapestry5.runtime.ComponentEvent; |
| import org.apache.tapestry5.services.*; |
| import org.slf4j.Logger; |
| |
| /** |
| * Implementation of the {@link org.apache.tapestry5.internal.services.InternalClassTransformation} interface. |
| */ |
| @SuppressWarnings("all") |
| public final class InternalClassTransformationImpl implements InternalClassTransformation |
| { |
| public static final MethodSignature INVOKE_SIGNATURE = new MethodSignature(MethodInvocationResult.class, "invoke", |
| new Class[] |
| { Object.class, Object[].class }, null); |
| |
| public static final MethodSignature FIELD_ACCESS_READ_SIGNATURE = new MethodSignature(Object.class, "read", |
| new Class[] |
| { Object.class }, null); |
| |
| public static final MethodSignature FIELD_ACCESS_WRITE_SIGNATURE = new MethodSignature(void.class, "write", |
| new Class[] |
| { Object.class, Object.class }, null); |
| |
| private static final int INIT_BUFFER_SIZE = 100; |
| |
| private boolean frozen; |
| |
| private final CtClass ctClass; |
| |
| private final Logger logger; |
| |
| private final InternalClassTransformation parentTransformation; |
| |
| private final ClassPool classPool; |
| |
| private final IdAllocator idAllocator; |
| |
| private final CtClass providerType; |
| |
| class TransformMethodImpl implements TransformMethod |
| { |
| final CtMethod method; |
| |
| private final TransformMethodSignature sig; |
| |
| private List<Annotation> annotations; |
| |
| private final boolean added; |
| |
| private ComponentMethodInvocationBuilder builder; |
| |
| private MethodAccess access; |
| |
| private String identifier; |
| |
| private Boolean override; |
| |
| private List<List<Annotation>> parameterAnnotations; |
| |
| TransformMethodImpl(CtMethod method, boolean added) |
| { |
| this.method = method; |
| this.sig = toMethodSignature(method); |
| this.added = added; |
| |
| } |
| |
| @Override |
| public String toString() |
| { |
| return String.format("TransformMethod[%s]", getMethodIdentifier()); |
| } |
| |
| public int compareTo(TransformMethod o) |
| { |
| return sig.compareTo(o.getSignature()); |
| } |
| |
| public <T extends Annotation> T getAnnotation(Class<T> annotationClass) |
| { |
| if (annotations == null) |
| annotations = extractAnnotations(method); |
| |
| return findAnnotationInList(annotationClass, annotations); |
| } |
| |
| public <A extends Annotation> A getParameterAnnotation(int index, Class<A> annotationType) |
| { |
| if (parameterAnnotations == null) |
| extractParameterAnnotations(); |
| |
| return findAnnotationInList(annotationType, parameterAnnotations.get(index)); |
| } |
| |
| private void extractParameterAnnotations() |
| { |
| int count = sig.getParameterTypes().length; |
| |
| parameterAnnotations = CollectionFactory.newList(); |
| |
| for (int parameterIndex = 0; parameterIndex < count; parameterIndex++) |
| { |
| List<Annotation> annotations = extractAnnotationsForParameter(parameterIndex); |
| |
| parameterAnnotations.add(annotations); |
| } |
| } |
| |
| private List<Annotation> extractAnnotationsForParameter(int parameterIndex) |
| { |
| List<Annotation> result = CollectionFactory.newList(); |
| |
| Object[] parameterAnnotations = method.getAvailableParameterAnnotations()[parameterIndex]; |
| |
| addAnnotationsToList(result, parameterAnnotations, false); |
| |
| return result; |
| } |
| |
| public TransformMethodSignature getSignature() |
| { |
| return sig; |
| } |
| |
| public String getName() |
| { |
| return sig.getMethodName(); |
| } |
| |
| public void addAdvice(ComponentMethodAdvice advice) |
| { |
| failIfFrozen(); |
| |
| assert advice != null; |
| |
| if (builder == null) |
| builder = createBuilder(sig); |
| |
| builder.addAdvice(advice); |
| |
| formatter.format("add advice %s : %s\n\n", sig.getMediumDescription(), advice); |
| } |
| |
| public void addOperationAfter(ComponentInstanceOperation operation) |
| { |
| addAdvice(toAfterAdvice(operation)); |
| } |
| |
| public void addOperationBefore(ComponentInstanceOperation operation) |
| { |
| addAdvice(toBeforeAdvice(operation)); |
| } |
| |
| public MethodAccess getAccess() |
| { |
| failIfFrozen(); |
| |
| if (access == null) |
| access = createMethodAccess(); |
| |
| return access; |
| } |
| |
| private MethodAccess createMethodAccess() |
| { |
| if (isPrivate()) |
| return createPrivateMethodAccess(); |
| |
| return createNonPrivateMethodAccess(); |
| } |
| |
| private boolean isPrivate() |
| { |
| return Modifier.isPrivate(sig.getModifiers()); |
| } |
| |
| private MethodAccess createNonPrivateMethodAccess() |
| { |
| // For a public method, given the instance, we can just invoke the method directly |
| // from the MethodAccess object. |
| |
| String accessTarget = "instance." + sig.getMethodName(); |
| |
| return createMethodAccessForTarget(accessTarget, false); |
| } |
| |
| private MethodAccess createMethodAccessForTarget(String accessTarget, boolean passInstance) |
| { |
| boolean isVoid = sig.getReturnType().equals("void"); |
| |
| BodyBuilder builder = new BodyBuilder().begin(); |
| |
| builder.addln("%s instance = (%<s) $1;", getClassName()); |
| |
| builder.addln("try").begin(); |
| |
| if (!isVoid) |
| { |
| builder.add("return success(($w) "); |
| } |
| |
| // Call the target, even if the eventual method is void |
| |
| builder.add(accessTarget); |
| builder.add("("); |
| |
| if (passInstance) |
| builder.add("instance"); |
| |
| int p = 0; |
| |
| for (String type : sig.getParameterTypes()) |
| { |
| if (passInstance || p != 0) |
| builder.add(", "); |
| |
| String ref = String.format("$2[%d]", p++); |
| builder.add(ClassFabUtils.castReference(ref, type)); |
| } |
| |
| // Balance the call to success() |
| if (!isVoid) |
| builder.add(")"); |
| |
| builder.addln(");"); |
| |
| if (isVoid) |
| builder.addln("return success(null);"); |
| |
| builder.end(); // try |
| builder.addln("catch (java.lang.RuntimeException ex) { throw ex; }"); |
| builder.addln("catch (java.lang.Exception ex) { return fail(ex); }"); |
| |
| builder.end(); |
| |
| return instantiateMethodAccessFromBody(builder.toString()); |
| } |
| |
| private MethodAccess instantiateMethodAccessFromBody(String body) |
| { |
| // The access object is created in the same package as the component, so that it can access |
| // protected and package private methods. |
| String accessClassName = String.format("%s$MethodAccess_%s_%s", getClassName(), sig.getMethodName(), |
| ClassFabUtils.nextUID()); |
| |
| ClassFab cf = classFactory.newClass(accessClassName, AbstractMethodAccess.class); |
| |
| cf.addMethod(Modifier.PUBLIC, INVOKE_SIGNATURE, body); |
| |
| cf.addToString(String.format("MethodAccess[method %s of class %s]", sig.getMediumDescription(), |
| getClassName())); |
| |
| Class accessClass = cf.createClass(); |
| |
| try |
| { |
| Object accessInstance = accessClass.newInstance(); |
| |
| return (MethodAccess) accessInstance; |
| } |
| catch (Exception ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| private MethodAccess createPrivateMethodAccess() |
| { |
| // As with Java inner classes, we have to create a static bridge method. |
| |
| String staticAccessMethodName = createStaticAccessMethodForNonPublicMethod(); |
| |
| // Have the MethodAccess object call the static method and pass the |
| // instance object as the first parameter. The static method will then |
| // invoke the non-public method on the passed instance. |
| |
| return createMethodAccessForTarget(String.format("%s#%s", getClassName(), staticAccessMethodName), true); |
| } |
| |
| /** |
| * The static method takes the same parameters as the main method, but takes |
| * an instance object first. Invoking the static method turns into an invocation |
| * of the proper method of the instance object. |
| * |
| * @return the name of the created static access method |
| */ |
| private String createStaticAccessMethodForNonPublicMethod() |
| { |
| List<String> parameterTypes = CollectionFactory.newList(getClassName()); |
| parameterTypes.addAll(Arrays.asList(sig.getParameterTypes())); |
| |
| String methodName = newMemberName("access", sig.getMethodName()); |
| |
| TransformMethodSignature accessMethodSignature = new TransformMethodSignature(Modifier.PUBLIC |
| + Modifier.STATIC, sig.getReturnType(), methodName, parameterTypes.toArray(new String[0]), |
| sig.getExceptionTypes()); |
| |
| boolean isVoid = sig.getReturnType().equals("void"); |
| |
| BodyBuilder builder = new BodyBuilder(); |
| |
| builder.begin(); |
| |
| if (!isVoid) |
| builder.add("return "); |
| |
| builder.add("$1.%s(", sig.getMethodName()); |
| |
| for (int i = 0; i < sig.getParameterTypes().length; i++) |
| { |
| if (i > 0) |
| builder.add(", "); |
| |
| builder.add("$%d", i + 2); |
| } |
| |
| builder.addln(");"); |
| |
| builder.end(); |
| |
| addNewMethod(accessMethodSignature, builder.toString()); |
| |
| return methodName; |
| } |
| |
| public String getMethodIdentifier() |
| { |
| if (identifier == null) |
| { |
| int lineNumber = method.getMethodInfo2().getLineNumber(0); |
| CtClass enclosingClass = method.getDeclaringClass(); |
| String sourceFile = enclosingClass.getClassFile2().getSourceFile(); |
| |
| identifier = String.format("%s.%s (at %s:%d)", enclosingClass.getName(), sig.getMediumDescription(), |
| sourceFile, lineNumber); |
| } |
| |
| return identifier; |
| } |
| |
| public boolean isOverride() |
| { |
| if (override == null) |
| override = searchForOverride(); |
| |
| return override; |
| } |
| |
| private boolean searchForOverride() |
| { |
| InternalClassTransformation search = parentTransformation; |
| |
| while (search != null) |
| { |
| if (search.isMethod(sig)) |
| return true; |
| |
| search = search.getParentTransformation(); |
| } |
| |
| // Not found in any super-class. |
| |
| return false; |
| } |
| |
| void doFinish() |
| { |
| if (builder != null) |
| { |
| builder.commit(); |
| builder = null; |
| } |
| } |
| } |
| |
| class TransformFieldImpl implements TransformField |
| { |
| private final CtField field; |
| |
| private final CtClass fieldType; |
| |
| private final String name, type; |
| |
| private boolean added; |
| |
| private List<Annotation> annotations; |
| |
| private Object claimTag; |
| |
| String readValueBody, writeValueBody; |
| |
| private DelegateFieldAccess delegateFieldAccess; |
| |
| private org.apache.tapestry5.services.FieldAccess access; |
| |
| TransformFieldImpl(CtField field, boolean added) |
| { |
| this.field = field; |
| this.name = field.getName(); |
| this.added = added; |
| |
| try |
| { |
| fieldType = field.getType(); |
| type = fieldType.getName(); |
| } |
| catch (NotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| void doFinish() |
| { |
| if (delegateFieldAccess != null) |
| { |
| access = createAccess(); |
| delegateFieldAccess.delegate = access; |
| delegateFieldAccess = null; |
| } |
| } |
| |
| @Override |
| public String toString() |
| { |
| return String.format("TransformField[%s %s.%s(%s)]", Modifier.toString(field.getModifiers()), |
| getClassName(), name, type); |
| } |
| |
| public int compareTo(TransformField o) |
| { |
| return name.compareTo(o.getName()); |
| } |
| |
| public String getName() |
| { |
| return name; |
| } |
| |
| public String getType() |
| { |
| return type; |
| } |
| |
| public <T extends Annotation> T getAnnotation(Class<T> annotationClass) |
| { |
| failIfFrozen(); |
| |
| if (annotations == null) |
| annotations = extractAnnotations(field); |
| |
| return findAnnotationInList(annotationClass, annotations); |
| } |
| |
| public void claim(Object tag) |
| { |
| assert tag != null; |
| |
| failIfFrozen(); |
| |
| if (claimTag != null) |
| throw new IllegalStateException(String.format( |
| "Field %s of class %s is already claimed by %s and can not be claimed by %s.", getName(), |
| getClassName(), claimTag, tag)); |
| |
| claimTag = tag; |
| |
| formatter.format("Field %s claimed by %s\n\n", name, tag); |
| } |
| |
| public boolean isClaimed() |
| { |
| return claimTag != null; |
| } |
| |
| public int getModifiers() |
| { |
| return field.getModifiers(); |
| } |
| |
| void replaceReadAccess(String methodName) |
| { |
| failIfFrozen(); |
| |
| if (readValueBody != null) |
| throw new IllegalStateException(String.format("Field %s.%s has already had read access replaced.", |
| getClassName(), name)); |
| |
| // Explicitly reference $0 (aka "this") because of TAPESTRY-1511. |
| // $0 is valid even inside a static method. |
| |
| readValueBody = String.format("$_ = $0.%s();", methodName); |
| |
| formatter.format("replace read %s: %s();\n\n", name, methodName); |
| |
| fieldAccessReplaced = true; |
| } |
| |
| void replaceWriteAccess(String methodName) |
| { |
| failIfFrozen(); |
| |
| if (writeValueBody != null) |
| throw new IllegalStateException(String.format("Field %s.%s has already had write access replaced.", |
| getClassName(), name)); |
| |
| // Explicitly reference $0 (aka "this") because of TAPESTRY-1511. |
| // $0 is valid even inside a static method. |
| |
| writeValueBody = String.format("$0.%s($1);", methodName); |
| |
| formatter.format("replace write %s: %s();\n\n", name, methodName); |
| |
| fieldAccessReplaced = true; |
| } |
| |
| public org.apache.tapestry5.services.FieldAccess getAccess() |
| { |
| failIfFrozen(); |
| |
| if (access != null) |
| return access; |
| |
| if (delegateFieldAccess == null) |
| { |
| delegateFieldAccess = new DelegateFieldAccess(); |
| } |
| |
| return delegateFieldAccess; |
| } |
| |
| private org.apache.tapestry5.services.FieldAccess createAccess() |
| { |
| TransformMethod reader = createReader(); |
| TransformMethod writer = createWriter(); |
| |
| return createFieldAccess(reader, writer); |
| } |
| |
| private org.apache.tapestry5.services.FieldAccess createFieldAccess(TransformMethod reader, |
| TransformMethod writer) |
| { |
| ClassFab cf = classFactory.newClass(org.apache.tapestry5.services.FieldAccess.class); |
| |
| addFieldAccessReadMethod(cf, reader); |
| addFieldAccessWriteMethod(cf, writer); |
| |
| cf.addToString(String.format("FieldAccess<%s.%s>", getClassName(), name)); |
| |
| Class accessClass = cf.createClass(); |
| |
| try |
| { |
| return (org.apache.tapestry5.services.FieldAccess) accessClass.newInstance(); |
| } |
| catch (Exception ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| private void addFieldAccessReadMethod(ClassFab cf, TransformMethod readAccess) |
| { |
| BodyBuilder builder = new BodyBuilder().begin(); |
| |
| builder.addln("%s instance = (%<s) $1;", getClassName()); |
| builder.addln("return ($w) instance.%s();", readAccess.getName()); |
| |
| builder.end(); |
| |
| cf.addMethod(Modifier.PUBLIC, FIELD_ACCESS_READ_SIGNATURE, builder.toString()); |
| } |
| |
| private void addFieldAccessWriteMethod(ClassFab cf, TransformMethod writeAccess) |
| { |
| BodyBuilder builder = new BodyBuilder().begin(); |
| |
| builder.addln("%s instance = (%<s) $1;", getClassName()); |
| builder.addln("%s value = %s;", type, ClassFabUtils.castReference("$2", type)); |
| builder.addln("instance.%s(value);", writeAccess.getName()); |
| |
| builder.end(); |
| |
| cf.addMethod(Modifier.PUBLIC, FIELD_ACCESS_WRITE_SIGNATURE, builder.toString()); |
| } |
| |
| private TransformMethod createReader() |
| { |
| String methodName = newMemberName("readaccess", name); |
| |
| TransformMethodSignature signature = new TransformMethodSignature(Modifier.PUBLIC, type, methodName, null, |
| null); |
| |
| // Add the method as existing, so that the field access may be replaced with a FieldValueConduit |
| // if necessary. |
| return addOrReplaceMethod(signature, String.format("return %s;", name), false); |
| } |
| |
| private TransformMethod createWriter() |
| { |
| String methodName = newMemberName("writeaccess", name); |
| |
| TransformMethodSignature signature = new TransformMethodSignature(Modifier.PUBLIC, "void", methodName, |
| new String[] |
| { type }, null); |
| |
| // Add the method as existing, so that the field access may be replaced with a FieldValueConduit |
| // if necessary. |
| |
| return addOrReplaceMethod(signature, String.format("%s = $1;", name), false); |
| } |
| |
| public void replaceAccess(ComponentValueProvider<FieldValueConduit> conduitProvider) |
| { |
| replaceAccess(addIndirectInjectedField(FieldValueConduit.class, name + "$conduit", conduitProvider)); |
| } |
| |
| public void replaceAccess(FieldValueConduit conduit) |
| { |
| String fieldName = addInjectedFieldUncached(FieldValueConduit.class, name + "$conduit", conduit); |
| |
| // TODO: If access != null? |
| |
| access = toFieldAccess(conduit); |
| |
| if (delegateFieldAccess != null) |
| { |
| delegateFieldAccess.delegate = access; |
| delegateFieldAccess = null; |
| } |
| |
| replaceAccess(getTransformFieldImpl(fieldName)); |
| } |
| |
| public void replaceAccess(TransformField conduitField) |
| { |
| failIfFrozen(); |
| |
| String conduitFieldName = conduitField.getName(); |
| |
| String readMethodName = newMemberName("get", name); |
| |
| TransformMethodSignature readSig = new TransformMethodSignature(Modifier.PRIVATE, type, readMethodName, |
| null, null); |
| |
| String cast = TransformUtils.getWrapperTypeName(type); |
| |
| // The ($r) cast will convert the result to the method return type; generally |
| // this does nothing. but for primitive types, it will unwrap |
| // the wrapper type back to a primitive. |
| |
| BodyBuilder builder = new BodyBuilder(); |
| |
| builder.begin(); |
| |
| builder.addln("%s result = ($r) ((%s) %s.get());", type, cast, conduitFieldName); |
| |
| if (developmentMode) |
| { |
| builder.addln("%s = result;", name); |
| } |
| |
| builder.addln("return result;"); |
| |
| builder.end(); |
| |
| addNewMethod(readSig, builder.toString()); |
| |
| replaceReadAccess(readMethodName); |
| |
| String writeMethodName = newMemberName("set", name); |
| |
| TransformMethodSignature writeSig = new TransformMethodSignature(Modifier.PRIVATE, "void", writeMethodName, |
| new String[] |
| { type }, null); |
| |
| builder.clear().begin(); |
| |
| if (developmentMode) |
| { |
| builder.addln("%s = $1;", name); |
| } |
| |
| builder.addln("%s.set(($w) $1);", conduitFieldName); |
| |
| builder.end(); |
| |
| addNewMethod(writeSig, builder.toString()); |
| |
| replaceWriteAccess(writeMethodName); |
| } |
| |
| public void inject(Object value) |
| { |
| failIfFrozen(); |
| |
| addInjectToConstructor(name, fieldType, value); |
| |
| makeReadOnly(name); |
| } |
| |
| public <T> void injectIndirect(ComponentValueProvider<T> provider) |
| { |
| assert provider != null; |
| |
| failIfFrozen(); |
| |
| String argReference = addConstructorArg(providerType, provider); |
| |
| addToConstructor(String.format(" %s = (%s) (%s).get(%s);", name, type, argReference, resourcesFieldName)); |
| |
| makeReadOnly(name); |
| } |
| |
| } |
| |
| private final Map<TransformMethodSignature, TransformMethodImpl> methods = CollectionFactory.newMap(); |
| |
| private Map<String, TransformFieldImpl> fields = CollectionFactory.newMap(); |
| |
| /** |
| * Map, keyed on InjectKey, of field name. Injections are always added as protected (not |
| * private) fields to support |
| * sharing of injections between a base class and a sub class. |
| */ |
| private final Map<InjectionKey, String> injectionCache = CollectionFactory.newMap(); |
| |
| // Cache of class annotation |
| |
| private List<Annotation> classAnnotations; |
| |
| /** |
| * Contains the assembled Javassist code for the class' default constructor. |
| */ |
| private StringBuilder constructor = new StringBuilder(INIT_BUFFER_SIZE); |
| |
| private final List<Object> constructorArgs; |
| |
| private final MutableComponentModel componentModel; |
| |
| private final String resourcesFieldName; |
| |
| private StringBuilder description = new StringBuilder(INIT_BUFFER_SIZE); |
| |
| private Formatter formatter = new Formatter(description); |
| |
| private final ClassFactory classFactory; |
| |
| private final ComponentClassCache componentClassCache; |
| |
| private final CtClassSource classSource; |
| |
| // In development mode, extra logic is inserted to "shadow" fields (that have been replaced with a FieldConduit). |
| // The "live" value is stored into the field any time it is read or updated, to assist with debugging. |
| // https://issues.apache.org/jira/browse/TAP5-1208 |
| private final boolean developmentMode; |
| |
| // If true, then during finish, it is necessary to search for field replacements |
| // (field reads or writes replaces with method calls). |
| private boolean fieldAccessReplaced; |
| |
| /** |
| * Signature for newInstance() method of Instantiator. |
| */ |
| private static final MethodSignature NEW_INSTANCE_SIGNATURE = new MethodSignature(Component.class, "newInstance", |
| new Class[] |
| { InternalComponentResources.class }, null); |
| |
| private static final TransformMethodSignature GET_COMPONENT_RESOURCES_SIGNATURE = new TransformMethodSignature( |
| Modifier.PUBLIC | Modifier.FINAL, ComponentResources.class.getName(), "getComponentResources", null, null); |
| |
| /** |
| * This is a constructor for a base class. |
| */ |
| public InternalClassTransformationImpl(ClassFactory classFactory, CtClass ctClass, |
| ComponentClassCache componentClassCache, MutableComponentModel componentModel, CtClassSource classSource, |
| boolean developmentMode) |
| { |
| this.ctClass = ctClass; |
| this.componentClassCache = componentClassCache; |
| this.classSource = classSource; |
| this.developmentMode = developmentMode; |
| classPool = this.ctClass.getClassPool(); |
| this.classFactory = classFactory; |
| parentTransformation = null; |
| this.componentModel = componentModel; |
| |
| providerType = toCtClass(ComponentValueProvider.class); |
| |
| idAllocator = new IdAllocator(); |
| |
| logger = componentModel.getLogger(); |
| |
| preloadMembers(); |
| |
| constructorArgs = CollectionFactory.newList(); |
| constructor.append("{\n"); |
| |
| addImplementedInterface(Component.class); |
| |
| resourcesFieldName = addField(Modifier.PROTECTED | Modifier.FINAL, InternalComponentResources.class.getName(), |
| "resources"); |
| |
| addToConstructor(String.format(" %s = $1;", resourcesFieldName)); |
| |
| addNewMethod(GET_COMPONENT_RESOURCES_SIGNATURE, "return " + resourcesFieldName + ";"); |
| |
| // The "}" will be added later, inside finish(). |
| } |
| |
| /** |
| * Constructor for a component sub-class. |
| * |
| * @param developmentMode |
| * TODO |
| */ |
| private InternalClassTransformationImpl(CtClass ctClass, InternalClassTransformation parentTransformation, |
| ClassFactory classFactory, CtClassSource classSource, ComponentClassCache componentClassCache, |
| MutableComponentModel componentModel, boolean developmentMode) |
| { |
| this.ctClass = ctClass; |
| this.componentClassCache = componentClassCache; |
| this.classSource = classSource; |
| classPool = this.ctClass.getClassPool(); |
| this.classFactory = classFactory; |
| logger = componentModel.getLogger(); |
| this.parentTransformation = parentTransformation; |
| this.componentModel = componentModel; |
| this.developmentMode = developmentMode; |
| |
| providerType = toCtClass(ComponentValueProvider.class); |
| |
| resourcesFieldName = parentTransformation.getResourcesFieldName(); |
| |
| idAllocator = parentTransformation.getIdAllocator(); |
| |
| preloadMembers(); |
| |
| constructorArgs = parentTransformation.getConstructorArgs(); |
| |
| // Re-invoke the constructor, passing the resources and array of values to the super class |
| |
| addToConstructor("{\n super($$);"); |
| |
| // The "}" will be added later, inside finish(). |
| } |
| |
| public InternalClassTransformation createChildTransformation(CtClass childClass, MutableComponentModel childModel) |
| { |
| return new InternalClassTransformationImpl(childClass, this, classFactory, classSource, componentClassCache, |
| childModel, developmentMode); |
| } |
| |
| private void freeze() |
| { |
| frozen = true; |
| |
| // Free up stuff we don't need after freezing. |
| // Everything else should be final. |
| |
| fields = null; |
| |
| classAnnotations = null; |
| constructor = null; |
| formatter = null; |
| description = null; |
| } |
| |
| public String getResourcesFieldName() |
| { |
| return resourcesFieldName; |
| } |
| |
| /** |
| * Loads all existing fields and methods defined by the class. |
| */ |
| private void preloadMembers() |
| { |
| preloadFields(); |
| preloadMethods(); |
| } |
| |
| private void preloadMethods() |
| { |
| for (CtMethod method : ctClass.getDeclaredMethods()) |
| { |
| recordMethod(method, false); |
| |
| idAllocator.allocateId(method.getName()); |
| } |
| } |
| |
| /** |
| * Converts and stores {@link CtField} to {@link TransformField}, and checks that each field is |
| * one of: |
| * <ul> |
| * <li>private</li> |
| * <li>static</li> |
| * <li>groovy.lang.MetaClass (for Groovy compatibility)</li> </li> |
| */ |
| private void preloadFields() |
| { |
| List<String> names = CollectionFactory.newList(); |
| |
| for (CtField field : ctClass.getDeclaredFields()) |
| { |
| String name = field.getName(); |
| |
| idAllocator.allocateId(name); |
| |
| TransformFieldImpl tfi = fields.put(name, new TransformFieldImpl(field, false)); |
| |
| int modifiers = field.getModifiers(); |
| |
| // Fields must be either static or private. |
| |
| if (Modifier.isStatic(modifiers) || Modifier.isPrivate(modifiers)) |
| continue; |
| |
| // Groovy injects a public field named metaClass. We ignore it, and add it as a claimed |
| // field to prevent any of the workers from seeing it. |
| |
| if (name.equals("metaClass") && getFieldType(name).equals("groovy.lang.MetaClass")) |
| { |
| tfi.claim("Ignored"); |
| continue; |
| } |
| |
| names.add(name); |
| } |
| |
| if (!names.isEmpty()) |
| throw new RuntimeException(ServicesMessages.nonPrivateFields(getClassName(), names)); |
| } |
| |
| public <T extends Annotation> T getFieldAnnotation(String fieldName, Class<T> annotationClass) |
| { |
| return getField(fieldName).getAnnotation(annotationClass); |
| } |
| |
| public <T extends Annotation> T getMethodAnnotation(TransformMethodSignature signature, Class<T> annotationClass) |
| { |
| return getOrCreateMethod(signature).getAnnotation(annotationClass); |
| } |
| |
| /** |
| * Searches an array of objects (that are really annotations instances) to find one that is of |
| * the correct type, |
| * which is returned. |
| * |
| * @param <T> |
| * @param annotationClass |
| * the annotation to search for |
| * @param annotations |
| * the available annotations |
| * @return the matching annotation instance, or null if not found |
| */ |
| private <T extends Annotation> T findAnnotationInList(Class<T> annotationClass, List<Annotation> annotations) |
| { |
| for (Object annotation : annotations) |
| { |
| if (annotationClass.isInstance(annotation)) |
| return annotationClass.cast(annotation); |
| } |
| |
| return null; |
| } |
| |
| public <T extends Annotation> T getAnnotation(Class<T> annotationClass) |
| { |
| return findAnnotationInList(annotationClass, getClassAnnotations()); |
| } |
| |
| private List<Annotation> extractAnnotations(CtMember member) |
| { |
| try |
| { |
| List<Annotation> result = CollectionFactory.newList(); |
| |
| addAnnotationsToList(result, member.getAnnotations(), false); |
| |
| return result; |
| } |
| catch (ClassNotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| private void addAnnotationsToList(List<Annotation> list, Object[] annotations, boolean filterNonInherited) |
| { |
| for (Object o : annotations) |
| { |
| Annotation a = (Annotation) o; |
| |
| // When assembling class annotations from a base class, you want to ignore any |
| // that are not @Inherited. |
| |
| if (filterNonInherited) |
| { |
| Class<? extends Annotation> annotationType = a.annotationType(); |
| |
| Inherited inherited = annotationType.getAnnotation(Inherited.class); |
| |
| if (inherited == null) |
| continue; |
| } |
| |
| list.add(a); |
| } |
| } |
| |
| public TransformField getField(String fieldName) |
| { |
| return getTransformFieldImpl(fieldName); |
| } |
| |
| private TransformFieldImpl getTransformFieldImpl(String fieldName) |
| { |
| failIfFrozen(); |
| |
| TransformFieldImpl result = fields.get(fieldName); |
| |
| if (result != null) |
| return result; |
| |
| throw new RuntimeException(String.format("Class %s does not contain a field named '%s'.", getClassName(), |
| fieldName)); |
| } |
| |
| public String newMemberName(String suggested) |
| { |
| failIfFrozen(); |
| |
| assert InternalUtils.isNonBlank(suggested); |
| |
| String memberName = InternalUtils.createMemberName(suggested); |
| |
| return idAllocator.allocateId(memberName); |
| } |
| |
| public String newMemberName(String prefix, String baseName) |
| { |
| return newMemberName(prefix + "_" + InternalUtils.stripMemberName(baseName)); |
| } |
| |
| public void addImplementedInterface(Class interfaceClass) |
| { |
| failIfFrozen(); |
| |
| try |
| { |
| CtClass ctInterface = toCtClass(interfaceClass); |
| |
| if (classImplementsInterface(ctInterface)) |
| return; |
| |
| implementDefaultMethodsForInterface(ctInterface); |
| |
| ctClass.addInterface(ctInterface); |
| } |
| catch (NotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| /** |
| * Adds default implementations for the methods defined by the interface (and all of its |
| * super-interfaces). The |
| * implementations return null (or 0, or false, as appropriate to to the method type). There are |
| * a number of |
| * degenerate cases that are not covered properly: these are related to base interfaces that may |
| * be implemented by |
| * base classes. |
| * |
| * @param ctInterface |
| * @throws NotFoundException |
| */ |
| private void implementDefaultMethodsForInterface(CtClass ctInterface) throws NotFoundException |
| { |
| // java.lang.Object is the parent interface of interfaces |
| |
| if (ctInterface.getName().equals(Object.class.getName())) |
| return; |
| |
| for (CtMethod method : ctInterface.getDeclaredMethods()) |
| { |
| addDefaultImplementation(method); |
| } |
| |
| for (CtClass parent : ctInterface.getInterfaces()) |
| { |
| implementDefaultMethodsForInterface(parent); |
| } |
| } |
| |
| private void addDefaultImplementation(CtMethod method) |
| { |
| // Javassist has an oddity for interfaces: methods "inherited" from java.lang.Object show |
| // up as methods of the interface. We skip those and only consider the methods |
| // that are abstract. |
| |
| if (!Modifier.isAbstract(method.getModifiers())) |
| return; |
| |
| try |
| { |
| CtMethod newMethod = CtNewMethod.copy(method, ctClass, null); |
| |
| // Methods from interfaces are always public. We definitely |
| // need to change the modifiers of the method so that |
| // it is not abstract. |
| |
| newMethod.setModifiers(Modifier.PUBLIC); |
| |
| // Javassist will provide a minimal implementation for us (return null, false, 0, |
| // whatever). |
| |
| newMethod.setBody(null); |
| |
| ctClass.addMethod(newMethod); |
| |
| TransformMethod tm = recordMethod(newMethod, true); |
| |
| addMethodToDescription("add default", tm.getSignature(), "<default>"); |
| } |
| catch (CannotCompileException ex) |
| { |
| throw new RuntimeException(ServicesMessages.errorAddingMethod(ctClass, method.getName(), ex), ex); |
| } |
| } |
| |
| private TransformMethodImpl recordMethod(CtMethod method, boolean asNew) |
| { |
| TransformMethodImpl tmi = new TransformMethodImpl(method, asNew); |
| |
| methods.put(tmi.getSignature(), tmi); |
| |
| return tmi; |
| } |
| |
| /** |
| * Check to see if the target class (or any of its super classes) implements the provided |
| * interface. This is geared |
| * for simple interfaces (that don't extend other interfaces), thus if the class (or a base |
| * class) implement |
| * interface Y that extends interface X, we may not return true for interface X. |
| */ |
| |
| private boolean classImplementsInterface(CtClass ctInterface) throws NotFoundException |
| { |
| |
| for (CtClass current = ctClass; current != null; current = current.getSuperclass()) |
| { |
| for (CtClass anInterface : current.getInterfaces()) |
| { |
| if (anInterface == ctInterface) |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| public void claimField(String fieldName, Object tag) |
| { |
| getField(fieldName).claim(tag); |
| } |
| |
| public void addMethod(TransformMethodSignature signature, String methodBody) |
| { |
| removed("addMethod(TransformMethodSignature,String)"); |
| } |
| |
| public TransformMethod addNewMethod(TransformMethodSignature signature, String methodBody) |
| { |
| return addOrReplaceMethod(signature, methodBody, true); |
| } |
| |
| public TransformMethod addNewTransformedMethod(TransformMethodSignature signature, String methodBody) |
| { |
| return addOrReplaceMethod(signature, methodBody, false); |
| } |
| |
| /** |
| * @param signature |
| * of method to add |
| * @param methodBody |
| * or null for default |
| * @param addAsNew |
| * if true, then fields in the method will not be transformed |
| */ |
| private TransformMethodImpl addOrReplaceMethod(TransformMethodSignature signature, String methodBody, |
| boolean addAsNew) |
| { |
| failIfFrozen(); |
| |
| CtClass returnType = findCtClass(signature.getReturnType()); |
| CtClass[] parameters = buildCtClassList(signature.getParameterTypes()); |
| CtClass[] exceptions = buildCtClassList(signature.getExceptionTypes()); |
| |
| String suffix = addAsNew ? "" : " transformed"; |
| |
| String action = "add" + suffix; |
| |
| TransformMethodImpl result = null; |
| |
| try |
| { |
| CtMethod existing = ctClass.getDeclaredMethod(signature.getMethodName(), parameters); |
| |
| if (existing != null) |
| { |
| action = "replace" + suffix; |
| |
| ctClass.removeMethod(existing); |
| } |
| } |
| catch (NotFoundException ex) |
| { |
| // That's ok. Kind of sloppy to rely on a thrown exception; wish getDeclaredMethod() |
| // would return null for |
| // that case. Alternately, we could maintain a set of the method signatures of declared |
| // or added methods. |
| } |
| |
| try |
| { |
| |
| CtMethod method = new CtMethod(returnType, signature.getMethodName(), parameters, ctClass); |
| |
| // TODO: Check for duplicate method add |
| |
| method.setModifiers(signature.getModifiers()); |
| |
| method.setBody(methodBody); |
| method.setExceptionTypes(exceptions); |
| |
| ctClass.addMethod(method); |
| |
| result = recordMethod(method, addAsNew); |
| } |
| catch (CannotCompileException ex) |
| { |
| throw new MethodCompileException(ServicesMessages.methodCompileError(signature, methodBody, ex), |
| methodBody, ex); |
| } |
| catch (NotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| |
| addMethodToDescription(action, signature, methodBody); |
| |
| return result; |
| } |
| |
| public void addTransformedMethod(TransformMethodSignature signature, String methodBody) |
| { |
| removed("addTransformedMethod(TransformMethodSignature,String)"); |
| } |
| |
| private CtClass[] buildCtClassList(String[] typeNames) |
| { |
| CtClass[] result = new CtClass[typeNames.length]; |
| |
| for (int i = 0; i < typeNames.length; i++) |
| result[i] = findCtClass(typeNames[i]); |
| |
| return result; |
| } |
| |
| private CtClass findCtClass(String type) |
| { |
| try |
| { |
| return classPool.get(type); |
| } |
| catch (NotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| public void extendMethod(TransformMethodSignature methodSignature, String methodBody) |
| { |
| removed("extendMethod(TransformMethodSignature, String)"); |
| } |
| |
| public void extendExistingMethod(TransformMethodSignature methodSignature, String methodBody) |
| { |
| removed("extendExistingMethod(TransformMethodSignature, String)"); |
| } |
| |
| public void copyMethod(TransformMethodSignature sourceMethod, int modifiers, String newMethodName) |
| { |
| failIfFrozen(); |
| |
| CtClass returnType = findCtClass(sourceMethod.getReturnType()); |
| CtClass[] parameters = buildCtClassList(sourceMethod.getParameterTypes()); |
| CtClass[] exceptions = buildCtClassList(sourceMethod.getExceptionTypes()); |
| |
| TransformMethodImpl tmi = locateExistingOrCreateOverrideMethod(sourceMethod); |
| |
| CtMethod source = tmi.method; |
| |
| try |
| { |
| CtMethod method = new CtMethod(returnType, newMethodName, parameters, ctClass); |
| |
| method.setModifiers(modifiers); |
| |
| method.setExceptionTypes(exceptions); |
| |
| method.setBody(source, null); |
| |
| ctClass.addMethod(method); |
| |
| recordMethod(method, false); |
| } |
| catch (CannotCompileException ex) |
| { |
| throw new RuntimeException(String.format("Error copying method %s to new method %s().", sourceMethod, |
| newMethodName), ex); |
| } |
| catch (NotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| |
| // The new method is *not* considered an added method, so field references inside the method |
| // will be transformed. |
| |
| formatter.format("\n%s renamed to %s\n\n", sourceMethod, newMethodName); |
| } |
| |
| public void addCatch(TransformMethodSignature methodSignature, String exceptionType, String body) |
| { |
| removed("addCatch(TransformMethodSignature, String, String)"); |
| } |
| |
| public void prefixMethod(TransformMethodSignature methodSignature, String methodBody) |
| { |
| removed("prefixMethod(TransformMethodSignature, String)"); |
| } |
| |
| private void addMethodToDescription(String operation, TransformMethodSignature methodSignature, String methodBody) |
| { |
| formatter.format("%s method: %s %s %s(", operation, Modifier.toString(methodSignature.getModifiers()), |
| methodSignature.getReturnType(), methodSignature.getMethodName()); |
| |
| String[] parameterTypes = methodSignature.getParameterTypes(); |
| for (int i = 0; i < parameterTypes.length; i++) |
| { |
| if (i > 0) |
| description.append(", "); |
| |
| formatter.format("%s $%d", parameterTypes[i], i + 1); |
| } |
| |
| description.append(")"); |
| |
| String[] exceptionTypes = methodSignature.getExceptionTypes(); |
| for (int i = 0; i < exceptionTypes.length; i++) |
| { |
| if (i == 0) |
| description.append("\n throws "); |
| else |
| description.append(", "); |
| |
| description.append(exceptionTypes[i]); |
| } |
| |
| if (methodBody != null) |
| formatter.format("\n%s", methodBody); |
| |
| description.append("\n\n"); |
| } |
| |
| public TransformMethod getOrCreateMethod(TransformMethodSignature signature) |
| { |
| failIfFrozen(); |
| |
| return findOverrideOrCreateMethod(signature); |
| } |
| |
| private TransformMethodImpl findOverrideOrCreateMethod(TransformMethodSignature signature) |
| { |
| TransformMethodImpl result = findOrOverrideMethod(signature); |
| |
| if (result != null) |
| return result; |
| |
| return addOrReplaceMethod(signature, null, true); |
| } |
| |
| private TransformMethodImpl findOrOverrideMethod(TransformMethodSignature signature) |
| { |
| TransformMethodImpl result = methods.get(signature); |
| |
| if (result != null) |
| return result; |
| |
| return addOverrideOfSuperclassMethod(signature); |
| } |
| |
| private TransformMethodImpl locateExistingOrCreateOverrideMethod(TransformMethodSignature signature) |
| { |
| TransformMethodImpl result = findOrOverrideMethod(signature); |
| |
| if (result != null) |
| return result; |
| |
| throw new IllegalArgumentException(String.format("Class %s does not declare method '%s'.", getClassName(), |
| signature)); |
| |
| } |
| |
| // TODO: Rework this method for efficiency, i.e., so that we can leverage the methods |
| // map in parent InternalClassTransformImpls, rather than the exhaustive |
| // search. |
| private TransformMethodImpl addOverrideOfSuperclassMethod(TransformMethodSignature methodSignature) |
| { |
| try |
| { |
| for (CtClass current = ctClass; current != null; current = current.getSuperclass()) |
| { |
| for (CtMethod method : current.getDeclaredMethods()) |
| { |
| if (match(method, methodSignature)) |
| { |
| // TODO: What if the method is not overridable (i.e. private, or final)? |
| // Perhaps we should limit it to just public methods. |
| |
| CtMethod newMethod = CtNewMethod.delegator(method, ctClass); |
| ctClass.addMethod(newMethod); |
| |
| // Record it as a new method. |
| return recordMethod(newMethod, true); |
| } |
| } |
| } |
| } |
| catch (NotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| catch (CannotCompileException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| |
| // Not found in a super-class. |
| |
| return null; |
| } |
| |
| private boolean match(CtMethod method, TransformMethodSignature sig) |
| { |
| if (!sig.getMethodName().equals(method.getName())) |
| return false; |
| |
| CtClass[] paramTypes; |
| |
| try |
| { |
| paramTypes = method.getParameterTypes(); |
| } |
| catch (NotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| |
| String[] sigTypes = sig.getParameterTypes(); |
| |
| int count = sigTypes.length; |
| |
| if (paramTypes.length != count) |
| return false; |
| |
| for (int i = 0; i < count; i++) |
| { |
| String paramType = paramTypes[i].getName(); |
| |
| if (!paramType.equals(sigTypes[i])) |
| return false; |
| } |
| |
| // Ignore exceptions thrown and modifiers. |
| // TODO: Validate a match on return type? |
| |
| return true; |
| } |
| |
| public List<String> findFieldsWithAnnotation(final Class<? extends Annotation> annotationClass) |
| { |
| return toFieldNames(matchFieldsWithAnnotation(annotationClass)); |
| } |
| |
| public List<String> findFields(final FieldFilter filter) |
| { |
| assert filter != null; |
| |
| failIfFrozen(); |
| |
| List<TransformField> fields = matchFields(new Predicate<TransformField>() |
| { |
| public boolean accept(TransformField object) |
| { |
| return filter.accept(object.getName(), object.getType()); |
| } |
| }); |
| |
| return toFieldNames(fields); |
| } |
| |
| public List<TransformField> matchFields(Predicate<TransformField> predicate) |
| { |
| failIfFrozen(); |
| |
| return InternalUtils.matchAndSort(fields.values(), predicate); |
| } |
| |
| public List<TransformField> matchFieldsWithAnnotation(final Class<? extends Annotation> annotationClass) |
| { |
| return matchFields(new Predicate<TransformField>() |
| { |
| public boolean accept(TransformField field) |
| { |
| return field.getAnnotation(annotationClass) != null; |
| } |
| }); |
| } |
| |
| public List<TransformMethodSignature> findMethodsWithAnnotation(final Class<? extends Annotation> annotationClass) |
| { |
| List<TransformMethod> methods = matchMethods(new Predicate<TransformMethod>() |
| { |
| public boolean accept(TransformMethod method) |
| { |
| return method.getAnnotation(annotationClass) != null; |
| }; |
| }); |
| |
| return toMethodSignatures(methods); |
| } |
| |
| public List<TransformMethodSignature> findMethods(final MethodFilter filter) |
| { |
| assert filter != null; |
| |
| List<TransformMethod> methods = matchMethods(new Predicate<TransformMethod>() |
| { |
| public boolean accept(TransformMethod object) |
| { |
| return filter.accept(object.getSignature()); |
| }; |
| }); |
| |
| return toMethodSignatures(methods); |
| } |
| |
| public List<TransformMethod> matchMethods(Predicate<TransformMethod> predicate) |
| { |
| failIfFrozen(); |
| |
| return InternalUtils.matchAndSort(methods.values(), predicate); |
| } |
| |
| public List<TransformMethod> matchMethodsWithAnnotation(final Class<? extends Annotation> annotationType) |
| { |
| return matchMethods(new Predicate<TransformMethod>() |
| { |
| public boolean accept(TransformMethod method) |
| { |
| return method.getAnnotation(annotationType) != null; |
| } |
| }); |
| } |
| |
| private TransformMethodSignature toMethodSignature(CtMethod method) |
| { |
| try |
| { |
| String type = method.getReturnType().getName(); |
| String[] parameters = toTypeNames(method.getParameterTypes()); |
| String[] exceptions = toTypeNames(method.getExceptionTypes()); |
| |
| return new TransformMethodSignature(method.getModifiers(), type, method.getName(), parameters, exceptions); |
| } |
| catch (NotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| private String[] toTypeNames(CtClass[] types) |
| { |
| String[] result = new String[types.length]; |
| |
| for (int i = 0; i < types.length; i++) |
| result[i] = types[i].getName(); |
| |
| return result; |
| } |
| |
| public List<String> findUnclaimedFields() |
| { |
| return toFieldNames(matchUnclaimedFields()); |
| } |
| |
| public List<TransformField> matchUnclaimedFields() |
| { |
| return matchFields(new Predicate<TransformField>() |
| { |
| public boolean accept(TransformField object) |
| { |
| TransformFieldImpl tmi = (TransformFieldImpl) object; |
| |
| return !(tmi.added || tmi.isClaimed()); |
| } |
| }); |
| } |
| |
| public String getFieldType(String fieldName) |
| { |
| return getField(fieldName).getType(); |
| } |
| |
| public boolean isField(String fieldName) |
| { |
| failIfFrozen(); |
| |
| // Only declared instance fields end up in this map, and all |
| // fields are either static or private. |
| |
| return fields.containsKey(fieldName); |
| } |
| |
| public int getFieldModifiers(String fieldName) |
| { |
| return getField(fieldName).getModifiers(); |
| } |
| |
| public String addField(int modifiers, String type, String suggestedName) |
| { |
| return createField(modifiers, type, suggestedName).getName(); |
| } |
| |
| public TransformField createField(int modifiers, String type, String suggestedName) |
| { |
| failIfFrozen(); |
| |
| String fieldName = newMemberName(suggestedName); |
| |
| TransformFieldImpl result = null; |
| |
| try |
| { |
| CtClass ctType = convertNameToCtType(type); |
| |
| CtField field = new CtField(ctType, fieldName, ctClass); |
| field.setModifiers(modifiers); |
| |
| ctClass.addField(field); |
| |
| result = new TransformFieldImpl(field, true); |
| |
| fields.put(fieldName, result); |
| |
| } |
| catch (NotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| catch (CannotCompileException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| |
| formatter.format("add field: %s %s %s;\n\n", Modifier.toString(modifiers), type, fieldName); |
| |
| return result; |
| } |
| |
| // Returns String for backwards compatibility reasons |
| public String addInjectedField(Class type, String suggestedName, Object value) |
| { |
| assert type != null; |
| |
| failIfFrozen(); |
| |
| InjectionKey key = new InjectionKey(type, value); |
| |
| String fieldName = searchForPreviousInjection(key); |
| |
| if (fieldName != null) |
| return fieldName; |
| |
| // TODO: Probably doesn't handle arrays and primitives. |
| |
| fieldName = addInjectedFieldUncached(type, suggestedName, value); |
| |
| // Remember the injection in-case this class, or a subclass, injects the value again. |
| |
| injectionCache.put(key, fieldName); |
| |
| return fieldName; |
| } |
| |
| public <T> TransformField addIndirectInjectedField(Class<T> type, String suggestedName, |
| ComponentValueProvider<T> provider) |
| { |
| assert type != null; |
| assert provider != null; |
| |
| TransformField field = createField(Modifier.PROTECTED | Modifier.FINAL, type.getName(), suggestedName); |
| |
| String argReference = addConstructorArg(providerType, provider); |
| |
| // Inside the constructor, |
| // pass the resources to the provider's get() method, cast to the |
| // field type and assign. This will likely not work with |
| // primitives and arrays, but that's ok for now. |
| |
| addToConstructor(String.format(" %s = (%s) (%s).get(%s);", field.getName(), type.getName(), argReference, |
| resourcesFieldName)); |
| |
| return field; |
| } |
| |
| private CtClass toCtClass(Class type) |
| { |
| try |
| { |
| return classPool.get(type.getName()); |
| } |
| catch (NotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| /** |
| * This is split out from {@link #addInjectedField(Class, String, Object)} to handle a special |
| * case for the |
| * InternalComponentResources, which is null when "injected" (during the class transformation) |
| * and is only |
| * determined when a component is actually instantiated. |
| */ |
| private String addInjectedFieldUncached(Class type, String suggestedName, Object value) |
| { |
| CtClass ctType = toCtClass(type); |
| |
| String fieldName = addField(Modifier.PROTECTED | Modifier.FINAL, type.getName(), suggestedName); |
| |
| addInjectToConstructor(fieldName, ctType, value); |
| |
| return fieldName; |
| } |
| |
| public String searchForPreviousInjection(InjectionKey key) |
| { |
| String result = injectionCache.get(key); |
| |
| if (result != null) |
| return result; |
| |
| if (parentTransformation != null) |
| return parentTransformation.searchForPreviousInjection(key); |
| |
| return null; |
| } |
| |
| public void advise(TransformMethodSignature methodSignature, ComponentMethodAdvice advice) |
| { |
| getOrCreateMethod(methodSignature).addAdvice(advice); |
| } |
| |
| public boolean isMethodOverride(TransformMethodSignature methodSignature) |
| { |
| if (!isMethod(methodSignature)) |
| throw new IllegalArgumentException(String.format("Method %s is not implemented by transformed class %s.", |
| methodSignature, getClassName())); |
| |
| return getOrCreateMethod(methodSignature).isOverride(); |
| } |
| |
| public InternalClassTransformation getParentTransformation() |
| { |
| return parentTransformation; |
| } |
| |
| public boolean isMethod(TransformMethodSignature signature) |
| { |
| assert signature != null; |
| |
| return methods.containsKey(signature); |
| } |
| |
| /** |
| * Adds a parameter to the constructor for the class; the parameter is used to initialize the |
| * value for a field. |
| * |
| * @param fieldName |
| * name of field to inject |
| * @param fieldType |
| * Javassist type of the field (and corresponding parameter) |
| * @param value |
| * the value to be injected (which will in unusual cases be null) |
| */ |
| private void addInjectToConstructor(String fieldName, CtClass fieldType, Object value) |
| { |
| addToConstructor(String.format(" %s = %s;", fieldName, addConstructorArg(fieldType, value))); |
| } |
| |
| public void injectField(String fieldName, Object value) |
| { |
| getField(fieldName).inject(value); |
| } |
| |
| private CtClass convertNameToCtType(String type) throws NotFoundException |
| { |
| return classPool.get(type); |
| } |
| |
| public String finish() |
| { |
| failIfFrozen(); |
| |
| // Finishing fields may sometimes create new methods, so finish the fields |
| // first. |
| |
| for (TransformFieldImpl tfi : fields.values()) |
| { |
| tfi.doFinish(); |
| } |
| |
| // doFinish() will sometimes create new methods on the ClassTransformation, yielding |
| // a concurrent modification exception, so do a defensive copy. |
| |
| List<TransformMethodImpl> tmis = CollectionFactory.newList(methods.values()); |
| |
| for (TransformMethodImpl tmi : tmis) |
| { |
| tmi.doFinish(); |
| } |
| |
| String initializer = convertConstructorToMethod(); |
| |
| performFieldTransformations(); |
| |
| addConstructor(initializer); |
| |
| String description = toString(); |
| |
| freeze(); |
| |
| return description; |
| } |
| |
| private void addConstructor(String initializer) |
| { |
| // Add a call to the initializer; the method converted from the class' default |
| // constructor. |
| |
| constructor.append(" "); |
| constructor.append(initializer); |
| |
| // This finally matches the "{" added inside the constructor |
| |
| constructor.append("();\n\n}"); |
| |
| String constructorBody = constructor.toString(); |
| |
| try |
| { |
| CtClass[] types = new CtClass[] |
| { toCtClass(InternalComponentResources.class), toCtClass(Object[].class) }; |
| |
| CtConstructor cons = CtNewConstructor.make(types, null, constructorBody, ctClass); |
| |
| ctClass.addConstructor(cons); |
| } |
| catch (CannotCompileException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| |
| formatter.format("add constructor: %s(ComponentResources, Object[])\n%s\n\n", getClassName(), constructorBody); |
| } |
| |
| private String convertConstructorToMethod() |
| { |
| String initializer = idAllocator.allocateId("initializer"); |
| |
| try |
| { |
| CtConstructor defaultConstructor = ctClass.getConstructor("()V"); |
| |
| CtMethod initializerMethod = defaultConstructor.toMethod(initializer, ctClass); |
| |
| ctClass.addMethod(initializerMethod); |
| |
| recordMethod(initializerMethod, false); |
| |
| // Replace the constructor body with one that fails. This leaves, as an open question, |
| // what to do about any other constructors. |
| |
| String body = String.format("throw new RuntimeException(\"%s\");", |
| ServicesMessages.forbidInstantiateComponentClass(getClassName())); |
| |
| defaultConstructor.setBody(body); |
| } |
| catch (Exception ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| |
| formatter.format("convert default constructor: %s();\n\n", initializer); |
| |
| return initializer; |
| } |
| |
| public Instantiator createInstantiator() |
| { |
| if (Modifier.isAbstract(ctClass.getModifiers())) |
| return createAbstractClassInstantiator(); |
| |
| String componentClassName = getClassName(); |
| |
| String name = ClassFabUtils.generateClassName("Instantiator"); |
| |
| ClassFab cf = classFactory.newClass(name, AbstractInstantiator.class); |
| |
| Object[] componentConstructorArgs = constructorArgs.toArray(new Object[constructorArgs.size()]); |
| |
| cf.addConstructor(new Class[] |
| { ComponentModel.class, String.class, Object[].class }, null, "super($1, $2, $3);"); |
| |
| // Pass $1 (the InternalComponentResources object) and the constructorArgs (from the AbstractIntantiator |
| // base class) into the new component instance's constructor |
| |
| cf.addMethod(Modifier.PUBLIC, NEW_INSTANCE_SIGNATURE, |
| String.format("return new %s($1, constructorArgs);", componentClassName)); |
| |
| Class instantiatorClass = cf.createClass(); |
| |
| try |
| { |
| Object instance = instantiatorClass.getConstructors()[0].newInstance(componentModel, |
| String.format("Instantiator[%s]", componentClassName), componentConstructorArgs); |
| |
| return (Instantiator) instance; |
| } |
| catch (Exception ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| private Instantiator createAbstractClassInstantiator() |
| { |
| return new Instantiator() |
| { |
| public Component newInstance(InternalComponentResources resources) |
| { |
| throw new RuntimeException(String.format("Component class %s is abstract and can not be instantiated.", |
| ctClass.getName())); |
| } |
| |
| public ComponentModel getModel() |
| { |
| return componentModel; |
| } |
| }; |
| } |
| |
| private void failIfFrozen() |
| { |
| if (frozen) |
| throw new IllegalStateException("The ClassTransformation instance (for " + getClassName() |
| + ") has completed all transformations and may not be further modified."); |
| } |
| |
| private void failIfNotFrozen() |
| { |
| if (!frozen) |
| throw new IllegalStateException("The ClassTransformation instance (for " + getClassName() |
| + ") has not yet completed all transformations."); |
| } |
| |
| public IdAllocator getIdAllocator() |
| { |
| failIfNotFrozen(); |
| |
| return idAllocator; |
| } |
| |
| public List<Object> getConstructorArgs() |
| { |
| failIfNotFrozen(); |
| |
| return CollectionFactory.newList(constructorArgs); |
| } |
| |
| public List<Annotation> getClassAnnotations() |
| { |
| failIfFrozen(); |
| |
| if (classAnnotations == null) |
| assembleClassAnnotations(); |
| |
| return classAnnotations; |
| } |
| |
| private void assembleClassAnnotations() |
| { |
| classAnnotations = CollectionFactory.newList(); |
| |
| boolean filter = false; |
| |
| try |
| { |
| for (CtClass current = ctClass; current != null; current = current.getSuperclass()) |
| { |
| addAnnotationsToList(classAnnotations, current.getAnnotations(), filter); |
| |
| // Super-class annotations are filtered |
| |
| filter = true; |
| } |
| } |
| catch (NotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| catch (ClassNotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| public String toString() |
| { |
| StringBuilder builder = new StringBuilder("InternalClassTransformation[\n"); |
| |
| try |
| { |
| Formatter formatter = new Formatter(builder); |
| |
| formatter.format("%s %s extends %s", Modifier.toString(ctClass.getModifiers()), ctClass.getName(), ctClass |
| .getSuperclass().getName()); |
| |
| CtClass[] interfaces = ctClass.getInterfaces(); |
| |
| for (int i = 0; i < interfaces.length; i++) |
| { |
| if (i == 0) |
| builder.append("\n implements "); |
| else |
| builder.append(", "); |
| |
| builder.append(interfaces[i].getName()); |
| } |
| |
| if (description != null) |
| formatter.format("\n\n%s", description.toString()); |
| } |
| catch (NotFoundException ex) |
| { |
| builder.append(ex); |
| } |
| |
| builder.append("]"); |
| |
| return builder.toString(); |
| } |
| |
| public void makeReadOnly(String fieldName) |
| { |
| String methodName = newMemberName("write", fieldName); |
| |
| String fieldType = getFieldType(fieldName); |
| |
| TransformMethodSignature sig = new TransformMethodSignature(Modifier.PRIVATE, "void", methodName, new String[] |
| { fieldType }, null); |
| |
| String message = ServicesMessages.readOnlyField(getClassName(), fieldName); |
| |
| String body = String.format("throw new java.lang.RuntimeException(\"%s\");", message); |
| |
| addNewMethod(sig, body); |
| |
| replaceWriteAccess(fieldName, methodName); |
| } |
| |
| public void removeField(String fieldName) |
| { |
| removed("removeField(String)"); |
| } |
| |
| public void replaceReadAccess(String fieldName, String methodName) |
| { |
| getTransformFieldImpl(fieldName).replaceReadAccess(methodName); |
| } |
| |
| public void replaceWriteAccess(String fieldName, String methodName) |
| { |
| getTransformFieldImpl(fieldName).replaceWriteAccess(methodName); |
| } |
| |
| private void performFieldTransformations() |
| { |
| // If no field transformations have been requested, then we can save ourselves some |
| // trouble! |
| |
| if (fieldAccessReplaced) |
| replaceFieldAccess(); |
| } |
| |
| static final int SYNTHETIC = 0x00001000; |
| |
| private void replaceFieldAccess() |
| { |
| final Map<String, String> fieldReadTransforms = CollectionFactory.newMap(); |
| final Map<String, String> fieldWriteTransforms = CollectionFactory.newMap(); |
| |
| for (TransformFieldImpl tfi : fields.values()) |
| { |
| putIfNotNull(fieldReadTransforms, tfi.name, tfi.readValueBody); |
| putIfNotNull(fieldWriteTransforms, tfi.name, tfi.writeValueBody); |
| } |
| |
| ExprEditor editor = new ExprEditor() |
| { |
| private final Set<CtBehavior> addedMethods = CollectionFactory.newSet(); |
| |
| { |
| for (TransformMethodImpl tmi : methods.values()) |
| { |
| if (tmi.added) |
| addedMethods.add(tmi.method); |
| } |
| } |
| |
| public void edit(FieldAccess access) throws CannotCompileException |
| { |
| CtBehavior where = access.where(); |
| |
| if (where instanceof CtConstructor) |
| return; |
| |
| // It may be access to a public field of a data object somewhere and |
| // that's ignored TAP5-1222 |
| |
| if (!access.getClassName().equals(getClassName())) |
| return; |
| |
| boolean isRead = access.isReader(); |
| String fieldName = access.getFieldName(); |
| CtMethod method = (CtMethod) where; |
| |
| formatter.format("Checking field %s %s in method %s(): ", isRead ? "read" : "write", fieldName, |
| method.getName()); |
| |
| // Ignore any methods to were added as part of the transformation. |
| // If we reference the field there, we really mean the field. |
| |
| if (addedMethods.contains(where)) |
| { |
| formatter.format("added method\n"); |
| return; |
| } |
| |
| Map<String, String> transformMap = isRead ? fieldReadTransforms : fieldWriteTransforms; |
| |
| String body = transformMap.get(fieldName); |
| if (body == null) |
| { |
| formatter.format("field not transformed\n"); |
| return; |
| } |
| |
| formatter.format("replacing with %s\n", body); |
| |
| access.replace(body); |
| } |
| }; |
| |
| try |
| { |
| ctClass.instrument(editor); |
| } |
| catch (CannotCompileException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| |
| formatter.format("\n"); |
| } |
| |
| private static <K, V> void putIfNotNull(Map<K, V> map, K key, V value) |
| { |
| if (value != null) |
| map.put(key, value); |
| } |
| |
| public Class toClass(String type) |
| { |
| String finalType = TransformUtils.getWrapperTypeName(type); |
| |
| try |
| { |
| return Class.forName(finalType, true, classFactory.getClassLoader()); |
| } |
| catch (ClassNotFoundException ex) |
| { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| public String getClassName() |
| { |
| return ctClass.getName(); |
| } |
| |
| public Logger getLogger() |
| { |
| return logger; |
| } |
| |
| public void extendConstructor(String statement) |
| { |
| removed("extendConstructor(String)"); |
| } |
| |
| void addToConstructor(String statement) |
| { |
| constructor.append(statement); |
| constructor.append("\n"); |
| } |
| |
| public String getMethodIdentifier(TransformMethodSignature signature) |
| { |
| return getOrCreateMethod(signature).getMethodIdentifier(); |
| } |
| |
| public boolean isRootTransformation() |
| { |
| return parentTransformation == null; |
| } |
| |
| /** |
| * Adds a new constructor argument to the transformed constructor. |
| * |
| * @param parameterType |
| * type of parameter |
| * @param value |
| * value of parameter |
| * @return de-referenced argument value |
| */ |
| private String addConstructorArg(CtClass parameterType, Object value) |
| { |
| |
| int index = constructorArgs.size(); |
| |
| constructorArgs.add(value); |
| |
| return ClassFabUtils.castReference(String.format("$2[%d]", index), parameterType.getName()); |
| } |
| |
| private static List<TransformMethodSignature> toMethodSignatures(List<TransformMethod> input) |
| { |
| List<TransformMethodSignature> result = CollectionFactory.newList(); |
| |
| for (TransformMethod m : input) |
| { |
| result.add(m.getSignature()); |
| } |
| |
| return result; |
| } |
| |
| private static List<String> toFieldNames(List<TransformField> fields) |
| { |
| List<String> result = CollectionFactory.newList(); |
| |
| for (TransformField f : fields) |
| { |
| result.add(f.getName()); |
| } |
| |
| return result; |
| } |
| |
| private ComponentMethodInvocationBuilder createBuilder(TransformMethodSignature signature) |
| { |
| return new ComponentMethodInvocationBuilder(this, componentClassCache, signature, classSource); |
| } |
| |
| public boolean isDeclaredMethod(TransformMethodSignature signature) |
| { |
| failIfFrozen(); |
| |
| assert signature != null; |
| |
| return methods.containsKey(signature); |
| } |
| |
| private void removed(String methodName) |
| { |
| throw new RuntimeException(String.format( |
| "Method ClassTransformation.%s has been deprecated and is no longer functional. " |
| + "Please consult the JavaDoc for a suitable replacement.", methodName)); |
| } |
| |
| private static ComponentMethodAdvice toBeforeAdvice(final ComponentInstanceOperation operation) |
| { |
| return new ComponentMethodAdvice() |
| { |
| |
| public void advise(ComponentMethodInvocation invocation) |
| { |
| operation.invoke(invocation.getInstance()); |
| |
| invocation.proceed(); |
| } |
| }; |
| } |
| |
| private static ComponentMethodAdvice toAfterAdvice(final ComponentInstanceOperation operation) |
| { |
| return new ComponentMethodAdvice() |
| { |
| public void advise(ComponentMethodInvocation invocation) |
| { |
| invocation.proceed(); |
| |
| operation.invoke(invocation.getInstance()); |
| } |
| }; |
| } |
| |
| public void addComponentEventHandler(String eventType, int minContextValues, String methodDescription, |
| ComponentEventHandler handler) |
| { |
| assert InternalUtils.isNonBlank(eventType); |
| assert InternalUtils.isNonBlank(methodDescription); |
| assert handler != null; |
| |
| componentModel.addEventHandler(eventType); |
| |
| getOrCreateMethod(TransformConstants.DISPATCH_COMPONENT_EVENT).addAdvice( |
| createEventHandlerAdvice(eventType, minContextValues, methodDescription, handler)); |
| |
| } |
| |
| private static ComponentMethodAdvice createEventHandlerAdvice(final String eventType, final int minContextValues, |
| final String methodDescription, final ComponentEventHandler handler) |
| { |
| return new ComponentMethodAdvice() |
| { |
| public void advise(ComponentMethodInvocation invocation) |
| { |
| // Invoke the super-class implementation first. |
| |
| invocation.proceed(); |
| |
| ComponentEvent event = (ComponentEvent) invocation.getParameter(0); |
| |
| if (!event.isAborted() && event.matches(eventType, "", minContextValues)) |
| { |
| event.setMethodDescription(methodDescription); |
| |
| handler.handleEvent(invocation.getInstance(), event); |
| |
| // Ensure that the caller knows that some event handler method |
| // was invoked. |
| invocation.overrideResult(true); |
| } |
| } |
| }; |
| } |
| |
| private static org.apache.tapestry5.services.FieldAccess toFieldAccess(final FieldValueConduit conduit) |
| { |
| return new org.apache.tapestry5.services.FieldAccess() |
| { |
| |
| public void write(Object instance, Object value) |
| { |
| conduit.set(value); |
| } |
| |
| public Object read(Object instance) |
| { |
| return conduit.get(); |
| } |
| }; |
| } |
| } |
