code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
protected void checkResourcePathWhiteBlackList(final String relativePath, final LogNode log) {
// Whitelist/blacklist classpath elements based on file resource paths
if (!scanSpec.classpathElementResourcePathWhiteBlackList.whitelistAndBlacklistAreEmpty()) {
if (scanSpec.classpathElementResourcePathWhiteBlackList.isBlacklisted(relativePath)) {
if (log != null) {
log.log("Reached blacklisted classpath element resource path, stopping scanning: "
+ relativePath);
}
skipClasspathElement = true;
return;
}
if (scanSpec.classpathElementResourcePathWhiteBlackList.isSpecificallyWhitelisted(relativePath)) {
if (log != null) {
log.log("Reached specifically whitelisted classpath element resource path: " + relativePath);
}
containsSpecificallyWhitelistedClasspathElementResourcePath = true;
}
}
} | java |
protected void addWhitelistedResource(final Resource resource, final ScanSpecPathMatch parentMatchStatus,
final LogNode log) {
final String path = resource.getPath();
final boolean isClassFile = FileUtils.isClassfile(path);
boolean isWhitelisted = false;
if (isClassFile) {
// Check classfile scanning is enabled, and classfile is not specifically blacklisted
if (scanSpec.enableClassInfo && !scanSpec.classfilePathWhiteBlackList.isBlacklisted(path)) {
// ClassInfo is enabled, and found a whitelisted classfile
whitelistedClassfileResources.add(resource);
isWhitelisted = true;
}
} else {
// Resources are always whitelisted if found in whitelisted directories
isWhitelisted = true;
}
// Add resource to whitelistedResources, whether for a classfile or non-classfile resource
whitelistedResources.add(resource);
// Write to log if enabled, and as long as classfile scanning is not disabled, and this is not
// a blacklisted classfile
if (log != null && isWhitelisted) {
final String type = isClassFile ? "classfile" : "resource";
String logStr;
switch (parentMatchStatus) {
case HAS_WHITELISTED_PATH_PREFIX:
logStr = "Found " + type + " within subpackage of whitelisted package: ";
break;
case AT_WHITELISTED_PATH:
logStr = "Found " + type + " within whitelisted package: ";
break;
case AT_WHITELISTED_CLASS_PACKAGE:
logStr = "Found specifically-whitelisted " + type + ": ";
break;
default:
logStr = "Found whitelisted " + type + ": ";
break;
}
// Precede log entry sort key with "0:file:" so that file entries come before dir entries for
// ClasspathElementDir classpath elements
resource.scanLog = log.log("0:" + path,
logStr + path + (path.equals(resource.getPathRelativeToClasspathElement()) ? ""
: " ; full path: " + resource.getPathRelativeToClasspathElement()));
}
} | java |
public URI getLocation() {
if (locationURI == null) {
locationURI = moduleRef != null ? moduleRef.getLocation() : null;
if (locationURI == null) {
locationURI = classpathElement.getURI();
}
}
return locationURI;
} | java |
void addAnnotations(final AnnotationInfoList moduleAnnotations) {
// Currently only class annotations are used in the module-info.class file
if (moduleAnnotations != null && !moduleAnnotations.isEmpty()) {
if (this.annotationInfo == null) {
this.annotationInfo = new AnnotationInfoList(moduleAnnotations);
} else {
this.annotationInfo.addAll(moduleAnnotations);
}
}
} | java |
static TypeVariableSignature parse(final Parser parser, final String definingClassName) throws ParseException {
final char peek = parser.peek();
if (peek == 'T') {
parser.next();
if (!TypeUtils.getIdentifierToken(parser)) {
throw new ParseException(parser, "Could not parse type variable signature");
}
parser.expect(';');
final TypeVariableSignature typeVariableSignature = new TypeVariableSignature(parser.currToken(),
definingClassName);
// Save type variable signatures in the parser state, so method and class type signatures can link
// to type signatures
@SuppressWarnings("unchecked")
List<TypeVariableSignature> typeVariableSignatures = (List<TypeVariableSignature>) parser.getState();
if (typeVariableSignatures == null) {
parser.setState(typeVariableSignatures = new ArrayList<>());
}
typeVariableSignatures.add(typeVariableSignature);
return typeVariableSignature;
} else {
return null;
}
} | java |
private void logJavaInfo() {
log("Operating system: " + VersionFinder.getProperty("os.name") + " "
+ VersionFinder.getProperty("os.version") + " " + VersionFinder.getProperty("os.arch"));
log("Java version: " + VersionFinder.getProperty("java.version") + " / "
+ VersionFinder.getProperty("java.runtime.version") + " ("
+ VersionFinder.getProperty("java.vendor") + ")");
log("Java home: " + VersionFinder.getProperty("java.home"));
final String jreRtJarPath = SystemJarFinder.getJreRtJarPath();
if (jreRtJarPath != null) {
log("JRE rt.jar:").log(jreRtJarPath);
}
} | java |
private void appendLine(final String timeStampStr, final int indentLevel, final String line,
final StringBuilder buf) {
buf.append(timeStampStr);
buf.append('\t');
buf.append(ClassGraph.class.getSimpleName());
buf.append('\t');
final int numDashes = 2 * (indentLevel - 1);
for (int i = 0; i < numDashes; i++) {
buf.append('-');
}
if (numDashes > 0) {
buf.append(' ');
}
buf.append(line);
buf.append('\n');
} | java |
private LogNode addChild(final String sortKey, final String msg, final long elapsedTimeNanos,
final Throwable exception) {
final String newSortKey = sortKeyPrefix + "\t" + (sortKey == null ? "" : sortKey) + "\t"
+ String.format("%09d", sortKeyUniqueSuffix.getAndIncrement());
final LogNode newChild = new LogNode(newSortKey, msg, elapsedTimeNanos, exception);
newChild.parent = this;
// Make the sort key unique, so that log entries are not clobbered if keys are reused; increment unique
// suffix with each new log entry, so that ties are broken in chronological order.
children.put(newSortKey, newChild);
return newChild;
} | java |
private LogNode addChild(final String sortKey, final String msg, final long elapsedTimeNanos) {
return addChild(sortKey, msg, elapsedTimeNanos, null);
} | java |
public LogNode log(final String sortKey, final String msg, final long elapsedTimeNanos) {
return addChild(sortKey, msg, elapsedTimeNanos);
} | java |
public LogNode log(final String msg, final Throwable e) {
return addChild("", msg, -1L).addChild(e);
} | java |
public LogNode log(final Collection<String> msgs) {
LogNode last = null;
for (final String m : msgs) {
last = log(m);
}
return last;
} | java |
public void flush() {
if (parent != null) {
throw new IllegalArgumentException("Only flush the toplevel LogNode");
}
if (!children.isEmpty()) {
final String logOutput = this.toString();
this.children.clear();
log.info(logOutput);
}
} | java |
public boolean checkAndReturn() {
// Check if any thread has been interrupted
if (interrupted.get()) {
// If so, interrupt this thread
interrupt();
return true;
}
// Check if this thread has been interrupted
if (Thread.currentThread().isInterrupted()) {
// If so, interrupt other threads
interrupted.set(true);
return true;
}
return false;
} | java |
public void check() throws InterruptedException, ExecutionException {
// If a thread threw an uncaught exception, re-throw it.
final ExecutionException executionException = getExecutionException();
if (executionException != null) {
throw executionException;
}
// If this thread or another thread has been interrupted, throw InterruptedException
if (checkAndReturn()) {
throw new InterruptedException();
}
} | java |
public boolean isSystemModule() {
if (name == null || name.isEmpty()) {
return false;
}
return name.startsWith("java.") || name.startsWith("jdk.") || name.startsWith("javafx.")
|| name.startsWith("oracle.");
} | java |
static MethodTypeSignature parse(final String typeDescriptor, final String definingClassName)
throws ParseException {
if (typeDescriptor.equals("<init>")) {
// Special case for instance initialization method signatures in a CONSTANT_NameAndType_info structure:
// https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.4.2
return new MethodTypeSignature(Collections.<TypeParameter> emptyList(),
Collections.<TypeSignature> emptyList(), new BaseTypeSignature("void"),
Collections.<ClassRefOrTypeVariableSignature> emptyList());
}
final Parser parser = new Parser(typeDescriptor);
final List<TypeParameter> typeParameters = TypeParameter.parseList(parser, definingClassName);
parser.expect('(');
final List<TypeSignature> paramTypes = new ArrayList<>();
while (parser.peek() != ')') {
if (!parser.hasMore()) {
throw new ParseException(parser, "Ran out of input while parsing method signature");
}
final TypeSignature paramType = TypeSignature.parse(parser, definingClassName);
if (paramType == null) {
throw new ParseException(parser, "Missing method parameter type signature");
}
paramTypes.add(paramType);
}
parser.expect(')');
final TypeSignature resultType = TypeSignature.parse(parser, definingClassName);
if (resultType == null) {
throw new ParseException(parser, "Missing method result type signature");
}
List<ClassRefOrTypeVariableSignature> throwsSignatures;
if (parser.peek() == '^') {
throwsSignatures = new ArrayList<>();
while (parser.peek() == '^') {
parser.expect('^');
final ClassRefTypeSignature classTypeSignature = ClassRefTypeSignature.parse(parser,
definingClassName);
if (classTypeSignature != null) {
throwsSignatures.add(classTypeSignature);
} else {
final TypeVariableSignature typeVariableSignature = TypeVariableSignature.parse(parser,
definingClassName);
if (typeVariableSignature != null) {
throwsSignatures.add(typeVariableSignature);
} else {
throw new ParseException(parser, "Missing type variable signature");
}
}
}
} else {
throwsSignatures = Collections.emptyList();
}
if (parser.hasMore()) {
throw new ParseException(parser, "Extra characters at end of type descriptor");
}
final MethodTypeSignature methodSignature = new MethodTypeSignature(typeParameters, paramTypes, resultType,
throwsSignatures);
// Add back-links from type variable signature to the method signature it is part of,
// and to the enclosing class' type signature
@SuppressWarnings("unchecked")
final List<TypeVariableSignature> typeVariableSignatures = (List<TypeVariableSignature>) parser.getState();
if (typeVariableSignatures != null) {
for (final TypeVariableSignature typeVariableSignature : typeVariableSignatures) {
typeVariableSignature.containingMethodSignature = methodSignature;
}
}
return methodSignature;
} | java |
void toJSONString(final Map<ReferenceEqualityKey<JSONReference>, CharSequence> jsonReferenceToId,
final boolean includeNullValuedFields, final int depth, final int indentWidth,
final StringBuilder buf) {
final boolean prettyPrint = indentWidth > 0;
final int n = items.size();
if (n == 0) {
buf.append("[]");
} else {
buf.append('[');
if (prettyPrint) {
buf.append('\n');
}
for (int i = 0; i < n; i++) {
final Object item = items.get(i);
if (prettyPrint) {
JSONUtils.indent(depth + 1, indentWidth, buf);
}
JSONSerializer.jsonValToJSONString(item, jsonReferenceToId, includeNullValuedFields, depth + 1,
indentWidth, buf);
if (i < n - 1) {
buf.append(',');
}
if (prettyPrint) {
buf.append('\n');
}
}
if (prettyPrint) {
JSONUtils.indent(depth, indentWidth, buf);
}
buf.append(']');
}
} | java |
boolean addRelatedClass(final RelType relType, final ClassInfo classInfo) {
Set<ClassInfo> classInfoSet = relatedClasses.get(relType);
if (classInfoSet == null) {
relatedClasses.put(relType, classInfoSet = new LinkedHashSet<>(4));
}
return classInfoSet.add(classInfo);
} | java |
static ClassInfo getOrCreateClassInfo(final String className, final int classModifiers,
final Map<String, ClassInfo> classNameToClassInfo) {
ClassInfo classInfo = classNameToClassInfo.get(className);
if (classInfo == null) {
classNameToClassInfo.put(className,
classInfo = new ClassInfo(className, classModifiers, /* classfileResource = */ null));
}
classInfo.setModifiers(classModifiers);
return classInfo;
} | java |
void setModifiers(final int modifiers) {
this.modifiers |= modifiers;
if ((modifiers & ANNOTATION_CLASS_MODIFIER) != 0) {
this.isAnnotation = true;
}
if ((modifiers & Modifier.INTERFACE) != 0) {
this.isInterface = true;
}
} | java |
void addSuperclass(final String superclassName, final Map<String, ClassInfo> classNameToClassInfo) {
if (superclassName != null && !superclassName.equals("java.lang.Object")) {
final ClassInfo superclassClassInfo = getOrCreateClassInfo(superclassName, /* classModifiers = */ 0,
classNameToClassInfo);
this.addRelatedClass(RelType.SUPERCLASSES, superclassClassInfo);
superclassClassInfo.addRelatedClass(RelType.SUBCLASSES, this);
}
} | java |
void addImplementedInterface(final String interfaceName, final Map<String, ClassInfo> classNameToClassInfo) {
final ClassInfo interfaceClassInfo = getOrCreateClassInfo(interfaceName,
/* classModifiers = */ Modifier.INTERFACE, classNameToClassInfo);
interfaceClassInfo.isInterface = true;
interfaceClassInfo.modifiers |= Modifier.INTERFACE;
this.addRelatedClass(RelType.IMPLEMENTED_INTERFACES, interfaceClassInfo);
interfaceClassInfo.addRelatedClass(RelType.CLASSES_IMPLEMENTING, this);
} | java |
static void addClassContainment(final List<SimpleEntry<String, String>> classContainmentEntries,
final Map<String, ClassInfo> classNameToClassInfo) {
for (final SimpleEntry<String, String> ent : classContainmentEntries) {
final String innerClassName = ent.getKey();
final ClassInfo innerClassInfo = ClassInfo.getOrCreateClassInfo(innerClassName,
/* classModifiers = */ 0, classNameToClassInfo);
final String outerClassName = ent.getValue();
final ClassInfo outerClassInfo = ClassInfo.getOrCreateClassInfo(outerClassName,
/* classModifiers = */ 0, classNameToClassInfo);
innerClassInfo.addRelatedClass(RelType.CONTAINED_WITHIN_OUTER_CLASS, outerClassInfo);
outerClassInfo.addRelatedClass(RelType.CONTAINS_INNER_CLASS, innerClassInfo);
}
} | java |
void addClassAnnotation(final AnnotationInfo classAnnotationInfo,
final Map<String, ClassInfo> classNameToClassInfo) {
final ClassInfo annotationClassInfo = getOrCreateClassInfo(classAnnotationInfo.getName(),
ANNOTATION_CLASS_MODIFIER, classNameToClassInfo);
if (this.annotationInfo == null) {
this.annotationInfo = new AnnotationInfoList(2);
}
this.annotationInfo.add(classAnnotationInfo);
this.addRelatedClass(RelType.CLASS_ANNOTATIONS, annotationClassInfo);
annotationClassInfo.addRelatedClass(RelType.CLASSES_WITH_ANNOTATION, this);
// Record use of @Inherited meta-annotation
if (classAnnotationInfo.getName().equals(Inherited.class.getName())) {
isInherited = true;
}
} | java |
private void addFieldOrMethodAnnotationInfo(final AnnotationInfoList annotationInfoList, final boolean isField,
final Map<String, ClassInfo> classNameToClassInfo) {
if (annotationInfoList != null) {
for (final AnnotationInfo fieldAnnotationInfo : annotationInfoList) {
final ClassInfo annotationClassInfo = getOrCreateClassInfo(fieldAnnotationInfo.getName(),
ANNOTATION_CLASS_MODIFIER, classNameToClassInfo);
// Mark this class as having a field or method with this annotation
this.addRelatedClass(isField ? RelType.FIELD_ANNOTATIONS : RelType.METHOD_ANNOTATIONS,
annotationClassInfo);
annotationClassInfo.addRelatedClass(
isField ? RelType.CLASSES_WITH_FIELD_ANNOTATION : RelType.CLASSES_WITH_METHOD_ANNOTATION,
this);
}
}
} | java |
void addFieldInfo(final FieldInfoList fieldInfoList, final Map<String, ClassInfo> classNameToClassInfo) {
for (final FieldInfo fi : fieldInfoList) {
// Index field annotations
addFieldOrMethodAnnotationInfo(fi.annotationInfo, /* isField = */ true, classNameToClassInfo);
}
if (this.fieldInfo == null) {
this.fieldInfo = fieldInfoList;
} else {
this.fieldInfo.addAll(fieldInfoList);
}
} | java |
void addMethodInfo(final MethodInfoList methodInfoList, final Map<String, ClassInfo> classNameToClassInfo) {
for (final MethodInfo mi : methodInfoList) {
// Index method annotations
addFieldOrMethodAnnotationInfo(mi.annotationInfo, /* isField = */ false, classNameToClassInfo);
// Index method parameter annotations
if (mi.parameterAnnotationInfo != null) {
for (int i = 0; i < mi.parameterAnnotationInfo.length; i++) {
final AnnotationInfo[] paramAnnotationInfoArr = mi.parameterAnnotationInfo[i];
if (paramAnnotationInfoArr != null) {
for (int j = 0; j < paramAnnotationInfoArr.length; j++) {
final AnnotationInfo methodParamAnnotationInfo = paramAnnotationInfoArr[j];
final ClassInfo annotationClassInfo = getOrCreateClassInfo(
methodParamAnnotationInfo.getName(), ANNOTATION_CLASS_MODIFIER,
classNameToClassInfo);
annotationClassInfo.addRelatedClass(RelType.CLASSES_WITH_METHOD_PARAMETER_ANNOTATION,
this);
this.addRelatedClass(RelType.METHOD_PARAMETER_ANNOTATIONS, annotationClassInfo);
}
}
}
}
}
if (this.methodInfo == null) {
this.methodInfo = methodInfoList;
} else {
this.methodInfo.addAll(methodInfoList);
}
} | java |
private static Set<ClassInfo> filterClassInfo(final Collection<ClassInfo> classes, final ScanSpec scanSpec,
final boolean strictWhitelist, final ClassType... classTypes) {
if (classes == null) {
return Collections.<ClassInfo> emptySet();
}
boolean includeAllTypes = classTypes.length == 0;
boolean includeStandardClasses = false;
boolean includeImplementedInterfaces = false;
boolean includeAnnotations = false;
for (final ClassType classType : classTypes) {
switch (classType) {
case ALL:
includeAllTypes = true;
break;
case STANDARD_CLASS:
includeStandardClasses = true;
break;
case IMPLEMENTED_INTERFACE:
includeImplementedInterfaces = true;
break;
case ANNOTATION:
includeAnnotations = true;
break;
case INTERFACE_OR_ANNOTATION:
includeImplementedInterfaces = includeAnnotations = true;
break;
default:
throw new IllegalArgumentException("Unknown ClassType: " + classType);
}
}
if (includeStandardClasses && includeImplementedInterfaces && includeAnnotations) {
includeAllTypes = true;
}
final Set<ClassInfo> classInfoSetFiltered = new LinkedHashSet<>(classes.size());
for (final ClassInfo classInfo : classes) {
// Check class type against requested type(s)
if ((includeAllTypes //
|| includeStandardClasses && classInfo.isStandardClass()
|| includeImplementedInterfaces && classInfo.isImplementedInterface()
|| includeAnnotations && classInfo.isAnnotation()) //
// Always check blacklist
&& !scanSpec.classOrPackageIsBlacklisted(classInfo.name) //
// Always return whitelisted classes, or external classes if enableExternalClasses is true
&& (!classInfo.isExternalClass || scanSpec.enableExternalClasses
// Return external (non-whitelisted) classes if viewing class hierarchy "upwards"
|| !strictWhitelist)) {
// Class passed strict whitelist criteria
classInfoSetFiltered.add(classInfo);
}
}
return classInfoSetFiltered;
} | java |
static ClassInfoList getAllClasses(final Collection<ClassInfo> classes, final ScanSpec scanSpec) {
return new ClassInfoList(
ClassInfo.filterClassInfo(classes, scanSpec, /* strictWhitelist = */ true, ClassType.ALL),
/* sortByName = */ true);
} | java |
static ClassInfoList getAllStandardClasses(final Collection<ClassInfo> classes, final ScanSpec scanSpec) {
return new ClassInfoList(ClassInfo.filterClassInfo(classes, scanSpec, /* strictWhitelist = */ true,
ClassType.STANDARD_CLASS), /* sortByName = */ true);
} | java |
public String getModifiersStr() {
final StringBuilder buf = new StringBuilder();
TypeUtils.modifiersToString(modifiers, ModifierType.CLASS, /* ignored */ false, buf);
return buf.toString();
} | java |
public boolean hasField(final String fieldName) {
for (final ClassInfo ci : getOverrideOrder()) {
if (ci.hasDeclaredField(fieldName)) {
return true;
}
}
return false;
} | java |
public boolean hasDeclaredFieldAnnotation(final String fieldAnnotationName) {
for (final FieldInfo fi : getDeclaredFieldInfo()) {
if (fi.hasAnnotation(fieldAnnotationName)) {
return true;
}
}
return false;
} | java |
public boolean hasFieldAnnotation(final String fieldAnnotationName) {
for (final ClassInfo ci : getOverrideOrder()) {
if (ci.hasDeclaredFieldAnnotation(fieldAnnotationName)) {
return true;
}
}
return false;
} | java |
public boolean hasMethod(final String methodName) {
for (final ClassInfo ci : getOverrideOrder()) {
if (ci.hasDeclaredMethod(methodName)) {
return true;
}
}
return false;
} | java |
public boolean hasMethodAnnotation(final String methodAnnotationName) {
for (final ClassInfo ci : getOverrideOrder()) {
if (ci.hasDeclaredMethodAnnotation(methodAnnotationName)) {
return true;
}
}
return false;
} | java |
public boolean hasMethodParameterAnnotation(final String methodParameterAnnotationName) {
for (final ClassInfo ci : getOverrideOrder()) {
if (ci.hasDeclaredMethodParameterAnnotation(methodParameterAnnotationName)) {
return true;
}
}
return false;
} | java |
private List<ClassInfo> getOverrideOrder(final Set<ClassInfo> visited, final List<ClassInfo> overrideOrderOut) {
if (visited.add(this)) {
overrideOrderOut.add(this);
for (final ClassInfo iface : getInterfaces()) {
iface.getOverrideOrder(visited, overrideOrderOut);
}
final ClassInfo superclass = getSuperclass();
if (superclass != null) {
superclass.getOverrideOrder(visited, overrideOrderOut);
}
}
return overrideOrderOut;
} | java |
public ClassInfoList getInterfaces() {
// Classes also implement the interfaces of their superclasses
final ReachableAndDirectlyRelatedClasses implementedInterfaces = this
.filterClassInfo(RelType.IMPLEMENTED_INTERFACES, /* strictWhitelist = */ false);
final Set<ClassInfo> allInterfaces = new LinkedHashSet<>(implementedInterfaces.reachableClasses);
for (final ClassInfo superclass : this.filterClassInfo(RelType.SUPERCLASSES,
/* strictWhitelist = */ false).reachableClasses) {
final Set<ClassInfo> superclassImplementedInterfaces = superclass.filterClassInfo(
RelType.IMPLEMENTED_INTERFACES, /* strictWhitelist = */ false).reachableClasses;
allInterfaces.addAll(superclassImplementedInterfaces);
}
return new ClassInfoList(allInterfaces, implementedInterfaces.directlyRelatedClasses,
/* sortByName = */ true);
} | java |
private ClassInfoList getClassesWithFieldOrMethodAnnotation(final RelType relType) {
final boolean isField = relType == RelType.CLASSES_WITH_FIELD_ANNOTATION;
if (!(isField ? scanResult.scanSpec.enableFieldInfo : scanResult.scanSpec.enableMethodInfo)
|| !scanResult.scanSpec.enableAnnotationInfo) {
throw new IllegalArgumentException("Please call ClassGraph#enable" + (isField ? "Field" : "Method")
+ "Info() and " + "#enableAnnotationInfo() before #scan()");
}
final ReachableAndDirectlyRelatedClasses classesWithDirectlyAnnotatedFieldsOrMethods = this
.filterClassInfo(relType, /* strictWhitelist = */ !isExternalClass);
final ReachableAndDirectlyRelatedClasses annotationsWithThisMetaAnnotation = this.filterClassInfo(
RelType.CLASSES_WITH_ANNOTATION, /* strictWhitelist = */ !isExternalClass, ClassType.ANNOTATION);
if (annotationsWithThisMetaAnnotation.reachableClasses.isEmpty()) {
// This annotation does not meta-annotate another annotation that annotates a method
return new ClassInfoList(classesWithDirectlyAnnotatedFieldsOrMethods, /* sortByName = */ true);
} else {
// Take the union of all classes with fields or methods directly annotated by this annotation,
// and classes with fields or methods meta-annotated by this annotation
final Set<ClassInfo> allClassesWithAnnotatedOrMetaAnnotatedFieldsOrMethods = new LinkedHashSet<>(
classesWithDirectlyAnnotatedFieldsOrMethods.reachableClasses);
for (final ClassInfo metaAnnotatedAnnotation : annotationsWithThisMetaAnnotation.reachableClasses) {
allClassesWithAnnotatedOrMetaAnnotatedFieldsOrMethods
.addAll(metaAnnotatedAnnotation.filterClassInfo(relType,
/* strictWhitelist = */ !metaAnnotatedAnnotation.isExternalClass).reachableClasses);
}
return new ClassInfoList(allClassesWithAnnotatedOrMetaAnnotatedFieldsOrMethods,
classesWithDirectlyAnnotatedFieldsOrMethods.directlyRelatedClasses, /* sortByName = */ true);
}
} | java |
public AnnotationParameterValueList getAnnotationDefaultParameterValues() {
if (!scanResult.scanSpec.enableAnnotationInfo) {
throw new IllegalArgumentException("Please call ClassGraph#enableAnnotationInfo() before #scan()");
}
if (!isAnnotation) {
throw new IllegalArgumentException("Class is not an annotation: " + getName());
}
if (annotationDefaultParamValues == null) {
return AnnotationParameterValueList.EMPTY_LIST;
}
if (!annotationDefaultParamValuesHasBeenConvertedToPrimitive) {
annotationDefaultParamValues.convertWrapperArraysToPrimitiveArrays(this);
annotationDefaultParamValuesHasBeenConvertedToPrimitive = true;
}
return annotationDefaultParamValues;
} | java |
public ClassInfoList getClassesWithAnnotation() {
if (!scanResult.scanSpec.enableAnnotationInfo) {
throw new IllegalArgumentException("Please call ClassGraph#enableAnnotationInfo() before #scan()");
}
if (!isAnnotation) {
throw new IllegalArgumentException("Class is not an annotation: " + getName());
}
// Get classes that have this annotation
final ReachableAndDirectlyRelatedClasses classesWithAnnotation = this
.filterClassInfo(RelType.CLASSES_WITH_ANNOTATION, /* strictWhitelist = */ !isExternalClass);
if (isInherited) {
// If this is an inherited annotation, add into the result all subclasses of the annotated classes.
final Set<ClassInfo> classesWithAnnotationAndTheirSubclasses = new LinkedHashSet<>(
classesWithAnnotation.reachableClasses);
for (final ClassInfo classWithAnnotation : classesWithAnnotation.reachableClasses) {
classesWithAnnotationAndTheirSubclasses.addAll(classWithAnnotation.getSubclasses());
}
return new ClassInfoList(classesWithAnnotationAndTheirSubclasses,
classesWithAnnotation.directlyRelatedClasses, /* sortByName = */ true);
} else {
// If not inherited, only return the annotated classes
return new ClassInfoList(classesWithAnnotation, /* sortByName = */ true);
}
} | java |
public ClassTypeSignature getTypeSignature() {
if (typeSignatureStr == null) {
return null;
}
if (typeSignature == null) {
try {
typeSignature = ClassTypeSignature.parse(typeSignatureStr, this);
typeSignature.setScanResult(scanResult);
} catch (final ParseException e) {
throw new IllegalArgumentException(e);
}
}
return typeSignature;
} | java |
void addReferencedClassNames(final Set<String> refdClassNames) {
if (this.referencedClassNames == null) {
this.referencedClassNames = refdClassNames;
} else {
this.referencedClassNames.addAll(refdClassNames);
}
} | java |
@Override
protected void findReferencedClassNames(final Set<String> referencedClassNames) {
if (this.referencedClassNames != null) {
referencedClassNames.addAll(this.referencedClassNames);
}
getMethodInfo().findReferencedClassNames(referencedClassNames);
getFieldInfo().findReferencedClassNames(referencedClassNames);
getAnnotationInfo().findReferencedClassNames(referencedClassNames);
if (annotationDefaultParamValues != null) {
annotationDefaultParamValues.findReferencedClassNames(referencedClassNames);
}
final ClassTypeSignature classSig = getTypeSignature();
if (classSig != null) {
classSig.findReferencedClassNames(referencedClassNames);
}
// Remove any self-references
referencedClassNames.remove(name);
} | java |
public ClassInfoList getClassDependencies() {
if (!scanResult.scanSpec.enableInterClassDependencies) {
throw new IllegalArgumentException(
"Please call ClassGraph#enableInterClassDependencies() before #scan()");
}
return referencedClasses == null ? ClassInfoList.EMPTY_LIST : referencedClasses;
} | java |
private static void translateSeparator(final String path, final int startIdx, final int endIdx,
final boolean stripFinalSeparator, final StringBuilder buf) {
for (int i = startIdx; i < endIdx; i++) {
final char c = path.charAt(i);
if (c == '\\' || c == '/') {
// Strip trailing separator, if necessary
if (i < endIdx - 1 || !stripFinalSeparator) {
// Remove duplicate separators
final char prevChar = buf.length() == 0 ? '\0' : buf.charAt(buf.length() - 1);
if (prevChar != '/') {
buf.append('/');
}
}
} else {
buf.append(c);
}
}
} | java |
private TypeSignature getTypeSignature() {
if (typeSignature == null) {
try {
// There can't be any type variables to resolve in either ClassRefTypeSignature or
// BaseTypeSignature, so just set definingClassName to null
typeSignature = TypeSignature.parse(typeDescriptorStr, /* definingClassName = */ null);
typeSignature.setScanResult(scanResult);
} catch (final ParseException e) {
throw new IllegalArgumentException(e);
}
}
return typeSignature;
} | java |
private String sanitizeFilename(final String filename) {
return filename.replace('/', '_').replace('\\', '_').replace(':', '_').replace('?', '_').replace('&', '_')
.replace('=', '_').replace(' ', '_');
} | java |
private File makeTempFile(final String filePath, final boolean onlyUseLeafname) throws IOException {
final File tempFile = File.createTempFile("ClassGraph--",
TEMP_FILENAME_LEAF_SEPARATOR + sanitizeFilename(onlyUseLeafname ? leafname(filePath) : filePath));
tempFile.deleteOnExit();
tempFiles.add(tempFile);
return tempFile;
} | java |
private File downloadTempFile(final String jarURL, final LogNode log) {
final LogNode subLog = log == null ? null : log.log(jarURL, "Downloading URL " + jarURL);
File tempFile;
try {
tempFile = makeTempFile(jarURL, /* onlyUseLeafname = */ true);
final URL url = new URL(jarURL);
try (InputStream inputStream = url.openStream()) {
Files.copy(inputStream, tempFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
}
if (subLog != null) {
subLog.addElapsedTime();
}
} catch (final IOException | SecurityException e) {
if (subLog != null) {
subLog.log("Could not download " + jarURL, e);
}
return null;
}
if (subLog != null) {
subLog.log("Downloaded to temporary file " + tempFile);
subLog.log("***** Note that it is time-consuming to scan jars at http(s) addresses, "
+ "they must be downloaded for every scan, and the same jars must also be "
+ "separately downloaded by the ClassLoader *****");
}
return tempFile;
} | java |
public String generateGraphVizDotFile(final float sizeX, final float sizeY) {
return generateGraphVizDotFile(sizeX, sizeY, /* showFields = */ true,
/* showFieldTypeDependencyEdges = */ true, /* showMethods = */ true,
/* showMethodTypeDependencyEdges = */ true, /* showAnnotations = */ true);
} | java |
public void generateGraphVizDotFile(final File file) throws IOException {
try (PrintWriter writer = new PrintWriter(file)) {
writer.print(generateGraphVizDotFile());
}
} | java |
public boolean containsName(final String name) {
for (final T i : this) {
if (i.getName().equals(name)) {
return true;
}
}
return false;
} | java |
public T get(final String name) {
for (final T i : this) {
if (i.getName().equals(name)) {
return i;
}
}
return null;
} | java |
public static <U> void runWorkQueue(final Collection<U> elements, final ExecutorService executorService,
final InterruptionChecker interruptionChecker, final int numParallelTasks, final LogNode log,
final WorkUnitProcessor<U> workUnitProcessor) throws InterruptedException, ExecutionException {
if (elements.isEmpty()) {
// Nothing to do
return;
}
// WorkQueue#close() is called when this try-with-resources block terminates, initiating a barrier wait
// while all worker threads complete.
try (WorkQueue<U> workQueue = new WorkQueue<>(elements, workUnitProcessor, numParallelTasks,
interruptionChecker, log)) {
// Start (numParallelTasks - 1) worker threads (may start zero threads if numParallelTasks == 1)
workQueue.startWorkers(executorService, numParallelTasks - 1);
// Use the current thread to do work too, in case there is only one thread available in the
// ExecutorService, or in case numParallelTasks is greater than the number of available threads in the
// ExecutorService.
workQueue.runWorkLoop();
}
} | java |
private void startWorkers(final ExecutorService executorService, final int numTasks) {
for (int i = 0; i < numTasks; i++) {
workerFutures.add(executorService.submit(new Callable<Void>() {
@Override
public Void call() throws Exception {
runWorkLoop();
return null;
}
}));
}
} | java |
private void sendPoisonPills() {
for (int i = 0; i < numWorkers; i++) {
workUnits.add(new WorkUnitWrapper<T>(null));
}
} | java |
public void addWorkUnit(final T workUnit) {
if (workUnit == null) {
throw new NullPointerException("workUnit cannot be null");
}
numIncompleteWorkUnits.incrementAndGet();
workUnits.add(new WorkUnitWrapper<>(workUnit));
} | java |
ClassFields get(final Class<?> cls) {
ClassFields classFields = classToClassFields.get(cls);
if (classFields == null) {
classToClassFields.put(cls,
classFields = new ClassFields(cls, resolveTypes, onlySerializePublicFields, this));
}
return classFields;
} | java |
private static Class<?> getConcreteType(final Class<?> rawType, final boolean returnNullIfNotMapOrCollection) {
// This list is not complete (e.g. EnumMap cannot be instantiated directly, you need to pass the
// enum key type into a factory method), but this should cover a lot of the common types
if (rawType == Map.class || rawType == AbstractMap.class || rawType == HashMap.class) {
return HashMap.class;
} else if (rawType == ConcurrentMap.class || rawType == ConcurrentHashMap.class) {
return ConcurrentHashMap.class;
} else if (rawType == SortedMap.class || rawType == NavigableMap.class || rawType == TreeMap.class) {
return TreeMap.class;
} else if (rawType == ConcurrentNavigableMap.class || rawType == ConcurrentSkipListMap.class) {
return ConcurrentSkipListMap.class;
} else if (rawType == List.class || rawType == AbstractList.class || rawType == ArrayList.class
|| rawType == Collection.class) {
return ArrayList.class;
} else if (rawType == AbstractSequentialList.class || rawType == LinkedList.class) {
return LinkedList.class;
} else if (rawType == Set.class || rawType == AbstractSet.class || rawType == HashSet.class) {
return HashSet.class;
} else if (rawType == SortedSet.class || rawType == TreeSet.class) {
return TreeSet.class;
} else if (rawType == Queue.class || rawType == AbstractQueue.class || rawType == Deque.class
|| rawType == ArrayDeque.class) {
return ArrayDeque.class;
} else if (rawType == BlockingQueue.class || rawType == LinkedBlockingQueue.class) {
return LinkedBlockingQueue.class;
} else if (rawType == BlockingDeque.class || rawType == LinkedBlockingDeque.class) {
return LinkedBlockingDeque.class;
} else if (rawType == TransferQueue.class || rawType == LinkedTransferQueue.class) {
return LinkedTransferQueue.class;
} else {
return returnNullIfNotMapOrCollection ? null : rawType;
}
} | java |
Constructor<?> getDefaultConstructorForConcreteTypeOf(final Class<?> cls) {
if (cls == null) {
throw new IllegalArgumentException("Class reference cannot be null");
}
// Check cache
final Constructor<?> constructor = defaultConstructorForConcreteType.get(cls);
if (constructor != null) {
return constructor;
}
final Class<?> concreteType = getConcreteType(cls, /* returnNullIfNotMapOrCollection = */ false);
for (Class<?> c = concreteType; c != null
&& (c != Object.class || cls == Object.class); c = c.getSuperclass()) {
try {
final Constructor<?> defaultConstructor = c.getDeclaredConstructor();
JSONUtils.isAccessibleOrMakeAccessible(defaultConstructor);
// Store found constructor in cache
defaultConstructorForConcreteType.put(cls, defaultConstructor);
return defaultConstructor;
} catch (final ReflectiveOperationException | SecurityException e) {
// Ignore
}
}
throw new IllegalArgumentException("Class " + cls.getName() //
+ " does not have an accessible default (no-arg) constructor");
} | java |
static Object getFieldValue(final Object containingObj, final Field field)
throws IllegalArgumentException, IllegalAccessException {
final Class<?> fieldType = field.getType();
if (fieldType == Integer.TYPE) {
return field.getInt(containingObj);
} else if (fieldType == Long.TYPE) {
return field.getLong(containingObj);
} else if (fieldType == Short.TYPE) {
return field.getShort(containingObj);
} else if (fieldType == Double.TYPE) {
return field.getDouble(containingObj);
} else if (fieldType == Float.TYPE) {
return field.getFloat(containingObj);
} else if (fieldType == Boolean.TYPE) {
return field.getBoolean(containingObj);
} else if (fieldType == Byte.TYPE) {
return field.getByte(containingObj);
} else if (fieldType == Character.TYPE) {
return field.getChar(containingObj);
} else {
return field.get(containingObj);
}
} | java |
static boolean isBasicValueType(final Type type) {
if (type instanceof Class<?>) {
return isBasicValueType((Class<?>) type);
} else if (type instanceof ParameterizedType) {
return isBasicValueType(((ParameterizedType) type).getRawType());
} else {
return false;
}
} | java |
static boolean isBasicValueType(final Object obj) {
return obj == null || obj instanceof String || obj instanceof Integer || obj instanceof Boolean
|| obj instanceof Long || obj instanceof Float || obj instanceof Double || obj instanceof Short
|| obj instanceof Byte || obj instanceof Character || obj.getClass().isEnum();
} | java |
static boolean fieldIsSerializable(final Field field, final boolean onlySerializePublicFields) {
final int modifiers = field.getModifiers();
if ((!onlySerializePublicFields || Modifier.isPublic(modifiers)) && !Modifier.isTransient(modifiers)
&& !Modifier.isFinal(modifiers) && ((modifiers & 0x1000 /* synthetic */) == 0)) {
return JSONUtils.isAccessibleOrMakeAccessible(field);
}
return false;
} | java |
public AnnotationParameterValueList getParameterValues() {
if (annotationParamValuesWithDefaults == null) {
final ClassInfo classInfo = getClassInfo();
if (classInfo == null) {
// ClassInfo has not yet been set, just return values without defaults
// (happens when trying to log AnnotationInfo during scanning, before ScanResult is available)
return annotationParamValues == null ? AnnotationParameterValueList.EMPTY_LIST
: annotationParamValues;
}
// Lazily convert any Object[] arrays of boxed types to primitive arrays
if (annotationParamValues != null && !annotationParamValuesHasBeenConvertedToPrimitive) {
annotationParamValues.convertWrapperArraysToPrimitiveArrays(classInfo);
annotationParamValuesHasBeenConvertedToPrimitive = true;
}
if (classInfo.annotationDefaultParamValues != null
&& !classInfo.annotationDefaultParamValuesHasBeenConvertedToPrimitive) {
classInfo.annotationDefaultParamValues.convertWrapperArraysToPrimitiveArrays(classInfo);
classInfo.annotationDefaultParamValuesHasBeenConvertedToPrimitive = true;
}
// Check if one or both of the defaults and the values in this annotation instance are null (empty)
final AnnotationParameterValueList defaultParamValues = classInfo.annotationDefaultParamValues;
if (defaultParamValues == null && annotationParamValues == null) {
return AnnotationParameterValueList.EMPTY_LIST;
} else if (defaultParamValues == null) {
return annotationParamValues;
} else if (annotationParamValues == null) {
return defaultParamValues;
}
// Overwrite defaults with non-defaults
final Map<String, Object> allParamValues = new HashMap<>();
for (final AnnotationParameterValue defaultParamValue : defaultParamValues) {
allParamValues.put(defaultParamValue.getName(), defaultParamValue.getValue());
}
for (final AnnotationParameterValue annotationParamValue : this.annotationParamValues) {
allParamValues.put(annotationParamValue.getName(), annotationParamValue.getValue());
}
// Put annotation values in the same order as the annotation methods (there is one method for each
// annotation constant)
if (classInfo.methodInfo == null) {
// Should not happen (when classfile is read, methods are always read, whether or not
// scanSpec.enableMethodInfo is true)
throw new IllegalArgumentException("Could not find methods for annotation " + classInfo.getName());
}
annotationParamValuesWithDefaults = new AnnotationParameterValueList();
for (final MethodInfo mi : classInfo.methodInfo) {
final String paramName = mi.getName();
switch (paramName) {
// None of these method names should be present in the @interface class itself, it should only
// contain methods for the annotation constants (but skip them anyway to be safe). These methods
// should only exist in concrete instances of the annotation.
case "<init>":
case "<clinit>":
case "hashCode":
case "equals":
case "toString":
case "annotationType":
// Skip
break;
default:
// Annotation constant
final Object paramValue = allParamValues.get(paramName);
// Annotation values cannot be null (or absent, from either defaults or annotation instance)
if (paramValue != null) {
annotationParamValuesWithDefaults.add(new AnnotationParameterValue(paramName, paramValue));
}
break;
}
}
}
return annotationParamValuesWithDefaults;
} | java |
public AnnotationInfoList getAnnotationInfo() {
if (!scanResult.scanSpec.enableAnnotationInfo) {
throw new IllegalArgumentException("Please call ClassGraph#enableAnnotationInfo() before #scan()");
}
return annotationInfo == null ? AnnotationInfoList.EMPTY_LIST
: AnnotationInfoList.getIndirectAnnotations(annotationInfo, /* annotatedClass = */ null);
} | java |
public boolean hasParameterAnnotation(final String annotationName) {
for (final MethodParameterInfo methodParameterInfo : getParameterInfo()) {
if (methodParameterInfo.hasAnnotation(annotationName)) {
return true;
}
}
return false;
} | java |
@Override
public int compareTo(final MethodInfo other) {
final int diff0 = declaringClassName.compareTo(other.declaringClassName);
if (diff0 != 0) {
return diff0;
}
final int diff1 = name.compareTo(other.name);
if (diff1 != 0) {
return diff1;
}
return typeDescriptorStr.compareTo(other.typeDescriptorStr);
} | java |
public static synchronized String getVersion() {
// Try to get version number from pom.xml (available when running in Eclipse)
final Class<?> cls = ClassGraph.class;
try {
final String className = cls.getName();
final URL classpathResource = cls.getResource("/" + JarUtils.classNameToClassfilePath(className));
if (classpathResource != null) {
final Path absolutePackagePath = Paths.get(classpathResource.toURI()).getParent();
final int packagePathSegments = className.length() - className.replace(".", "").length();
// Remove package segments from path
Path path = absolutePackagePath;
for (int i = 0; i < packagePathSegments && path != null; i++) {
path = path.getParent();
}
// Remove up to two more levels for "bin" or "target/classes"
for (int i = 0; i < 3 && path != null; i++, path = path.getParent()) {
final Path pom = path.resolve("pom.xml");
try (InputStream is = Files.newInputStream(pom)) {
final Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(is);
doc.getDocumentElement().normalize();
String version = (String) XPathFactory.newInstance().newXPath().compile("/project/version")
.evaluate(doc, XPathConstants.STRING);
if (version != null) {
version = version.trim();
if (!version.isEmpty()) {
return version;
}
}
} catch (final IOException e) {
// Not found
}
}
}
} catch (final Exception e) {
// Ignore
}
// Try to get version number from maven properties in jar's META-INF directory
try (InputStream is = cls.getResourceAsStream(
"/META-INF/maven/" + MAVEN_PACKAGE + "/" + MAVEN_ARTIFACT + "/pom.properties")) {
if (is != null) {
final Properties p = new Properties();
p.load(is);
final String version = p.getProperty("version", "").trim();
if (!version.isEmpty()) {
return version;
}
}
} catch (final IOException e) {
// Ignore
}
// Fallback to using Java API (version number is obtained from MANIFEST.MF)
final Package pkg = cls.getPackage();
if (pkg != null) {
String version = pkg.getImplementationVersion();
if (version == null) {
version = "";
}
version = version.trim();
if (version.isEmpty()) {
version = pkg.getSpecificationVersion();
if (version == null) {
version = "";
}
version = version.trim();
}
if (!version.isEmpty()) {
return version;
}
}
return "unknown";
} | java |
private ByteBuffer getChunk(final int chunkIdx) throws IOException, InterruptedException {
ByteBuffer chunk = chunkCache[chunkIdx];
if (chunk == null) {
final ByteBuffer byteBufferDup = zipFileSlice.physicalZipFile.getByteBuffer(chunkIdx).duplicate();
chunk = chunkCache[chunkIdx] = byteBufferDup;
}
return chunk;
} | java |
static int getShort(final byte[] arr, final long off) throws IndexOutOfBoundsException {
final int ioff = (int) off;
if (ioff < 0 || ioff > arr.length - 2) {
throw new IndexOutOfBoundsException();
}
return ((arr[ioff + 1] & 0xff) << 8) | (arr[ioff] & 0xff);
} | java |
int getShort(final long off) throws IOException, InterruptedException {
if (off < 0 || off > zipFileSlice.len - 2) {
throw new IndexOutOfBoundsException();
}
if (read(off, scratch, 0, 2) < 2) {
throw new EOFException("Unexpected EOF");
}
return ((scratch[1] & 0xff) << 8) | (scratch[0] & 0xff);
} | java |
static int getInt(final byte[] arr, final long off) throws IOException {
final int ioff = (int) off;
if (ioff < 0 || ioff > arr.length - 4) {
throw new IndexOutOfBoundsException();
}
return ((arr[ioff + 3] & 0xff) << 24) //
| ((arr[ioff + 2] & 0xff) << 16) //
| ((arr[ioff + 1] & 0xff) << 8) //
| (arr[ioff] & 0xff);
} | java |
static long getLong(final byte[] arr, final long off) throws IOException {
final int ioff = (int) off;
if (ioff < 0 || ioff > arr.length - 8) {
throw new IndexOutOfBoundsException();
}
return ((arr[ioff + 7] & 0xffL) << 56) //
| ((arr[ioff + 6] & 0xffL) << 48) //
| ((arr[ioff + 5] & 0xffL) << 40) //
| ((arr[ioff + 4] & 0xffL) << 32) //
| ((arr[ioff + 3] & 0xffL) << 24) //
| ((arr[ioff + 2] & 0xffL) << 16) //
| ((arr[ioff + 1] & 0xffL) << 8) //
| (arr[ioff] & 0xffL);
} | java |
long getLong(final long off) throws IOException, InterruptedException {
if (off < 0 || off > zipFileSlice.len - 8) {
throw new IndexOutOfBoundsException();
}
if (read(off, scratch, 0, 8) < 8) {
throw new EOFException("Unexpected EOF");
}
return ((scratch[7] & 0xffL) << 56) //
| ((scratch[6] & 0xffL) << 48) //
| ((scratch[5] & 0xffL) << 40) //
| ((scratch[4] & 0xffL) << 32) //
| ((scratch[3] & 0xffL) << 24) //
| ((scratch[2] & 0xffL) << 16) //
| ((scratch[1] & 0xffL) << 8) //
| (scratch[0] & 0xffL);
} | java |
static String getString(final byte[] arr, final long off, final int lenBytes) throws IOException {
final int ioff = (int) off;
if (ioff < 0 || ioff > arr.length - lenBytes) {
throw new IndexOutOfBoundsException();
}
return new String(arr, ioff, lenBytes, StandardCharsets.UTF_8);
} | java |
String getString(final long off, final int lenBytes) throws IOException, InterruptedException {
if (off < 0 || off > zipFileSlice.len - lenBytes) {
throw new IndexOutOfBoundsException();
}
final byte[] scratchToUse = lenBytes <= scratch.length ? scratch : new byte[lenBytes];
if (read(off, scratchToUse, 0, lenBytes) < lenBytes) {
throw new EOFException("Unexpected EOF");
}
// Assume the entry names are encoded in UTF-8 (should be the case for all jars; the only other
// valid zipfile charset is CP437, which is the same as ASCII for printable high-bit-clear chars)
return new String(scratchToUse, 0, lenBytes, StandardCharsets.UTF_8);
} | java |
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;
} | java |
static ReferenceTypeSignature parseClassBound(final Parser parser, final String definingClassName)
throws ParseException {
parser.expect(':');
// May return null if there is no signature after ':' (class bound signature may be empty)
return parseReferenceTypeSignature(parser, definingClassName);
} | java |
public static boolean isClassfile(final String path) {
final int len = path.length();
return len > 6 && path.regionMatches(true, len - 6, ".class", 0, 6);
} | java |
public static String getParentDirPath(final String path, final char separator) {
final int lastSlashIdx = path.lastIndexOf(separator);
if (lastSlashIdx <= 0) {
return "";
}
return path.substring(0, lastSlashIdx);
} | java |
public static Object getStaticFieldVal(final Class<?> cls, final String fieldName, final boolean throwException)
throws IllegalArgumentException {
if (cls == null || fieldName == null) {
if (throwException) {
throw new NullPointerException();
} else {
return null;
}
}
return getFieldVal(cls, null, fieldName, throwException);
} | java |
private static String getContentLocation(final Object content) {
final File file = (File) ReflectionUtils.invokeMethod(content, "getFile", false);
return file != null ? file.toURI().toString() : null;
} | java |
private static void addBundle(final Object bundleWiring, final ClassLoader classLoader,
final ClasspathOrder classpathOrderOut, final Set<Object> bundles, final ScanSpec scanSpec,
final LogNode log) {
// Track the bundles we've processed to prevent loops
bundles.add(bundleWiring);
// Get the revision for this wiring
final Object revision = ReflectionUtils.invokeMethod(bundleWiring, "getRevision", false);
// Get the contents
final Object content = ReflectionUtils.invokeMethod(revision, "getContent", false);
final String location = content != null ? getContentLocation(content) : null;
if (location != null) {
// Add the bundle object
classpathOrderOut.addClasspathEntry(location, classLoader, scanSpec, log);
// And any embedded content
final List<?> embeddedContent = (List<?>) ReflectionUtils.invokeMethod(revision, "getContentPath",
false);
if (embeddedContent != null) {
for (final Object embedded : embeddedContent) {
if (embedded != content) {
final String embeddedLocation = embedded != null ? getContentLocation(embedded) : null;
if (embeddedLocation != null) {
classpathOrderOut.addClasspathEntry(embeddedLocation, classLoader, scanSpec, log);
}
}
}
}
}
} | java |
void toStringParamValueOnly(final StringBuilder buf) {
if (value == null) {
buf.append("null");
} else {
final Object paramVal = value.get();
final Class<?> valClass = paramVal.getClass();
if (valClass.isArray()) {
buf.append('[');
for (int j = 0, n = Array.getLength(paramVal); j < n; j++) {
if (j > 0) {
buf.append(", ");
}
final Object elt = Array.get(paramVal, j);
buf.append(elt == null ? "null" : elt.toString());
}
buf.append(']');
} else if (paramVal instanceof String) {
buf.append('"');
buf.append(paramVal.toString().replace("\"", "\\\"").replace("\n", "\\n").replace("\r", "\\r"));
buf.append('"');
} else if (paramVal instanceof Character) {
buf.append('\'');
buf.append(paramVal.toString().replace("'", "\\'").replace("\n", "\\n").replace("\r", "\\r"));
buf.append('\'');
} else {
buf.append(paramVal.toString());
}
}
} | java |
private static boolean addJREPath(final File dir) {
if (dir != null && !dir.getPath().isEmpty() && FileUtils.canRead(dir) && dir.isDirectory()) {
final File[] dirFiles = dir.listFiles();
if (dirFiles != null) {
for (final File file : dirFiles) {
final String filePath = file.getPath();
if (filePath.endsWith(".jar")) {
final String jarPathResolved = FastPathResolver.resolve(FileUtils.CURR_DIR_PATH, filePath);
if (jarPathResolved.endsWith("/rt.jar")) {
RT_JARS.add(jarPathResolved);
} else {
JRE_LIB_OR_EXT_JARS.add(jarPathResolved);
}
try {
final File canonicalFile = file.getCanonicalFile();
final String canonicalFilePath = canonicalFile.getPath();
if (!canonicalFilePath.equals(filePath)) {
final String canonicalJarPathResolved = FastPathResolver
.resolve(FileUtils.CURR_DIR_PATH, filePath);
JRE_LIB_OR_EXT_JARS.add(canonicalJarPathResolved);
}
} catch (IOException | SecurityException e) {
// Ignored
}
}
}
return true;
}
}
return false;
} | java |
private static Entry<String, Integer> getManifestValue(final byte[] manifest, final int startIdx) {
// See if manifest entry is split across multiple lines
int curr = startIdx;
final int len = manifest.length;
while (curr < len && manifest[curr] == (byte) ' ') {
// Skip initial spaces
curr++;
}
final int firstNonSpaceIdx = curr;
boolean isMultiLine = false;
for (; curr < len && !isMultiLine; curr++) {
final byte b = manifest[curr];
if (b == (byte) '\r' && curr < len - 1 && manifest[curr + 1] == (byte) '\n') {
if (curr < len - 2 && manifest[curr + 2] == (byte) ' ') {
isMultiLine = true;
}
break;
} else if (b == (byte) '\r' || b == (byte) '\n') {
if (curr < len - 1 && manifest[curr + 1] == (byte) ' ') {
isMultiLine = true;
}
break;
}
}
String val;
if (!isMultiLine) {
// Fast path for single-line value
val = new String(manifest, firstNonSpaceIdx, curr - firstNonSpaceIdx, StandardCharsets.UTF_8);
} else {
// Skip (newline + space) sequences in multi-line values
final ByteArrayOutputStream buf = new ByteArrayOutputStream();
curr = firstNonSpaceIdx;
for (; curr < len; curr++) {
final byte b = manifest[curr];
boolean isLineEnd;
if (b == (byte) '\r' && curr < len - 1 && manifest[curr + 1] == (byte) '\n') {
// CRLF
curr += 2;
isLineEnd = true;
} else if (b == '\r' || b == '\n') {
// CR or LF
curr += 1;
isLineEnd = true;
} else {
buf.write(b);
isLineEnd = false;
}
if (isLineEnd && curr < len && manifest[curr] != (byte) ' ') {
// Value ends if line break is not followed by a space
break;
}
// If line break was followed by a space, then the curr++ in the for loop header will skip it
}
try {
val = buf.toString("UTF-8");
} catch (final UnsupportedEncodingException e) {
// Should not happen
throw ClassGraphException.newClassGraphException("UTF-8 encoding unsupported", e);
}
}
return new SimpleEntry<>(val.endsWith(" ") ? val.trim() : val, curr);
} | java |
private static byte[] manifestKeyToBytes(final String key) {
final byte[] bytes = new byte[key.length()];
for (int i = 0; i < key.length(); i++) {
bytes[i] = (byte) Character.toLowerCase(key.charAt(i));
}
return bytes;
} | java |
private static boolean keyMatchesAtPosition(final byte[] manifest, final byte[] key, final int pos) {
if (pos + key.length + 1 > manifest.length || manifest[pos + key.length] != ':') {
return false;
}
for (int i = 0; i < key.length; i++) {
// Manifest keys are case insensitive
if (toLowerCase[manifest[i + pos]] != key[i]) {
return false;
}
}
return true;
} | java |
@Override
public String getModuleName() {
String moduleName = moduleRef.getName();
if (moduleName == null || moduleName.isEmpty()) {
moduleName = moduleNameFromModuleDescriptor;
}
return moduleName == null || moduleName.isEmpty() ? null : moduleName;
} | java |
void addAnnotations(final AnnotationInfoList packageAnnotations) {
// Currently only class annotations are used in the package-info.class file
if (packageAnnotations != null && !packageAnnotations.isEmpty()) {
if (this.annotationInfo == null) {
this.annotationInfo = new AnnotationInfoList(packageAnnotations);
} else {
this.annotationInfo.addAll(packageAnnotations);
}
}
} | java |
public PackageInfoList getChildren() {
if (children == null) {
return PackageInfoList.EMPTY_LIST;
}
final PackageInfoList childrenSorted = new PackageInfoList(children);
// Ensure children are sorted
CollectionUtils.sortIfNotEmpty(childrenSorted, new Comparator<PackageInfo>() {
@Override
public int compare(final PackageInfo o1, final PackageInfo o2) {
return o1.name.compareTo(o2.name);
}
});
return childrenSorted;
} | java |
static String getParentPackageName(final String packageOrClassName) {
if (packageOrClassName.isEmpty()) {
return null;
}
final int lastDotIdx = packageOrClassName.lastIndexOf('.');
return lastDotIdx < 0 ? "" : packageOrClassName.substring(0, lastDotIdx);
} | java |
public String getPositionInfo() {
final int showStart = Math.max(0, position - SHOW_BEFORE);
final int showEnd = Math.min(string.length(), position + SHOW_AFTER);
return "before: \"" + JSONUtils.escapeJSONString(string.substring(showStart, position)) + "\"; after: \""
+ JSONUtils.escapeJSONString(string.substring(position, showEnd)) + "\"; position: " + position
+ "; token: \"" + token + "\"";
} | java |
public void expect(final char expectedChar) throws ParseException {
final int next = getc();
if (next != expectedChar) {
throw new ParseException(this, "Expected '" + expectedChar + "'; got '" + (char) next + "'");
}
} | java |
public void skipWhitespace() {
while (position < string.length()) {
final char c = string.charAt(position);
if (c == ' ' || c == '\n' || c == '\r' || c == '\t') {
position++;
} else {
break;
}
}
} | java |
void toJSONString(final Map<ReferenceEqualityKey<JSONReference>, CharSequence> jsonReferenceToId,
final boolean includeNullValuedFields, final int depth, final int indentWidth,
final StringBuilder buf) {
final boolean prettyPrint = indentWidth > 0;
final int n = items.size();
int numDisplayedFields;
if (includeNullValuedFields) {
numDisplayedFields = n;
} else {
numDisplayedFields = 0;
for (final Entry<String, Object> item : items) {
if (item.getValue() != null) {
numDisplayedFields++;
}
}
}
if (objectId == null && numDisplayedFields == 0) {
buf.append("{}");
} else {
buf.append(prettyPrint ? "{\n" : "{");
if (objectId != null) {
// id will be non-null if this object does not have an @Id field, but was referenced by
// another object (need to include ID_TAG)
if (prettyPrint) {
JSONUtils.indent(depth + 1, indentWidth, buf);
}
buf.append('"');
buf.append(JSONUtils.ID_KEY);
buf.append(prettyPrint ? "\": " : "\":");
JSONSerializer.jsonValToJSONString(objectId, jsonReferenceToId, includeNullValuedFields, depth + 1,
indentWidth, buf);
if (numDisplayedFields > 0) {
buf.append(',');
}
if (prettyPrint) {
buf.append('\n');
}
}
for (int i = 0, j = 0; i < n; i++) {
final Entry<String, Object> item = items.get(i);
final Object val = item.getValue();
if (val != null || includeNullValuedFields) {
final String key = item.getKey();
if (key == null) {
// Keys must be quoted, so the unquoted null value cannot be a key
// (Should not happen -- JSONParser.parseJSONObject checks for null keys)
throw new IllegalArgumentException("Cannot serialize JSON object with null key");
}
if (prettyPrint) {
JSONUtils.indent(depth + 1, indentWidth, buf);
}
buf.append('"');
JSONUtils.escapeJSONString(key, buf);
buf.append(prettyPrint ? "\": " : "\":");
JSONSerializer.jsonValToJSONString(val, jsonReferenceToId, includeNullValuedFields, depth + 1,
indentWidth, buf);
if (++j < numDisplayedFields) {
buf.append(',');
}
if (prettyPrint) {
buf.append('\n');
}
}
}
if (prettyPrint) {
JSONUtils.indent(depth, indentWidth, buf);
}
buf.append('}');
}
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.