Determine whether class named by given ClassDescriptor is an Obligation
type.

@param classDescriptor
a class
@return true if the class is an Obligation type, false otherwise
16692
public boolean isObligationType(ClassDescriptor classDescriptor) {
        try {
            return getObligationByType(BCELUtil.getObjectTypeInstance(classDescriptor.toDottedClassName())) != null;
        } catch (ClassNotFoundException e) {
            Global.getAnalysisCache().getErrorLogger().reportMissingClass(e);
            return false;
        }
    }
481447
public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
        boolean result = false;
        if (field != null) {
            result = field.isAnnotationPresent(annotationClass);
        }
        if (!result && setter != null) {
            result = setter.isAnnotationPresent(annotationClass);
        }
        if (!result && getter != null) {
            result = getter.isAnnotationPresent(annotationClass);
        }
        return result;
    }
27672
protected final FilterDescriptor<?, ?> getFilterBeanDescriptorForClassUnbounded(final Class<?> filterClass) {
        for (final FilterDescriptor<?, ?> descriptor : getFilterDescriptors()) {
            if (filterClass == descriptor.getComponentClass()) {
                return descriptor;
            }
        }
        return notFoundFilter(filterClass);
    }
22908
private static boolean hasConflictingClassName(FileDescriptorProto file, String name) {
    for (EnumDescriptorProto enumDesc : file.getEnumTypeList()) {
      if (name.equals(enumDesc.getName())) {
        return true;
      }
    }
    for (ServiceDescriptorProto serviceDesc : file.getServiceList()) {
      if (name.equals(serviceDesc.getName())) {
        return true;
      }
    }
    for (DescriptorProto messageDesc : file.getMessageTypeList()) {
      if (hasConflictingClassName(messageDesc, name)) {
        return true;
      }
    }
    return false;
  }
1091106
public static ClassDescriptor getClassDescriptor(JavaClass jclass) {
        return DescriptorFactory.instance().getClassDescriptor(ClassName.toSlashedClassName(jclass.getClassName()));
    }
84448
public static boolean isSARLAnnotation(Class<?> type) {
		return (type != null && Annotation.class.isAssignableFrom(type))
				&& isSARLAnnotation(type.getPackage().getName());
	}
420398
public boolean isCoreClass(TypeElement typeElement) {
        return utils.getEnclosingTypeElement(typeElement) == null || utils.isStatic(typeElement);
    }
909467
public static boolean classNodeImplementsType(ClassNode node, Class target) {
        ClassNode targetNode = ClassHelper.make(target);
        if (node.implementsInterface(targetNode)) {
            return true;
        }
        if (node.isDerivedFrom(targetNode)) {
            return true;
        }
        if (node.getName().equals(target.getName())) {
            return true;
        }
        if (node.getName().equals(target.getSimpleName())) {
            return true;
        }
        if (node.getSuperClass() != null && node.getSuperClass().getName().equals(target.getName())) {
            return true;
        }
        if (node.getSuperClass() != null && node.getSuperClass().getName().equals(target.getSimpleName())) {
            return true;
        }
        if (node.getInterfaces() != null) {
            for (ClassNode declaredInterface : node.getInterfaces()) {
                if (classNodeImplementsType(declaredInterface, target)) {
                    return true;
                }
            }
        }
        return false;
    }
58836
public @Nonnull
    ClassDescriptor getClassDescriptor(@SlashedClassName String className) {
        assert className.indexOf('.') == -1;
        ClassDescriptor classDescriptor = classDescriptorMap.get(className);
        if (classDescriptor == null) {
            if (MODULE_INFO.getClassName().equals(className)) {
                // don't allow module info to be added to the map,
                // which could be used to check referenced classes
                return MODULE_INFO;
            }
            classDescriptor = new ClassDescriptor(className);
            classDescriptorMap.put(className, classDescriptor);
        }
        return classDescriptor;
    }
963488
private boolean isDescriptorProperty(Object property) {

        return (getBundleType().equals(BundleType.DESCRIPTOR)
            || (hasDescriptor()
                && (property.equals(TableProperty.KEY)
                    || property.equals(TableProperty.DEFAULT)
                    || property.equals(TableProperty.DESCRIPTION))));
    }
754337
private boolean hasClassFileOnDiskInParentLoaderPath( ClassLoader loader, IType type ) {
    if( !(loader instanceof IInjectableClassLoader) ) {
      return false;
    }
    ClassLoader parent = loader.getParent();
    while( parent instanceof IInjectableClassLoader ) {
      parent = parent.getParent();
    }
    IType outer = TypeLord.getOuterMostEnclosingClass( type );
    try {
      parent.loadClass( outer.getName() );
      return true;
    }
    catch( ClassNotFoundException e ) {
      return false;
    }
  }
280639
function isStage1ClassDescriptor(possibleDesc) {
  let [target] = possibleDesc;

  return (
    possibleDesc.length === 1 &&
    typeof target === 'function' &&
    'prototype' in target &&
    !target.__isComputedDecorator
  );
}
1235383
public static <T extends ByteCodeElement> ElementMatcher.Junction<T> hasDescriptor(String descriptor) {
        return new DescriptorMatcher<T>(new StringMatcher(descriptor, StringMatcher.Mode.EQUALS_FULLY));
    }
1208379
static boolean isClassPresent(String className) {
        try {
            ClassUtils.class.getClassLoader().loadClass(className);
            return true;
        } catch (Throwable e) {
            return false;
        }
    }
1352786
private boolean isNotAssignedToOwnSlice(JavaClass javaClass) {
        List<String> dependencyIdentifier = sliceAssignment.getIdentifierOf(javaClass).getParts();
        return !dependencyIdentifier.equals(matchingGroups);
    }
1079228
public boolean isDescriptorOf(Class<? extends Describable> c) {
        return instance instanceof Descriptor && ((Descriptor)instance).isSubTypeOf(c);
    }
753994
private static boolean classIsJPAEntity(JavaClass cls) {
		AnnotationEntry[] annotations = cls.getAnnotationEntries();
		if (annotations != null) {
			for (AnnotationEntry annotation : annotations) {
				if ("Ljavax/persistence/Entity;".equals(annotation.getAnnotationType())) {
					return true;
				}
			}
		}

		return false;
	}