Returns true if class has been generated

@param string $className

@return bool
189626
public function supports($className)
    {
        return (strpos($className, ucfirst($this->classSuffix)) === strlen($className) - strlen($this->classSuffix));
    }
975935
public function isMethodFinal($className, $methodName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_FINAL]);
    }
812519
public function autoload ($classname) {
        // if the class where already loaded. should not happen
        if (class_exists($classname)) {
            return TRUE;
        }

        // Works for PEAR style class names and namespaced class names
        $path = str_replace(
            array('_', '\\'),
            '/',
            $classname
        ) . '.php';
        
        foreach ($this->paths as $basePath) {
            $tail = $path;
            if (!is_string($basePath)) {
                $namespace = $basePath[1];
                $basePath = $basePath[0];
                $tail = str_replace($namespace . '/', '', $tail);
            }
            if (file_exists($basePath . '/' . $tail)) {
                include_once $basePath . '/' . $tail;
                return TRUE;
            }
        }
        // @codeCoverageIgnoreStart
        // returning false makes PHP throwing a fatal error
        return FALSE;
        // @codeCoverageIgnoreEnd
    }
130739
public function loadClass($className) {
        $cache = $this->getCache();
        $entries = $cache->load($this->cacheKey);
        if($entries == false) {
            $entries = array();
        }
        $status = $this->tryAndLoadClass($className, $entries);
        if($status) {
            // class loaded
            return true;
        }
        if(preg_match($this->ignoreClassNamesRegexp, $className)) {
            return false;
        }
 
        foreach($this->classPaths as $path) {
            // Scan for file
            $realPath = $this->searchForClassFile($className, $path);
            if($realPath !== false) {
                $entries[$className] = $realPath;
                break;
            }
        }
        $cache->save($entries, $this->cacheKey);
        $status = $this->tryAndLoadClass($className, $entries);
        return $status;
    }
382347
public function hasClass($name)
    {
        foreach ($this as $node) {
            if ($node instanceof \DOMElement && $class = $node->getAttribute('class')) {
                $classes = preg_split('/\s+/s', $class);
                if (in_array($name, $classes)) {
                    return true;
                }
            }
        }
        return false;
    }
168669
public function hasClass($class_name)
    {
        foreach ($this->nodes as $node) {
            if ($node instanceof \DOMElement && $node_class_attr = $node->getAttribute('class')) {
                $node_classes = explode(' ', $node_class_attr);
                if (\in_array($class_name, $node_classes, true)) {
                    return true;
                }
            }
        }

        return false;
    }
948845
public function isController(string $className) : bool
    {
        $refClass = new \ReflectionClass($className);


        foreach ($refClass->getMethods() as $refMethod) {
            $actionAnnotation = $this->annotationReader->getMethodAnnotation($refMethod, Action::class);
            if ($actionAnnotation) {
                return true;
            }
            $urlAnnotation = $this->annotationReader->getMethodAnnotation($refMethod, URL::class);
            if ($urlAnnotation) {
                return true;
            }
        }

        return false;
    }
315579
public function removeClass($classname)
    {
        $classArr = array_diff($this->getClassArray(), [$classname]);
        return $this->setClassArray($classArr);
    }
1236887
public function classUsesParentsTrait($className)
    {
        if (is_object($className)) {
            $className = get_class($className);
        }

        if (false === isset($this->classUsingParentsTrait[$className])) {
            $this->classUsingParentsTrait[$className] = $this->checkClassUsesParentsTrait($className);
        }

        return $this->classUsingParentsTrait[$className];
    }
843779
public function hasObjectManagerByClassName($className)
    {
        $realClass = ClassUtils::getRealClass($className);

        if ($this->hasObjectManagerNameByClassName($realClass)) {
            $objectManagerName = $this->getObjectManagerNameByClassName($realClass);
            return $this->getDoctrineObjectManager()->has($objectManagerName);
        }
        return false;
    }
172424
public function getClassMetadata($className)
    {
        if (!$this->initialized) {
            $this->initialize();
        }
        if (array_key_exists($className, $this->metadata)) {
            return $this->metadata[$className];
        }

        return false;
    }
947406
public function isValidConfigurator($className)
    {
        //====================================================================//
        // Verify Class Exists
        if (false == class_exists($className)) {
            return Splash::log()->err('Configurator Class Not Found: '.$className);
        }

        //====================================================================//
        // Verify Configurator Class Extends ConfiguratorInterface
        try {
            $class = new $className();
            if (!($class instanceof ConfiguratorInterface)) {
                return Splash::log()->err(Splash::trans('ErrLocalInterface', $className, ConfiguratorInterface::class));
            }
        } catch (Exception $exc) {
            echo $exc->getMessage();

            return Splash::log()->err($exc->getMessage());
        }

        return true;
    }
969143
public function hasClass($className)
    {
        if ($this->hasAttribute('class')) {
            return in_array($className, preg_split('/\s+/', $this->getAttribute('class')));
        }

        return false;
    }
658840
public function hasDiscriminatorValue($className)
    {
        if (array_key_exists($className, $this->discriminatorValueMap)) {
            return false !== $this->discriminatorValueMap[$className];
        }
        $this->discriminatorValueMap[$className] = $this->buildDiscriminatorValueMap($className);

        return $this->discriminatorValueMap[$className];
    }
572636
public function isValidDriverClass($className)
    {
        if (!class_exists($className)) {
            return false;
        }

        if (!is_subclass_of($className, 'Bex\\Behat\\ExtensionDriverLocator\\DriverInterface')) {
            return false;
        }

        if (!empty($this->parent) && !is_subclass_of($className, $this->parent)) {
            return false;
        }

        return true;
    }
964699
public function hasInterfaceUsageByClass($className)
    {
        if (!isset($this->interfaceUsages[$className])) {
            return false;
        }

        return count($this->interfaceUsages[$className]) > 0;
    }
163671
private function isValidWidgetClass($className)
    {
        //====================================================================//
        // Safety Check => Widget Type is String
        if (!is_string($className)) {
            return "Widget Type is Not a String";
        }
        //====================================================================//
        // Safety Check => Class Exists
        if (!class_exists($className)) {
            return "Widget Class Not Found";
        }
        //====================================================================//
        // Safety Check => Class Extends
        if (!is_subclass_of($className, AbstractWidget::class)) {
            return "Widget Class MUST extends ".AbstractWidget::class;
        }

        return true;
    }