Registers the service provider
960895
public function register()
    {
        $this->registerUploadPath();
        $this->registerAssetPath();

        $this->registerUploadService();
        $this->registerDownloadService();

        $this->registerCommands();
    }
687356
protected function registerProviders()
    {
        $providers = $this->def('provider');

        if ($providers)
        {
            if (is_array($providers))
            {
                foreach ($providers as $provider)
                {
                    $this->app->register($instance = new $provider($this->app));
                }
            }
            else
            {
                $this->app->register($instence = new $providers($this->app));
            }
        }
    }
974342
public function register() {

        // Bind the returned class to the namespace 'Ooglee\Domain\Contracts\IHashingService'
        $this->app->singleton('Ooglee\Domain\Contracts\IHashingService', function($app)
        {
            //$hasher = $this->app['config']['ioc.app.hasher'];
            $hasher = \Config::get('ooglee::ioc.app.hasher');
            //return new HashingService(new HasherExample());
            return new HashingService(new $hasher);
        });
    }
843845
public function register()
    {
        //Load helpers
        load_module_helpers(__DIR__);

        //Merge configs
        $configs = split_files_with_basename($this->app['files']->glob(__DIR__ . '/../../config/*.php'));

        foreach ($configs as $key => $row) {
            $this->mergeConfigFrom($row, $key);
        }

        $this->app->register(RouteServiceProvider::class);
        $this->app->register(BootstrapModuleServiceProvider::class);
        $this->app->register(ViewComposerServiceProvider::class);
    }
432239
def register(self, provider):
        ''''''
        if isinstance(provider,type):
            provider = provider()
        self[provider.code] = provider
779788
public function register()
	{
		// Register providers.
		$this->app['sypexgeo'] = $this->app->share(function($app)
		{
            $sypexConfig = $app['config'];
            $sypexConfigType = $sypexConfig->get('sypexgeo.sypexgeo.type', array());
            $sypexConfigPath = $sypexConfig->get('sypexgeo.sypexgeo.path', array());

			switch ($sypexConfigType){
                case ('database'):
                    $sypexConfigFile = $sypexConfig->get('sypexgeo.sypexgeo.file', array());
                    $sxgeo = new SxGeo(base_path().$sypexConfigPath.$sypexConfigFile);
                    break;
                case ('web_service'):
                    $license_key = $sypexConfig->get('sypexgeo.sypexgeo.license_key', array());
                    $sxgeo = new SxGeoHttp($license_key);
                    break;
                default:
                    $sypexConfigFile = $sypexConfig->get('sypexgeo.sypexgeo.file', array());
                    $sxgeo = new SxGeo(base_path().$sypexConfigPath.$sypexConfigFile);
            }

			//return new GeoIP($app['config'], $app["session.store"]);


            return new SypexGeo($sxgeo, $app['config']);
		});
	}
1326388
protected function registerService()
	{
	    $this->app->singleton($this->getProviderKey(), function($app)
	    {
	    	return new Service($this->getProviderKey(), new Processor($this->getAggregateService()), $this->getAggregateService());
	    });
	}
307946
public function register()
	{
        $this->app->singleton('FilemanagerLaravel', function () {
            return new FilemanagerLaravel;
        });
		$this->app->booting(function()
		{
		  $loader = \Illuminate\Foundation\AliasLoader::getInstance();
		  $loader->alias('FilemanagerLaravel', 'Pqb\FilemanagerLaravel\Facades\FilemanagerLaravel');
		});
		$this->publishes([
            __DIR__ . '/../../controllers' => base_path('app/Http/Controllers'),
            __DIR__ . '/../../views' => base_path('resources/views/vendor/filemanager-laravel'),
            __DIR__ . '/../../../public' => base_path('public'),
        ]);
        $this->loadViewsFrom(__DIR__ . 'resources/views', 'filemanager-laravel');
	}
168730
protected function registerProviders()
    {
        $this->app->register(ConfigurationServiceProvider::class);
        $this->app->register(RouteServiceProvider::class);
        $this->app->register(ViewComposerServiceProvider::class);
        $this->app->register(BaumServiceProvider::class);
        $this->app->register(RepositoryServiceProvider::class);
        $this->app->register(FormServiceProvider::class);
        $this->app->register(WidgetServiceProvider::class);
        $this->app->register(TaggingServiceProvider::class);
    }
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);
        });
    }
161758
public function register()
	{
		$method = version_compare(Application::VERSION, '5.2', '>=') ? 'singleton' : 'bindShared';

		// Bind the manager as a singleton on the container.
		$this->app->$method('anlutro\LaravelSettings\SettingsManager', function($app) {
			// When the class has been resolved once, make sure that settings
			// are saved when the application shuts down.
			if (version_compare(Application::VERSION, '5.0', '<')) {
				$app->shutdown(function($app) {
					$app->make('anlutro\LaravelSettings\SettingStore')->save();
				});
			}
			
			/**
			 * Construct the actual manager.
			 */
			return new SettingsManager($app);
		});

		// Provide a shortcut to the SettingStore for injecting into classes.
		$this->app->bind('anlutro\LaravelSettings\SettingStore', function($app) {
			return $app->make('anlutro\LaravelSettings\SettingsManager')->driver();
		});

		$this->app->alias('anlutro\LaravelSettings\SettingStore', 'setting');

		if (version_compare(Application::VERSION, '5.0', '>=')) {
			$this->mergeConfigFrom(__DIR__ . '/config/config.php', 'settings');
		}
	}
1367761
protected function registerService()
	{
	    $this->app->singleton($this->getProviderKey(), function($app)
	    {
	    	return new Service($this->getProviderKey(), null, $this->getAggregateService());
	    });
	}
1353357
protected function registerHorizonServiceProvider()
    {
        $namespace = Str::replaceLast('\\', '', $this->getAppNamespace());

        $appConfig = file_get_contents(config_path('app.php'));

        if (Str::contains($appConfig, $namespace.'\\Providers\\HorizonServiceProvider::class')) {
            return;
        }

        file_put_contents(config_path('app.php'), str_replace(
            "{$namespace}\\Providers\EventServiceProvider::class,".PHP_EOL,
            "{$namespace}\\Providers\EventServiceProvider::class,".PHP_EOL."        {$namespace}\Providers\HorizonServiceProvider::class,".PHP_EOL,
            $appConfig
        ));

        file_put_contents(app_path('Providers/HorizonServiceProvider.php'), str_replace(
            "namespace App\Providers;",
            "namespace {$namespace}\Providers;",
            file_get_contents(app_path('Providers/HorizonServiceProvider.php'))
        ));
    }
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);
                };
            }
        }
    }
694622
public function register()
	{
		// Overcome router to my own implementation
		$this->app['router'] = $this->app->share(function($app)
		{
			$router = new Router($app['events'], $app);

			// If the current application environment is "testing", we will disable the
			// routing filters, since they can be tested independently of the routes
			// and just get in the way of our typical controller testing concerns.
			if ($app['env'] == 'testing')
			{
				$router->disableFilters();
			}

			return $router;
		});

		// w.eloquent router by Cortex
		$this->app->bindShared('weloquent.route', function ($app)
		{
			return Container::instance()->get('cortex.api');
		});

		$this->registerUrlGenerator();

		$this->registerRedirector();

	}
897417
public function register()
    {
        // Register the HtmlServiceProvider
        $this->app->register(\Collective\Html\HtmlServiceProvider::class);

        // Add aliases to Form/Html Facade
        $loader = AliasLoader::getInstance();

        // Add aliases to Form/Html Facade
        $loader->alias('Form', FormFacade::class);
        $loader->alias('Html', HtmlFacade::class);

        // Add alias for datagrid
        $loader->alias('Datagrid', Datagrid::class);
    }
1051415
public function register()
    {
        $this->app->register(\Netcore\Translator\ServiceProvider::class);

        $this->commands([
            ImportTranslations::class,
            FindTranslations::class,
        ]);
    }