Java tutorial
/* ******************************************************************* * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC). * All rights reserved. * This program and the accompanying materials are made available * under the terms of the Eclipse Public License v1.0 * which accompanies this distribution and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * PARC initial implementation * Alexandre Vasseur @AspectJ ITDs * ******************************************************************/ package org.aspectj.weaver; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.EOFException; import java.io.File; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import org.aspectj.bridge.ISourceLocation; import org.aspectj.bridge.SourceLocation; import org.aspectj.util.TypeSafeEnum; /** * This is an abstraction over method/field introduction. It might not have the chops to handle other inter-type declarations. This * is the thing that is used on the eclipse side and serialized into a ConcreteTypeMunger. */ public abstract class ResolvedTypeMunger { protected Kind kind; protected ResolvedMember signature; /** * The declared signature is filled in when a type munger is parameterized for application to a particular type. It represents * the signature originally declared in the source file. */ protected ResolvedMember declaredSignature; // This list records the occurences (in order) of any names specified in the <> // for a target type for the ITD. So for example, for List<C,B,A> this list // will be C,B,A - the list is used later to map other occurrences of C,B,A // across the intertype declaration to the right type variables in the generic // type upon which the itd is being made. // might need serializing the class file for binary weaving. protected List<String> typeVariableAliases; private Set<ResolvedMember> superMethodsCalled = Collections.emptySet(); private ISourceLocation location; private ResolvedType onType = null; public ResolvedTypeMunger(Kind kind, ResolvedMember signature) { this.kind = kind; this.signature = signature; UnresolvedType declaringType = signature != null ? signature.getDeclaringType() : null; if (declaringType != null) { if (declaringType.isRawType()) { throw new IllegalStateException("Use generic type, not raw type"); } if (declaringType.isParameterizedType()) { throw new IllegalStateException("Use generic type, not parameterized type"); } } // boolean aChangeOccurred = false; // // UnresolvedType rt = signature.getReturnType(); // if (rt.isParameterizedType() || rt.isGenericType()) {rt = rt.getRawType();aChangeOccurred=true;} // UnresolvedType[] pt = signature.getParameterTypes(); // for (int i = 0; i < pt.length; i++) { // if (pt[i].isParameterizedType() || pt[i].isGenericType()) { pt[i] = pt[i].getRawType();aChangeOccurred=true;} // } // if (aChangeOccurred) { // this.signature = new // ResolvedMemberImpl(signature.getKind(),signature.getDeclaringType(),signature.getModifiers(),rt,signature // .getName(),pt,signature.getExceptions()); // } } public void setSourceLocation(ISourceLocation isl) { location = isl; } public ISourceLocation getSourceLocation() { return location; } // ---- // fromType is guaranteed to be a non-abstract aspect // public ConcreteTypeMunger concretize(World world, ResolvedType aspectType) { // // ConcreteTypeMunger munger = world.concreteTypeMunger(this, aspectType); // return munger; // } public boolean matches(ResolvedType matchType, ResolvedType aspectType) { if (onType == null) { onType = matchType.getWorld().resolve(getDeclaringType()); if (onType.isRawType()) { onType = onType.getGenericType(); } } // System.err.println("matching: " + this + " to " + matchType + " onType = " + onType); if (matchType.equals(onType)) { if (!onType.isExposedToWeaver()) { // if the onType is an interface, and it already has the member we are about // to munge, then this is ok... boolean ok = (onType.isInterface() && (onType.lookupMemberWithSupersAndITDs(getSignature()) != null)); if (!ok && onType.getWeaverState() == null) { if (matchType.getWorld().getLint().typeNotExposedToWeaver.isEnabled()) { matchType.getWorld().getLint().typeNotExposedToWeaver.signal(matchType.getName(), signature.getSourceLocation()); } } } return true; } // System.err.println("NO MATCH DIRECT"); if (onType.isInterface()) { return matchType.isTopmostImplementor(onType); } else { return false; } } // ---- @Override public String toString() { return "ResolvedTypeMunger(" + getKind() + ", " + getSignature() + ")"; // .superMethodsCalled + ")"; } // ---- public static ResolvedTypeMunger read(VersionedDataInputStream s, ISourceContext context) throws IOException { Kind kind = Kind.read(s); if (kind == Field) { return NewFieldTypeMunger.readField(s, context); } else if (kind == Method) { return NewMethodTypeMunger.readMethod(s, context); } else if (kind == Constructor) { return NewConstructorTypeMunger.readConstructor(s, context); } else if (kind == MethodDelegate) { return MethodDelegateTypeMunger.readMethod(s, context, false); } else if (kind == FieldHost) { return MethodDelegateTypeMunger.FieldHostTypeMunger.readFieldHost(s, context); } else if (kind == MethodDelegate2) { return MethodDelegateTypeMunger.readMethod(s, context, true); } else if (kind == InnerClass) { return NewMemberClassTypeMunger.readInnerClass(s, context); } else { throw new RuntimeException("unimplemented"); } } protected static Set<ResolvedMember> readSuperMethodsCalled(VersionedDataInputStream s) throws IOException { Set<ResolvedMember> ret = new HashSet<ResolvedMember>(); int n = -1; if (s.isAtLeast169()) { n = s.readByte(); } else { n = s.readInt(); } if (n < 0) { throw new BCException("Problem deserializing type munger"); } for (int i = 0; i < n; i++) { ret.add(ResolvedMemberImpl.readResolvedMember(s, null)); } return ret; } protected final void writeSuperMethodsCalled(CompressingDataOutputStream s) throws IOException { if (superMethodsCalled == null || superMethodsCalled.size() == 0) { s.writeByte(0); return; } List<ResolvedMember> ret = new ArrayList<ResolvedMember>(superMethodsCalled); Collections.sort(ret); int n = ret.size(); s.writeByte(n); for (ResolvedMember m : ret) { m.write(s); } } protected static ISourceLocation readSourceLocation(VersionedDataInputStream s) throws IOException { // Location persistence for type mungers was added after 1.2.1 was shipped... if (s.getMajorVersion() < AjAttribute.WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ150) { return null; } SourceLocation ret = null; ObjectInputStream ois = null; try { // This logic copes with the location missing from the attribute - an EOFException will // occur on the next line and we ignore it. byte b = 0; // if we aren't on 1.6.9 or we are on 1.6.9 but not compressed, then read as object stream if (!s.isAtLeast169() || (b = s.readByte()) == 0) { ois = new ObjectInputStream(s); boolean validLocation = (Boolean) ois.readObject(); if (validLocation) { File f = (File) ois.readObject(); Integer ii = (Integer) ois.readObject(); Integer offset = (Integer) ois.readObject(); ret = new SourceLocation(f, ii.intValue()); ret.setOffset(offset.intValue()); } } else { boolean validLocation = b == 2; if (validLocation) { String path = s.readUtf8(s.readShort()); File f = new File(path); ret = new SourceLocation(f, s.readInt()); int offset = s.readInt(); ret.setOffset(offset); } } } catch (EOFException eof) { return null; // This exception occurs if processing an 'old style' file where the // type munger attributes don't include the source location. } catch (IOException ioe) { // Something went wrong, maybe this is an 'old style' file that doesnt attach locations to mungers? // (but I thought that was just an EOFException?) ioe.printStackTrace(); return null; } catch (ClassNotFoundException e) { } finally { if (ois != null) { ois.close(); } } return ret; } protected final void writeSourceLocation(CompressingDataOutputStream s) throws IOException { if (s.canCompress()) { s.writeByte(1 + (location == null ? 0 : 1)); // 1==compressed no location 2==compressed with location if (location != null) { s.writeCompressedPath(location.getSourceFile().getPath()); s.writeInt(location.getLine()); s.writeInt(location.getOffset()); } } else { s.writeByte(0); ObjectOutputStream oos = new ObjectOutputStream(s); oos.writeObject(new Boolean(location != null)); if (location != null) { oos.writeObject(location.getSourceFile()); oos.writeObject(new Integer(location.getLine())); oos.writeObject(new Integer(location.getOffset())); } oos.flush(); oos.close(); } } public abstract void write(CompressingDataOutputStream s) throws IOException; public Kind getKind() { return kind; } public static class Kind extends TypeSafeEnum { /* private */ Kind(String name, int key) { super(name, key); } public static Kind read(DataInputStream s) throws IOException { int key = s.readByte(); switch (key) { case 1: return Field; case 2: return Method; case 5: return Constructor; case 9: return MethodDelegate; case 10: return FieldHost; case 11: return MethodDelegate2; case 12: return InnerClass; } throw new BCException("bad kind: " + key); } @Override public String toString() { // we want MethodDelegate to appear as Method in WeaveInfo messages // TODO we may want something for fieldhost ? if (getName().startsWith(MethodDelegate.getName())) {// startsWith will cover MethodDelegate2 as well return Method.toString(); } else { return super.toString(); } } } // ---- fields public static final Kind Field = new Kind("Field", 1); public static final Kind Method = new Kind("Method", 2); public static final Kind Constructor = new Kind("Constructor", 5); // not serialized, only created during concretization of aspects public static final Kind PerObjectInterface = new Kind("PerObjectInterface", 3); public static final Kind PrivilegedAccess = new Kind("PrivilegedAccess", 4); public static final Kind Parent = new Kind("Parent", 6); // PTWIMPL not serialized, used during concretization of aspects public static final Kind PerTypeWithinInterface = new Kind("PerTypeWithinInterface", 7); public static final Kind AnnotationOnType = new Kind("AnnotationOnType", 8); // not serialized public static final Kind MethodDelegate = new Kind("MethodDelegate", 9);// serialized, @AJ ITDs public static final Kind FieldHost = new Kind("FieldHost", 10);// serialized, @AJ ITDs public static final Kind MethodDelegate2 = new Kind("MethodDelegate2", 11);// serialized, @AJ ITDs public static final Kind InnerClass = new Kind("InnerClass", 12); public static final String SUPER_DISPATCH_NAME = "superDispatch"; public void setSuperMethodsCalled(Set<ResolvedMember> c) { this.superMethodsCalled = c; } public Set<ResolvedMember> getSuperMethodsCalled() { return superMethodsCalled; } public ResolvedMember getSignature() { return signature; } // ---- public ResolvedMember getMatchingSyntheticMember(Member member, ResolvedType aspectType) { if ((getSignature() != null) && getSignature().isPublic() && member.equals(getSignature())) { return getSignature(); } return null; } public boolean changesPublicSignature() { return kind == Field || kind == Method || kind == Constructor; } public boolean needsAccessToTopmostImplementor() { if (kind == Field) { return true; } else if (kind == Method) { return !signature.isAbstract(); } else { return false; } } protected static List<String> readInTypeAliases(VersionedDataInputStream s) throws IOException { if (s.getMajorVersion() >= AjAttribute.WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ150) { int count = -1; if (s.isAtLeast169()) { count = s.readByte(); } else { count = s.readInt(); } if (count != 0) { List<String> aliases = new ArrayList<String>(); for (int i = 0; i < count; i++) { aliases.add(s.readUTF()); } return aliases; } } return null; } protected final void writeOutTypeAliases(DataOutputStream s) throws IOException { // Write any type variable aliases if (typeVariableAliases == null || typeVariableAliases.size() == 0) { s.writeByte(0); } else { s.writeByte(typeVariableAliases.size()); for (String element : typeVariableAliases) { s.writeUTF(element); } } } public List<String> getTypeVariableAliases() { return typeVariableAliases; } protected void setTypeVariableAliases(List<String> typeVariableAliases) { this.typeVariableAliases = typeVariableAliases; } public boolean hasTypeVariableAliases() { return (typeVariableAliases != null && typeVariableAliases.size() > 0); } /** * return true if type variables are specified with the target type for this ITD. e.g. this would return true: * "int I<A,B>.m() { return 42; }" */ public boolean sharesTypeVariablesWithGenericType() { return (typeVariableAliases != null && typeVariableAliases.size() > 0); } /** * Parameterizes a resolved type munger for a particular usage of its target type (this is used when the target type is generic * and the ITD shares type variables with the target) see ConcreteTypeMunger.parameterizedFor */ public ResolvedTypeMunger parameterizedFor(ResolvedType target) { throw new BCException("Dont call parameterizedFor on a type munger of this kind: " + this.getClass()); } // ResolvedType genericType = target; // if (target.isRawType() || target.isParameterizedType()) genericType = genericType.getGenericType(); // ResolvedMember parameterizedSignature = null; // // If we are parameterizing it for a generic type, we just need to 'swap the letters' from the ones used // // in the original ITD declaration to the ones used in the actual target type declaration. // if (target.isGenericType()) { // TypeVariable vars[] = target.getTypeVariables(); // UnresolvedTypeVariableReferenceType[] varRefs = new UnresolvedTypeVariableReferenceType[vars.length]; // for (int i = 0; i < vars.length; i++) { // varRefs[i] = new UnresolvedTypeVariableReferenceType(vars[i]); // } // parameterizedSignature = getSignature().parameterizedWith(varRefs,genericType,true,typeVariableAliases); // } else { // // For raw and 'normal' parameterized targets (e.g. Interface, Interface<String>) // parameterizedSignature = // getSignature().parameterizedWith(target.getTypeParameters(),genericType,target.isParameterizedType(),typeVariableAliases); // } // return new NewMethodTypeMunger(parameterizedSignature,getSuperMethodsCalled(),typeVariableAliases); // } // /** // * see ResolvedTypeMunger.parameterizedFor(ResolvedType) // */ // public ResolvedTypeMunger parameterizedFor(ResolvedType target) { // ResolvedType genericType = target; // if (target.isRawType() || target.isParameterizedType()) genericType = genericType.getGenericType(); // ResolvedMember parameterizedSignature = // getSignature().parameterizedWith(target.getTypeParameters(),genericType,target.isParameterizedType(),typeVariableAliases); // return new NewFieldTypeMunger(parameterizedSignature,getSuperMethodsCalled(),typeVariableAliases); // } public void setDeclaredSignature(ResolvedMember rm) { declaredSignature = rm; } public ResolvedMember getDeclaredSignature() { return declaredSignature; } /** * A late munger has to be done after shadow munging since which shadows are matched can affect the operation of the late * munger. e.g. perobjectinterfacemunger */ public boolean isLateMunger() { return false; } /** * Some type mungers are created purely to help with the implementation of shadow mungers. For example to support the cflow() * pointcut we create a new cflow field in the aspect, and that is added via a BcelCflowCounterFieldAdder. * * During compilation we need to compare sets of type mungers, and if some only come into existence after the 'shadowy' type * things have been processed, we need to ignore them during the comparison. * * Returning true from this method indicates the type munger exists to support 'shadowy' stuff - and so can be ignored in some * comparison. */ public boolean existsToSupportShadowMunging() { return false; } public ResolvedTypeMunger parameterizeWith(Map<String, UnresolvedType> m, World w) { throw new BCException("Dont call parameterizeWith() on a type munger of this kind: " + this.getClass()); } public UnresolvedType getDeclaringType() { return getSignature().getDeclaringType(); } }