Register bindings in the container.

@return void
351970
public function register()
    {
        $this->app->singleton('soda.block-type.repository', function ($app) {
            return new BlockTypeRepository(new BlockType);
        });

        $this->app->singleton('soda.block-type-field.repository', function ($app) {
            return new BlockTypeFieldRepository(new BlockType, new Field);
        });

        $this->registerAliases($this->aliases);
    }
629937
protected function registerBindings()
    {
        foreach ($this->bindings as $concrete => $abstracts) {
            if (!is_array($abstracts)) {
                $this->app->bind($abstracts, $concrete);
                continue;
            }

            $first = array_shift($abstracts);

            $this->app->bind($first, $concrete);

            foreach ($abstracts as $abstract) {
                $this->app->alias($first, $abstract);
            }
        }
    }
251372
public function registerClasses()
    {
        // Register user defined libraries in the DI container
        $aLibraries = $this->getOptionNames('dialogs.classes');
        foreach($aLibraries as $sShortName => $sFullName)
        {
            $this->registerLibrary($sShortName, $this->getOption($sFullName));
        }
    }
1124230
public function register()
    {
        $this->bindRouteModel();

        $this->loadAdminAuthConfig();

        $this->registerRouteMiddleware();

        $this->registerPolicies();

        $this->commands($this->commands);
    }
950711
protected function registerContainer()
    {
        static::setInstance($this);

        $this->instance('app', $this);
        $this->alias('app', static::class);
        $this->alias('app', 'Illuminate\Container\Container');
        $this->alias('app', 'Illuminate\Contracts\Container\Container');
    }
1179336
public function register()
    {
        $this->registerBindings();
        $this->app['events']->listen(BuildingSidebar::class, RegisterCartSidebar::class);

        $this->app['events']->listen(LoadingBackendTranslations::class, function (LoadingBackendTranslations $event) {
            $event->load('cartitems', array_dot(trans('cart::cartitems')));
            // append translations
        });
    }
1026321
protected function registerBindings()
    {
        // TODO: Change to bind the implementation to the interface instead.
        $this->app->bind(CorsService::class, function () {
            return new CorsService(config(self::CONFIG_KEY));
        });

        $this->app->alias(CorsService::class, CorsServiceContract::class);
    }
1069912
public function register()
    {
        // Register our binding resolver in the service container
        $this->binder = new BindingResolver([$this->app, 'make']);
        $this->app->instance('bindingResolver', $this->binder);

        // Create a new FastRoute dispatcher (our extended one)
        // with no routes data at the moment because routes file is not loaded yet
        $this->dispatcher = new FastRouteDispatcher(null);

        // Set binding resolver
        $this->dispatcher->setBindingResolver($this->binder);

        // Set routes resolver (will be called when request is dispatched and the routes file is loaded)
        $this->dispatcher->setRoutesResolver($this->getRoutesResolver());

        // Set our dispatcher to be used by the application instead of the default one
        $this->app->setDispatcher($this->dispatcher);

        // Save the dispatcher in the container in case someone needs it later (you're welcome)
        $this->app->instance('dispatcher', $this->dispatcher);
    }
1290693
private function registerProviders(): void
    {
        $this->providers = array_merge($this->providers, $this->getConfigProviders());

        foreach ($this->providers as $provider) {
            $provider = $this->container->get($provider);
            $provider->boot();
        }
    }
257296
public function initialize()
    {
        Facade::setContainer($this->container);

        if (null !== $loader = $this->loader) {
            $loader->register();
        }
    }
914909
private function registerBindings()
    {
        $this->app->bind('society.isInstalled', function ($app) {
            return
                file_exists(base_path('.env')) &&
                file_exists(storage_path('app/installed')) &&
                Schema::hasTable('migrations');
        });
    }
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());
        });
    }
207383
protected function registerBindings()
    {
        // Bind Personality Insights interface.
        $this->app->bind(InsightsContract::class, PersonalityInsights::class);

        // Bind Personality Insights Service.
        $this->app->bind(PersonalityInsights::SERVICE_ID, PersonalityInsights::class);

        // Registers the Access Manager.
        $this->registerAccessManager();

        // Registers the Bridge.
        $this->registerBridge();

        // Bind PersonalityInsights ContentListContainer in App.
        $this->app->bind(ContentListContainer::SERVICE_ID, function () {
            return (new ContentListContainer)->cleanContainer();
        });
    }
782456
protected function registerViewBindings()
    {
        $this->singleton('view', function ()
        {
            $this->configure('view');

            $this['config']['view.paths'] = [
                realpath(base_path('views')),
            ];
            
            return $this->loadComponent('view', 'Illuminate\View\ViewServiceProvider');
        });
    }
309874
public function register()
    {
        $configPath = __DIR__ . '/../config/sql-logging.php';
        $this->mergeConfigFrom($configPath, 'sql-logging');

        if (config('sql-logging.log', false)) {
            Event::listen('illuminate.query',
                function ($query, $bindings, $time) {
                    $data = compact('bindings', 'time');

                    // Format binding data for sql insertion
                    foreach ($bindings as $i => $binding) {
                        if ($binding instanceof \DateTime) {
                            $bindings[$i] = $binding->format('\'Y-m-d H:i:s\'');
                        } else if (is_string($binding)) {
                            $bindings[$i] = "'$binding'";
                        }
                    }

                    // Insert bindings into query
                    $query = str_replace(array('%', '?'), array('%%', '%s'), $query);
                    $query = vsprintf($query, $bindings);

                    $log = new Logger('sql');
                    $log->pushHandler(new StreamHandler(storage_path() . '/logs/sql-' . date('Y-m-d') . '.log',
                        Logger::INFO));

                    // if log request data
                    if (config('sql-logging.log_request', false)) {
                        $data['request_path'] = Request::path();
                        $data['request_method'] = Request::method();
                        $data['request_data'] = Request::all();
                    }

                    // add records to the log
                    $log->addInfo($query, $data);
                });
        }
    }
663366
public function register() {

		$this->app->bind( Attributes::class, Attr::class );

		$this->app->alias( Attributes::class, 'attr' );
	}
961282
public function registerCommands()
    {
        $this->app->bind('mediasort.fasten', function ($app) {
            return new Commands\FastenCommand(
                $app['view'], $app['files']
            );
        });

        // TODO: Get this working
        //$this->app->bind('mediasort.refresh', function ($app) {
        //    return new Commands\RefreshCommand(
        //        new Services\ImageRefreshService()
        //    );
        //});

        $this->commands([
            'mediasort.fasten',
            //'mediasort.refresh',
        ]);
    }