Checks to see if a given class is blacklisted or not.

@param className class name/package
@return true if not blacklisted and false if it is blacklisted
499508
public static boolean classAllowed(String className) {
        for (String name: BLACK_LIST) {
            if (className.startsWith(name)) {
                return false;
            }
        }
        return true;
    }
664360
public ClassGraph blacklistModules(final String... moduleNames) {
        for (final String moduleName : moduleNames) {
            scanSpec.moduleWhiteBlackList.addToBlacklist(WhiteBlackList.normalizePackageOrClassName(moduleName));
        }
        return this;
    }
500670
protected function isSuffixValid(string $className): bool
    {
        if ($this->isSourcePluginSuffixValid($className)) {
            return true;
        }

        if ($this->isTestPluginSuffixValid($className)) {
            return true;
        }

        return false;
    }
643970
public boolean hasClass(String className) {
        for (Element element : this) {
            if (element.hasClass(className))
                return true;
        }
        return false;
    }
386836
private boolean isExcluded(String className) {
    if (excludes == null || excludes.size() == 0) {
      return false;
    }
    return excludes.stream()
        .filter(pattern -> SelectorUtils.matchPath(pattern, className, ".", true))
        .count() == 0;
  }
699335
private static boolean isRiskyName(String className, String methodName) {
		if (riskyClassNames.contains(className)) {
			return true;
		}

		String qualifiedMethodName = className + '.' + methodName;
		if (riskyMethodNameContents.contains(qualifiedMethodName)) {
			return true;
		}

		for (String riskyName : riskyMethodNameContents) {
			if (methodName.indexOf(riskyName) >= 0) {
				return true;
			}
		}

		return methodName.indexOf(Values.SYNTHETIC_MEMBER_CHAR) >= 0;
	}
198992
public function isClassAbstract($className)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_ABSTRACT]);
    }
241832
public static boolean isClassPresent(String classname) {
		try {
			Class.forName(classname);
			return true;
		} catch (ClassNotFoundException e) {

		}
		return false;
	}
844260
public static boolean verifyClass(String className){
        try {
            Class<?> cl = Class.forName(className);
            cl.newInstance();
            return true;
        }
        catch (Exception ex) {
          logger.severeException("ApplicationContext: verifyClass(): General Exception occurred: " + ex.getMessage(), ex);
          return false;
        }
    }
798014
public boolean isClassUnmarkedForRemoval(String className) {
		for (ControlEntry controlEntry : controlList) {
			if (controlEntry.pattern.matcher(className).matches() && controlEntry.controlMode == ControlMode.KEEP) {
				return true;
			}
		}

		return false;
	}
127170
public boolean processClassName(String className) {
        try {
            ClassFile cf = finder.find(className);
            if (cf == null) {
                errorNoClass(className);
                return false;
            } else {
                processClass(cf);
                return true;
            }
        } catch (ConstantPoolException ex) {
            errorException(ex);
            return false;
        }
    }
129116
public static boolean isClassBelowPackage(Class<?> theClass, List<?> packageList) {
        String classPackage = theClass.getPackage().getName();
        for (Object packageName : packageList) {
            if (packageName != null) {
                if (classPackage.startsWith(packageName.toString())) {
                    return true;
                }
            }
        }
        return false;
    }
960014
public final boolean isAlwaysAllowed(final String packageName) {
        if (packageName.equals("java.lang")) {
            return true;
        }
        return Utils.findAllowedByName(getAlwaysAllowed(), packageName) != null;
    }
29142
private boolean specificMatching(String className) {

    for (int i = 0; i < processPackages.length; i++) {
      if (className.startsWith(processPackages[i])) {
        // a positive match
        return false;
      }
    }
    // we can ignore this class
    return true;
  }
544512
public @CheckForNull
    ClassStats getClassStats(@DottedClassName String className) {
        if (hasClassStats) {
            return null;
        }
        String packageName;
        int lastDot = className.lastIndexOf('.');
        if (lastDot < 0) {
            packageName = "";
        } else {
            packageName = className.substring(0, lastDot);
        }
        PackageStats stat = getPackageStats(packageName);
        return stat.getClassStatsOrNull(className);
    }
896554
function isBlacklisted(moduleId)
{
  var i;

  // strip basePath
  moduleId = moduleId.replace(this.basePathRegexp, '');

  for (i = 0; i < this.blackList.length; i++)
  {
    if (minimatch(moduleId, this.blackList[i]))
    {
      return true;
    }
  }

  return false;
}
1081682
public function isClassTaggedWith($className, $tag)
    {
        if ($this->initialized === false) {
            return false;
        }
        if (!isset($this->reflectedClassNames[$className])) {
            $this->reflectClass($className);
        }
        if (!isset($this->classTagsValues[$className])) {
            return false;
        }
        return isset($this->classTagsValues[$className][$tag]);
    }