register the provider

@return mixed
329249
public function register()
    {
        $all = Config::get('security');

        if (isset($all['firewall'])) {
            $this->registerFirewallSecurity($all['firewall']);
        }

        $this->prepareCsrfInstance();

        // register the type hint
        if (isset($all['type_hint'])) {
            if (true === $all['type_hint']) {
                $this->registerTypeHint();
            }
        }

        $this->filterGetParameters();

    }
200529
public function register()
	{
		$driver = $this->app['config']['auth.driver'];

		if($driver === 'wordpress')
		{
			$this->app->bindShared('auth', function($app)
			{
				// Once the authentication service has actually been requested by the developer
				// we will set a variable in the application indicating such. This helps us
				// know that we need to set any queued cookies in the after event later.
				$app['auth.loaded'] = true;

				$auth = new WpAuth($app);

				$auth->setDispatcher($app['events']);

				return $auth;
			});
		}
		else
		{
			parent::register();
		}
	}
1034745
public function register()
    {
        $this->app->singleton('admin', function ($app) {
            return new Admin($app['config'], $app['auth'], $app['router']);
        });
        
        $this->registerRouteMiddleware($this->app['router']);
    }
705399
public function register()
    {
        $app = $this->app;

        // register spec path for app
        $app['path.specs'] = $app->basePath().'/resources/specs';

        // register spec repository
        $app->singleton('specs', function ($app) {
            $loader = new Repository\FileLoader($app['files'], $app['path.specs']);

            return new Repository\NamespacedRepository($loader);
        });

        // register addon environment
        $app->instance('addon', $this->addonEnvironment = new AddonEnvironment($app));
        $app->alias('addon', AddonEnvironment::class);

        // register addon generator
        $app->singleton('addon.generator', function ($app) {
            return new AddonGenerator();
        });
        $app->alias('addon.generator', AddonGenerator::class);

        // register database migrator
        $app->singleton('database.migrator', function ($app) {
            return new Migrator($app['db'], $app['config']);
        });
        $app->alias('database.migrator', Migrator::class);

        $app['events']->fire(new AddonWorldCreated($this->addonEnvironment));

        $this->registerClassResolvers();

        (new AddonRegistrar)->register($app, $this->addonEnvironment->addons());

        $app['events']->fire(new AddonRegistered($this->addonEnvironment));
    }
701250
public function register() {
		// if the provider method exists then we are at least in Laravel 5.1
		if(method_exists('Illuminate\Auth\AuthManager', 'provider')) {
			// LDAP auth extension
			Auth::provider('ldap', function($app, array $config) {
				return new \CSUNMetaLab\Authentication\Providers\UserProviderLDAP();
			});

			// database auth extension
			Auth::provider('dbauth', function($app, array $config) {
				return new \CSUNMetaLab\Authentication\Providers\UserProviderDB();
			});
		}
		else
		{
			// Laravel 5.0
			Auth::extend('ldap', function() {
				return new Guard(new \CSUNMetaLab\Authentication\Providers\UserProviderLDAP,
					App::make('session.store'));
			});
			Auth::extend('dbauth', function() {
				return new Guard(new \CSUNMetaLab\Authentication\Providers\UserProviderDB,
					App::make('session.store'));
			});
		}
	}
613042
public function register()
    {

        $app = $this->app;

        foreach ($app->getProviders() as $provider) {

            $provider = new $provider($app);

            if (!$provider instanceof ServiceProvider) {
                throw new ProviderException(sprintf('Your %s proiver must be a instance of ServiceProvider', get_class($provider)));
            }


            $provider->register();

            $app = $provider->app();
        }
    }
735574
public function register()
    {
        // Configure any bindings that are version dependent
        $this->provider->register();

        // Let the IoC container be able to make a Symfony event dispatcher
        $this->app->bind(
            'Symfony\Component\EventDispatcher\EventDispatcherInterface',
            'Symfony\Component\EventDispatcher\EventDispatcher'
        );

        // Setup default configurations for the Tmdb Client
        $this->app->singleton('Tmdb\Client', function() {
            $config = $this->provider->config();
            $options = $config['options'];

            // Use an Event Dispatcher that uses the Laravel event dispatcher
            $options['event_dispatcher'] = $this->app->make('Tmdb\Laravel\Adapters\EventDispatcherAdapter');

            // Register the client using the key and options from config
            $token = new ApiToken($config['api_key']);
            return new Client($token, $options);
        });

        // bind the configuration (used by the image helper)
        $this->app->bind('Tmdb\Model\Configuration', function() {
            $configuration = $this->app->make('Tmdb\Repository\ConfigurationRepository');
            return $configuration->load();
        });
    }
537092
public function register()
    {
        // If script is running CLI we don't activate this plugin
        if ($this->app->runningInConsole())
        {
            return;
        }

        // Default package configuration
        $this->mergeConfig();
        
        // Register singleton
        $this->app->singleton('active', function ($app) {
           return new Active($app['router']->current()->getName());
        });
        
        // Register Facade
        $loader = \Illuminate\Foundation\AliasLoader::getInstance();
        $loader->alias('Active', Facades\Active::class);
    }
595513
public function register()
	{
		$this->mergeConfigFrom(__DIR__.'/../config/rpc.php', 'rpc');

		// Shared Client
		$this->app->singleton('JsonRpcClient', function($app)
		{
			$options = $this->app['config']->get('rpc.client');
			$client = new RpcClientWrapper($options);
			return $client;
		});

		// Shared Server
		$this->app->bind('JsonRpcServer', function($app, $params=[])
		{
			$options = $this->app['config']->get('rpc.server');

			$class = new \ReflectionClass(JsonRPC\Server::class);
			$server = $class->newInstanceArgs($params);

			return $server;
		});

	}
944738
public function registerProviders()
	{
		$providers = $this['config']->get('app.providers');

		foreach ($providers as $provider) {
			$this->providers[$provider] = new $provider($this);
			$this->providers[$provider]->register();
		}
	}
375965
public function register() {
        $this->larapackage('larakit/laravel-larakit', 'larakit', 'public');
        $this->app->bind('larakit:env',
            function ($app) {
                return new \Larakit\Command\Env();
            });
        $this->app->bind('larakit:readiness',
            function ($app) {
                return new \Larakit\Command\Readiness();
            });
        $this->app->bind('larakit:app-provider',
            function ($app) {
                return new \Larakit\Command\AppProvider();
            });
        $this->app->bind('larakit:app-alias',
            function ($app) {
                return new \Larakit\Command\AppAlias();
            });
        $this->app->bind('larakit:app-db',
            function ($app) {
                return new \Larakit\Command\AppDb();
            });
        $this->app->bind('larakit:app-migrate',
            function ($app) {
                return new \Larakit\Command\AppMigrate();
            });
        $this->commands([
            'larakit:env',
            'larakit:app-provider',
            'larakit:app-alias',
            'larakit:app-db',
            'larakit:readiness',
            'larakit:app-migrate',
        ]);
    }
795445
public function register()
    {
        // Register Facade
        $this->app->bind('settings', function (Application $app) {
            return $app->make(SettingsHelper::class);
        });

        // Register Alias
        $this->app->booting(function () {
            $loader = AliasLoader::getInstance();
            $loader->alias('Settings', SettingsFacade::class);
        });
    }
994111
public function register()
    {
        // Auto register the support service provider
        if (! get_class($this) == SupportServiceProvider::class) {
            $this->app->register(SupportServiceProvider::class);
        }

        $this->viewsPath  = Str::replace($this->viewsPath, '{resourcesPath}', $this->getResourcesPath());
        $this->assetsPath = Str::replace($this->assetsPath, '{resourcesPath}', $this->getResourcesPath());

        $router = $this->app->make('router');
        $kernel = $this->app->make('Illuminate\Contracts\Http\Kernel');

        $this->registerConfigFiles();

        foreach ($this->prependMiddleware as $middleware) {
            $kernel->prependMiddleware($middleware);
        }

        foreach ($this->middleware as $middleware) {
            $kernel->pushMiddleware($middleware);
        }

        foreach ($this->routeMiddleware as $key => $middleware) {
            $router->middleware($key, $middleware);
        }

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

        foreach ($this->deferredProviders as $provider) {
            $this->app->registerDeferredProvider($provider);
        }

        foreach ($this->bindings as $binding => $class) {
            $this->app->bind($binding, $class);
        }

        foreach ($this->singletons as $binding => $class) {
            if ($this->strict && ! class_exists($class) && ! interface_exists($class)) {
                throw new \Exception(get_called_class() . ": Could not find alias class [{$class}]. This exception is only thrown when \$strict checking is enabled");
            }
            $this->app->singleton($binding, $class);
        }

        foreach ($this->aliases as $alias => $full) {
            if ($this->strict && ! class_exists($full) && ! interface_exists($full)) {
                throw new \Exception(get_called_class() . ": Could not find alias class [{$full}]. This exception is only thrown when \$strict checking is enabled");
            }
            $this->app->alias($alias, $full);
        }

        if (is_array($this->commands) and count($this->commands) > 0) {
            $this->commands($this->commands);
        }

        AliasLoader::getInstance($this->facades)->register();

        $this->requireHelpersFor('register');

        return $this->app;
    }
416619
public function register()
    {
        Paginator::viewFactoryResolver(function ()
        {
            return $this->app['view'];
        });

        Paginator::currentPathResolver(function ($pageName = 'page')
        {
            return $this->app['request']->url();
        });

        Paginator::currentPageResolver(function ($pageName = 'page')
        {
            $page = $this->app['request']->input($pageName, 1);

            if ((filter_var($page, FILTER_VALIDATE_INT) !== false) && ((int) $page >= 1)) {
                return $page;
            }

            return 1;
        });

        Paginator::urlGeneratorResolver(function (AbstractPaginator $paginator)
        {
            return new UrlGenerator($paginator);
        });
    }
1126231
public function register()
    {
        $this->app->singleton('larinfo', function ($app) {
            $larinfo = new Larinfo(new Ipinfo(), new Request(), new Linfo(), new Manager());

            $token = config('services.ipinfo.token');

            if (! empty($token)) {
                return $larinfo->setIpinfoConfig($token);
            }

            $larinfo->setDatabaseConfig(config('database.connections.'.config('database.default')));

            return $larinfo;
        });
    }
516157
public function register()
    {

        $this->app->singleton( Registrar::class, function( $app ){
            return new Registrar;
        });

        $this->app->singleton( HelpersBlueprint::class, Helpers::class );

        $this->app->singleton( 'ensphere.exception.handler', function( $app ) {
            return new Bucket();
        });

        $this->app->singleton( ProcessorRegistrar::class, function( $app ) {
            return new ProcessorRegistrar;
        });

        $this->commands([
            RenameCommand::class,
            ExportCommand::class,
            ImportCommand::class,
            BowerCommand::class,
            MigrateCommand::class,
            RegistrationCommand::class,
            InstallCommand::class,
            UpdateCommand::class,
            MakeCommand::class,
            DatabaseCommand::class,
            ModulesCommand::class,
            ExternalAssetsCommand::class,
            DotEnv::class,
            ExtendCommand::class,
            InformCentralHub::class,
            PostProcessCommand::class,
            PreProcessCommand::class,
            BackResourceCommand::class,
            MigrationSeedCommand::class,
            SearchAndReplaceCommand::class,
            MediaCleanseCommand::class,
            JsRoutesCommand::class,
        ]);
    }
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);
		};
	}