@param $className

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

        return count($this->interfaceUsages[$className]) > 0;
    }
333195
public function load($className)
    {
        $class = ltrim($className, '\\');

        if (strpos($class, $this->namespace) !== 0) {
            return false;
        }

        $nsparts   = explode('\\', $class);
        $class     = array_pop($nsparts);
        $nsparts[] = '';
        $path      = $this->path . implode(DIRECTORY_SEPARATOR, $nsparts);
        $path     .= str_replace('_', DIRECTORY_SEPARATOR, $class) . '.php';

        if (!is_readable($path)) {
            return false;
        }

        require $path;

        return class_exists($className,false);
    }
371198
public function isClassFinal($className)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_FINAL]);
    }
264376
public function isClass($className)
    {
        foreach ($this->definitions as $key => $value) {
            if (!strcasecmp($key, $className) && 'class' === $value->getType()) {
                return true;
            }
        }

        /*
         * Try to autoload the class from an external dependency
         */
        if (\count($this->externalDependencies)) {
            foreach ($this->externalDependencies as $namespace => $location) {
                if (preg_match('#^'.$namespace.'\\\\#i', $className)) {
                    return $this->loadExternalClass($className, $location);
                }
            }
        }

        return false;
    }
649281
private function containsClassName($className, array $allowedClassNames)
    {
        foreach ($allowedClassNames as $allowedClassName) {
            if (false !== stripos($className, $allowedClassName)) {
                return true;
            }
        }

        return false;
    }
880955
public function isEntity(string $className): bool
    {
        return class_exists($className) && !$this->entityManager->getMetadataFactory()->isTransient($className);
    }
953823
public function hasAttributeClass($className)
    {
        if ( ! $this->offsetExists('class')) {
            $this->storage[ 'class' ] = [];
        }

        return in_array($className, $this->storage[ 'class' ]);
    }
301159
public function resolveClassName($className)
    {

        if (isset($this->_aliases[$className]))
            $className = $this->_aliases[$className];

        return $className;
    }
699773
public function canLoadClass($className)
    {
        if ($this->namespace !== null && strpos($className, $this->namespace.$this->namespaceSeparator) !== 0) {
            return false;
        }

        $file = str_replace($this->namespaceSeparator, DIRECTORY_SEPARATOR, $className) . $this->fileExtension;

        if ($this->includePath !== null) {
            return file_exists($this->includePath . DIRECTORY_SEPARATOR . $file);
        }

        return (false !== stream_resolve_include_path($file));
    }
1011232
protected static function getClassName($className) {
		if (class_exists($className)) {
			while (class_exists('ux_' . $className, FALSE)) {
				$className = 'ux_' . $className;
			}
		}

		return $className;
	}
14059
public static function boot($className)
    {
        if (!class_exists($className)) {
            return false;
        }

        $bootstrap = new $className;
        $dispatcher = Dispatcher::getInstance();

        $class = new \ReflectionClass($className);
        foreach ($class->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
            $methodName = $method->name;
            if (!$method->isStatic() && substr_compare('_init', $methodName, 0, 5) === 0) {
                $bootstrap->$methodName($dispatcher);
            }
        }

        return true;
    }
835766
public function getClassDefinition($className)
    {
        foreach ($this->definitions as $key => $value) {
            if (!strcasecmp($key, $className)) {
                return $value;
            }
        }

        return false;
    }
70878
public static function getMappedClassName($className)
    {
        $mappedName = array_search($className, self::$classMap);

        if ($mappedName) {
            return $mappedName;
        }

        $mappedName = array_search($className, array_flip(self::$classMap));

        if ($mappedName) {
            return $mappedName;
        }

        return false;
    }
106846
public function hasDescendant(ClassName $className, Comparator $comparator = null)
    {
        if ($this->isAbsolute() !== $className->isAbsolute()) {
            return false;
        }

        if (null === $comparator) {
            $comparator = new Comparator;
        }

        while ($className->hasParent()) {
            $className = $className->parent();
            if ($comparator->equals($this, $className)) {
                return true;
            }
        }

        return false;
    }
577794
public function autoDetectModuleNameByClassName($className)
    {
        if (array_key_exists($className, $this->classNameToModuleName)) {
            $resultModuleName =  $this->classNameToModuleName[$className];
        } else {
            $index = $this->getModulesIndex();
            $classNameLength = strlen($className);

            $resultModuleName = null;
            foreach ($index as $moduleName => $moduleNameLength) {
                if ($classNameLength > $moduleNameLength && 0 === strrpos($className, $moduleName)) {
                    $resultModuleName = $moduleName;
                    break;
                }
            }
            $this->classNameToModuleName[$className] = $resultModuleName;
        }

        return $resultModuleName;
    }
58410
public static function getClassName($className)
    {
        if (is_object($className)) {
            $className = get_class($className);
        }
        $className = array_slice(explode('\\', $className), - 1);
        return $className[0];
    }
844283
public function hasMethod($className, $methodName)
    {
        try {
            if (!array_key_exists($className, $this->classMethodNames) || !array_key_exists($methodName, $this->classMethodNames[$className])) {
                $this->getMethodReflection($className, $methodName);
                $this->classMethodNames[$className][$methodName] = true;
            }
        } catch (\ReflectionException $e) {
            // Method does not exist. Store this information in cache.
            $this->classMethodNames[$className][$methodName] = null;
        }
        return isset($this->classMethodNames[$className][$methodName]);
    }