@Override public void visitEnd(TypeDescriptor resolvedTypeDescriptor) { cachedType.getTypeDescriptor().getInterfaces().add(resolvedTypeDescriptor); } };
public void storeDependencies(TypeCache.CachedType<?> cachedType) { Map<TypeDescriptor, Integer> dependencies = cachedType.getDependencies(); for (Map.Entry<TypeDescriptor, Integer> entry : dependencies.entrySet()) { TypeDescriptor dependency = entry.getKey(); final Integer weight = entry.getValue(); TypeDescriptor dependent = cachedType.getTypeDescriptor(); TypeDependsOnDescriptor dependsOnDescriptor = scannerContext.getStore().create(dependent, TypeDependsOnDescriptor.class, dependency); if (classModelConfiguration.isTypeDependsOnWeight()) { dependsOnDescriptor.setWeight(weight); } } } }
private void addTypes(List<String> typeNames, List<TypeDescriptor> types, ScannerContext scannerContext) { for (String typeName : typeNames) { TypeDescriptor type = scannerContext.peek(TypeResolver.class).resolve(typeName, scannerContext).getTypeDescriptor(); types.add(type); } } }
private ListenerDescriptor createListener(ListenerType listenerType, ScannerContext context) { Store store = context.getStore(); ListenerDescriptor listenerDescriptor = store.create(ListenerDescriptor.class); for (DescriptionType descriptionType : listenerType.getDescription()) { listenerDescriptor.getDescriptions().add(XmlDescriptorHelper.createDescription(descriptionType, store)); } for (DisplayNameType displayNameType : listenerType.getDisplayName()) { listenerDescriptor.getDisplayNames().add(XmlDescriptorHelper.createDisplayName(displayNameType, store)); } for (IconType iconType : listenerType.getIcon()) { listenerDescriptor.getIcons().add(XmlDescriptorHelper.createIcon(iconType, store)); } TypeResolver typeResolver = context.peek(TypeResolver.class); FullyQualifiedClassType listenerClass = listenerType.getListenerClass(); TypeCache.CachedType<TypeDescriptor> listenerClassDescriptor = typeResolver.resolve(listenerClass.getValue(), context); listenerDescriptor.setType(listenerClassDescriptor.getTypeDescriptor()); return listenerDescriptor; }
@Override public org.objectweb.asm.AnnotationVisitor visitParameterAnnotation(final int parameter, final String desc, final boolean visible) { String annotationType = SignatureHelper.getType(desc); if (JAVA_LANG_SYNTHETIC.equals(annotationType)) { // Ignore synthetic parameters add the start of the signature, i.e. // determine the number of synthetic parameters syntheticParameters = Math.max(syntheticParameters, parameter + 1); return null; } ParameterDescriptor parameterDescriptor = visitorHelper.getParameterDescriptor(methodDescriptor, parameter - syntheticParameters); if (parameterDescriptor == null) { LOGGER.warn("Cannot find parameter with index " + (parameter - syntheticParameters) + " in method signature " + containingType.getTypeDescriptor().getFullQualifiedName() + "#" + methodDescriptor.getSignature()); return null; } AnnotationValueDescriptor annotationDescriptor = visitorHelper.addAnnotation(containingType, parameterDescriptor, SignatureHelper.getType(desc)); return new AnnotationVisitor(containingType, annotationDescriptor, visitorHelper); }
private ErrorPageDescriptor createErrorPage(ErrorPageType errorPageType, ScannerContext context) { ErrorPageDescriptor errorPageDescriptor = context.getStore().create(ErrorPageDescriptor.class); ErrorCodeType errorCode = errorPageType.getErrorCode(); if (errorCode != null) { errorPageDescriptor.setErrorCode(errorCode.getValue().intValue()); } FullyQualifiedClassType exceptionType = errorPageType.getExceptionType(); if (exceptionType != null) { TypeResolver typeResolver = context.peek(TypeResolver.class); TypeCache.CachedType<TypeDescriptor> cachedType = typeResolver.resolve(exceptionType.getValue(), context); errorPageDescriptor.setExceptionType(cachedType.getTypeDescriptor()); } errorPageDescriptor.setErrorPage(errorPageType.getLocation().getValue()); return errorPageDescriptor; }
private ErrorPageDescriptor createErrorPage(ErrorPageType errorPageType, ScannerContext context) { ErrorPageDescriptor errorPageDescriptor = context.getStore().create(ErrorPageDescriptor.class); ErrorCodeType errorCode = errorPageType.getErrorCode(); if (errorCode != null) { errorPageDescriptor.setErrorCode(errorCode.getValue().intValue()); } FullyQualifiedClassType exceptionType = errorPageType.getExceptionType(); if (exceptionType != null) { TypeResolver typeResolver = context.peek(TypeResolver.class); TypeCache.CachedType<TypeDescriptor> cachedType = typeResolver.resolve(exceptionType.getValue(), context); errorPageDescriptor.setExceptionType(cachedType.getTypeDescriptor()); } errorPageDescriptor.setErrorPage(errorPageType.getLocation().getValue()); return errorPageDescriptor; }
@Override public void visitClassType(String name) { resolvedTypeDescriptor = visitorHelper.resolveType(SignatureHelper.getObjectType(name), containingType).getTypeDescriptor(); }
@Override public void visitSource(final String source, final String debug) { cachedType.getTypeDescriptor().setSourceFileName(source); }
@Override public void visitEnd(TypeDescriptor resolvedTypeDescriptor) { cachedType.getTypeDescriptor().setSuperClass(resolvedTypeDescriptor); }
private TypeDescriptor getTypeDescriptor(String fqn, ScannerContext scannerContext) { TypeResolver typeResolver = scannerContext.peek(TypeResolver.class); return typeResolver.resolve(fqn, scannerContext).getTypeDescriptor(); }
@Override public void visitInnerClass(final String name, final String outerName, final String innerName, final int access) { String fullQualifiedName = cachedType.getTypeDescriptor().getFullQualifiedName(); // innerName always represents the name of the inner class String innerTypeName = SignatureHelper.getObjectType(name); TypeDescriptor innerType = visitorHelper.resolveType(innerTypeName, cachedType).getTypeDescriptor(); // set relation only if outerName is current class if (outerName != null) { String outerTypeName = SignatureHelper.getObjectType(outerName); if (fullQualifiedName.equals(outerTypeName)) { cachedType.getTypeDescriptor().getDeclaredInnerClasses().add(innerType); } } }
@Override public void visit(final String name, final Object value) { if (value instanceof Type) { String type = SignatureHelper.getType((Type) value); ClassValueDescriptor valueDescriptor = createValue(ClassValueDescriptor.class, name); valueDescriptor.setValue(visitorHelper.resolveType(type, containingType).getTypeDescriptor()); addValue(name, valueDescriptor); } else { PrimitiveValueDescriptor valueDescriptor = createValue(PrimitiveValueDescriptor.class, name); TypeDescriptor typeDescriptor = visitorHelper.resolveType(value.getClass().getName(), containingType).getTypeDescriptor(); valueDescriptor.setType(typeDescriptor); valueDescriptor.setValue(value); addValue(name, valueDescriptor); } }
@Override public void visitInnerClassType(String name) { String innerClassName = resolvedTypeDescriptor.getFullQualifiedName() + "$" + name; resolvedTypeDescriptor = visitorHelper.resolveType(innerClassName, containingType).getTypeDescriptor(); }
TypeCache.CachedType resolveType(String fullQualifiedName, TypeCache.CachedType<? extends ClassFileDescriptor> dependentType) { TypeCache.CachedType cachedType = getTypeResolver().resolve(fullQualifiedName, scannerContext); if (!dependentType.equals(cachedType)) { dependentType.addDependency(cachedType.getTypeDescriptor()); } return cachedType; }
@Override public void visitOuterClass(final String owner, final String name, final String desc) { String outerTypeName = SignatureHelper.getObjectType(owner); TypeCache.CachedType cachedOuterType = visitorHelper.resolveType(outerTypeName, this.cachedType); TypeDescriptor innerType = this.cachedType.getTypeDescriptor(); cachedOuterType.getTypeDescriptor().getDeclaredInnerClasses().add(innerType); if (name != null) { String methodSignature = SignatureHelper.getMethodSignature(name, desc); MethodDescriptor methodDescriptor = visitorHelper.getMethodDescriptor(cachedOuterType, methodSignature); methodDescriptor.getDeclaredInnerClasses().add(innerType); } }
@Override public AnnotationVisitor visitAnnotation(final String name, final String desc) { AnnotationValueDescriptor valueDescriptor = createValue(AnnotationValueDescriptor.class, name); valueDescriptor.setType(visitorHelper.resolveType(SignatureHelper.getType(desc), containingType).getTypeDescriptor()); addValue(name, valueDescriptor); return new AnnotationVisitor(containingType, valueDescriptor, visitorHelper); }
/** * Return the type descriptor created by visiting the class. * * @return The type descriptor. */ public ClassFileDescriptor getTypeDescriptor() { return cachedType != null ? cachedType.getTypeDescriptor() : null; }
@Override public AnnotationVisitor visitAnnotation(final String desc, final boolean visible) { AnnotationValueDescriptor annotationDescriptor = visitorHelper.addAnnotation(cachedType, cachedType.getTypeDescriptor(), SignatureHelper.getType(desc)); return new AnnotationVisitor(cachedType, annotationDescriptor, visitorHelper); }
@Override public void visitEnum(final String name, final String desc, final String value) { EnumValueDescriptor valueDescriptor = createValue(EnumValueDescriptor.class, name); TypeCache.CachedType cachedTypeDescriptor = visitorHelper.resolveType(SignatureHelper.getType(desc), containingType); FieldDescriptor fieldDescriptor = visitorHelper.getFieldDescriptor(cachedTypeDescriptor, SignatureHelper.getFieldSignature(value, desc)); valueDescriptor.setType(visitorHelper.resolveType(Enum.class.getName(), containingType).getTypeDescriptor()); valueDescriptor.setValue(fieldDescriptor); addValue(name, valueDescriptor); }