Initialize all registered loaders
494116
private function initialize()
    {

        if (is_file($file = getcwd().'/vendor/autoload.php')) {
            include_once $file;
        }
        $functions = spl_autoload_functions();
        foreach ($functions as $loader) {
            if (is_array($loader)) {
                $ob = $loader[0];
                if (is_object($ob)) {
                    $this->addAutoloader($ob);
                }
            }
        }
    }
381667
public void registerLoaderIndicators(By... loaderIndicators) {
    	for(By locator : loaderIndicators) {
    		log.debug("Registered loader: " + locator);
    		this.expectedGlobalConditions.add(new ExpectedWebElementCondition(locator));
    	}
    }
331509
public function boot()
    {
        $this->getContainer()
            ->addProvider(ArraySerializerProvider::class)
            ->addProvider(JsonSerializerProvider::class)
            ->addProvider(CompressorProvider::class)
            ->addProvider(ArrayCacheDriver::class);
    }
495649
public static function initialize() {
		if( static::isInitialized() ) { return; }
		static::$initialized = true;

		$routes = array();

		// TODO: Add cache, but what kind of ?

		static::loadRoutes($routes);

		// Register routes
		foreach( $routes as $type => $typeRoutes ) {
			$routeClass = RequestHandler::getRouteClass($type);
			if( !class_exists($routeClass, true) || !in_array(get_class(), class_parents($routeClass)) ) {
				continue;
			}
			foreach( $typeRoutes as $routeName => $routeConfig ) {
				$routeClass::registerConfig($routeName, $routeConfig);
			}
		}
	}
354701
public static function init() {
		if ( ! isset( self::$instance ) && ! ( self::$instance instanceof Loader ) ) {
			self::$instance = new Loader();
			$modules        = array_merge( self::$available_modules, apply_filters( 'themeisle_sdk_modules', [] ) );
			foreach ( $modules as $key => $module ) {
				if ( ! class_exists( 'ThemeisleSDK\\Modules\\' . ucwords( $module, '_' ) ) ) {
					unset( $modules[ $key ] );
				}
			}
			self::$available_modules = $modules;
		}
	}
917584
public void initialise(File[] files, ClassLoader loader) throws MalformedURLException {
        _loader= loader;
        
        // TODO: remove this debugging stuff
        _filters= new LinkedList<IFilter>();
        _filters.add(new IgnoreFilter());
        _filters.add(new ServiceFilter());
//        _filters.add(new AgentElementFilter());
//        _filters.add(new NodeFilter());
//        _filters.add(new AgentFilter());
        
        // initialise enumerators
        _classEnumerations= new LinkedList<Enumeration<Class<?>>>();
        for(File current : files) {
            if(current.isDirectory()) {
                _classEnumerations.add(new DirectoryClassEnumerator(current, _loader));
            } else {
                _classEnumerations.add(new ArchiveClassEnumerator(current, _loader));
            }
        }
    }
1371485
private function registerDefaultWebLoaders()
    {
        if (function_exists('curl_init')) {
            $this->loaders['https'] = new CurlWebLoader('https://');
            $this->loaders['http']  = new CurlWebLoader('http://');
        } else {
            $this->loaders['https'] = new FileGetContentsWebLoader('https://');
            $this->loaders['http']  = new FileGetContentsWebLoader('http://');
        }
    }
933028
def reload(self):
        """"""
        for loader in self._loaders:
            loader.reload()

        self.varz = {}  # reset varz
        self._load()
891501
private function initDataProviders()
    {
        $this->dataProviders = [];

        foreach ($this->loadDataProviders() as $name => $dataProvider) {
            $this->dataProviders[$name] = $dataProvider;
        }
    }
831821
protected function initNamespace()
    {
        $namespaces = $this->config->get('namespaces', null);

        if ($namespaces !== null) {
            foreach ($namespaces as $namespace => $path) {
                $this->loader->registerNamespaces([$namespace => $path], true);
            }
            $this->loader->register();
            $this->di->set('loader', $this->loader);
        }
    }
468789
protected function loadInits()
    {
        $this->hook->trigger(self::HOOK_LOAD_INITS_BEFORE);

        if ($this->config->get('parable.inits')) {
            $initLoader = \Parable\DI\Container::create(\Parable\Framework\Loader\InitLoader::class);
            $initLoader->load($this->config->get('parable.inits'));
        }

        $this->hook->trigger(self::HOOK_LOAD_INITS_AFTER);
        return $this;
    }
921851
public static void init(ClassLoader loader)
  {
    for (; loader != null; loader = loader.getParent()) {
      if (loader instanceof EnvironmentClassLoader) {
        ((EnvironmentClassLoader) loader).init();
        return;
      }
    }

    for (int i = 0; i < _globalLoaderListeners.size(); i++) {
      EnvLoaderListener listener = _globalLoaderListeners.get(i);

      listener.classLoaderInit(null);
    }
  }
717903
function initialize(done) {
		debug('prepare');

		parser(options.index, options, function(err,  modules) {
			if(err) return done(err)

			debug('Parser return, now build the tree...');
			tree          = buildTree(options, modules, true);

			debug('Tree builded');

			// Extract from tree as a flatten list of packets to compile
			packets       = tree.getAllBundles(options);

			done(null);
		})

	}
245424
public static final void init(final CClassLoaderConfig config) {
		CClassLoader.installURLStreamHandlerFactory();
		if (CClassLoader.getRootLoader().isInit()) {
			return;
		}

		// initialize the loaders default parameters.
		for (final Iterator it = config.getLoadersInfoMap().entrySet()
				.iterator(); it.hasNext();) {
			final Map.Entry entry = (Map.Entry) it.next();
			final String loaderPath = (String) entry.getKey();
			final CClassLoaderConfig.CLoaderInfo info = (CClassLoaderConfig.CLoaderInfo) entry
					.getValue();
			final CClassLoader loader = CClassLoader.getLoader(loaderPath);
			loader.config = config;
			loader.booAlone = info.isAlone();
			loader.booDoNotForwardToParent = info.isDoNotForwardToParent();
			loader.booMandatory = info.isMandatory();

			if (loader.isMandatory()) {
				CClassLoader.mandatoryLoadersMap.put(loader.getPath(), loader);
			}

			loader.booResourceOnly = info.isResourceOnly();
		}
		// lookup classes/resources in filesystem
		for (final Iterator it = config.getFilesMap().entrySet().iterator(); it
				.hasNext();) {
			final Map.Entry entry = (Map.Entry) it.next();
			final String loaderPath = (String) entry.getKey();
			final List list = (List) entry.getValue();
			final CClassLoader loader = CClassLoader.getLoader(loaderPath);

			for (final Iterator f = list.iterator(); f.hasNext();) {
				final Object obj = f.next();
				if (obj instanceof URL) {
					final URL file = (URL) obj;
					String name = file.toString();
					final int index = name.indexOf(loaderPath);
					if (index != -1) {
						name = name.substring(index + loaderPath.length());
					}
					if (name.endsWith(".jar")) {
						loader.addResource(name, file);
						loader.readDirectories(file);
					} else {
						loader.addResource(name, file);
						if (!loader.booResourceOnly && name.endsWith(".class")) {
							name = name.substring(0, name.lastIndexOf('.'));
							name = name.replace('\\', '/');
							name = name.replace('/', '.');
							loader.addClass(name, file);
						} else if (name.startsWith("native/")) {
							String system = name.substring(7);
							system = system.substring(0, system.indexOf('/'));
							if (!loader.dllMap.containsKey(system)) {
								loader.dllMap.put(system, file);
							}
							if (!loader.resourcesMap.containsKey(name)) {
								loader.resourcesMap.put(name, file);
							} else {
								final Object to = loader.resourcesMap.get(name);
								if (to instanceof URL) {
									final URL uo = (URL) to;
									final List l = new ArrayList();
									l.add(uo);
									l.add(file);
									loader.resourcesMap.put(name, l);
								} else if (to instanceof List) {
									final List uo = (List) to;
									uo.add(file);
									loader.resourcesMap.put(name, uo);
								}
							}
						}
					}
				}
			}
		}

		// set init state
		CClassLoader.setInit(CClassLoader.getRootLoader());
	}
314849
def init_backend(self, *args, **kwargs):
        """"""
        self.model.attrs = {}

        self.use_memory_cache = kwargs.get('use_memory_cache', True)
        if self.use_memory_cache:
            self.init_memory_cache()
        self.use_disk_cache = kwargs.get('use_disk_cache', False)
        if self.use_disk_cache:
            self.init_disk_cache()
        self.load_model()
        self.model.unpicklable += ['_backend']
586513
private function initialize()
    {
        $this->extension = 'module';
        $this->extensions = [
            'module' => [],
            'theme' => [],
            'profile' => [],
        ];
        $this->filters = [
            'showInstalled' => false,
            'showUninstalled' => false,
            'showCore' => false,
            'showNoCore' => false
        ];
    }
1344122
protected function initialize() {
		foreach ( $this->apply_filters( 'filter', $this->app->config->load( 'filter' ) ) as $class => $tags ) {
			$this->register_class_filter( $class, $tags );
		}
	}