Register the guard's clipboard at the container.

@return $this
359129
public function registerClipboardAtContainer()
    {
        $clipboard = $this->guard->getClipboard();

        Container::getInstance()->instance(Contracts\Clipboard::class, $clipboard);

        return $this;
    }
142912
protected function registerConfig() {
        $config = new Configuration($this->configFile);
        $this->container->set('config', function() use ($config) {
                return $config;
        });
    }
915725
protected function registerStaplerFastenCommand()
    {
        $this->app->bind('stapler.fasten', function ($app) {
            $migrationsFolderPath = base_path().'/database/migrations';

            return new FastenCommand($app['view'], $app['files'], $migrationsFolderPath);
        });
    }
817985
public function bootstrap()
    {
        $this->registerBootstrapArguments();
        $this->registerEventDispatcher();
        $this->registerConfigLoader();
        $this->registerConfig();
        $this->registerPlugins();
        $this->registerTaskDispatcherCollection();
        $this->registerLogger();

        // phs: Ensure plugin container is build an all plugins are initialized
        $this->getContainer()->plugins();

        $this->getContainer()
            ->events()
            ->dispatch(
                BootstrapFinishedEvent::EVENT_NAME,
                new BootstrapFinishedEvent($this->getContainer())
            );

        return $this->getContainer();
    }
821413
protected function registerGuard()
    {
        \Auth::extend('openid', function ($app, $name, array $config) {
            return new CustomSessionGuard($app['session.store']);
        });

        \Auth::extend('basic-api', function ($app, $name, array $config) {
            return new CustomTokenGuard();
        });
    }
866533
public function register()
    {
        $this->files->register();
        $this->psr0->register();
        $this->psr4->register();

        return $this;
    }
1125391
public function register() {
        if (!$this->registered) {
            spl_autoload_register([$this, 'autoLoad'], $throw=true, $prepend=false);
            $this->registered = true;
        }
        return $this;
    }
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;
    }
906113
protected function registerEnvironment()
    {
        $this->app->singleton('markdown.environment', function (Container $app) {
            $environment = Environment::createCommonMarkEnvironment();

            $config = $app->config->get('markdown');

            $environment->mergeConfig(array_except($config, ['extensions', 'views']));

            foreach ((array) array_get($config, 'extensions') as $extension) {
                $environment->addExtension($app->make($extension));
            }

            return $environment;
        });

        $this->app->alias('markdown.environment', Environment::class);
    }
742840
protected function registerSecurity()
    {
        $this->app->singleton('security', function (Container $app) {
            $evil = $app->config->get('security.evil');

            return new Security($evil);
        });

        $this->app->alias('security', Security::class);
    }
405188
protected function registerEventScanner()
    {
        $this->app->singleton('annotations.event.scanner', function ($app) {
            $scanner = new EventScanner([]);

            $scanner->addAnnotationNamespace(
              'Collective\Annotations\Events\Annotations\Annotations',
              __DIR__.'/Events/Annotations/Annotations'
            );

            return $scanner;
        });
    }
1365645
protected function registerFacadeBindings()
    {
        $this->app->bind('cms-models-modelinfo', RepositoriesContracts\CurrentModelInformationInterface::class);
        $this->app->bind('cms-translation-locale-helper', TranslationLocaleHelperInterface::class);

        return $this;
    }
267511
protected function registerBanCommand()
    {
        $this->app->singleton('command.authentication.user.ban', function ($app) {
            return $app->make(Ban::class);
        });
        $this->commands('command.authentication.user.ban');
    }
39436
public function registerKernel()
    {
        if ($this->runningInConsole()) {
            $this->register('ConsoleKernel', new ConsoleKernel($this));
        }
        else {
            $this->register('HttpKernel', new HttpKernel($this));
        }

        return $this;
    }
1291784
protected function registerCommands()
	{
		$this->app->bindShared('command.auth.reminders', function($app)
		{
			return new RemindersTableCommand($app['files']);
		});

		$this->app->bindShared('command.auth.reminders.clear', function($app)
		{
			return new ClearRemindersCommand;
		});

		$this->app->bindShared('command.auth.reminders.controller', function($app)
		{
			return new RemindersControllerCommand($app['files']);
		});

		$this->commands(
			'command.auth.reminders', 'command.auth.reminders.clear', 'command.auth.reminders.controller'
		);
	}
659748
protected function registerCoreBootstrappers()
    {
        foreach ($this->getBootStrappers() as $key => $class) {
            $this->container->set($key, $this->compose('\\'.$class));
        }

        $this->bootstrappers->execute();

        return $this;
    }
42432
protected function registerAuthenticator()
    {
        $this->app->singleton('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;

            return new AuthManager($app);
        });

        $this->app->singleton('auth.driver', function ($app) {
            return $app['auth']->guard();
        });
    }