Report that a class has been analyzed.

@param className
the full name of the class
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);
    }
120714
public static String extractName(String className) {
	if (className == null) return null;
	int index = className.lastIndexOf('.');
	if (index != -1) return className.substring(index + 1);
	return className;
    }
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;
    }
1072545
@Override
    public void visitClass(ClassDescriptor classDescriptor) throws CheckedAnalysisException {

        // Just get the ClassContext from the analysis cache
        // and apply the detector to it.

        IAnalysisCache analysisCache = Global.getAnalysisCache();
        ClassContext classContext = analysisCache.getClassAnalysis(ClassContext.class, classDescriptor);
        Profiler profiler = analysisCache.getProfiler();
        profiler.start(detector.getClass());
        try {
            detector.visitClassContext(classContext);
        } finally {
            profiler.end(detector.getClass());
        }
    }
395843
@Override
    public FBClassReader analyze(IAnalysisCache analysisCache, ClassDescriptor descriptor) throws CheckedAnalysisException {

        ClassData classData = analysisCache.getClassAnalysis(ClassData.class, descriptor);

        FBClassReader classReader = new FBClassReader(classData.getData());

        return classReader;
    }
1048764
@Override
    @SuppressFBWarnings("DM_EXIT")
    public void reportMissingClass(ClassDescriptor classDescriptor) {
        System.out.println("Missing class: " + classDescriptor);
        System.exit(1);
    }
1124194
public void writeClass(String className)
    throws IOException
  {
    ConstantPool pool =  _javaClass.getConstantPool();
    ClassConstant classConst = pool.getClass(className);

    if (classConst != null)
      writeShort(classConst.getIndex());
    else
      writeShort(0);
  }
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;
        }
    }
85276
final protected function assertClassExtends(string $parentClassName, string $className): void
    {
        $this->assertClassExists($parentClassName);
        $this->assertClassExists($className);

        $reflection = new \ReflectionClass($className);

        self::assertTrue($reflection->isSubclassOf($parentClassName), \sprintf(
            'Failed asserting that class "%s" extends "%s".',
            $className,
            $parentClassName
        ));
    }
1098066
public function hasClass($className)
    {
        if (!$class = $this->dom->getAttribute("class")) {
            return false;
        }

        $classes = explode(" ", $class);

        return in_array($className, $classes, true);
    }
17017
final protected function assertClassExists(string $className): void
    {
        self::assertTrue(\class_exists($className), \sprintf(
            'Failed asserting that a class "%s" exists.',
            $className
        ));
    }
673245
public void driveToClass( String classname ) {
        String [] sa = BshClassPath.splitClassname( classname );
        String packn = sa[0];
        String classn = sa[1];

        // Do we have the package?
        if ( classPath.getClassesForPackage(packn).size()==0 )
            return;

        ptree.setSelectedPackage( packn );

        for(int i=0; i< classesList.length; i++) {
            if ( classesList[i].equals(classn) ) {
                classlist.setSelectedIndex(i);
                classlist.ensureIndexIsVisible(i);
                break;
            }
        }
    }
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;
  }
969143
public function hasClass($className)
    {
        if ($this->hasAttribute('class')) {
            return in_array($className, preg_split('/\s+/', $this->getAttribute('class')));
        }

        return false;
    }
410447
public static String determineQualifiedName(String className) {

        String readableClassName = StringUtils.removeWhitespace(className);
        if (readableClassName == null) {

            throw new IllegalArgumentException("readableClassName must not be null.");

        } else if (readableClassName.endsWith("[]")) {

            StringBuilder classNameBuffer = new StringBuilder();

            while (readableClassName.endsWith("[]")) {
                readableClassName = readableClassName.substring(0, readableClassName.length() - 2);
                classNameBuffer.append("[");
            }

            String abbreviation = PRIMITIVE_MAPPING.get(readableClassName);

            if (abbreviation == null) {
                classNameBuffer.append("L").append(readableClassName).append(";");
            } else {
                classNameBuffer.append(abbreviation);
            }

            readableClassName = classNameBuffer.toString();
        }
        return readableClassName;
    }
363447
private static @CheckForNull <T extends Descriptor> T findByClassName(Collection<? extends T> list, String className) {
        for (T d : list) {
            if(d.getClass().getName().equals(className))
                return d;
        }
        return null;
    }
643970
public boolean hasClass(String className) {
        for (Element element : this) {
            if (element.hasClass(className))
                return true;
        }
        return false;
    }