Whether the given class name is an internal class and should be filtered
@param className The class name
@return true if is internal
14802
protected boolean isApplicationClass(String className) {
        for (String packageName : packagesToFilter) {
            if (className.startsWith(packageName)) return false;
        }
        return true;
    }
520724
public static boolean isClassAvilableInClassPath(String string) {
		try {
			Class.forName(string);
			return true;
		} catch (ClassNotFoundException e) {
			return false;
		}
	}
499508
public static boolean classAllowed(String className) {
        for (String name: BLACK_LIST) {
            if (className.startsWith(name)) {
                return false;
            }
        }
        return true;
    }
419144
private static boolean isInternal(String clsName) {
        boolean internal = false;
        for (String internalPackage : internalPackages) {
            if (clsName.startsWith(internalPackage)) {
                internal = true;
                break;
            }
        }

        if (internal) {
            for (String externalPackage : externalPackages) {
                if (clsName.startsWith(externalPackage)) {
                    internal = false;
                    break;
                }
            }
        }

        return internal;
    }
448689
public static boolean isClassAvailable(final String className) {
        try {
            final Class<?> clazz = loadClass(className);
            return clazz != null;
        } catch (final ClassNotFoundException | LinkageError e) {
            return false;
        } catch (final Throwable e) {
            LowLevelLogUtil.logException("Unknown error checking for existence of class: " + className, e);
            return false;
        }
    }
1012402
@SuppressWarnings("unchecked")
    public static boolean findClass(String className) {
        try {
            return getClassLoader().loadClass(className) != null;
        } catch (ClassNotFoundException e) {
            return false;
        } catch (NoClassDefFoundError e) {
            return false;
        }
    }
1369523
final public function checkInjections($className) {
        if (is_array($this->inject())) {
            foreach ($this->inject() as $classArray) {
                if (!is_array($classArray) ||
                        (is_array($classArray) && !isset($classArray['class'])) ||
                        (is_array($classArray) && !class_exists($classArray['class'])))
                    continue;

                if ($classArray['class'] === $className)
                    return false;

                if (!$this->canInject($classArray, $className))
                    return false;
            }
        }

        return true;
    }
824108
public ClassDoc findClass(String className) {
        ClassDoc searchResult = searchClass(className);
        if (searchResult == null) {
            ClassDocImpl enclosingClass = (ClassDocImpl)containingClass();
            //Expand search space to include enclosing class.
            while (enclosingClass != null && enclosingClass.containingClass() != null) {
                enclosingClass = (ClassDocImpl)enclosingClass.containingClass();
            }
            searchResult = enclosingClass == null ?
                null : enclosingClass.searchClass(className);
        }
        return searchResult;
    }
915786
public static boolean isAssignableTo(String classInternalName, Class<?> type) {
        checkArgNotNull(classInternalName, "classInternalName");
        checkArgNotNull(type, "type");
        return type.isAssignableFrom(getClassForInternalName(classInternalName));
    }
82190
public Class<?> getClassForName(String className) {
        if (!StringUtils.hasText(className)) {
            return null;
        }

        for (Class<?> c : allClasses) {
            if (c.getName().equals(className)) {
                return c;
            }
        }
        return null;
    }
831880
public function filterSubClasses( $className) {
        $FilteredClasses = [];
        foreach( $this->loadedClasses as $loadedClass){
            if( is_subclass_of( $loadedClass, $className)){
                $FilteredClasses[] = $loadedClass;
            }
        }
        $this->loadedClasses = $FilteredClasses;
    }
320428
public boolean remove(String classname) {
    String		pkgname;
    HashSet<String>	names;

    classname = ClassPathTraversal.cleanUp(classname);
    pkgname   = ClassPathTraversal.extractPackage(classname);
    names     = m_NameCache.get(pkgname);
    if (names != null)
      return names.remove(classname);
    else
      return false;
  }
982250
private boolean isJavaSystemClassName(String className) {
        if (className == null) {
            return false;
        }

        if (className.startsWith("java/") || className.startsWith("javax/")) {
            return true;
        }
        return false;
    }
621832
public static boolean isClassDeclaration(Node n) {
    return n.isClass() && isDeclarationParent(n.getParent()) && isNamedClass(n);
  }
1196674
private boolean isClientClass(String className, Set<ASMData> clientClasses)
	{
		for (ASMData data : clientClasses)
		{
			if (data.getClassName().equals(className) && data.getObjectName().equals(data.getClassName())
					&& ((ModAnnotation.EnumHolder) data.getAnnotationInfo().get("value")).getValue().equals("CLIENT"))
				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;
    }
605796
public static boolean isNonStaticInnerClass(Class<?> clazz) {
		if (clazz.getEnclosingClass() == null) {
			// no inner class
			return false;
		} else {
			// inner class
			if (clazz.getDeclaringClass() != null) {
				// named inner class
				return !Modifier.isStatic(clazz.getModifiers());
			} else {
				// anonymous inner class
				return true;
			}
		}
	}