Register the profile builder class.

@return void
971846
protected function registerProfileBuilder()
    {
        $this->app->singleton('backup.builder', function (Container $app) {
            $config = $app['config']['backup'];

            $factory = new ProfileBuilderFactory($app);

            return $factory->make($config);
        });

        $this->app->alias('backup.builder', ProfileBuilder::class);
    }
313212
public function register()
    {
        $this->app->bind('geomanager', function ($app) {
            return new GeoManager($app);
        });

        $this->setupRoutes($this->app->router);
    }
627456
protected function registerFormBuilder()
    {
        $this->app->singleton('form', function ($app) {
            $this->loadConfigurationOptions();

            $form = new FormBuilder(
                $app['html'],
                $app['url'],
                $app['session.store']->token(),
                $this->getTheme()
            );

            $form->novalidate(
                $app['config']->get('html.novalidate', false)
            );

            return $form->setSessionStore($app['session.store']);
        });
    }
696730
protected function register()
    {
        // Make comment model for the factory.
        $this->setModel($this->makeCommentModel());

        // Build comment with model.
        $this->setSingularity($this->makeCommentInstance());

        // Set columns to the comment, after admin init.
        if ($this->methodExist('columns')) {
            $this->registerColumns();
        }
    }
297625
public function register()
    {
        $this->registerHtmlBuilder();

        $this->registerFormBuilder();

        $this->app->alias('html', 'Collective\Html\HtmlBuilder');
        $this->app->alias('form', 'Rokde\LaravelBootstrap\Html\BootstrapFormBuilder');
    }
415497
protected function registerDebugger(): void
    {
        $this->app->singleton('orchestra.debug', function ($app) {
            return new Debugger($app->make(ProfilerContract::class), $app->make('orchestra.debug.socket'));
        });
    }
338201
public function register()
    {
        $this->registerBindings();

        $this->app['setting.settings'] = $this->app->share(function ($app) {
            return new Settings($app[SettingRepository::class]);
        });
        $this->app->booting(function () {
            $loader = AliasLoader::getInstance();
            $loader->alias('Settings', SettingsFacade::class);
        });

        $this->app['setting.themeOptions'] = $this->app->share(function ($app) {
            return new ThemeOptions($this->app['stylist']->current());
        });
    }
1350502
public function registerProfiler()
	{
		$sessionHash = static::SESSION_HASH;

		$this->app['profiler'] = $this->app->share(function($app) use ($sessionHash)
		{
			$startTime = null;
			$enabled = false;

			// Let's use the Laravel start time if it is defined.
			if(defined('LARAVEL_START'))
			{
				$startTime = LARAVEL_START;
			}

			// Check the session to see if the profiler has been manually enabled
			// or disabled through the session. Note that the session completely overrides
			// the configuration.
			if($app['session']->has($sessionHash))
			{
				$enabled = $app['session']->get($sessionHash);
			}
			
			else
			{
				// The session contains no information as to wether the profiler is enabled
				// or not. Let's check the configurations now. 
				$enabled = $app['config']->get('profiler::enabled', null);

				// If the config is set to null (or doesn't exist), we will fallback to the application's
				// debug setting.
				if(is_null($enabled))
				{
					$enabled = $app['config']->get('app.debug');
				}
			}

			return new Profiler(new Logger, $startTime, $enabled);
		});
	}
1042290
protected function registerFieldBuilder()
    {
        $this->app->bind('field', function ($app) {

            $this->loadConfigurationOptions();

            $fieldBuilder = new FieldBuilder(
                $app['form'],
                $this->theme,
                $app['translator']
            );

            if ($this->options['control_access']) {
                $fieldBuilder->setAccessHandler($app[AccessHandler::class]);
            }

            $fieldBuilder->setAbbreviations($this->options['abbreviations']);

            if (isset ($this->options['theme_values']['field_classes'])) {
                $fieldBuilder->setCssClasses(
                    $this->options['theme_values']['field_classes']
                );
            }

            if (isset ($this->options['theme_values']['field_templates'])) {
                $fieldBuilder->setTemplates(
                    $this->options['theme_values']['field_templates']
                );
            }

            $fieldBuilder->setSessionStore($app['session.store']);

            return $fieldBuilder;
        });
    }
224132
public function register() : void
    {
        $environment = $this->app->environment();

        $providers = $this->app['config']->get('app.' . $environment . '_providers', []);

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

        $facades = $this->app['config']->get('app.' . $environment . '_aliases', []);

        foreach ($facades as $class => $name) {
            AliasLoader::getInstance()->alias($class, $name);
        }
    }
1335224
protected function registerBadger()
    {
        $this->app->singleton(Badger::class, function (Container $app) {
            $calculator = $app->make('badger.calculator');
            $path = realpath($raw = __DIR__.'/../resources/templates') ?: $raw;

            $renderers = [
                new PlasticRender($calculator, $path),
                new PlasticFlatRender($calculator, $path),
                new FlatSquareRender($calculator, $path),
                new SocialRender($calculator, $path),
            ];

            return new Badger($renderers);
        });

        $this->app->singleton('badger', Badger::class);
    }
1086945
public function register() {
        // bind blueprint manager
        $this->app->singleton(Navigation::class, function () {
            return new Navigation();
        });

        // bind blueprint manager
        $this->app->singleton(BlueprintManager::class, function () {
            return new BlueprintManager(
                $this->app->make(Navigation::class),
                $this->app->make(CoreConfiguration::class)
            );
        });

        $this->app->bind(BlueprintRegistrarContract::class, BlueprintRegistrar::class);

        $this->app->singleton('oxygen.layout', function () {
            return $this->app[CoreConfiguration::class]->getAdminLayout();
        });
    }
982137
protected function registerFormBuilder()
    {
        // Load cms configuration
        $this->mergeConfigFrom(
            __DIR__ . '/../config/form-builder.php', 'form-builder'
        );
        // Register FormBuilder as singleton instance
        $this->app->singleton('form', function($app) {
            $form = new BootstrapFormBuilder(
                $app['html'],
                $app['url'],
                $app['view'],
                $app['session.store']->token()
            );
            // Return session store
            return $form->setSessionStore($app['session.store']);
        });
    }
968811
protected function registerFormBuilder()
    {
        $this->app->singleton('form', function ($app) {
            $form = new BootstrapFormBuilder($app['html'], $app['url'], $app['view'], $app['session.store']->getToken());

            return $form->setSessionStore($app['session.store']);
        });
    }
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);
        });
    }
267924
protected function registerFormBuilder()
    {
        $this->app->bindShared('bootstrap-form', function($app)
        {
            $form = new FormBuilder($app['bootstrap-html'], $app['url'], $app['session.store']->getToken(), $app['view']);

            return $form->setSessionStore($app['session.store']);
        });
    }
17024
public function register()
    {
        Model::clearBootedModels();

        $this->registerEloquentFactory();

        $this->registerQueueableEntityResolver();

        // The connection factory is used to create the actual connection instances on
        // the database. We will inject the factory into the manager so that it may
        // make the connections while they are actually needed and not of before.
        $this->app->singleton('db.factory', function ($app) {
            return new ConnectionFactory($app);
        });

        // The database manager is used to resolve various connections, since multiple
        // connections might be managed. It also implements the connection resolver
        // interface which may be used by other components requiring connections.
        $this->app->singleton('db', function ($app) {
            return new DatabaseManager($app, $app['db.factory']);
        });

        $this->app->bind('db.connection', function ($app) {
            return $app['db']->connection();
        });
    }