Looks for and loads required class via require_once
@param $class_name
@return bool
@throws TaskManagerException
439977
public static function loadController($class_name)
    {
        foreach (self::$class_folders as $f) {
            $f = rtrim($f, '/');
            $filename = $f . '/' . $class_name . '.php';
            if (file_exists($filename)) {
                require_once $filename;
                if (class_exists($class_name)) {
                    return true;
                } else {
                    throw new TaskManagerException('file found but class ' . $class_name . ' not loaded');
                }
            }
        }

        throw new TaskManagerException('class ' . $class_name . ' not found');
    }
1194017
<T> Class<T> loadClass(String name) throws ClassNotFoundException {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        if (null == cl) {
            cl = ToHelper.class.getClassLoader();
        }
        return (Class<T>) cl.loadClass(name);
    }
722308
public function loadClass($className) {
		try {
// 			global $AUTOLOADS;
			// PHP's class' names are not case sensitive.
			$bFile = strtolower($className);

			// If the class file path is known in the our array
			if( !empty($this->classes[$bFile]) ) {
				$path	= null;
				$path	= $this->classes[$bFile];
				require_once $path;
				if( !class_exists($className, false) && !interface_exists($className, false) ) {
					throw new \Exception('Wrong use of Autoloads, the class "'.$className.'" should be declared in the given file "'.$path.'". Please use Class Loader correctly.');
				}
			}
		} catch( Exception $e ) {
			log_error($e, 'loading_class_'.$className);
		}
	}
507707
private static function splAutoloader($class_name) {
        if('Treffynnon\\Navigator' === substr(ltrim($class_name, '\\'), 0, 20)) {
            $class_path = realpath(__DIR__ . '/..') . '/' . str_replace('\\', DIRECTORY_SEPARATOR, $class_name);
            require_once $class_path . '.php';
        }
    }
13650
protected static function _GetInstance ($class_name) {
		return (isset(static::$_instanceList[$class_name])) ? static::$_instanceList[$class_name] : static::$_instanceList[$class_name] = new static($class_name);
	}
847689
public function detectController($class_name = null)
    {

        // Setup the two schemes
        if (!$class_name) {
            $class_name = $this->detectControllerClass();
        }
        $app = 'App\\Http\\Controllers\\'
            . ucfirst(Str::studly($this->dir))
            . '\\'.$class_name;
        $decoy = 'Bkwld\Decoy\Controllers\\'.$class_name;

        // Find the right one
        if (class_exists($app)) {
            return $app;
        } elseif (class_exists($decoy)) {
            return $decoy;
        }

        return false;
    }
932009
public function importsClass($class_name = NULL) {
    if ($this->useFunction || $this->useConst) {
      return FALSE;
    }
    if ($class_name) {
      foreach ($this->getDeclarations() as $declaration) {
        if ($declaration->getName()->getPath() === $class_name) {
          return TRUE;
        }
      }
      return FALSE;
    }
    else {
      return TRUE;
    }
  }
555657
public function load($class)
    {
        if ($class[0] == '\\') $class = substr($class, 1);
        $class = str_replace(array('\\', '_'), DIRECTORY_SEPARATOR, $class).'.php';

        foreach ($this->directories as $directory)
        {
            if (file_exists($path = $directory.DIRECTORY_SEPARATOR.$class))
            {
                require_once $path;
                return true;
            }
        }
        return false;
    }
499615
public static @CheckForNull Class<?> _findLoadedClass(ClassLoader cl, String name) {
        synchronized (getClassLoadingLock(cl, name)) {
            return (Class) invoke(FIND_LOADED_CLASS, RuntimeException.class, cl, name);
        }
    }
717055
protected function loadTask($task_name) {
		try {
			if (file_exists($this->root_path . $task_name .'.php')) {
				$task = include $this->root_path . $task_name .'.php';
				if($task instanceof AbstractTask) {
				    $task->setProvider($this);
					return $task;
				}
			}
		}
		catch(\Exception $ex) { }
		
		return null;
	}
606194
public static function load($class)
    {
        $class = static::normalizeClass($class);

        foreach (static::$directories as $directory)
        {
            if (file_exists($path = $directory.DIRECTORY_SEPARATOR.$class))
            {
                require_once $path;

                return true;
            }
        }
        return false;
    }
1230021
public function loadClass($className)
    {
        if (null === $this->_namespace || $this->_namespace.$this->_namespaceSeparator === substr($className, 0, strlen($this->_namespace.$this->_namespaceSeparator))) {
            $fileName = '';
            $namespace = '';
            if (false !== ($lastNsPos = strripos($className, $this->_namespaceSeparator))) {
                $namespace = substr($className, 0, $lastNsPos);
                $className = substr($className, $lastNsPos + 1);
                $fileName = str_replace($this->_namespaceSeparator, DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
            }
            $fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . $this->_fileExtension;
            $filePath = ($this->_includePath !== null ? $this->_includePath . DIRECTORY_SEPARATOR : '') . $fileName;

            if (file_exists($filePath)) {
                require $filePath;
            }
        }
    }
866067
static function load($class_name)
    {
        if (stream_resolve_include_path(
            "modules/archi/includes/".$class_name.".class.php"
        )) {
            include_once "modules/archi/includes/".$class_name.".class.php";
        } else if (stream_resolve_include_path(
            __DIR__."/frameworkClasses/".$class_name.".class.php"
        )) {
            include_once __DIR__."/frameworkClasses/".$class_name.".class.php";
        }
    }
921085
public function load($className)
    {
        if (isset($this->_classes[$className])) {
            $file = $this->_classes[$className];
            if (!is_file($file)) {
                trigger_error(strtr('load `:class` class failed: `:file` is not exists.', [':class' => $className, ':file' => $file]), E_USER_ERROR);
            }

            //either linux or phar://
            if (PHP_EOL === "\n" || $file[0] === 'p') {
                /** @noinspection PhpIncludeInspection */
                require $file;
            } else {
                $this->requireFile($file);
            }

            return true;
        }

        /** @noinspection LoopWhichDoesNotLoopInspection */
        foreach ($this->_namespaces as $namespace => $path) {
            if (strpos($className, $namespace) !== 0) {
                continue;
            }

            $file = $path . strtr(substr($className, strlen($namespace)), '\\', '/') . '.php';
            if (is_file($file)) {
                //either linux or phar://
                if (PHP_EOL === "\n" || $file[0] === 'p') {
                    /** @noinspection PhpIncludeInspection */
                    require $file;
                } else {
                    $this->requireFile($file);
                }

                return true;
            }
        }

        return false;
    }
686163
public static function create($class_name, $method_name) {
    if (is_string($class_name)) {
      $class_name = NameNode::create($class_name);
    }
    /** @var ClassMethodCallNode $node */
    $node = new static();
    $node->addChild($class_name, 'className');
    $node->addChild(Token::doubleColon());
    $node->addChild(Token::identifier($method_name), 'methodName');
    $node->addChild(Token::openParen(), 'openParen');
    $node->addChild(new CommaListNode(), 'arguments');
    $node->addChild(Token::closeParen(), 'closeParen');
    return $node;
  }
1202063
public function getRowsByClass($class_name)
    {
        $rows = array();
        foreach ($this->extra_rows as $row) {
            if ($row instanceof $class_name) {
                $rows[] = $row;
            }
        }

        return $rows;
    }
156844
public void require(Namer packageNamer, Namer classNamer) {
        requireFirstTime(packageNamer.getPackageName() + "." + classNamer.getType());
    }