Default boot events.
326729
protected static function bootBootEventsTrait()
    {
        $explode = explode('\\', get_class());
        $modelName = lcfirst(str_replace('Model', '', end($explode)));

        self::saving(
            function ($album) use ($modelName) {
                Event::fire($modelName.':saving', [$album]);
            }
        );

        self::saved(
            function ($album) use ($modelName) {
                Event::fire($modelName.':saved', [$album]);
            }
        );

        self::creating(
            function ($album) use ($modelName) {
                Event::fire($modelName.':creating', [$album]);
            }
        );

        self::created(
            function ($album) use ($modelName) {
                Event::fire($modelName.':created', [$album]);
            }
        );

        self::updating(
            function ($album) use ($modelName) {
                Event::fire($modelName.':updating', [$album]);
            }
        );

        self::updated(
            function ($album) use ($modelName) {
                Event::fire($modelName.':updated', [$album]);
            }
        );

        self::deleting(
            function ($album) use ($modelName) {
                Event::fire($modelName.':eleting', [$album]);
            }
        );

        self::deleted(
            function ($album) use ($modelName) {
                Event::fire($modelName.':deleted', [$album]);
            }
        );
    }
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;
    }
465532
protected static function boot ()
    {
        parent::boot ();

        /**
         * Attach to the 'creating' Model Event to provide a UUID
         * for the `id` field (provided by $model->getKeyName())
         */
        static::creating (function ($model)
        {
            if (!isset($model->attributes['id']))
                $model->attributes['id'] = uuid4 ();

            $model->{$model->getKeyName ()} = $model->attributes['id'];
        });
    }
524078
public function boot()
    {
        $this->publishConfig();
        $this->publishMigrations();
        $this->loadMigrations();

        $this->registerGates();
        $this->registerBladeDirectives();
    }
404829
public function boot()
    {
        if (config('modules.register.translations', true) === true) {
            $this->registerTranslation();
        }

        if ($this->isLoadFilesOnBoot()) {
            $this->registerFiles();
        }

        $this->fireEvent('boot');
    }
491395
public function boot()
    {
        if (! defined("DT_STARTED")) {
            /** @deprecated  */
            define('DT_STARTED', true);
            /** @deprecated  */
            define('DT_Unique', 'Unique');
            /** @deprecated  */
            define('DT_UniqueNum', 'UniqueNumber');
            /** @deprecated  */
            define('DT_UniqueStr', 'UniqueString');
            /** @deprecated  */
            define('DT_Random', 'Random');
            /** @deprecated  */
            define('DT_RandomNum', 'RandomNumber');
            /** @deprecated  */
            define('DT_RandomStr', 'RandomString');
        }
    }
32573
public static function boot()
    {
        parent::boot();

        static::created(function(ApiKey $apiKey) {
            self::logApiKeyAdminEvent($apiKey, self::EVENT_NAME_CREATED);
        });

        static::updated(function($apiKey) {

            $changed = $apiKey->getDirty();

            if (isset($changed) && $changed['active'] === 1) {
                self::logApiKeyAdminEvent($apiKey, self::EVENT_NAME_ACTIVATED);
            }

            if (isset($changed) && $changed['active'] === 0) {
                self::logApiKeyAdminEvent($apiKey, self::EVENT_NAME_DEACTIVATED);
            }

        });

        static::deleted(function($apiKey) {
            self::logApiKeyAdminEvent($apiKey, self::EVENT_NAME_DELETED);
        });
    }
896834
public void boot() {
        LOGGER.debug("performing setup");
        checkNotConfiguredYet();
        configured = true;

        // Set the properties provider into the registry early
        // so that it is available to the modules being bootstrapped
        moduleRegistry.setPropertiesProvider(propertiesProvider);

        setupServiceUrlProvider();
        setupServiceDiscovery();
        setupQuerySpecUrlMapper();
        bootDiscovery();

        LOGGER.debug("completed setup");
    }
981201
public function boot()
    {
        foreach ($this->getFiles() as $filename) {
            $path = $this->path . '/' . $filename;
            
            if (file_exists($path)) {
                require $path;
            };
        }
    }
242381
public static function boot() {
        parent::boot();

        $myself   = get_called_class();
        $hooks    = array('before' => 'ing', 'after' => 'ed');
        $radicals = array('sav', 'validat', 'creat', 'updat', 'delet');

        foreach ($radicals as $rad) {
            foreach ($hooks as $hook => $event) {
                $method = $hook.ucfirst($rad).'e';
                if (method_exists($myself, $method)) {
                    $eventMethod = $rad.$event;
                    self::$eventMethod(function($model) use ($method){
                        return $model->$method($model);
                    });
                }
            }
        }
    }
242884
public function boot()
    {
        $app = $this->app;

        // Listen to log messages.
        $app['log']->listen(function ($level, $message, $context) use ($app) {
            $app['rollbar.handler']->log($level, $message, $context);
        });
    }
832596
public function boot()
    {
        $this->bootBlade();
        $this->bootDatatable();
        $this->bootModal();
        $this->bootMail();
        $this->bootValidator();
        $this->publish();
    }
657297
public function boot()
    {
        $app = $this->app;

        //
        $this->registerBladeExtensions();

        // boot all addons
        (new AddonRegistrar)->boot($app, $this->addonEnvironment->addons());

        $app['events']->fire(new AddonBooted($this->addonEnvironment));
    }
953637
public function boot()
    {
        parent::boot();

        $this->publishConfig();
        $this->publishFactories();

        Auth::$runsMigrations ? $this->loadMigrations() : $this->publishMigrations();
    }
868352
public function boot()
    {
        $router = $this->app->make(Router::class);
        $events = $this->app->make(Dispatcher::class);
        $kernel = $this->app->make(Kernel::class);

        $this->setExtensionPath();

        $this->registerEventListeners($events);
        $this->registerRouteMiddleware($router, $kernel);
        $this->bootConfiguration();
        $this->bootMemory();
        $this->bootExtensionComponents();
        $this->bootExtensionRouting();
        $this->bootApiRouting($router);
        $this->loadMenuFile();
        $this->loadBreadcrumbsFile();
    }
1312165
protected static function boot()
    {
        parent::boot();

        Event::listen(TranslationHasBeenSet::class, function (TranslationHasBeenSet $event) {
            $event->model->updateCustomProperty($event->key, $event->newValue);
            unset($event->model->attributes[$event->key]);
        });
    }
607221
public function boot()
    {
        $path = realpath(__DIR__ . '/../resources');
        $this->addConfigComponent('antares/memory', 'antares/memory', $path . '/config');
        if (!$this->hasPackageRepository()) {
            $this->bootUnderLaravel($path);
        }
        $this->bootMemoryEvent();
        Model\Permission::observe(new Observer\PermissionObserver());
        \Antares\Model\UserRole::observe(new Observer\PermissionObserver());
        \Antares\Model\Role::observe(new Observer\PermissionObserver());
        \Antares\Model\Action::observe(new Observer\PermissionObserver());
    }