Register the application services.
198424
public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/../config/referer.php', 'referer');

        $this->app->when(Referer::class)
            ->needs('$sessionKey')
            ->give(function () {
                return $this->app['config']->get('referer.session_key');
            });

        $this->app->when(Referer::class)
            ->needs('$sources')
            ->give(function () {
                return $this->app['config']->get('referer.sources', []);
            });

        $this->app->singleton(Referer::class);
        $this->app->alias(Referer::class, 'referer');
    }
1134755
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/config.php', 'slack-output');

        $this->app->singleton(Service::class, function () {
            return new Service(config('slack-output'));
        });
    }
297625
public function register()
    {
        $this->registerHtmlBuilder();

        $this->registerFormBuilder();

        $this->app->alias('html', 'Collective\Html\HtmlBuilder');
        $this->app->alias('form', 'Rokde\LaravelBootstrap\Html\BootstrapFormBuilder');
    }
1249297
protected function registerServices()
    {
        $this->app->bindShared('modules', function ($app) {
            $path = $app['config']->get('modules.paths.modules');

            return new Repository($app, $path);
        });
    }
1124230
public function register()
    {
        $this->bindRouteModel();

        $this->loadAdminAuthConfig();

        $this->registerRouteMiddleware();

        $this->registerPolicies();

        $this->commands($this->commands);
    }
782650
public function register()
    {
        $this->config = ConfigurationLoader::load($this->app);

        $this->registerServices();

        // If we want Laravel's Redis API to use Sentinel, we'll return an
        // instance of the RedisSentinelManager when requesting the "redis"
        // service:
        if ($this->config->shouldOverrideLaravelRedisApi) {
            $this->registerOverrides();
        }
    }
331426
public function register()
    {
        $this->loadViewsFrom(__DIR__.'/../../resources/views', 'sigesui');
        $this->publishes([
            __DIR__.'/../../public' => public_path(),
        ], 'sigespublic');
        $this->publishes([
            __DIR__.'/../../resources/views' => base_path('resources/views/vendor/sigesui'),
        ], 'sigesviews');
    }
400240
protected function registerServices()
    {
        foreach (self::$diMap as $serviceKey => $serviceClass) {
            if (\is_int($serviceKey)) {
                $this->register(new $serviceClass);
            } else {
                $this[$serviceKey] = function ($c) use ($serviceClass) {
                    return new $serviceClass($c);
                };
            }
        }
    }
673329
public function register(){
        //register commands
        $this->commands([
            Commands\CrudCommand::class,
            Commands\ControllerCommand::class,
            Commands\ServiceCommand::class,
            Commands\ContractCommand::class,
            Commands\ViewCommand::class,
        ]);
        //Merge config
        $this->mergeConfigFrom(
            __DIR__.'/../config/crudable.php', 'crudable'
        );
        //Load config
        $config = $this->app->make('config');
        //Check for auto binding
        if($config->get('crudable.use_auto_binding')){
            //Run contextual binding first
            foreach($config->get('crudable.implementations') as $usage){
                $this->app->when($usage['when'])
                    ->needs(isset($usage['needs'])?$usage['needs']:\Flobbos\Crudable\Contracts\Crud::class)
                    ->give($usage['give']);
            }
            //Run fixed bindings
            foreach($config->get('crudable.bindings') as $binding){
                $this->app->bind($binding['contract'],$binding['target']);
            }
        }
    }
224132
public function register() : void
    {
        $environment = $this->app->environment();

        $providers = $this->app['config']->get('app.' . $environment . '_providers', []);

        foreach ($providers as $provider) {
            $this->app->register($provider);
        }

        $facades = $this->app['config']->get('app.' . $environment . '_aliases', []);

        foreach ($facades as $class => $name) {
            AliasLoader::getInstance()->alias($class, $name);
        }
    }
1255182
public function register()
    {
        if (class_exists('\\TastPHP\\Service\\ServiceKernel')) {
            $this->app['serviceKernel'] = \TastPHP\Service\ServiceKernel::instance();
            $this->app['serviceKernel']->setContainer($this->app);
            $this->app['serviceKernel']->setConnection($this->app['dbs']);
            if (!empty($this->app['serviceKernel']->getConnection()['master'])) {
                $this->app['serviceKernel']->getConnection()['master']->exec("SET names utf8mb4");
            }
        }
    }
577991
public function register()
    {
        $this->app->register(\Webpatser\Countries\CountriesServiceProvider::class);

        $loader = \Illuminate\Foundation\AliasLoader::getInstance();
        $loader->alias('Countries', 'Webpatser\Countries\CountriesFacade');
    }
1367761
protected function registerService()
	{
	    $this->app->singleton($this->getProviderKey(), function($app)
	    {
	    	return new Service($this->getProviderKey(), null, $this->getAggregateService());
	    });
	}
1306414
public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/config/scms.php', 'scms');
        $this->initAliases();
        $this->app->register('Cviebrock\EloquentSluggable\SluggableServiceProvider');
        $this->app->register('SleepingOwl\Admin\AdminServiceProvider');
        $this->app->register('Illuminate\Html\HtmlServiceProvider');
        foreach($this->aliases as $alias => $class){
            $this->app->bind($alias, function($app){
                return new $app;
            });
        }
        include __DIR__ . '/routes.php';
    }
1091213
protected function registerBaseServices(): void
    {
        $this->services['acl'] = $this->app->make('orchestra.acl')->make('orchestra');
        $this->app->instance('orchestra.platform.acl', $this->services['acl']);

        $this->services['menu'] = $this->widget('menu');
        $this->app->instance('orchestra.platform.menu', $this->services['menu']);
    }
156642
public void register() {
        if (registration != null) {
            throw new IllegalStateException("Webapplication is already registered.");
        }
        validateNotNull(applicationName, "applicationName");
        validateNotNull(mountPoint, "mountPoint");
        Hashtable<String, Object> props = new Hashtable<String, Object>();
        props.put(Constants.APPLICATION_NAME, applicationName);
        props.put(Constants.MOUNTPOINT, mountPoint);
        props.put(Constants.CONTEXT_PARAMS, contextParam);
        registration = bundleContext.registerService(WebApplicationFactory.class, this, props);
    }
445998
public function register(): void
    {
        $this->app->register(EventServiceProvider::class);

        $this->commands([
            InstallCommand::class
        ]);

        $this->registerBindings();
    }