Register the application services.
349822
public function register()
    {
        if (!defined('LARAVELSOCIAL_PATH')) {
            define('LARAVELSOCIAL_PATH', realpath(__DIR__.'/../../'));
        }

        if ($this->app->runningInConsole()) {
            $this->commands([\Acacha\LaravelSocial\Console\Commands\Social::class]);
            $this->commands([\Acacha\LaravelSocial\Console\Commands\MakeSocial::class]);
        }

        $this->app->bind('LaravelSocial', function () {
            return new \Acacha\LaravelSocial\LaravelSocial();
        });

        $this->registerSocialiteProvider();

        $this->registerSocialProviderManager();

        $this->registerConfigureSocialServicesManager();

        $this->registerOAuthApp();

        $this->registerSocialProviders();

        $this->registerLaravelSocialiteService();

        $this->registerSocialUsersRepository();
    }
600930
public function register()
    {
        $loader = \Illuminate\Foundation\AliasLoader::getInstance();

        $loader->alias('Features', \App\Facades\Features::class);

        $this->app->singleton('FeatureService', function ($app) {
            return app(\App\Services\FeatureService::class);
        });
    }
177595
public function register()
    {
        $this->app->singleton(Client\ApiClient::class, function () {

            $kollusApiClient = new Client\ApiClient(
                config('kollus.domain'),
                config('kollus.api_version'),
                config('kollus.language')
            );

            $serviceAccount = new Container\ServiceAccount([
                'key' => config('kollus.service_account.key'),
                'api_access_token' => config('kollus.service_account.api_access_token')
            ]);

            $kollusApiClient->setServiceAccount($serviceAccount);
            $kollusApiClient->connect();
            if (config('kollus.use_https')) {
                $kollusApiClient->setSchema('https');
            }

            return $kollusApiClient;
        });

        $this->app->singleton(Client\VideoGatewayClient::class, function () {

            $kollusVideoGatewayClient = new Client\VideoGatewayClient(
                config('kollus.domain'),
                config('kollus.api_version'),
                config('kollus.language')
            );

            $serviceAccount = new Container\ServiceAccount([
                'key' => config('kollus.service_account.key'),
                'custom_key' => config('kollus.service_account.custom_key'),
                'security_key' => config('kollus.service_account.security_key', null),
            ]);
            if (config('kollus.use_https')) {
                $kollusVideoGatewayClient->setSchema('https');
            }

            $kollusVideoGatewayClient->setServiceAccount($serviceAccount);
            $kollusVideoGatewayClient->connect();

            return $kollusVideoGatewayClient;
        });

        $this->app->singleton(Callback::class, function () {

            $serviceAccount = new Container\ServiceAccount([
                'key' => config('kollus.service_account.key'),
                'custom_key' => config('kollus.service_account.custom_key'),
                'security_key' => config('kollus.service_account.security_key'),
            ]);

            $kollusCallback = new Callback($serviceAccount);

            return $kollusCallback;
        });
    }
422664
public function register()
    {
        // Register 'defaultprofileimage' instance container to our defaultprofileimage object
        $this->app->singleton('defaultprofileimage', function($app)
        {
            return new DefaultProfileImage;
        });

        // Shortcut so developers don't need to add an Alias in app/config/app.php
        $this->app->booting(function()
        {
            $loader = \Illuminate\Foundation\AliasLoader::getInstance();
            $loader->alias('DefaultProfileImage', 'A6digital\Image\Facades\DefaultProfileImage');
        });
    }
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();
        }
    }
702579
public function register()
    {
        $this->registerHtmlBuilder();

        $this->registerFormBuilder();

        $this->registerAntaresFormBuilder();

        $this->registerCustomfieldsFinder();

        $this->app->alias('html', 'Antares\Html\HtmlBuilder');
        $this->app->alias('form', 'Antares\Html\FormBuilder');
    }
530708
public function register()
	{
		$this->app['db'] = function($app)
		{
			// @FIXME: this isn't pretty, but it will shim the removal of the old mysql_* calls from php
			$driver = (Config::get('dbtype') == 'mysql') ? 'pdo' : Config::get('dbtype');

			$options = [
				'driver'   => $driver,
				'host'     => Config::get('host'),
				'user'     => Config::get('user'),
				'password' => Config::get('password'),
				'database' => Config::get('db'),
				'prefix'   => Config::get('dbprefix')
			];

			return Driver::getInstance($options);
		};
	}
349738
public function register()
    {
        $this->registerInstallCommand();
        $this->registerAuthSettingsInstallCommand();
        $this->registerAuthFilesInstallCommand();
        $this->registerAuthModelInstallCommand();
        $this->registerAuthViewsInstallCommand();
        //$this->registerInstallMiddlewareCommand();
    }
1309047
public function register()
    {
        $this->app->bindShared('composer', function($app)
        {
            return new Composer($app['files'], $app['path.base']);
        });

        $this->app->bindShared('forge', function($app)
        {
           return new Forge($app);
        });

        // Register the additional service providers.
        $this->app->register('Nova\Console\ScheduleServiceProvider');
        $this->app->register('Nova\Queue\ConsoleServiceProvider');
    }
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']);
    }
139149
public function register()
    {
        $prefix = 'Rocket\Taxonomy\Repositories';
        $this->app->bind("$prefix\TermRepositoryInterface", "$prefix\TermRepository");
        $this->app->bind("$prefix\TermHierarchyRepositoryInterface", "$prefix\TermHierarchyRepository");

        $this->app['taxonomy'] = $this->app->share(
            function ($app) {
                return $app->make('\Rocket\Taxonomy\Taxonomy');
            }
        );
    }
1213158
protected function registerServices()
    {
        foreach (Antvel::bindings() as $key => $value) {
            is_numeric($key)
                ? $this->app->singleton($value)
                : $this->app->singleton($key, $value);
        }
    }
470498
public function register()
    {
        //Config
        $this->app->singleton(CoreConfig::class, function ($app) {
            return new CoreConfig();
        });

        //Facade
        $this->app->alias(CoreService::class, 'core-service');
    }
574438
public function register()
    {
        foreach (array_keys(config('modules.locations')) as $location) {
            $repository = $this->repository($location);
            $modules    = $repository->enabled();

            $modules->each(function ($module) use ($repository) {
                try {
                    $this->registerServiceProvider($repository, $module);

                    $this->autoloadFiles($module);
                } catch (ModuleNotFoundException $e) {
                    //
                }
            });
        }
    }
1134755
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/config.php', 'slack-output');

        $this->app->singleton(Service::class, function () {
            return new Service(config('slack-output'));
        });
    }
474954
public function register()
    {
        $commands = array(
            'PackageList',
            'PackageMigrate',
            'PackageMigrateRefresh',
            'PackageMigrateReset',
            'PackageMigrateRollback',
            'PackageMigrateStatus',
            'PackageSeed',
            'PackageOptimize',

            //
            'PackageMake',
            'ConsoleMake',
            'ControllerMake',
            'EventMake',
            'JobMake',
            'ListenerMake',
            'MiddlewareMake',
            'ModelMake',
            'NotificationMake',
            'PolicyMake',
            'ProviderMake',
            'MigrationMake',
            'RequestMake',
            'SeederMake',
        );

        foreach ($commands as $command) {
            $method = 'register' .$command .'Command';

            call_user_func(array($this, $method));
        }
    }
1367761
protected function registerService()
	{
	    $this->app->singleton($this->getProviderKey(), function($app)
	    {
	    	return new Service($this->getProviderKey(), null, $this->getAggregateService());
	    });
	}