@Override public void visitLocalVariable(final String name, final String desc, final String signature, final Label start, final Label end, final int index) { if (visitorHelper.getClassModelConfiguration().isMethodDeclaresVariable() && !THIS.equals(name)) { final VariableDescriptor variableDescriptor = visitorHelper.getVariableDescriptor(name, SignatureHelper.getFieldSignature(name, desc)); if (signature == null) { TypeDescriptor type = visitorHelper.resolveType(SignatureHelper.getType((desc)), containingType).getTypeDescriptor(); variableDescriptor.setType(type); } else { new SignatureReader(signature).accept(new AbstractTypeSignatureVisitor(containingType, visitorHelper) { @Override public SignatureVisitor visitArrayType() { return dependentTypeSignatureVisitor; } @Override public SignatureVisitor visitTypeArgument(char wildcard) { return dependentTypeSignatureVisitor; } @Override public void visitEnd(TypeDescriptor resolvedTypeDescriptor) { variableDescriptor.setType(resolvedTypeDescriptor); } }); } methodDescriptor.getVariables().add(variableDescriptor); } }
/** * Return the method descriptor for the given type and method signature. * * @param cachedType * The containing type. * @param signature * The method signature. * @return The method descriptor. */ MethodDescriptor getMethodDescriptor(TypeCache.CachedType<?> cachedType, String signature) { MethodDescriptor methodDescriptor = cachedType.getMethod(signature); if (methodDescriptor == null) { if (signature.startsWith(CONSTRUCTOR_METHOD)) { methodDescriptor = scannerContext.getStore().create(ConstructorDescriptor.class); } else { methodDescriptor = scannerContext.getStore().create(MethodDescriptor.class); } methodDescriptor.setSignature(signature); cachedType.addMember(signature, methodDescriptor); } return methodDescriptor; }
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); } } } }
if (servletClass != null) { TypeCache.CachedType<TypeDescriptor> servletClassType = context.peek(TypeResolver.class).resolve(servletClass.getValue(), context); servletDescriptor.setType(servletClassType.getTypeDescriptor());
if (servletClass != null) { TypeCache.CachedType<TypeDescriptor> servletClassType = context.peek(TypeResolver.class).resolve(servletClass.getValue(), context); servletDescriptor.setType(servletClassType.getTypeDescriptor());
TypeDescriptor typeDescriptor = scanner.getContext().peek(TypeResolver.class).resolve(clazz, scanner.getContext()).getTypeDescriptor(); persistenceUnitDescriptor.getContains().add(typeDescriptor);
setModifiers(access, fieldDescriptor); if (signature == null) { TypeDescriptor type = visitorHelper.resolveType(SignatureHelper.getType((desc)), cachedType).getTypeDescriptor(); fieldDescriptor.setType(type); } else {
TypeResolver typeResolver = context.peek(TypeResolver.class); TypeCache.CachedType<TypeDescriptor> filterClassDescriptor = typeResolver.resolve(filterClass.getValue(), context); filterDescriptor.setType(filterClassDescriptor.getTypeDescriptor());
TypeResolver typeResolver = context.peek(TypeResolver.class); TypeCache.CachedType<TypeDescriptor> filterClassDescriptor = typeResolver.resolve(filterClass.getValue(), context); filterDescriptor.setType(filterClassDescriptor.getTypeDescriptor());
@Override public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) { MethodDescriptor methodDescriptor = visitorHelper.getMethodDescriptor(cachedType, SignatureHelper.getMethodSignature(name, desc)); methodDescriptor.setName(name); setModifiers(access, methodDescriptor); if (hasFlag(access, Opcodes.ACC_ABSTRACT)) { methodDescriptor.setAbstract(Boolean.TRUE); } if (hasFlag(access, Opcodes.ACC_NATIVE)) { methodDescriptor.setNative(Boolean.TRUE); } if (signature == null) { String returnType = SignatureHelper.getType(org.objectweb.asm.Type.getReturnType(desc)); methodDescriptor.setReturns(visitorHelper.resolveType(returnType, cachedType).getTypeDescriptor()); org.objectweb.asm.Type[] types = org.objectweb.asm.Type.getArgumentTypes(desc); for (int i = 0; i < types.length; i++) { String parameterType = SignatureHelper.getType(types[i]); TypeDescriptor typeDescriptor = visitorHelper.resolveType(parameterType, cachedType).getTypeDescriptor(); ParameterDescriptor parameterDescriptor = visitorHelper.addParameterDescriptor(methodDescriptor, i); parameterDescriptor.setType(typeDescriptor); } } else { new SignatureReader(signature).accept(new MethodSignatureVisitor(cachedType, methodDescriptor, visitorHelper, dependentTypeSignatureVisitor)); } for (int i = 0; exceptions != null && i < exceptions.length; i++) { TypeDescriptor exceptionType = visitorHelper.resolveType(SignatureHelper.getObjectType(exceptions[i]), cachedType).getTypeDescriptor(); methodDescriptor.getDeclaredThrowables().add(exceptionType); } return new MethodVisitor(cachedType, methodDescriptor, visitorHelper, dependentTypeSignatureVisitor); }
@Override public void visit(final int version, final int access, final String name, final String signature, final String superName, final String[] interfaces) { Class<? extends ClassFileDescriptor> javaType = getJavaType(access); String fullQualifiedName = SignatureHelper.getObjectType(name); cachedType = visitorHelper.createType(fullQualifiedName, fileDescriptor, javaType); dependentTypeSignatureVisitor = new DependentTypeSignatureVisitor(cachedType, visitorHelper); ClassFileDescriptor classFileDescriptor = cachedType.getTypeDescriptor(); classFileDescriptor.setByteCodeVersion(version); if (hasFlag(access, Opcodes.ACC_ABSTRACT) && !hasFlag(access, Opcodes.ACC_INTERFACE)) { classFileDescriptor.setAbstract(Boolean.TRUE); } setModifiers(access, classFileDescriptor); if (signature == null) { if (superName != null) { TypeDescriptor superClassType = visitorHelper.resolveType(SignatureHelper.getObjectType(superName), cachedType).getTypeDescriptor(); classFileDescriptor.setSuperClass(superClassType); } for (int i = 0; interfaces != null && i < interfaces.length; i++) { TypeDescriptor interfaceType = visitorHelper.resolveType(SignatureHelper.getObjectType(interfaces[i]), cachedType).getTypeDescriptor(); classFileDescriptor.getInterfaces().add(interfaceType); } } else { new SignatureReader(signature).accept(new ClassSignatureVisitor(cachedType, visitorHelper, dependentTypeSignatureVisitor)); } }
/** * Add an annotation descriptor of the given type name to an annotated * descriptor. * * @param annotatedDescriptor * The annotated descriptor. * @param typeName * The type name of the annotation. * @return The annotation descriptor. */ AnnotationValueDescriptor addAnnotation(TypeCache.CachedType containingDescriptor, AnnotatedDescriptor annotatedDescriptor, String typeName) { if (typeName != null) { TypeDescriptor type = resolveType(typeName, containingDescriptor).getTypeDescriptor(); AnnotationValueDescriptor annotationDescriptor = scannerContext.getStore().create(AnnotationValueDescriptor.class); annotationDescriptor.setType(type); annotatedDescriptor.getAnnotatedBy().add(annotationDescriptor); return annotationDescriptor; } return null; }
@Override public BeansXmlDescriptor scan(FileResource item, BeansXmlDescriptor beansXmlDescriptor, String path, Scope scope, Scanner scanner) throws IOException { ScannerContext context = scanner.getContext(); Beans beans = unmarshaller.unmarshal(item); beansXmlDescriptor.setVersion(beans.getVersion()); beansXmlDescriptor.setBeanDiscoveryMode(beans.getBeanDiscoveryMode()); for (Object o : beans.getInterceptorsOrDecoratorsOrAlternatives()) { if (o instanceof Interceptors) { addTypes(((Interceptors) o).getClazz(), beansXmlDescriptor.getInterceptors(), context); } else if (o instanceof Decorators) { addTypes(((Decorators) o).getClazz(), beansXmlDescriptor.getDecorators(), context); } else if (o instanceof Alternatives) { List<JAXBElement<String>> clazzOrStereotype = ((Alternatives) o).getClazzOrStereotype(); for (JAXBElement<String> element : clazzOrStereotype) { TypeDescriptor alternative = scanner.getContext().peek(TypeResolver.class).resolve(element.getValue(), context).getTypeDescriptor(); beansXmlDescriptor.getAlternatives().add(alternative); } } } return beansXmlDescriptor; }
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; }
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); }
/** * Return the field descriptor for the given type and field signature. * * @param cachedType * The containing type. * @param signature * The field signature. * @return The field descriptor. */ FieldDescriptor getFieldDescriptor(TypeCache.CachedType<?> cachedType, String signature) { FieldDescriptor fieldDescriptor = cachedType.getField(signature); if (fieldDescriptor == null) { fieldDescriptor = scannerContext.getStore().create(FieldDescriptor.class); fieldDescriptor.setSignature(signature); cachedType.addMember(signature, fieldDescriptor); } return fieldDescriptor; }
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 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); } }