public function register()
 {
     // Params
     set_time_limit(0);
     clearstatcache();
     // Error log
     $this->initErrorHandling();
     // External classes
     require_once $this->getCorePath() . '/classes/class.util.php';
     Util::logSeparator();
     // Autoloader
     require_once $this->getCorePath() . '/classes/class.autoloader.php';
     $neardAutoloader = new Autoloader();
     $neardAutoloader->register();
     // Load
     self::loadCore();
     self::loadConfig();
     self::loadLang();
     self::loadBins();
     self::loadTools();
     self::loadApps();
     self::loadWinbinder();
     self::loadRegistry();
     self::loadHomepage();
     // Init
     if ($this->isBootstrap) {
         $this->procs = Win32Ps::getListProcs();
     }
 }

 /**
  * Asserts that the tokenizer is used as default
  *
  * @return void
  */
 public function testAutoloaderUsesTokenizer()
 {
     $this->assertTrue(AutoloaderFileParser_Tokenizer::isSupported());
     $autoloader = new Autoloader();
     $autoloader->register();
     $autoloader->remove();
     $this->assertTrue($autoloader->getParser() instanceof AutoloaderFileParser_Tokenizer);
 }

 /**
  * @return void
  * @covers \pdepend\reflection\Autoloader
  * @group reflection
  * @group unittest
  */
 public function testAutoloaderIncludesMatchingSourceFile()
 {
     $classFixture = '\\pdepend\\reflection\\autoloader\\Test';
     if (class_exists($classFixture, false)) {
         $this->fail('Class ' . $classFixture . ' should not exist');
     }
     $autoloader = new Autoloader(__DIR__ . '/_source/');
     $autoloader->autoload($classFixture);
     $this->assertTrue(class_exists($classFixture, false), 'Class should exist ' . $classFixture);
 }

 /**
  * __construct
  *
  * Constructs the object.
  *
  * @access public
  * @param  \Pimple $pimple
  * @return void
  */
 public function __construct(\Pimple $pimple)
 {
     $this->pimple = $pimple;
     $this->config = $pimple['config'];
     $this->setReporting();
     $appDir = $this->config['general.appDir'] . 'src';
     $appLoader = new Autoloader($this->config['general.namespace'], $appDir);
     $appLoader->register();
     $this->router = new Router($this->pimple);
     $this->session = $this->pimple['session'];
     $this->session->start();
     $this->session->set('language', $this->session->get('language', $this->config['general.default_language']));
 }

 /**
  * This method will load and register a new autoloader for the system
  * multiple autoloader instances may be used.
  */
 public static function registerAutoloaders()
 {
     require_once 'Autoloader.php';
     $autoloader = new Autoloader(__NAMESPACE__, BASE);
     $autoloader->register();
     /**
      * Override Basic error handling with Whoops
      */
     $whoopsload = new Autoloader('Whoops', BASE . 'vendor' . DS . 'filp' . DS . 'whoops' . DS . 'src' . DS . '');
     $whoopsload->register();
     $wh = new \Whoops\Run();
     $wh->pushHandler(new \Whoops\Handler\PrettyPageHandler());
     $wh->register();
 }

 public static function LoadComponents()
 {
     $Components = array('Classes');
     foreach ($Components as $Component) {
         Autoloader::LoadOrder($Component);
     }
 }

 /**
  * Add a path to the class directories
  *
  * @param string        $sDir                The path to the directory
  * @param string|null    $sNamespace            The associated namespace
  * @param array         $aExcluded            The functions that are not to be exported
  *
  * @return boolean
  */
 public function addClassDir($sDir, $sNamespace = null, array $aExcluded = array())
 {
     if (!is_dir($sDir = trim($sDir))) {
         return false;
     }
     if (!($sNamespace = trim($sNamespace))) {
         $sNamespace = null;
     }
     if ($sNamespace) {
         $sNamespace = trim($sNamespace, '\\');
         // If there is an autoloader, register the dir with PSR4 autoloading
         if ($this->xAutoloader) {
             $this->xAutoloader->setPsr4($sNamespace . '\\', $sDir);
         }
     } else {
         if ($this->xAutoloader) {
             // If there is an autoloader, register the dir with classmap autoloading
             $itDir = new RecursiveDirectoryIterator($sDir);
             $itFile = new RecursiveIteratorIterator($itDir);
             // Iterate on dir content
             foreach ($itFile as $xFile) {
                 // skip everything except PHP files
                 if (!$xFile->isFile() || $xFile->getExtension() != 'php') {
                     continue;
                 }
                 $this->xAutoloader->addClassMap(array($xFile->getBasename('.php') => $xFile->getPathname()));
             }
         }
     }
     $this->aClassDirs[] = array('path' => $sDir, 'namespace' => $sNamespace, 'excluded' => $aExcluded);
     return true;
 }

 /**
  * Formats the output and saved it to disc.
  *
  * @param   string     $identifier  filename
  * @param   $contents  $contents    language array to save
  * @return  bool       \File::update result
  */
 public function save($identifier, $contents)
 {
     // store the current filename
     $file = $this->file;
     // save it
     $return = parent::save($identifier, $contents);
     // existing file? saved? and do we need to flush the opcode cache?
     if ($file == $this->file and $return and static::$flush_needed) {
         if ($this->file[0] !== '/' and (!isset($this->file[1]) or $this->file[1] !== ':')) {
             // locate the file
             if ($pos = strripos($identifier, '::')) {
                 // get the namespace path
                 if ($file = \Autoloader::namespace_path('\\' . ucfirst(substr($identifier, 0, $pos)))) {
                     // strip the namespace from the filename
                     $identifier = substr($identifier, $pos + 2);
                     // strip the classes directory as we need the module root
                     $file = substr($file, 0, -8) . 'lang' . DS . $identifier;
                 } else {
                     // invalid namespace requested
                     return false;
                 }
             } else {
                 $file = \Finder::search('lang', $identifier);
             }
         }
         // make sure we have a fallback
         $file or $file = APPPATH . 'lang' . DS . $identifier;
         // flush the opcode caches that are active
         static::$uses_opcache and opcache_invalidate($file, true);
         static::$uses_apc and apc_compile_file($file);
     }
     return $return;
 }

 public function testCacheFileCanBeManuallySaved()
 {
     Autoloader::saveCachedPaths();
     $this->assertTrue(file_exists($this->cacheFile), 'Cache file should exist');
     $this->assertTrue(filesize($this->cacheFile) > 0, 'Cache file should be non-empty');
     $this->removeCacheFile();
 }

 public function attach()
 {
     if (!isset($this->name)) {
         $this->name = Autoloader::uniqueName();
     }
     Autoloader::attach($this);
 }

 public static function initialize()
 {
     if (defined('TESTS_ENV') || self::is_dev()) {
         ini_set('display_errors', 'on');
         error_reporting(E_ALL);
     } else {
         ini_set('display_errors', 'off');
         error_reporting(0);
     }
     require_once ROOT_PATH . DS . 'common' . DS . 'classes' . DS . 'autoloader.php';
     Autoloader::init_autoload();
     FileSystemHelper::init_dirs();
     LIVR::defaultAutoTrim(true);
     /**
      * @var $system \System
      */
     $system = static::get_class(\System::class);
     $system->initialize();
     /**
      * @var $configuration Configuration
      */
     $configuration = Application::get_class(Configuration::class);
     $current_lang = $configuration->language;
     defined('CURRENT_LANG') or define('CURRENT_LANG', $current_lang);
 }

 /**
  * Test unregister method unregisters autoloader class and method properly.
  */
 public function testUnregisterRegistersAutoloaderProperly()
 {
     $this->setUpAutoloaderWithStrategy();
     $this->registerAutoloaderStrategyMock();
     $this->autoloader->unregister();
     $this->assertAutoloaderUnregistered();
 }

 public function testAutoloadValidGeodeticClass()
 {
     $className = 'Geodetic\\Angle';
     $result = Autoloader::Load($className);
     //    Check that class has been loaded
     $this->assertTrue(class_exists($className));
 }

 static function loadAutoloader($class)
 {
     spl_autoload_unregister(array(__CLASS__, __FUNCTION__));
     require PATCHWORK_PROJECT_PATH . '.patchwork.autoloader.php';
     spl_autoload_register(array('Patchwork\\Autoloader', 'loadClass'));
     Autoloader::loadClass($class);
 }

 /**
  * Well, if you want, you can use it as a singleton....
  * @return Autoloader $singleton instance
  */
 public static function getInstance()
 {
     if (self::$instance == null) {
         self::$instance = new Autoloader();
     }
     return self::$instance;
 }

 public function testLoad()
 {
     $autoloader = new Autoloader();
     $autoloader->addPath('Foo', 'src/Models');
     $autoloader->addPath('Foo', 'src/Helpers');
     $autoloader->addPath('Foo\\Selection', 'src/Models/Selection');
     $this->assertFalse($autoloader->load('Bar'));
     $this->assertFalse($autoloader->load('Foo\\Bar'));
     $this->assertTrue($autoloader->load('Foo\\Helper'));
     $this->assertTrue($autoloader->load('Foo\\Model'));
     $this->assertTrue($autoloader->load('Foo\\Selection\\SelectionBuilder'));
     // TODO: mock loadFrom and test paths etc.
 }

 public function run()
 {
     $loader = Autoloader::instance();
     pc($loader, 'loader');
     $ViewClass = $loader->view();
     $view = new $ViewClass();
     $view->render();
 }

 public static function load_class($class_name)
 {
     $filename = Autoloader::load_class_path($class_name);
     if (file_exists($filename)) {
         require $filename;
         return true;
     }
 }

 /**
  * create an autoloader instance
  *
  * @return Autoloader
  */
 public static function singleton()
 {
     if (self::$_instance instanceof self === true) {
         return self::$_instance;
     }
     self::$_instance = new self();
     return self::$_instance;
 }

 /**
  * Asserts that the class $class is loadable after
  * registration of its class definition $path
  *
  * @param String $class The class which is autoloaded
  * @param String $path  The class defintion
  * 
  * @dataProvider provideTestAutoload
  * @return void
  * @see InternalAutoloader::registerClass()
  */
 public function testAutoload($class, $path)
 {
     $autoloaderTestHelper = new AutoloaderTestHelper($this);
     Autoloader::removeAll();
     $autoloaderTestHelper->assertNotLoadable($class);
     InternalAutoloader::getInstance()->registerClass($class, $path);
     $autoloaderTestHelper->assertLoadable($class);
 }