Check whether the Injector has been configured to allow automatic construction of the given FQCN as a dependency

@param string $className
@return bool
189706
public function canAutoCreate($className)
    {
        foreach ($this->autoCreateWhiteList as $regex) {
            if (preg_match($regex, $className)) {
                return true;
            }
        }

        return false;
    }
934098
public function createClassConstantReference(string $className): ClassConstFetch
    {
        $nameNode = new FullyQualified($className);

        return $this->builderFactory->classConstFetch($nameNode, 'class');
    }
1315609
private function loadFixtureClass($className)
    {
        $fixture = new $className();

        if ($this->loader->hasFixture($fixture)) {
            unset($fixture);

            return;
        }

        $this->loader->addFixture(new $className());

        if ($fixture instanceof DependentFixtureInterface) {
            foreach ($fixture->getDependencies() as $dependency) {
                $this->loadFixtureClass($dependency);
            }
        }
    }
529509
private function isClassLoadable($className)
    {
        try {
            $exists = class_exists($className);
        } catch (ContextErrorException $e) {
            if ($e->getSeverity() === E_WARNING && basename($e->getFile()) === 'ClassLoader.php') {
                return false;
            }
            throw $e;
        }

        return $exists;
    }
427611
protected function build(string $classname, string $entry) : Closure
    {
        if (isset($this->dependencies[$entry])) {
            return $this->dependencies[$entry];
        }

        return function () use ($classname) {
            return $this->make($classname);
        };
    }
917318
public function hasMethod($className, $methodName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName]);
    }
164485
public function isClassAnnotatedWith($className, $annotationClassName)
    {
        if (!$this->initialized) {
            $this->initialize();
        }
        $className = $this->cleanClassName($className);

        $annotationClassName = $this->cleanClassName($annotationClassName);

        return (isset($this->annotatedClasses[$annotationClassName][$className]));
    }
1009798
public function isOperational($moduleName) {
    	if(!array_key_exists($moduleName, $this->modules_list)) {
    		if($module = fw\Module::getModuleByName($moduleName)) {
    			if($module instanceof DependentInterface) {
    				if($module->validatePrerequisites()) {
    					$this->modules_list[$moduleName] = TRUE;
    					return true;
    				} else {
    					// Do not cache the result,
    					// as they could change by the next call to the method
    					return false;
    				}
    			}
    			else {
    				$this->modules_list[$moduleName] = TRUE;
    				return true;
    			}
    		}
    		else {
    			$this->modules_list[$moduleName] = FALSE;
    		}
    	}
    	return $this->modules_list[$moduleName];
    	
    }
1146802
public static function loadClass($className)
  {
    if (!class_exists($className)) {
      $path = self::getPath($className);

      $realPath = stream_resolve_include_path($path);

      if (file_exists($realPath)) {
        require_once($realPath);

        return class_exists($className);
      }
      return false;
    } else {
      return true;
    }
  }
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;
    }
723672
private function classExists( $fqcn )
	{
		if ( isset( $this->classExists[$fqcn] ) )
			return $this->classExists[$fqcn];

		// first check if the class already exists, maybe loaded through another AnnotationReader
		if ( class_exists( $fqcn ) )
			return $this->classExists[$fqcn] = true;

		return false;
	}
884354
public function autoload($className)
    {
        if (substr($className, 0, 8) == 'PhpThumb')
        {
            $filename = $this->getCodeDir() . '/phpthumb/ThumbLib.inc.php';
            /** @noinspection PhpIncludeInspection */
            include_once $filename;
            return class_exists($className, false) || interface_exists($className, false);
        }
        return false;
    }
377316
protected function loadFactorableInstance(string $factorableClassName)
    {
        $factorable = $this->instanciateFactorable($factorableClassName);

        $factorable->setFactory($this);

        $this->injectDependancies($factorable);
        $this->injectServices($factorable);

        return $factorable;
    }
975935
public function isMethodFinal($className, $methodName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_FINAL]);
    }
500670
protected function isSuffixValid(string $className): bool
    {
        if ($this->isSourcePluginSuffixValid($className)) {
            return true;
        }

        if ($this->isTestPluginSuffixValid($className)) {
            return true;
        }

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

        return $this->cachedRoutes[$className];
    }
240545
private function shouldBeController($className) : bool
    {
        if (strpos($className, 'Controller') !== false) {
            return true;
        }

        $reflectionClass = new \ReflectionClass($className);
        $file = $reflectionClass->getFileName();

        $content = file_get_contents($file);

        if (strpos($content, '@URL') !== false) {
            return true;
        }
        return false;
    }