Bootstraps this factory with a Configuration and a ComponentRegistry.
435393
private void bootstrap(String cacheName, AdvancedCache<?, ?> cache, Configuration configuration,
                          GlobalComponentRegistry globalComponentRegistry, StreamingMarshaller globalMarshaller) {
      this.configuration = configuration;

      // injection bootstrap stuff
      componentRegistry = new ComponentRegistry(cacheName, configuration, cache, globalComponentRegistry, globalComponentRegistry.getClassLoader());

      EncoderRegistry encoderRegistry = globalComponentRegistry.getComponent(EncoderRegistry.class);

      // Wraps the compatibility marshaller so that it can be used as a transcoder
      if (configuration.compatibility().enabled() && configuration.compatibility().marshaller() != null) {
         Marshaller marshaller = configuration.compatibility().marshaller();
         componentRegistry.wireDependencies(marshaller);
         if (!encoderRegistry.isConversionSupported(MediaType.APPLICATION_OBJECT, marshaller.mediaType())) {
            encoderRegistry.registerTranscoder(new TranscoderMarshallerAdapter(marshaller));
         }
      }

      // Wraps the GlobalMarshaller so that it can be used as a transcoder
      encoderRegistry.registerTranscoder(new TranscoderMarshallerAdapter(globalMarshaller));

      /*
         --------------------------------------------------------------------------------------------------------------
         This is where the bootstrap really happens.  Registering the cache in the component registry will cause
         the component registry to look at the cache's @Inject methods, and construct various components and their
         dependencies, in turn.
         --------------------------------------------------------------------------------------------------------------
       */
      basicComponentRegistry = componentRegistry.getComponent(BasicComponentRegistry.class);
      basicComponentRegistry.registerAlias(Cache.class.getName(), AdvancedCache.class.getName(), AdvancedCache.class);
      basicComponentRegistry.registerComponent(AdvancedCache.class.getName(), cache, false);

      componentRegistry.registerComponent(new CacheJmxRegistration(), CacheJmxRegistration.class.getName(), true);
      if (configuration.transaction().recovery().enabled()) {
         componentRegistry.registerComponent(new RecoveryAdminOperations(), RecoveryAdminOperations.class.getName(), true);
      }
      if (configuration.sites().hasEnabledBackups()) {
         componentRegistry.registerComponent(new XSiteAdminOperations(), XSiteAdminOperations.class.getName(), true);
      }
      // The RollingUpgradeManager should always be added so it is registered in JMX.
      componentRegistry.registerComponent(new RollingUpgradeManager(), RollingUpgradeManager.class.getName(), true);
   }
727343
public function boot()
    {
        $this->registerMorphs();
        $this->setTablePrefix();
        $this->setUserModel();

        $this->registerAtGate();

        if ($this->runningInConsole()) {
            $this->publishMiddleware();
            $this->publishMigrations();
        }
    }
699756
public function bootstrap()
    {
        if ( ! $this->app->hasBeenBootstrapped())
            $this->app->bootstrapWith($this->bootstrappers);
        $this->app->loadDeferredProviders();
    }
799917
public function boot()
    {
        // Assets
        $this->publishes([
            __DIR__.'/../public/jquery-file-upload' => public_path('vendor/flare/jquery-file-upload'),
            __DIR__.'/../public/js' => public_path('vendor/flare/js'),
        ], 'public');

        // Config
        $this->publishes([
            __DIR__.'/../config/flare/media.php' => config_path('flare-config/media.php'),
        ]);

        // Migrations
        $this->publishes([
            __DIR__.'/Database/Migrations' => base_path('database/migrations'),
        ]);

        // Views
        $this->loadViewsFrom(__DIR__.'/../resources/views', 'flare');
        $this->publishes([
            __DIR__.'/../resources/views' => base_path('resources/views/vendor/flare'),
        ]);

        $this->registerBladeOperators();
    }
644181
public function boot()
    {
        if ($this->booted) {
            return;
        }

        $this->booted = true;

        foreach ($this->providers as $provider) {
            if ($provider instanceof EventListenerProviderInterface) {
                $provider->subscribe($this, $this['dispatcher']);
            }

            if ($provider instanceof BootableProviderInterface) {
                $provider->boot($this);
            }
        }
    }
1204109
public function bootstrap()
    {

        // setup autoloader
        require SERVER_AUTOLOADER;

        // make the application available and register the class loaders
        $application = $this->application;
        $application->registerClassLoaders();

        // register the applications annotation registries
        $application->registerAnnotationRegistries();

        // add the application instance to the environment
        Environment::singleton()->setAttribute(EnvironmentKeys::APPLICATION, $application);

        // create s simulated request/session ID whereas session equals request ID
        Environment::singleton()->setAttribute(EnvironmentKeys::SESSION_ID, $sessionId = SessionUtils::generateRandomString());
        Environment::singleton()->setAttribute(EnvironmentKeys::REQUEST_ID, $sessionId);

        // try to load the profile logger
        if (isset($this->loggers[$profileLoggerKey = \AppserverIo\Logger\LoggerUtils::PROFILE])) {
            $this->profileLogger = $this->loggers[$profileLoggerKey];
            $this->profileLogger->appendThreadContext('timer-service-executor');
        }
    }
783649
protected function bootConfiguration(): void
    {
        $config = $this->app->make('config');
        $namespace = $this->hasPackageRepository() ? 'orchestra/html::' : 'orchestra.';

        $this->app->make('orchestra.form')->setConfig($config->get("{$namespace}form"));
        $this->app->make('orchestra.table')->setConfig($config->get("{$namespace}table"));
    }
947643
public function boot()
    {
        if ($this->booted) return;

        // Register service providers
        foreach ($this['config']->get('app.providers') as $provider) {
            $this->addProvider($provider);
        }

        // Register aliases
        AliasLoader::getInstance($this['config']->get('app.aliases'))->register();

        // Now run boot events on service providers
        array_walk($this->registered, function($p) {
            if (method_exists($p, 'boot')) $p->boot();
        });

        if (file_exists($bootstrap = $this->appPath."/bootstrap/{$this->mode}.php")) {
            require $bootstrap;
        }

        $this->booted = true;
    }
359762
public function boot()
    {
        // Load configs files and publish them
        $path = __DIR__ . '/../../config';
        $this->loadYamlFrom($path, $this->namespace, $this->publish);

        // Load more configs and aliases
        parent::boot();
    }
986801
public function boot(): void
	{
		$fileSystem = $this->container->get(FileSystem::class);

		// Register configuration namespace

		if($fileSystem->isDirectory($path = $this->getConfigPath()))
		{
			$configLoader = $this->container->get(Config::class)->getLoader();

			if(in_array(NamespacedFileLoaderTrait::class, class_uses($configLoader)))
			{
				$configLoader->registerNamespace($this->getFileNamespace(), $path);
			}
		}

		// Register i18n namespace

		if($fileSystem->isDirectory($path = $this->getI18nPath()) && $this->container->has(I18n::class))
		{
			$i18nLoader = $this->container->get(I18n::class)->getLoader();

			if(in_array(NamespacedFileLoaderTrait::class, class_uses($i18nLoader)))
			{
				$i18nLoader->registerNamespace($this->getFileNamespace(), $path);
			}
		}

		// Register view namespace

		if($fileSystem->isDirectory($path = $this->getViewPath()) && $this->container->has(ViewFactory::class))
		{
			$this->container->get(ViewFactory::class)->registerNamespace($this->getFileNamespace(), $path);
		}

		// Bootstrap package

		$this->bootstrap();
	}
1333954
public function boot()
    {
        $this->publishes([
            __DIR__ . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 'config' . DIRECTORY_SEPARATOR .'config.php' => config_path('jsonapi.php'),
        ]);

        $this->configureJsonApiRequests();
        $this->registerExceptionHandler();
    }
510472
public function boot()
    {
        foreach ($this->registry->getManagers() as $em) {
            $this->em       = $em;
            $this->chain    = new MappingDriverChain();
            $this->evm      = $this->em->getEventManager();
            $this->metadata = $this->em->getConfiguration();
            $this->reader   = method_exists($this->metadata->getMetadataDriverImpl(), 'getReader')
                ? $this->metadata->getMetadataDriverImpl()->getReader()
                : false;

            if ($this->gedmo['enabled']) {
                $this->bootGedmoExtensions($this->gedmo['namespace'], $this->gedmo['all']);
            }

            foreach ($this->extensions as $extenion) {
                $this->bootExtension($extenion);
            }
        }
    }
1113766
public function bootStrap()
    {
        $this->initEnvironment();
        $this->initConfig();

        if ('testing'==env('APP_ENV')) {
            error_reporting(-1);
            ini_set('display_errors', 'On');
        } else {
            error_reporting(E_ALL);
            ini_set('display_errors', 'Off');
        }

        set_error_handler([$this, 'handleError']);

        register_shutdown_function([$this, 'handleShutdown']);
    }
739287
@Constructed
	public void constructed() {
		Context context = factory.enterContext();
		
		try {
			scope = new ImporterTopLevel(context);
		} finally {
			Context.exit();
		}
		
		Container container = Jaguar.component(Container.class);
		Object store = container.component(container.contexts().get(Application.class)).store();
		
		if (store instanceof ServletContext) {
			org.eiichiro.bootleg.Configuration configuration = new DefaultConfiguration();
			configuration.init((ServletContext) store);
			this.configuration = configuration;
		}
	}
420659
public function boot()
    {
        $ns = (new \ReflectionClass($this->package))->getNamespaceName();

        RecordResolver::addNamespace($ns . '\Record');
        DataMapperResolver::addNamespace($ns . '\DataMapper');
        FieldHelper::addNamespace($ns . '\Field');
        ValidatorHelper::addNamespace($ns . 'Validator');
        // FieldDefinitionResolver::addNamespace($ns . '\Form');
    }
426095
public function boot()
    {
        $this->setupConfig();

        if ($this->app->runningInConsole()) {
            $this->commands([
                TransformerMakeCommand::class,
            ]);
        }

        $this->setupMacro();
    }
199857
public function bootstrap()
    {

        // register the default autoloader
        require SERVER_AUTOLOADER;

        // synchronize the application instance and register the class loaders
        $application = $this->application;
        $application->registerClassLoaders();

        // register the applications annotation registries
        $application->registerAnnotationRegistries();

        // create a reference to the workers/messages
        $workers = $this->workers;
        $messages = $this->messages;
        $managerSettings = $this->managerSettings;

        // try to load the profile logger
        if ($this->profileLogger = $application->getInitialContext()->getLogger(LoggerUtils::PROFILE)) {
            $this->profileLogger->appendThreadContext(sprintf('message-queue-%s', $this->getName()));
        }

        // prepare the storages
        $jobsToExceute = array();

        // initialize the counter for the storages
        $counter = 0;

        // create a separate queue for each priority
        foreach (PriorityKeys::getAll() as $priorityKey) {
            // create the containers for the worker
            $jobsToExceute[$counter] = new GenericStackable();

            // initialize and start the queue worker
            $queueWorker = new QueueWorker();
            $queueWorker->injectMessages($messages);
            $queueWorker->injectApplication($application);
            $queueWorker->injectPriorityKey($priorityKey);
            $queueWorker->injectManagerSettings($managerSettings);

            // attach the storages
            $queueWorker->injectJobsToExecute($jobsToExceute[$counter]);

            // start the worker instance
            $queueWorker->start();

            // add the queue instance to the module
            $workers[$this->uniqueWorkerName($priorityKey)] = $queueWorker;

            // raise the counter
            $counter++;
        }
    }