Registers the throttle checkpoint.

@return void
774647
protected function registerThrottleCheckpoint()
    {
        $this->registerThrottling();

        $this->app->singleton('sentinel.checkpoint.throttle', function ($app) {
            return new ThrottleCheckpoint(
                $app['sentinel.throttling'], $app['request']->getClientIp()
            );
        });
    }
538720
public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/../config/demo-mode.php', 'demo-mode');

        $router = $this->app['router'];

        $router->macro('demoAccess', function ($url) use ($router) {
            if (!config('demo-mode.enabled') || config('demo-mode.strict_mode')) {
                return;
            }

            $router->get($url, '\Spatie\DemoMode\DemoModeController@grantAccess');
        });

        $router->fallback('\Spatie\DemoMode\DemoModeController@catchFallback');

        $this->app->singleton(DemoGuard::class, config('demo-mode.guard'));
    }
264456
private function makeCheckpoint($checkpoint, $context)
    {
        switch ($checkpoint)
        {
            case ThrottleCheckpoint::class:
                return new ThrottleCheckpoint(
                    $this->repositories->createThrottleRepository($context),
                    $this->container->make('request')->getClientIp()
                );
            case ActivationCheckpoint::class:
                return new ActivationCheckpoint(
                    $this->repositories->createActivationRepository($context)
                );
            default:
                return $this->container->make($checkpoint);
        }
    }
36509
public function register()
    {
        if (!$this->isRegistered) {
            $this->system->setErrorHandler([$this, self::ERROR_HANDLER]);
            $this->system->setExceptionHandler([$this, self::EXCEPTION_HANDLER]);
            $this->system->registerShutdownFunction([$this, self::SHUTDOWN_HANDLER]);

            $this->isRegistered = true;
        }

        return $this;
    }
1034445
public function register()
    {
        $this->app->singleton('command.down', function($app)
        {
            return new StartMaintenanceCommand();
        });


        $this->app->singleton('command.up', function($app)
        {
            return new EndMaintenanceCommand();
        });
        $this->commands(['command.down', 'command.up']);
    }
45669
public function register()
    {
        
          if ($this->app->runningInConsole()) {
                $this->commands([
                    Commands\CrudCommand::class,
                    Commands\CrudControllerCommand::class,
                    Commands\CrudModelCommand::class,
                    Commands\CrudMigrationCommand::class,
                    Commands\CrudViewCommand::class,
                    Commands\PivotMigrationCommand::class,
                    
                ]);
            }

     }
569200
public function register()
    {
        $this->app->singleton(DispatcherInterface::class, function ($app) {
            return new Dispatcher($this->mappings, $app);
        });
    }
1307895
public function register()
    {
        $this->publishes([
            __DIR__ . '/config/setting.php' => config_path('setting.php'),
        ]);

        $this->app->bind(['setting' => 'Thetispro\Setting\Setting'],
                function($app) {
            return new Setting(
                    config('setting.path'), config('setting.filename'),
                    config('setting.fallback') ? new LaravelFallbackInterface() : null);
        }); 
    }
1013479
public function register()
    {
        $this->publishes([$this->configPath() => config_path('iplimit.php')]);

        /** @var \Illuminate\Foundation\Http\Kernel $kernel */
        $kernel = $this->app->make(Kernel::class);
        // When the IpLimit middleware is not attached globally, add the PreflightCheck
        if (! $kernel->hasMiddleware(IpLimit::class)) {
            $kernel->prependMiddleware(IpLimit::class);
        }
    }
561546
public function register()
    {
        $this->registerConfigurationMapper();
        $this->registerCacheManager();
        $this->registerEntityManager();
        $this->registerClassMetadataFactory();
        $this->registerValidationVerifier();

        $this->commands([
            'Mitch\LaravelDoctrine\Console\GenerateProxiesCommand',
            'Mitch\LaravelDoctrine\Console\SchemaCreateCommand',
            'Mitch\LaravelDoctrine\Console\SchemaUpdateCommand',
            'Mitch\LaravelDoctrine\Console\SchemaDropCommand'
        ]);
    }
1074573
public function register()
    {
        $this->commands('Someline\Repository\Generators\Commands\RepositoryCommand');
        $this->commands('Someline\Repository\Generators\Commands\TransformerCommand');
        $this->commands('Someline\Repository\Generators\Commands\PresenterCommand');
        $this->commands('Someline\Repository\Generators\Commands\EntityCommand');
        $this->commands('Someline\Repository\Generators\Commands\ValidatorCommand');
        $this->commands('Someline\Repository\Generators\Commands\ControllerCommand');
        $this->commands('Someline\Repository\Generators\Commands\BindingsCommand');
        $this->commands('Someline\Repository\Generators\Commands\CriteriaCommand');
    }
333046
public function register()
    {
        set_exception_handler(new ExceptionHandler($this->request, $this->factory));
        register_shutdown_function(new ShutdownHandler($this->request, $this->factory));
    }
1136833
protected function registerFlysystem()
    {
        $this->registerManager();

        $this->getContainer()->share('filesystem.disk', function () {
            return app('filesystem')->disk($this->getDefaultDriver());
        });
        $this->getContainer()->share('filesystem.cloud', function () {
            return app('filesystem')->disk($this->getCloudDriver());
        });
    }
207689
protected function registerCloseCallback()
    {
        $this->swoolePort->on('Close', function ($server, $fd, $reactorId) {
            $this->dispatchEvent('Close', $this->server, $this, $fd, $reactorId);
        });
    }
698927
public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/../config/roles.php', 'roles');
        $this->loadMigrationsFrom(__DIR__.'/Database/Migrations');
        $this->publishFiles();
        $this->loadSeedsFrom();
    }
957705
protected function registerThrottleProvider()
	{
		$this->app['sentry.throttle'] = $this->app->share(function($app)
		{
			$model = $app['config']['cartalyst/sentry::throttling.model'];

			$throttleProvider = new ThrottleProvider($app['sentry.user'], $model);

			if ($app['config']['cartalyst/sentry::throttling.enabled'] === false)
			{
				$throttleProvider->disable();
			}

			if (method_exists($model, 'setAttemptLimit'))
			{
				$attemptLimit = $app['config']['cartalyst/sentry::throttling.attempt_limit'];

				forward_static_call_array(
					array($model, 'setAttemptLimit'),
					array($attemptLimit)
				);
			}
			if (method_exists($model, 'setSuspensionTime'))
			{
				$suspensionTime = $app['config']['cartalyst/sentry::throttling.suspension_time'];

				forward_static_call_array(
					array($model, 'setSuspensionTime'),
					array($suspensionTime)
				);
			}
			
			// Define the User model to use for relationships.
			if (method_exists($model, 'setUserModel'))
			{
				$userModel = $app['config']['cartalyst/sentry::users.model'];

				forward_static_call_array(
					array($model, 'setUserModel'),
					array($userModel)
				);
			}

			return $throttleProvider;
		});
	}
728162
public function register()
    {
        if ($this->hasHelpers()) {
            foreach ($this->helpers as $helper => $config) {
                $this->controller->view->loadHelper($helper, $config);
            }

            $this->logAvailableHelpers();
        }
    }