bootTymlyServices
502972
async function bootTymly (options, messages) {
  const loadedComponents = loadComponents(
    options,
    messages
  )

  preBootTymlyRefResolution(
    loadedComponents,
    messages
  )

  const parsedServices = parseServices(
    loadedComponents,
    messages
  )

  const bootedServices = await bootServices(
    parsedServices,
    loadedComponents,
    options,
    messages
  )

  await postBootTymlyRefResolution(
    loadedComponents,
    bootedServices,
    messages
  )

  return bootedServices
}
1094126
public function boot()
	{
		if ($this->booted)
		{
			return;
		}

		array_walk($this->serviceProviders, function($p)
		{
			$this->bootProvider($p);
		});

		$this->booted = true;
	}
28045
public function boot()
    {
        $this->publishes([
            $this->basepath . "config" . DIRECTORY_SEPARATOR . EabUtilServiceProvider::CONFIG_FILENAME . ".php" => config_path(EabUtilServiceProvider::CONFIG_FILENAME . '.php')
        ]);
    }
1241846
public static function bootTask()
    {
        if (!self::isTaskBooted()) {
            self::configure();
            foreach (self::scheme() as $name => $scheme) {
                self::registerDriver($name, $scheme);
            }
        }
    }
178063
protected function bootTraits()
    {
        foreach (class_uses_recursive($this) as $trait) {
            if (method_exists($this, $method = 'boot' . class_basename($trait))) {
                $this->$method();
            }
        }
    }
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');
        }
    }
390762
static private function bootstrap()
    {
        if (self::$expressions === null) {
            $configuration = new Configuration();
            $parameters = $configuration->getConfig();
            self::$expressions = $configuration->setUp($parameters);
        }
    }
417434
private function boot()
    {
        if ($this->booted) {
            return;
        }

        $this->booted = true;

        foreach ($this->finder->findAllTemplates() as $reference) {
            $this->addTemplate($reference);
        }

        foreach (array_keys($this->bundle_paths) as $name) {
            if (false !== ($resolved_path = $this->resolveResourcePath('@' . $name))) {
                $this->aliases['@' . $name] = $resolved_path;
                $this->addPath($resolved_path);
            }
        }

        $this->profiler->set('bundles', $this->aliases);
        $this->profiler->set('templates', $this->templates);
    }
1273509
public static function bootLaratrustRoleTrait()
    {
        $flushCache = function ($role) {
            $role->flushCache();
        };

        // If the role doesn't use SoftDeletes.
        if (method_exists(static::class, 'restored')) {
            static::restored($flushCache);
        }

        static::deleted($flushCache);
        static::saved($flushCache);

        static::deleting(function ($role) {
            if (method_exists($role, 'bootSoftDeletes') && !$role->forceDeleting) {
                return;
            }

            $role->permissions()->sync([]);

            foreach (array_keys(Config::get('laratrust.user_models')) as $key) {
                $role->$key()->sync([]);
            }
        });
    }
331509
public function boot()
    {
        $this->getContainer()
            ->addProvider(ArraySerializerProvider::class)
            ->addProvider(JsonSerializerProvider::class)
            ->addProvider(CompressorProvider::class)
            ->addProvider(ArrayCacheDriver::class);
    }
96153
public function bootstrap()
    {
        $config = Zilf::$container->getShare('config');

        $this->loadConfigurationFiles($config);

        Zilf::$app->environment = $config->get('app.app_env');

        date_default_timezone_set($config->get('app.timezone', 'UTC'));

        mb_internal_encoding('UTF-8');
    }
1356104
public function boot()
    {
        /** @var Application\AbstractApplication $app */
        $app = $this->getContainer()->get(ApplicationInterface::class);

        $errorHandler = new Run(new ApplicationSystemFacade($app));
        $handlerService = new HandlerService($app);

        $errorHandler->pushHandler([$handlerService, 'recognizeErrorResponseHandler']);
        $errorHandler->pushHandler([$handlerService, 'notifySystemWithError']);
        $errorHandler->register();

        $service = new Application\Services\WhoopsService($errorHandler, $app);
        $this->getContainer()->share(Application\Services\WhoopsService::class, $service);
    }
229687
public function boot()
    {
        Blade::directive('profanity', function ($str) {
            return "<?php echo(profanity_blocker({$str})) ?>";
        });

        Blade::directive('alphanumeric', function ($str) {
            return "<?php echo(str_alphanumeric({$str})) ?>";
        });

        Blade::directive('numbers', function ($str) {
            return "<?php echo(only_numbers({$str})) ?>";
        });

        Blade::directive('phone_locale', function ($args) {
            $args = explode(', ', str_replace("'", "", $args));

            if(count($args) == 1){
                list($phone) = $args;
            }elseif(count($args) == 2){
                list($phone, $locale) = $args;
            }elseif(count($args) == 3){
                list($phone, $locale, $format) = $args;
            }else{
                return null;
            }

            $phone = isset($phone) && $phone ? $phone : 0;
            $locale = isset($locale) && $locale ? $locale : 'pt-BR';
            $format = isset($format) && $format ? $format : 'n';

            return "<?php echo(\GRGroup\GRSupport\Facades\Support::phoneFormatByLocale('{$phone}', '{$locale}', '{$format}')) ?>";
        });

        Blade::directive('agent', function ($expression) {
            return "<?php if(agent({$expression})): ?>";
        });
        Blade::directive('endagent', function () {
            return '<?php endif; ?>';
        });
    }
981201
public function boot()
    {
        foreach ($this->getFiles() as $filename) {
            $path = $this->path . '/' . $filename;
            
            if (file_exists($path)) {
                require $path;
            };
        }
    }
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);
            }
        }
    }
1350687
public void bootstrap() throws Exception {
        final HostRunningModeControl runningModeControl = environment.getRunningModeControl();
        final ControlledProcessState processState = new ControlledProcessState(true);
        shutdownHook.setControlledProcessState(processState);
        ServiceTarget target = serviceContainer.subTarget();
        ControlledProcessStateService controlledProcessStateService = ControlledProcessStateService.addService(target, processState).getValue();
        RunningStateJmx.registerMBean(controlledProcessStateService, null, runningModeControl, false);
        final HostControllerService hcs = new HostControllerService(environment, runningModeControl, authCode, processState);
        target.addService(HostControllerService.HC_SERVICE_NAME, hcs).install();
    }
164141
public function boot()
    {
        Validator::extend('uuid', function ($attribute, $value, $parameters, $validator) {
            return Uuid::validate($value);
        });
    }