Bootstrap the application events.

@param \Illuminate\Contracts\Events\Dispatcher $dispatcher
@return void
551926
public function boot(Dispatcher $dispatcher)
    {
        $this->publishes(array(
            __DIR__ . '/../../config/notification.php' => config_path('notification.php'),
        ), 'config');

        $dispatcher->subscribe('Krucas\Notification\Subscriber');

        $this->app->afterResolving('blade.compiler', function ($bladeCompiler) {
            $bladeCompiler->directive('notification', function ($container = null) {
                if (strcasecmp('()', $container) === 0) {
                    $container = null;
                }

                return "<?php echo app('notification')->container({$container})->show(); ?>";
            });
        });
    }
897162
public function boot(\Neos\Flow\Core\Bootstrap $bootstrap)
    {
        $dispatcher = $bootstrap->getSignalSlotDispatcher();
        $dispatcher->connect(ConfigurationManager::class, 'configurationManagerReady', function (ConfigurationManager $configurationManager) use ($dispatcher) {
            $enabled = $configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'MOC.Varnish.enabled');
            if ((boolean)$enabled === true) {
                $dispatcher->connect('Neos\Neos\Service\PublishingService', 'nodePublished', 'MOC\Varnish\Service\ContentCacheFlusherService', 'flushForNode');
                $dispatcher->connect('Neos\Flow\Mvc\Dispatcher', 'afterControllerInvocation', 'MOC\Varnish\Service\CacheControlService', 'addHeaders');
            }
        });
    }
854245
private function bootProviders()
    {
        foreach ($this->providers as $provider) {
            if ($provider instanceof Closure) {
                $provider($this);
            } else {
                (new $provider($this))->boot();
            }
        }
    }
199661
public function boot(Router $router)
    {
        $router->middlewareGroup('checkHTTPS', [CheckHTTPS::class]);
        $router->middlewareGroup('forceHTTPS', [ForceHTTPS::class]);
        $this->loadTranslationsFrom(__DIR__.'/resources/lang/', 'LaravelHttps');
    }
143766
public function boot(Router $router)
    {
        // Tell Laravel where the views for a given namespace are located.
        $this->loadViewsFrom(base_path('vendor/aginev/acl/src/resources/views'), 'acl');

        $this->publishes([
            base_path('vendor/aginev/acl/src/resources/views') => base_path('resources/views/vendor/acl'),
        ], 'views');

        // Publish assets
        $this->publishes([
            base_path('vendor/aginev/acl/src/public') => public_path('vendor/acl'),
        ], 'public');

        // Tell Laravel where the translations for a given namespace are located.
        $this->loadTranslationsFrom(base_path('vendor/aginev/acl/src/resources/lang'), 'acl');

        $this->publishes([
            base_path('vendor/aginev/acl/src/resources/lang') => base_path('resources/lang/vendor/acl'),
        ], 'lang');

        // Merge config
        $this->mergeConfigFrom(base_path('vendor/aginev/acl/src/config/acl.php'), 'acl');

        $this->publishes([
            base_path('vendor/aginev/acl/src/config/acl.php') => config_path('acl.php'),
        ], 'config');

        // Publish migrations
        $this->publishes([
            base_path('vendor/aginev/acl/src/Database/Migrations/') => base_path('/database/migrations')
        ], 'migrations');

        // Publish seeds
        $this->publishes([
            base_path('vendor/aginev/acl/src/Database/Seeds/') => base_path('/database/seeds')
        ], 'seeds');

        // Define the ACL route middleware
        $router->middleware('acl', 'Aginev\Acl\Http\Middleware\Acl');

        /**
         * Including A Routes File From A Service Provider
         * NB! Keep this line at the very end of the method to be able to use the config at routes.php
         */
        include base_path('vendor/aginev/acl/src/Http/routes.php');
    }
654041
public function boot()
    {
        $events = array_merge_recursive(
            $this->discoveredEvents(),
            $this->listens()
        );

        foreach ($events as $event => $listeners) {
            foreach (array_unique($listeners) as $listener) {
                Event::listen($event, $listener);
            }
        }

        foreach ($this->subscribe as $subscriber) {
            Event::subscribe($subscriber);
        }
    }
103814
public function boot(Router $router)
    {
        $this->publishes([
            realpath(__DIR__ . '/../config/laravel-theme.php') => config_path('laravel-theme.php'),
        ]);
        if (!app()->runningInConsole()) {
            if (!$this->app->routesAreCached()) {
                $config = config('laravel-theme.screenshot_route');
                $router->group(array_merge(['namespace' => __NAMESPACE__], isset($config['options'])?$config['options']:[]), function ($router) use ($config){
                    $router->get((isset($config['url'])?$config['url']:'laravel-theme').'/{themeId}', 'ScreenshotController@show')->name($config['name']);
                });

            }
        }
    }
712712
public function boot(Router $router)
    {
        $this->publishes([
            __DIR__.'/Config/kbaapi.php' => config_path('kbaapi.php'),
        ], 'kbaapi_config');

        $this->loadRoutesFrom(__DIR__ . '/Routes/web.php');

        if ($this->app->runningInConsole()) {
            $this->commands([
                \Cierra\Kbaapi\Commands\KbaapiCommand::class,
            ]);
        }
    }
226381
public function boot(Router $router)
    {
        $this->publishes([
            __DIR__ . '/Config/version.php' => config_path('version.php'),
        ], 'version');

        $this->app->singleton('version', function ($app) {
            return new Version($app);
        });
    }
68744
public function boot(\Illuminate\Routing\Router $router)
    {
        // Publishing of configuration
        $this->publishes([
            $this->config => config_path('very_basic_auth.php'),
        ]);

        // Load default view/s
        $this->loadViewsFrom(__DIR__ . '/resources/views', 'very_basic_auth');

        // Register middleware
        $router->aliasMiddleware('auth.very_basic', \Olssonm\VeryBasicAuth\Http\Middleware\VeryBasicAuth::class);
    }
762176
public function boot(DispatcherContract $events)
    {
        if (method_exists('Illuminate\\Support\\ServiceProvider', 'boot')) {
            parent::boot($events);
        }

        // Publish the database migrations and seeders
        $this->publishes([
            __DIR__ . '/../database/migrations' => $this->app->databasePath() . '/migrations'
        ], 'migrations');
        $this->publishes([
            __DIR__ . '/../database/seeds' => $this->app->databasePath() . '/seeds'
        ], 'seeds');
        $this->publishes([
            __DIR__ . '/../config' => config_path()
        ], 'config');
        // TODO: Instead of publishing the views, load them up into the database using a seeder.
        $this->publishes([
            __DIR__ . '/../resources/views' => base_path('resources/views')
        ], 'views');

        // Register other providers required by this provider, which saves the caller
        // from having to register them each individually.
        $this->app->register(\Delatbabel\SiteConfig\SiteConfigServiceProvider::class);
        $this->app->register(\Delatbabel\ViewPages\Providers\TwigBridgeServiceProvider::class);
        $this->app->register(\Delatbabel\ViewPages\Providers\IlluminateViewServiceProvider::class);
    }
975502
public function boot(Router $router)
    {
        $this->publishConfigs();
        $this->bootViews();
        $this->bootAssets();
        $this->bootCommands();
        $this->publishDatabaseFiles();
        $this->registerMorphmaps();
        $this->registerBladeExtensions();
    }
1144329
public function boot(Settings $settings, Repository $config, Dispatcher $dispatcher)
    {
        $this->publishes([
            __DIR__ . '/../../../config/settings.php' => config_path('settings.php'),
        ], 'config');

        $override = $config->get('settings.override', []);

        $dispatcher->listen(
            'settings.override: app.timezone',
            function ($configKey, $configValue, $settingKey, $settingValue) {
                date_default_timezone_set($settingValue);
            }
        );

        if (count($override) > 0) {
            $this->overrideConfig($override, $config, $settings, $dispatcher);
        }
    }
725120
public function bootEloquent()
    {
        Eloquent::setConnectionResolver($this->manager);

        // If we have an event dispatcher instance, we will go ahead and register it
        // with the Eloquent ORM, allowing for model callbacks while creating and
        // updating "model" instances; however, it is not necessary to operate.
        if ($dispatcher = $this->getEventDispatcher()) {
            Eloquent::setEventDispatcher($dispatcher);
        }
    }
928807
public function boot(Router $router)
	{
		$this->setRootControllerNamespace();

		if ($this->app->routesAreCached())
		{
			$this->loadCachedRoutes();
		}
		else
		{
			$this->loadRoutes();
		}
	}
193400
public function subscribe(Dispatcher $dispatcher)
    {
        $dispatcher->listen('*.entity.created', __CLASS__.'@entityCreated');
        $dispatcher->listen('*.entity.updated', __CLASS__.'@entityUpdated');
        $dispatcher->listen('*.entity.deleted', __CLASS__.'@entityDeleted');
    }
1336099
public function boot()
    {
        $this->loader->loadManifest();

        foreach ($this->extensions as $extension) {
            try {
                $this->eventDispatcher->dispatch(new Booted($extension));

                $name = $extension->getPackage()->getName();

                $this->eventDispatcher->dispatch('extension.started', [$name, []]);
                $this->eventDispatcher->dispatch('extension.started: {$name}', [[]]);
                $this->eventDispatcher->dispatch(new ComponentStarted($name));

                $this->eventDispatcher->dispatch('extension.booted', [$name, []]);
                $this->eventDispatcher->dispatch('extension.booted: {$name}', [[]]);
                $this->eventDispatcher->dispatch(new ComponentBooted($name));
            } catch (Exception $e) {
                throw $e;
            }
        }

        $this->eventDispatcher->dispatch(new BootedAll());
        $this->eventDispatcher->dispatch('antares.extension: booted');
        $this->eventDispatcher->dispatch(new ComponentsBooted());

        $this->loader->writeManifest();
        $this->booted = true;
    }