/** * @return The name of the referenced class. */ public String getName() { return getClassName(); }
@Override public boolean equals(final Object obj) { if (!(obj instanceof AnnotationClassRef)) { return false; } return getTypeSignature().equals(((AnnotationClassRef) obj).getTypeSignature()); }
/** * Loads the referenced class, returning a {@code Class<?>} reference for the referenced class. * * @return The {@code Class<?>} reference for the referenced class. * @throws IllegalArgumentException * if the class could not be loaded. */ @Override public Class<?> loadClass() { return loadClass(/* ignoreExceptions = */ false); }
/** * Resolves the {@link Class}[] of the {@code HandlesTypes}-annotations present on the given * {@code ServletContainerInitializer} implementation. * * @param servletContainerInitializerClassInfo The {@link ClassInfo} object representing the {@code ServletContainerInitializer} implementation * @return The classes listed in the {@code HandlesTypes} annotation of the given class. */ private List<ClassInfo> resolveHandledTypes(ClassInfo servletContainerInitializerClassInfo) { AnnotationInfo handlesTypes = servletContainerInitializerClassInfo.getAnnotationInfo(HANDLES_TYPES); Object[] value = (Object[]) handlesTypes.getParameterValues().get("value"); return Arrays.stream(value) .map(AnnotationClassRef.class::cast) .map(annotationClassRef -> { ClassInfo classInfo = annotationClassRef.getClassInfo(); if (classInfo == null) { log.warn("{} not found in the scan result, but declared in the @HandlesTypes annotation of {}", annotationClassRef.getName(), servletContainerInitializerClassInfo.getName()); } return classInfo; }) .filter(Objects::nonNull) .collect(Collectors.toList()); }
@Override void setScanResult(final ScanResult scanResult) { super.setScanResult(scanResult); if (enumValue != null) { enumValue.setScanResult(scanResult); } else if (classRef != null) { classRef.setScanResult(scanResult); } else if (annotationInfo != null) { annotationInfo.setScanResult(scanResult); } else if (objectArrayValue != null) { for (final ObjectTypedValueWrapper anObjectArrayValue : objectArrayValue) { if (anObjectArrayValue != null) { anObjectArrayValue.setScanResult(scanResult); } } } }
return new AnnotationClassRef(classRefTypeDescriptor); case '@':
@Override public String toString() { return getTypeSignature().toString(); } }
@Override protected void getReferencedClassNames(final Set<String> classNames) { classNames.add(getClassName()); }
return instantiate ? enumValue.loadClassAndReturnEnumValue() : enumValue; } else if (classRef != null) { return instantiate ? classRef.loadClass() : classRef; } else if (annotationInfo != null) { return instantiate ? annotationInfo.loadClassAndInstantiate() : annotationInfo;
@Override public int hashCode() { return getTypeSignature().hashCode(); }
/** * @return The {@link ClassInfo} object for the referenced class, or null if the referenced class was not * encountered during scanning (i.e. if no ClassInfo object was created for the class during scanning). * N.B. even if this method returns null, {@link #loadClass()} may be able to load the referenced class * by name. */ @Override public ClassInfo getClassInfo() { getClassName(); return super.getClassInfo(); }
@Override protected String getClassName() { if (className == null) { getTypeSignature(); if (typeSignature instanceof BaseTypeSignature) { className = ((BaseTypeSignature) typeSignature).getType().getName(); } else if (typeSignature instanceof ClassRefTypeSignature) { className = ((ClassRefTypeSignature) typeSignature).getFullyQualifiedClassName(); } else { throw new IllegalArgumentException("Got unexpected type " + typeSignature.getClass().getName() + " for ref type signature: " + typeDescriptorStr); } } return className; }
/** Get the names of any classes referenced in the annotation parameters. */ @Override void getReferencedClassNames(final Set<String> referencedClassNames) { if (enumValue != null) { enumValue.getReferencedClassNames(referencedClassNames); } else if (classRef != null) { referencedClassNames.add(classRef.getClassName()); } else if (annotationInfo != null) { annotationInfo.getReferencedClassNames(referencedClassNames); } else if (objectArrayValue != null) { for (final ObjectTypedValueWrapper item : objectArrayValue) { item.getReferencedClassNames(referencedClassNames); } } } }
/** * Loads the referenced class, returning a {@code Class<?>} reference for the referenced class. * * @param ignoreExceptions * if true, ignore exceptions and instead return null if the class could not be loaded. * @return The {@code Class<?>} reference for the referenced class. * @throws IllegalArgumentException * if the class could not be loaded and ignoreExceptions was false. */ @Override public Class<?> loadClass(final boolean ignoreExceptions) { getTypeSignature(); if (typeSignature instanceof BaseTypeSignature) { return ((BaseTypeSignature) typeSignature).getType(); } else if (typeSignature instanceof ClassRefTypeSignature) { return ((ClassRefTypeSignature) typeSignature).loadClass(ignoreExceptions); } else { throw new IllegalArgumentException("Got unexpected type " + typeSignature.getClass().getName() + " for ref type signature: " + typeDescriptorStr); } }