Initializes the addons for this manager.
486909
def _initAddons(cls, recurse=True):
        
        for addon_module in cls.addonModules(recurse):
            projex.importmodules(addon_module)
424766
static void initialize() {
        if (INITIALIZED.getAndSet(true)) {
            throw new IllegalStateException("Already initialized");
        }
        // Set the default initializer if none has been provided yet.
        INITIALIZER.compareAndSet(null, new ServiceLoaderZoneRulesInitializer());
        INITIALIZER.get().initializeProviders();
    }
343781
public void init() {
        if (manifests == null) {
            manifests = new ArrayList<>();
            
            try {
                primaryManifest = addToList(applicationContext.getResource(MANIFEST_PATH));
                Resource[] resources = applicationContext.getResources("classpath*:/" + MANIFEST_PATH);

                for (Resource resource : resources) {
                    Manifest manifest = addToList(resource);
                    
                    if (primaryManifest == null) {
                        primaryManifest = manifest;
                    }
                }

            } catch (Exception e) {
                log.error("Error enumerating manifests.", e);
            }

        }
    }
893965
protected function initializeDependencies()
    {
        if ($this->persistenceManager === null) {
            $this->persistenceManager = Bootstrap::$staticObjectManager->get(PersistenceManagerInterface::class);
            $this->reflectionService = Bootstrap::$staticObjectManager->get(ReflectionService::class);
        }
    }
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);
    }
  }
509617
private void initialize() {
		this.add(getMenuFile());
		this.add(getMenuEdit());
		this.add(getMenuView());
		this.add(getMenuAnalyse());
		this.add(getMenuReport());
		this.add(getMenuTools());
		this.add(getMenuImport());
		this.add(getMenuOnline());
		this.add(getMenuHelp());

	}
537410
protected function init()
    {
        $this->addCommand(new SyncCommand());
        $this->addCommand(new MakesumCommand());

        $this->addGlobalOption('e')
            ->alias('env')
            ->description('The environment application name or class.')
            ->defaultValue('dev');
    }
1191436
protected void preloadModules() {

        // Add default ModuleModel component interface (because it cannot be added by module starter, API is not processed with annotation engine)
        JRebirthThread.getThread().getFacade().componentFactory().define(
                                                                         RegistrationPointItemBase.create()
                                                                                                  .interfaceClass(ModuleModel.class)
                                                                                                  .exclusive(false)
                                                                                                  .reverse(false));

        final ServiceLoader<ModuleStarter> loader = ServiceLoader.load(ModuleStarter.class);

        final List<ModuleStarter> modules = new ArrayList<>();
        loader.iterator().forEachRemaining(modules::add);

        modules.stream()
               .sorted((m1, m2) -> -1 * Integer.compare(m1.priority(), m2.priority()))
               .forEach(ModuleStarter::start);

    }
1041023
def _add_addon_views(self):
        
        for addon in self._addon_managers:
            addon_class = dynamic_class_import(addon)
            if addon_class:
                # Instantiate manager with appbuilder (self)
                addon_class = addon_class(self)
                try:
                    addon_class.pre_process()
                    addon_class.register_views()
                    addon_class.post_process()
                    self.addon_managers[addon] = addon_class
                    log.info(LOGMSG_INF_FAB_ADDON_ADDED.format(str(addon)))
                except Exception as e:
                    log.exception(e)
                    log.error(LOGMSG_ERR_FAB_ADDON_PROCESS.format(addon, e))
309480
public function initialize(): void
    {
        $this->twig = new Environment($this->getLoader(), $this->resolveConfig());

        $this->getEventManager()->dispatch(ConstructEvent::create($this, $this->twig));

        $this->_ext = self::EXT;

        parent::initialize();
    }
1082443
@Override
	public synchronized void initialize(Manager manager) {
		if (this.manager != null) {
			throw new IllegalStateException("Callback was already initialized");
		}
		this.manager = manager;
		for (Callback callback : callbacks) {
			try {
				callback.initialize(manager);
			} catch (Exception e) {
				onManagerWarning("Callback initialization error", e);
			}
		}
	}
44532
public function init()
    {
        // Check filepath
        if (empty($this->filepath)) {
            return;
        }

        // Get configurations
        $configs = include $this->filepath;

        // Add sidebars
        $this->addSidebars($configs);
    }
433304
def setup_addon_register(self, harpoon):
        """"""
        # Create the addon getter and register the crosshairs namespace
        self.addon_getter = AddonGetter()
        self.addon_getter.add_namespace("harpoon.crosshairs", Result.FieldSpec(), Addon.FieldSpec())

        # Initiate the addons from our configuration
        register = Register(self.addon_getter, self)

        if "addons" in harpoon:
            addons = harpoon["addons"]
            if type(addons) in (MergedOptions, dict) or getattr(addons, "is_dict", False):
                spec = sb.dictof(sb.string_spec(), sb.listof(sb.string_spec()))
                meta = Meta(harpoon, []).at("addons")
                for namespace, adns in spec.normalise(meta, addons).items():
                    register.add_pairs(*[(namespace, adn) for adn in adns])

        # Import our addons
        register.recursive_import_known()

        # Resolve our addons
        register.recursive_resolve_imported()

        return register
333737
protected void initOptions() {
        if (null != toolOptions && !optionsHaveInited) {
            for (CLIToolOptions toolOpts : toolOptions) {
                toolOpts.addOptions(options);
            }
            optionsHaveInited=true;
        }
    }
820005
private void initialize() {
		this.setOrder(EXTENSION_ORDER);
		this.customParsers = new LinkedList<>();
		this.customFetchFilters = new LinkedList<>();
		this.customParseFilters = new LinkedList<>();
		this.scanController = new SpiderScanController(this);
	}
129026
protected function initializeDependencies()
    {
        if ($this->securityContext === null) {
            $this->securityContext = Bootstrap::$staticObjectManager->get(Context::class);
        }

        if ($this->policyService === null) {
            $this->policyService = Bootstrap::$staticObjectManager->get(PolicyService::class);
        }
    }
898320
protected function init()
    {
        $this->bindContainerObjects();
        $this->metaFile = storage_path('cms/disabled.json');
        $this->loadDisabled();
        $this->loadPlugins();

        if ($this->app->runningInBackend()) {
            $this->loadDependencies();
        }
    }