Return true if any of the given classes have a @serialinclude tag.

@param classes the classes to check.
@return true if any of the given classes have a @serialinclude tag.
559655
private boolean serialClassFoundToDocument(ClassDoc[] classes) {
        for (ClassDoc aClass : classes) {
            if (serialClassInclude(aClass)) {
                return true;
            }
        }
        return false;
    }
361884
private boolean checkAnnotations(List<? extends AnnotationTree> annotations, Tree node) {
    for (AnnotationTree annotation : annotations) {
      if (isJ2ObjCIncompatible(annotation)) {
        nodesToStrip.add(node);
        return false;
      }
    }
    return true;
  }
224777
private static boolean checkModifiers(Class<? extends AbstractPlugin> pluginClass) {
        int modifiers = pluginClass.getModifiers();
        return !Modifier.isAbstract(modifiers) &&
                !Modifier.isInterface(modifiers) &&
                !Modifier.isPrivate(modifiers);
    }
1184356
public static boolean hasSuperclass(Class<?> clazz, String superClassName) {
		List<Type> hierarchy = new ArrayList<>();
		getTypeHierarchy(hierarchy, clazz, Object.class);
		for (Type t : hierarchy) {
			if (isClassType(t) && typeToClass(t).getName().equals(superClassName)) {
				return true;
			}
		}
		return false;
	}
159379
private boolean isIncluded(String className) {
    if (includes == null || includes.size() == 0) {
      // generate nothing if no include defined - it makes no sense to generate for all classes from classpath
      return false;
    }
    return includes.stream()
        .filter(pattern -> SelectorUtils.matchPath(pattern, className, ".", true))
        .count() > 0;
  }
738366
private static boolean sameType(Type[] types, Class<?>[] classes) {
        if (types.length != classes.length) return false;
        for (int i = 0; i < types.length; i++) {
            if (!Type.getType(classes[i]).equals(types[i])) return false;
        }
        return true;
    }
570989
public static boolean nonDitaContext(final Deque<DitaClass> classes) {
        final Iterator<DitaClass> it = classes.iterator();
        it.next(); // Skip first, because we're checking if current element is inside non-DITA context
        while (it.hasNext()) {
            final DitaClass cls = it.next();
            if (cls != null && cls.isValid() &&
                    (TOPIC_FOREIGN.matches(cls) || TOPIC_UNKNOWN.matches(cls))) {
                return true;
            } else if (cls != null && cls.isValid()) {
                return false;
            }
        }
        return false;
    }
1105250
@SuppressWarnings("unchecked")
    @SafeVarargs
    public final boolean containsAnnotations(Class<? extends Annotation>... annotationClass) {
        if (ArrayUtils.isEmpty(annotationClass)) {
            return false;
        }

        for (Object anno : getAnnotations()) {
            for (Class cls : annotationClass) {
                if (((Annotation) anno).annotationType().equals(cls)) {
                    return true;
                }
            }
        }
        return false;
    }
46
List<JCClassDecl> listClasses(List<JCCompilationUnit> trees) {
        List<JCClassDecl> result = new ArrayList<>();
        for (JCCompilationUnit t : trees) {
            for (JCTree def : t.defs) {
                if (def.hasTag(JCTree.Tag.CLASSDEF))
                    result.add((JCClassDecl)def);
            }
        }
        return result;
    }
1018499
public boolean hasWebDocumentation(final Class<?>  clazz) {
        for (final String pkg : PACKAGES_WITH_WEB_DOCUMENTATION) {
            if (clazz.getPackage().getName().startsWith(pkg)) {
                return true;
            }
        }
        return false;
    }
453483
public boolean hasClass(String name) {
        byte[] b = classesFound.get(name);
        Boolean found = b == null ? null : b.length > 0;
        if (found != null)
            return found;

        try {
            // try dynamic jar assets
            String path = name.replace('.', '/') + ".class";
            b = findInJarAssets(path);
            // try the file system
            if (b == null)
                b = findInFileSystem(path);
        }
        catch (Exception ex) {
            logger.severeException(ex.getMessage(),  ex);
        }
        found = b != null;
        classesFound.put(name, found ? b : new byte[0]);
        return found;
    }
578819
public static boolean strictCheckMatchingTags(Collection<String> tags, Set<String> includeTags, Set<String> excludeTags)
    {
        boolean includeTagsEnabled = !includeTags.isEmpty();

        for (String tag : tags)
        {
            boolean isIncluded = includeTags.contains(tag);
            boolean isExcluded = excludeTags.contains(tag);

            if ((includeTagsEnabled && isIncluded) || (!includeTagsEnabled && !isExcluded))
            {
                return true;
            }
        }

        return false;
    }
399086
protected boolean checkPackageLocators(String classPackageName) {
		if (packageLocators != null && !disablePackageLocatorsScanning && classPackageName.length() > 0
				&& (packageLocatorsBasePackage == null || classPackageName.startsWith(packageLocatorsBasePackage))) {
			for (String packageLocator : packageLocators) {
				String[] splitted = classPackageName.split("\\.");

				if (es.cenobit.struts2.json.util.StringUtils.contains(splitted, packageLocator, false))
					return true;
			}
		}
		return false;
	}
368079
def has_class(self, classname):
        
        def element_has_class():
            """Wrapper to test if element has a class"""
            pattern = re.compile('(\s|^){classname}(\s|$)'.format(classname=classname))
            classes = self.element.get_attribute('class')
            matches = re.search(pattern, classes)

            if matches is not None:
                return True
            return False

        return self.execute_and_handle_webelement_exceptions(
            element_has_class,
            'check for element class "{}"'.format(classname)
        )
677904
static boolean isIn(TypeName value, Class<?>... classes) {
		for (Class<?> item : classes) {
			if (value.toString().equals(TypeName.get(item).toString())) {
				return true;
			}
		}

		return false;
	}
170004
private void removeVetoedClasses(Set<Class<?>> classes) {
        //get hold of classnames
        Set<String> classNames = new HashSet<String>();
        for (Class<?> clazz : classes) {
            classNames.add(clazz.getName());
        }
        // take into considerations of the exclude in beans.xml
        Collection<String> includedClasses = WeldCDIUtils.filterClassesBasedOnBeansXML(this.beansXml, this.resourceLoader, classNames);
        Iterator<Class<?>> iterator = classes.iterator();
        while (iterator.hasNext()) {
            Class<?> clazz = iterator.next();
            if (WeldCDIUtils.isClassVetoed(clazz)) {
                iterator.remove();
            } else if (!includedClasses.contains(clazz.getName())) {
                iterator.remove();
            }

        }
    }
879881
@SuppressWarnings("unchecked")
    public static <T> boolean hasClass(Class<T> type, ClassLoader classloader) {
        try {
            loadClass(type.getName(), classloader);
            return true;
        } catch (RuntimeException e) {
            if(e.getCause() instanceof ClassNotFoundException) {
                return false;
            }
            throw e;
        }
    }