Bootstrap application required class
183895
protected function bootstrap()
    {
        $this->make('Sun\Bootstrap\Application')->bootstrap();

        $this->make('Sun\Bootstrap\HandleExceptions')->bootstrap();

        $this->make('Sun\Bootstrap\Route')->bootstrap();

        $this->make('Sun\Bootstrap\Provider')->bootstrap();

        $this->route = $this->make('Sun\Contracts\Routing\Route');
    }
937988
public function bootstrap(Application $app)
    {
        foreach ($app['config']->get('supports', []) as $feature => $value)
        {
            if ($value === 'automatic-feed-links')
            {
                add_theme_support($value);
            }
            else
            {
                add_theme_support($feature, $value);
            }
        }
    }
704735
public function bootstrap()
    {
        $this->_startErrorHandler();

        $routesFile = "routes.php";
        $bootstrap = "bootstrap.php";

        $router = $this->getRouter();

        $event = new Bootstrap([
            'router' => $router,
            'application' => $this
        ]);
        $this->getEventManager()
            ->trigger(Bootstrap::BEFORE_BOOTSTRAP, $this, $event);

        Template::addPath(
            getcwd() .'/'. $this->getConfiguration()
                ->get('paths.views', 'Views')
        );

        Template::appendPath(__DIR__ . '/Views');

        foreach (Configuration::getPathList() as $path) {
            if (is_file("{$path}/{$bootstrap}")) {
                include("{$path}/{$bootstrap}");
            }

            if (is_file("{$path}/{$routesFile}")) {
                include("{$path}/{$routesFile}");
            }
        }
        $this->getEventManager()
            ->trigger(Bootstrap::AFTER_BOOTSTRAP, $this, $event);
    }
450772
public void runAfterApplicationCreateBootstrap(
      Instrumentation instrumentation, String[] bootstrapClasses) {
    if (!isWithExtension) {
      SelendroidLogger.error("Cannot run bootstrap. Must load an extension first.");
      return;
    }

    for (String bootstrapClassName : bootstrapClasses) {
      try {
        SelendroidLogger.info("Running afterApplicationCreate bootstrap: " + bootstrapClassName);
        loadBootstrap(bootstrapClassName).runAfterApplicationCreate(instrumentation);
        SelendroidLogger.info("\"Running afterApplicationCreate bootstrap: " + bootstrapClassName);
      } catch (Exception e) {
        throw new SelendroidException(
            "Cannot run bootstrap " + bootstrapClassName, e);
      }
    }
  }
720723
public function bootstrap(Application $app)
    {
        $uri = $app->make('config')->get('app.url', 'http://localhost');

        $components = parse_url($uri);

        $server = $_SERVER;

        if (isset($components['path'])) {
            $server = array_merge($server, [
                'SCRIPT_FILENAME' => $components['path'],
                'SCRIPT_NAME' => $components['path']
            ]);
        }

        $app->instance('request', Request::create(
            $uri,
            'GET',
            [],
            [],
            [],
            $server
        ));
    }
1149743
protected function requireClasses()
    {
        foreach ($this->classes as $classPath => $className) {

            $className = '\\' . ltrim($className, '\\');
//            if (preg_match('/dbQuery/', $className)) {
//                trace('sdf');
//            }
            if (file_exists($classPath)
                && !preg_match('/\/api\/generated\//', $className)
                && !preg_match('/activerecord\/dbQuery/', $className)
                && !preg_match('/samson\/activerecord\//', $className)
                && !preg_match('/Field.php$/', $classPath)
                && !preg_match('/Navigation.php$/', $classPath)
                && !preg_match('/TableVirtualCollection.php$/', $classPath)
                && !preg_match('/TableVirtualEntity.php$/', $classPath)
                && !preg_match('/TableVirtualQuery.php$/', $classPath)
                && !class_exists($className)
            ) {
                require_once($classPath);
            }
        }
    }
35360
public function bootstrap(Application $app)
    {
        $app['actions']->listen(
            'init',
            function () use ($app) {

                $this->extractWordpressClasses($app);

                $this->setDefaultPermalinkStructure($app);

                $this->bootstrapRoutes($app['router']);
            }
        );
    }
463445
function bootstrap (appFn) {

    // remove all the old listeners
    removeAllListeners()

    // turn the pairs into Kefir streams
    var newAppArgs = emitEventPairs.map(function (p) {
      return userFn(p[0], p[1])
    })

    // next, we try/catch executing the function
    // TODO - does this do anything?
    try {
      return appFn.apply(null, newAppArgs)
    } catch (err) {
      emitter.emit('error', err)
    }
  }
668867
def bootstrap_app():
    '''
    
    '''
    from salt.netapi.rest_cherrypy import app
    import salt.config

    __opts__ = salt.config.client_config(
            os.environ.get('SALT_MASTER_CONFIG', '/etc/salt/master'))
    return app.get_app(__opts__)
513392
public function bootstrap()
    {

        // setup autoloader
        require SERVER_AUTOLOADER;

        // enable garbage collection
        gc_enable();

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

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

        // try to load the profile logger
        if ($this->profileLogger = $this->getApplication()->getInitialContext()->getLogger(LoggerUtils::PROFILE)) {
            $this->profileLogger->appendThreadContext('startup-bean-task-garbage-collector');
        }
    }
457391
def get_config():
    
    app_module = os.getenv('APP_MODULE')
    if not app_module:
        err = 'Unable to bootstrap application APP_MODULE is not defined'
        raise x.BootstrapException(err)

    app_config = os.getenv('APP_CONFIG')
    if not app_module:
        err = 'Unable to bootstrap application APP_CONFIG is not defined'
        raise x.BootstrapException(err)

    try:
        config_class = import_string(app_config)
    except ImportError:
        err = 'Failed imported config file [{}]'
        raise x.BootstrapException(err.format(app_config))

    # and return
    config = config_class()
    return config
424361
public static synchronized void bootstrap(Application application) throws Exception {
        if (Ameba.container != null) {
            throw new AmebaException(Messages.get("info.service.start"));
        }

        app = application;
        container = Container.create(app);

        // run
        logger.info(Messages.get("info.service.start"));
        container.start();
    }
935143
public function bootstrap()
    {
        $app = Zilf::$app;
        $this->checkForSpecificEnvironmentFile($app);

        try {
            (new Dotenv($app->environmentPath(), $app->environmentFile()))->load();
        } catch (InvalidPathException $e) {
            //
        } catch (InvalidFileException $e) {
            die('The environment file is invalid: ' . $e->getMessage());
        }
    }
67826
protected function bootstrap()
    {
        foreach (static::$bootstrappers as $bootstrapper) {
            try{
                $bootstrapper($this);
            }catch (\Exception $e){
                echo $e->getMessage();
            }
        }
    }
1198597
private function registerAppNamespace()
    {
        // get app namespace
        $namespace = $this->applicationConfig->get('Application.Namespace', false);
        if (!$namespace) {
            throw new BootstrapException('Unable to register application namespace. You must define the application namespace in your App.yaml config file.');
        }

        try{
            // register the namespace
            ClassLoader::getInstance()->registerMap([$namespace => $this->applicationAbsolutePath.'App']);
        }catch (\Exception $e){
            throw new BootstrapException('Unable to register application ('.$namespace.' => '.$this->applicationAbsolutePath.'App'.') namespace with ClassLoader.');
        }

    }
699756
public function bootstrap()
    {
        if ( ! $this->app->hasBeenBootstrapped())
            $this->app->bootstrapWith($this->bootstrappers);
        $this->app->loadDeferredProviders();
    }
627938
public function bootstrap(): void
    {
        foreach ($this->bootstrap as $mixed) {
            $component = null;
            if ($mixed instanceof \Closure) {
                $this->debug('Bootstrap with Closure', __METHOD__);
                if (empty($component = call_user_func($mixed, $this))) {
                    continue;
                }
            } elseif (is_string($mixed)) {
                if ($this->has($mixed)) {
                    $component = $this->get($mixed);
                } elseif ($this->hasModule($mixed)) {
                    $component = $this->getModule($mixed);
                } elseif (strpos($mixed, '\\') === false) {
                    throw new InvalidConfigException("Unknown bootstrapping component ID: $mixed");
                }
            }

            if (!isset($component)) {
                $component = $this->createObject($mixed);
            }

            if ($component instanceof BootstrapInterface) {
                $this->debug('Bootstrap with ' . get_class($component) . '::bootstrap()', __METHOD__);
                $component->bootstrap($this);
            } else {
                $this->debug('Bootstrap with ' . get_class($component), __METHOD__);
            }
        }
    }