Returns true if the class is configured in xml (also checking the super classes), false otherwise.
@param classToCheck class to check
@return true if the class is configured in xml, false otherwise
352901
public boolean isInheritedMapped(Class<?> classToCheck){
				
		for (Class<?> clazz : getAllsuperClasses(classToCheck))
			if(isMapped(clazz))return true;
				
		return false;
	}
691634
public static boolean classHasAnnotation(Class clazz, Class<? extends Annotation> annotation) {
		try {
			Set<Class> hierarchy = ReflectionUtil.flattenHierarchy(clazz);
			for (Class c : hierarchy) {
				if (c.isAnnotationPresent(annotation)) return true;
			}
		} catch (Throwable t) {
			t.printStackTrace();
		}
		return false;
	}
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;
  }
838516
public boolean checkInstanceOf(Context context, CharSequence targetClassName,
            CharSequence loaderPackage, CharSequence referenceClassName) {
        if ((targetClassName == null) || (referenceClassName == null)) {
            return false;
        }

        // Try a shortcut for efficiency.
        if (TextUtils.equals(targetClassName, referenceClassName)) {
            return true;
        }

        final Class<?> referenceClass = loadOrGetCachedClass(
                context, referenceClassName, loaderPackage);
        if (referenceClass == null) {
            return false;
        }

        return checkInstanceOf(context, targetClassName, loaderPackage, referenceClass);
    }
278126
private Set<Class<?>> getClasses(XML xml){
		HashSet<Class<?>> result = new HashSet<Class<?>>();
		
		// in case of override only the last global configuration must be analyzed
		Global global = null;
		
		for (Class<?> clazz : getAllsuperClasses(configuredClass)) {
			// only if global configuration is null will be searched global configuration on super classes
			if(isNull(global)){
				  
				global = xml.loadGlobals().get(clazz.getName());
				if(!isNull(global)){
					addClasses(global.getClasses(),result);
					if(global.getExcluded()!=null)
						for (Attribute attribute : xml.loadAttributes().get(clazz.getName()))
							for (String fieldName : global.getExcluded())
								if(attribute.getName().equals(fieldName))
									addClasses(attribute.getClasses(),result,attribute.getName());
				}
			}
			
			List<Attribute> attributes = xml.loadAttributes().get(clazz.getName());
			
			if(!isNull(attributes))
				for (Attribute attribute : attributes)
					if(    isNull(global) 
						|| isPresent(global.getExcluded(), attribute.getName())
					    || ( !isEmpty(global.getAttributes()) 
						     && !isPresent(global.getAttributes(), new SimplyAttribute(attribute.getName()))
						   )
					   )
					addClasses(attribute.getClasses(),result,attribute.getName());
		}
				
		return result;
	}
650846
private boolean isLoggerWithClassParm(XMethod m) {
        String signature = m.getSignature();
        return SIG_CLASS_TO_SLF4J_LOGGER.equals(signature) || SIG_CLASS_TO_LOG4J_LOGGER.equals(signature) || SIG_CLASS_TO_LOG4J2_LOGGER.equals(signature)
                || SIG_CLASS_TO_COMMONS_LOGGER.equals(signature);
        // otherwise check the calling class?
    }
470364
public <T extends AbstractJaxb> boolean hasCssClass(String clazz) {
        boolean result = false;
        List<String> classList = this.getCssClass();
        if (classList != null && classList.contains(clazz)) {
            result = true;
        }
        return result;
    }
1294095
public static boolean isListedAsParametrisation(JClass classToCheck, JType type) {
		return type instanceof JClass && ((JClass) type).getTypeParameters().contains(classToCheck);
	}
392791
protected boolean shouldApplyThisRuleTo(ClassNode classNode) {
        // TODO Consider caching applyTo, doNotApplyTo and associated WildcardPatterns
        boolean shouldApply = true;

        String applyTo = getApplyToClassNames();
        String doNotApplyTo = getDoNotApplyToClassNames();

        if (applyTo != null  && applyTo.length() > 0) {
            WildcardPattern pattern = new WildcardPattern(applyTo, true);
            shouldApply = pattern.matches(classNode.getNameWithoutPackage()) || pattern.matches(classNode.getName());
        }

        if (shouldApply && doNotApplyTo != null && doNotApplyTo.length() > 0) {
            WildcardPattern pattern = new WildcardPattern(doNotApplyTo, true);
            shouldApply = !pattern.matches(classNode.getNameWithoutPackage()) && !pattern.matches(classNode.getName());
        }

        return shouldApply;
    }
1152024
public static boolean isSubclassOf(ClassNode classNode, String parentClassName) {
        ClassNode currentSuper = classNode.getSuperClass();
        while (currentSuper != null && !currentSuper.getName().equals(OBJECT_CLASS)) {
            if (currentSuper.getName().equals(parentClassName)) return true;
            currentSuper = currentSuper.getSuperClass();
        }
        return false;
    }
573950
private boolean isCheckedException(TypeMirror t) {
        return !(env.types.isAssignable(t, env.java_lang_Error)
                || env.types.isAssignable(t, env.java_lang_RuntimeException));
    }
1018611
private boolean serialClassFoundToDocument(ClassDoc[] classes) {
        for (int i = 0; i < classes.length; i++) {
            if (serialClassInclude(classes[i])) {
                return true;
            }
        }
        return false;
    }
112656
public static boolean isProvider(ClassInfo classInfo) {
        AnnotationInfo annotationInfo = classInfo.getAnnotation(JaxWsConstants.WEB_SERVICE_ANNOTATION_NAME);
        if (annotationInfo == null) {
            annotationInfo = classInfo.getAnnotation(JaxWsConstants.WEB_SERVICE_PROVIDER_ANNOTATION_NAME);
            if (annotationInfo != null) {
                return true;
            }
        }
        return false;
    }
721051
public static boolean isUncheckedException(ObjectType type) throws ClassNotFoundException {
        if (type.equals(Type.THROWABLE) || type.equals(RUNTIME_EXCEPTION_TYPE) || type.equals(ERROR_TYPE)) {
            return true;
        }
        ClassDescriptor c = DescriptorFactory.getClassDescriptor(type);
        Subtypes2 subtypes2 = Global.getAnalysisCache().getDatabase(Subtypes2.class);
        return subtypes2.isSubtype(c, RUNTIME_EXCEPTION, ERROR);

    }
122777
protected function isNodeElementAware($class_name)
	{
		$node_element_aware_interface = 'QATools\\QATools\\PageObject\\Element\\INodeElementAware';

		if ( class_exists($class_name) ) {
			return in_array($node_element_aware_interface, class_implements($class_name));
		}

		return false;
	}
931691
public static boolean isVetoed(Class<?> javaClass) {
        if (javaClass.isAnnotationPresent(Vetoed.class)) {
            return true;
        }
        return isPackageVetoed(javaClass.getPackage());
    }
1175194
public static boolean isClassFile(IJavaElement elt) {
        if (elt == null) {
            return false;
        }
        return elt instanceof IClassFile || elt instanceof ICompilationUnit;

    }