@param string $className

@return bool
432732
private function checkDoNotHaveRequiredParametersOnCreate(string $className): bool
    {
        try {
            $reflection  = new ReflectionClass($className);
            if ($reflection->isInstantiable() === false) {
                throw new InvalidSettingsClassException($className);
            }
            if (($constructor = $reflection->getConstructor()) !== null) {
                foreach ($constructor->getParameters() as $parameter) {
                    if ($parameter->isOptional() === false && $parameter->isDefaultValueAvailable() === false) {
                        // there is no default constructor
                        throw new InvalidSettingsClassException($className);
                    }
                }
            }
        } catch (ReflectionException $exception) {
            throw new InvalidSettingsClassException($className, 0, $exception);
        }

        return true;
    }
315579
public function removeClass($classname)
    {
        $classArr = array_diff($this->getClassArray(), [$classname]);
        return $this->setClassArray($classArr);
    }
990009
public function matchesMethod($className, $methodName): bool
    {
        $this->initialize();

        $methodIdentifier = strtolower($className . '->' . $methodName);
        if (isset(static::$methodPermissions[$methodIdentifier][$this->getCacheEntryIdentifier()])) {
            return true;
        }

        return false;
    }
167402
public function isTransient($className)
    {
        foreach ($this->drivers as $driver) {
            if (false !== $driver->isTransient($className)) {
                return true;
            }
        }

        return false;
    }
1363317
public function loadClass( $className )
	{
		if( $this->prefix )
		{
			$prefix	= strtolower( substr( $className, 0, strlen( $this->prefix ) ) );
			if( $prefix != $this->prefix )
				return FALSE;
			$className	= str_ireplace( $this->prefix, '', $className );
		}
		$basePath		= $this->path ? $this->path : "";
		if( $this->lowerPath )
		{
			$matches	= array();
			preg_match_all( '/^(.*)([a-z0-9]+)$/iU', $className, $matches );
			$fileName	= $matches[2][0];
			$pathName	= str_replace( "_","/", strtolower( $matches[1][0] ) );
			$fileName	= $pathName.$fileName;
		}
		else
			$fileName	= str_replace( "_","/", $className );
		foreach( $this->extensions as $extension )
		{
			$filePath	= $basePath.$fileName.".".$extension;
			if( $this->verbose > 1 )
				echo $this->lineBreak."autoload: ".$filePath;
			if( defined( 'LOADER_LOG' ) && LOADER_LOG )
				error_log( $filePath."\n", 3, LOADER_LOG );
#			if( !@fopen( $filePath, "r", TRUE ) )
			if( !file_exists( $filePath ) )
#			if( !is_readable( $filePath ) )
				continue;
			$this->loadFile( $filePath, TRUE );
			return TRUE;
		}
		return FALSE;
	}
1038105
private function classNameMatchesFileName(string $filename, string $className): bool
    {
        return strpos($filename, $className) !== false
            || strpos($filename, $this->invertSlashes($className)) !== false;
    }
679046
public function isTransient($className)
    {
        $fileName = str_replace('\\', '.', $className) . $this->fileExtension;

        // Check whether file exists
        foreach ((array) $this->paths as $path) {
            if (file_exists($path . DIRECTORY_SEPARATOR . $fileName)) {
                return false;
            }
        }

        return true;
    }
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;
    }
33438
protected function checkClassForCompability( $className ) {
    $result = $className;
    if( isset( DeferredExceptionsGlobal::$defExcClasses [$className])){
       if( ! DeferredExceptionsGlobal::$defExcClasses [$className] ){
         $result = null;
       }
    } else {
      if( ! class_exists( $className ) || ! is_subclass_of( $className, 'Exception')) {
        DeferredExceptionsGlobal::$defExcClasses [$className] = false;
        $result = null;
      } else {
        DeferredExceptionsGlobal::$defExcClasses [$className] = true;
      }
    }
    return $result;
  }
1206213
public function loadClass($className)
    {
        $className = ltrim($className, '\\');

        $namespaceParts = explode('\\', $className);
        // Workaround for Doctrine's annotation parser which does a class_exists() for annotations like "@param" and so on:
        if (isset($this->ignoredClassNames[$className]) || isset($this->ignoredClassNames[end($namespaceParts)])) {
            return false;
        }

        // Loads any known proxied class:
        if ($this->classesCache !== null && ($this->availableProxyClasses === null || isset($this->availableProxyClasses[implode('_', $namespaceParts)])) && $this->classesCache->requireOnce(implode('_', $namespaceParts)) !== false) {
            return true;
        }

        return false;
    }
1283888
public function hasClass($className)
    {
        foreach ($this->meta['classes'] as $classInMeta) {
            if ($classInMeta === $className) {
                return true;
            }
        }

        return false;
    }
843779
public function hasObjectManagerByClassName($className)
    {
        $realClass = ClassUtils::getRealClass($className);

        if ($this->hasObjectManagerNameByClassName($realClass)) {
            $objectManagerName = $this->getObjectManagerNameByClassName($realClass);
            return $this->getDoctrineObjectManager()->has($objectManagerName);
        }
        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];
    }
959380
public function hasOptionsByClassName($className)
    {
        if (!$this->hasModuleNameByClassName($className)) {
            return false;
        }

        $moduleName = $this->getModuleNameByClassName($className);

        return $this->hasOptionsByModuleName($moduleName);
    }
670150
public function detect($className)
    {
        if (!empty($this->cachedRoutes[$className])) {
            return $this->cachedRoutes[$className];
        }
        $this->cachedRoutes[$className] = parent::detect($className);

        return $this->cachedRoutes[$className];
    }
783276
protected function classFile($className)
	{
		$classFile = preg_replace('#[_\\\]#', '/', $className).'.php';

		foreach ($this->_paths as $path)
		{
			$classPath = "$path/$classFile";
			if (file_exists($classPath))
			{
				return $classPath;
			}
		}
	}
509790
public static function classExists($className, $namespace)
    {
        if (class_exists($className)) {
            return $className;
        }

        // add namespace
        $className = sprintf('%s%s', static::getFormatNamespace($namespace, true), $className);

        if (class_exists($className)) {
            return $className;
        }

        return false;
    }