@Override public boolean equals(final Object obj) { if (!(obj instanceof ClassTypeSignature)) { return false; } final ClassTypeSignature o = (ClassTypeSignature) obj; return o.typeParameters.equals(this.typeParameters) && o.superclassSignature.equals(this.superclassSignature) && o.superinterfaceSignatures.equals(this.superinterfaceSignatures); }
/** * Get the fully qualified class name (used by {@link #getClassInfo()} and {@link #loadClass()}. * * @return The fully qualified name of the class. */ @Override protected String getClassName() { return getFullyQualifiedClassName(); }
@Override void getReferencedClassNames(final Set<String> classNameListOut) { for (final TypeParameter typeParameter : typeParameters) { typeParameter.getReferencedClassNames(classNameListOut); } if (superclassSignature != null) { superclassSignature.getReferencedClassNames(classNameListOut); } for (final ClassRefTypeSignature typeSignature : superinterfaceSignatures) { typeSignature.getReferencedClassNames(classNameListOut); } }
/** * Parse a reference type signature. * * @param parser * The parser * @param definingClassName * The class containing the type descriptor. * @return The parsed type reference type signature. * @throws ParseException * If the type signature could not be parsed. */ static ReferenceTypeSignature parseReferenceTypeSignature(final Parser parser, final String definingClassName) throws ParseException { final ClassRefTypeSignature classTypeSignature = ClassRefTypeSignature.parse(parser, definingClassName); if (classTypeSignature != null) { return classTypeSignature; } final TypeVariableSignature typeVariableSignature = TypeVariableSignature.parse(parser, definingClassName); if (typeVariableSignature != null) { return typeVariableSignature; } final ArrayTypeSignature arrayTypeSignature = ArrayTypeSignature.parse(parser, definingClassName); if (arrayTypeSignature != null) { return arrayTypeSignature; } return null; }
/** * 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); } }
@Override public int hashCode() { return typeParameters.hashCode() + superclassSignature.hashCode() * 7 + superinterfaceSignatures.hashCode() * 15; }
@Override void setScanResult(final ScanResult scanResult) { super.setScanResult(scanResult); if (typeParameters != null) { for (final TypeParameter typeParameter : typeParameters) { typeParameter.setScanResult(scanResult); } } if (this.superclassSignature != null) { this.superclassSignature.setScanResult(scanResult); } if (superinterfaceSignatures != null) { for (final ClassRefTypeSignature classRefTypeSignature : superinterfaceSignatures) { classRefTypeSignature.setScanResult(scanResult); } } }
.filter(ClassRefTypeSignature.class::isInstance) .map(ClassRefTypeSignature.class::cast) .map(classRefTypeSignature -> classRefTypeSignature.getTypeArguments().get(0)) .map(TypeArgument::getTypeSignature) .filter(ClassRefTypeSignature.class::isInstance)
return new ClassRefTypeSignature(className, typeArguments, suffixes, suffixTypeArguments); } else { return null;
final ClassRefTypeSignature superclassSignature = ClassRefTypeSignature.parse(parser, definingClassNameNull); List<ClassRefTypeSignature> superinterfaceSignatures; superinterfaceSignatures = new ArrayList<>(); while (parser.hasMore()) { final ClassRefTypeSignature superinterfaceSignature = ClassRefTypeSignature.parse(parser, definingClassNameNull); if (superinterfaceSignature == null) {
if (elementTypeSig instanceof ClassRefTypeSignature) { eltClass = ((ClassRefTypeSignature) elementTypeSig).loadClass(); } else if (elementTypeSig instanceof BaseTypeSignature) {
@Override public boolean equalsIgnoringTypeParams(final TypeSignature other) { if (other instanceof TypeVariableSignature) { // Compare class type signature to type variable -- the logic for this // is implemented in TypeVariableSignature, and is not duplicated here return other.equalsIgnoringTypeParams(this); } if (!(other instanceof ClassRefTypeSignature)) { return false; } final ClassRefTypeSignature o = (ClassRefTypeSignature) other; if (o.suffixes.equals(this.suffixes)) { return o.className.equals(this.className); } else { return o.getFullyQualifiedClassName().equals(this.getFullyQualifiedClassName()); } }
while (parser.peek() == '^') { parser.expect('^'); final ClassRefTypeSignature classTypeSignature = ClassRefTypeSignature.parse(parser, definingClassName); if (classTypeSignature != null) {
@Override void getReferencedClassNames(final Set<String> classNameListOut) { classNameListOut.add(className); classNameListOut.add(getFullyQualifiedClassName()); for (final TypeArgument typeArgument : typeArguments) { typeArgument.getReferencedClassNames(classNameListOut); } }
@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; }
if (elementTypeSig instanceof ClassRefTypeSignature) { targetElementTypeName = ((ClassRefTypeSignature) elementTypeSig).getFullyQualifiedClassName(); } else if (elementTypeSig instanceof BaseTypeSignature) {