public static NamePattern read(VersionedDataInputStream in) throws IOException { String s = in.readUTF(); if (s.length() == 0) { return ELLIPSIS; } return new NamePattern(s); }
public static AnnotationTypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException { ExactAnnotationFieldTypePattern ret; String formalName = s.readUTF(); UnresolvedType annotationType = UnresolvedType.read(s); ret = new ExactAnnotationFieldTypePattern(annotationType, formalName); ret.readLocation(context, s); return ret; }
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; }
public static ResolvedTypeMunger readMethod(VersionedDataInputStream s, ISourceContext context, boolean isEnhanced) throws IOException { ResolvedMemberImpl signature = ResolvedMemberImpl.readResolvedMember(s, context); UnresolvedType aspect = UnresolvedType.read(s); String implClassName = s.readUTF(); TypePattern tp = TypePattern.read(s, context); MethodDelegateTypeMunger typeMunger = new MethodDelegateTypeMunger(signature, aspect, implClassName, tp); UnresolvedType fieldType = null; if (isEnhanced) { fieldType = UnresolvedType.read(s); } else { // a guess... that will work in a lot of cases fieldType = signature.getDeclaringType(); } typeMunger.setFieldType(fieldType); if (isEnhanced) { typeMunger.factoryMethodName = s.readUTF(); typeMunger.factoryMethodSignature = s.readUTF(); typeMunger.bitflags = s.readInt(); } return typeMunger; }
public static Declare read(VersionedDataInputStream s, ISourceContext context) throws IOException { Declare ret = new DeclareErrorOrWarning(s.readBoolean(), Pointcut.read(s, context), s.readUTF()); ret.readLocation(context, s); return ret; }
public static Declare read(VersionedDataInputStream s, ISourceContext context) throws IOException { Declare ret = new DeclareTypeErrorOrWarning(s.readBoolean(), TypePattern.read(s, context), s.readUTF()); ret.readLocation(context, s); return ret; }
str = s.readSignature(); } else { str = s.readUTF();
public static TypeVariable read(VersionedDataInputStream s) throws IOException { // if (s.getMajorVersion()>=AjAttribute.WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ150) { String name = s.readUTF(); UnresolvedType ubound = UnresolvedType.read(s); int iboundcount = s.readInt(); UnresolvedType[] ibounds = UnresolvedType.NONE; if (iboundcount > 0) { ibounds = new UnresolvedType[iboundcount]; for (int i = 0; i < iboundcount; i++) { ibounds[i] = UnresolvedType.read(s); } } TypeVariable newVariable = new TypeVariable(name, ubound, ibounds); return newVariable; }
public static AnnotationTypePattern read2(VersionedDataInputStream s, ISourceContext context) throws IOException { BindingAnnotationFieldTypePattern ret = new BindingAnnotationFieldTypePattern(UnresolvedType.read(s), s.readShort(), UnresolvedType.read(s)); ret.formalName = s.readUTF(); ret.readLocation(context, s); return ret; }
public static Pointcut read(VersionedDataInputStream s, ISourceContext context) throws IOException { UnresolvedType onType = null; if (s.readBoolean()) { onType = UnresolvedType.read(s); } ReferencePointcut ret = new ReferencePointcut(onType, s.readUTF(), TypePatternList.read(s, context)); ret.readLocation(context, s); return ret; }
ret = new ExactAnnotationTypePattern(s.readUTF()); } else { ret = new ExactAnnotationTypePattern(UnresolvedType.read(s)); Map<String, String> aValues = new HashMap<String, String>(); for (int i = 0; i < annotationValueCount; i++) { String key = s.readUTF(); String val = s.readUTF(); aValues.put(key, val);
public static AnnotationTypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException { WildAnnotationTypePattern ret; byte version = s.readByte(); if (version > VERSION) { throw new BCException("ExactAnnotationTypePattern was written by a newer version of AspectJ"); } TypePattern t = TypePattern.read(s, context); ret = new WildAnnotationTypePattern(t); ret.readLocation(context, s); if (s.getMajorVersion() >= WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ160) { if (s.readBoolean()) { ret.setForParameterAnnotationMatch(); } } if (s.getMajorVersion() >= WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ160M2) { int annotationValueCount = s.readInt(); if (annotationValueCount > 0) { Map<String, String> aValues = new HashMap<String, String>(); for (int i = 0; i < annotationValueCount; i++) { String key = s.readUTF(); String val = s.readUTF(); aValues.put(key, val); } ret.annotationValues = aValues; } } return ret; }
public static ResolvedPointcutDefinition read(VersionedDataInputStream s, ISourceContext context) throws IOException { ResolvedPointcutDefinition rpd = new ResolvedPointcutDefinition(UnresolvedType.read(s), s.readInt(), s.readUTF(), UnresolvedType.readArray(s), Pointcut.read(s, context)); rpd.setSourceContext(context); // whilst we have a source context, let's remember it return rpd; }
public static ResolvedTypeMunger readInnerClass(VersionedDataInputStream stream, ISourceContext context) throws IOException { /* int version = */stream.readInt(); UnresolvedType targetType = UnresolvedType.read(stream); String memberTypeName = stream.readUTF(); ISourceLocation sourceLocation = readSourceLocation(stream); List<String> typeVarAliases = readInTypeAliases(stream); NewMemberClassTypeMunger newInstance = new NewMemberClassTypeMunger(targetType, memberTypeName); newInstance.setTypeVariableAliases(typeVarAliases); newInstance.setSourceLocation(sourceLocation); return newInstance; }
public static SourceContextAttribute read(VersionedDataInputStream s) throws IOException { String sourceFileName = s.isAtLeast169() ? s.readPath() : s.readUTF(); int lineBreaks = s.readInt(); int[] lines = new int[lineBreaks]; int previous = 0; for (int i = 0; i < lineBreaks; i++) { if (s.isAtLeast169()) { lines[i] = s.readShort() + previous; previous = lines[i]; } else { lines[i] = s.readInt(); } } return new SourceContextAttribute(sourceFileName, lines); }
public static TypeVariablePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException { TypeVariablePattern tv = null; String name = s.readUTF(); TypePattern upperBound = TypePattern.read(s, context); TypePattern[] additionalInterfaceBounds = null; int numInterfaceBounds = s.readInt(); if (numInterfaceBounds > 0) { additionalInterfaceBounds = new TypePattern[numInterfaceBounds]; for (int i = 0; i < additionalInterfaceBounds.length; i++) { additionalInterfaceBounds[i] = TypePattern.read(s, context); } } boolean hasLowerBound = s.readBoolean(); TypePattern lowerBound = null; if (hasLowerBound) { lowerBound = TypePattern.read(s, context); } tv = new TypeVariablePattern(name, upperBound, additionalInterfaceBounds, lowerBound); tv.readLocation(context, s); return tv; }
UnresolvedType declaringType = compressed ? UnresolvedType.forSignature(s.readUtf8(s.readShort())) : UnresolvedType.read(s); int modifiers = s.readInt(); String name = compressed ? s.readUtf8(s.readShort()) : s.readUTF(); String signature = compressed ? s.readUtf8(s.readShort()) : s.readUTF(); ResolvedMemberImpl m = new ResolvedMemberImpl(mk, declaringType, modifiers, name, signature); m.checkedExceptions = UnresolvedType.readArray(s); params[i] = TypeFactory.createTypeFromSignature(s.readSignature()); } else { params[i] = TypeFactory.createTypeFromSignature(s.readUTF()); .createTypeFromSignature(s.readUTF()); m.parameterTypes = params; m.returnType = rt;