Register the IoC container bindings.

@return void
171980
protected function registerBindings()
    {
        $this->app->bind('FluxBB\Models\GroupRepositoryInterface', function ($app) {
            return new GroupRepository($app['cache']);
        });

        $this->app->bind('FluxBB\Models\ConfigRepositoryInterface', function ($app) {
            return new ConfigRepository($app['cache.store'], $app['Illuminate\Database\ConnectionInterface']);
        });

        $this->app->bind('FluxBB\Models\CategoryRepositoryInterface', function ($app) {
            return new CategoryRepository($app['Illuminate\Database\ConnectionInterface']);
        });

        $this->app->bind('FluxBB\Models\ConversationRepositoryInterface', function ($app) {
            return new ConversationRepository($app['Illuminate\Database\ConnectionInterface']);
        });
    }
430706
public function register()
	{
		// Bind 'stolz.assets.group.default' shared component to the IoC container
		$this->app->singleton('stolz.assets.group.default', function ($app) {
			return new Assets();
		});

		// Bind 'stolz.assets.command.flush' component to the IoC container
		$this->app->bind('stolz.assets.command.flush', function ($app) {
			return new LegacyFlushPipelineCommand();
		});
	}
996518
protected function registerCustomBindings(): void
    {
        $entityServiceFactory = $this->app->make(IEntityServiceFactory::class);

        foreach (config('laravel_entity_services.bindings') as $className => $entityService) {
            $entityServiceFactory->register($className, $entityService);
        }
    }
560039
protected function registerBindings()
    {
        $this->app->bind('dropbox.connection', function (Container $app) {
            $manager = $app['dropbox'];

            return $manager->connection();
        });

        $this->app->alias('dropbox.connection', Client::class);
    }
152521
protected function booting()
    {
        $this->setInstance();

        $this->bind('Sun\Contracts\Container\Container', $this->getContainer());

        $this->bind('Sun\Contracts\Application', $this);

        $this->config = $this->make('Sun\Support\Config');
    }
297351
public function register()
    {
        $this->registerFileConfig();
        $this->registerDatabaseConfig();

        // Bind the concrete types
        $this->app->bind('Concrete\Core\Config\Repository\Repository', 'config');
        $this->app->bind('Illuminate\Config\Repository', 'Concrete\Core\Config\Repository\Repository');
    }
159767
public function register()
    {
        $this->add_config_location(\realpath(__DIR__ . '/../config'));

        $this->add_blade();

        Container::add(
            Blade_Strategy::class,
            function (\Snap\Core\Container $container) {
                return $container->resolve(Blade_Strategy::class);
            }
        );

        Container::remove(Standard_Strategy::class);
        Container::remove(Partial::class);

        // Bind blade strategy as the current Templating engine.
        Container::bind(Blade_Strategy::class, Templating_Interface::class);

        $this->publishes_config(\realpath(__DIR__ . '/../config'));

        $this->publishes_directory(
            \realpath(__DIR__ . '/../templates'),
            Config::get('theme.templates_directory')
        );
    }
659748
protected function registerCoreBootstrappers()
    {
        foreach ($this->getBootStrappers() as $key => $class) {
            $this->container->set($key, $this->compose('\\'.$class));
        }

        $this->bootstrappers->execute();

        return $this;
    }
57978
protected function initialize()
    {
        $this->container = new Container();

        $containerProvider = new ContainerProvider($this->disabledMethods, $this->disabledFormats);
        $this->container->register($containerProvider);

        $this->initialized = false;
    }
677248
public function register()
    {
        $this->instances = [];

        foreach ($this->providers as $provider) {
            Zilf::$container->register($provider, $provider);
            $this->instances[] = Zilf::$container->get($provider)->register();
        }
    }
1094817
public function register()
    {
        $container = $this->getContainer();
        $config    = $container->get('config');

        $container->share(Client::class)
            ->withArgument(new RawArgument([
                'base_uri' => $config->get('base_uri'),
                'handler'  => $container->get(HandlerStack::class),
            ]));

        if ($config->get('http_adapter') === GuzzleAdapter::class) {
            $container->share(AdapterInterface::class, function () use ($container) {
                return new GuzzleAdapter($container->get(Client::class));
            });
        }

        if ($config->get('http_adapter') === MockAdapter::class) {
            $path = realpath(__DIR__.'/../../tests/fixtures').'/';
            $container->share(AdapterInterface::class, new MockAdapter($path));
        }
    }
496780
protected function registerBindings()
    {
        $binding = config('binding')?: [];

        foreach($binding as $contract => $implementation) {
            $this->bind($contract, $implementation);
        }
    }
319283
public function register(Container $container)
    {
        // Authentication
        $container->share(Authentication::class, [$this, 'authentication'])
            ->bindShared(AuthenticationInterface::class, Authentication::class);

        // Authorisation
        $container->share(Authorisation::class, [$this, 'authorisation'])
            ->bindShared(AuthorisationInterface::class, Authorisation::class);

        // User Handler
        $this->prepareHandler($container);

        // User Manager
        $container->prepareSharedObject(UserManager::class);
    }
1268102
public function register()
    {
        $this->config = $this->app->make('config');
        $this->packages = $this->config->get('domains.user-binding');

        $files = \File::allFiles(config_path('domains'));

        foreach ($files as $file) {
            if ($bindings = $this->config->get('domains.'.basename($file->getFilename(), '.php'))) {
                if (array_has($bindings, 'providers')) {
                    $this->provideService(array_get($bindings, 'providers'));
                }

                if (array_has($bindings, 'repositories')) {
                    $this->provideRepositories(array_get($bindings, 'repositories'));
                }

                if (array_has($bindings, 'eloquent_repositories')) {
                    $this->provideEloquentRepositories(array_get($bindings, 'eloquent_repositories'));
                }
            }
        }

        if ($this->app->runningInConsole()) {
            $this->commands([
                GenerateDomain::class,
            ]);
        }
    }
1092143
public function register()
    {
        $container = $this->getContainer();
        $config    = $container->get('config');

        $container->share(HandlerStack::class, function () {
            return HandlerStack::create();
        });

        // If access token was provided, then instantiate and add to middleware
        if ($config->has('access_token')
            && $config->get('access_token') !== null
        ) {

            // Convert the JSON serialized token into an `AccessToken` instance.
            $config->set(
                'access_token',
                new AccessToken(json_decode($config->get('access_token'), true))
            );
        }

        $this->addMiddleware();
    }
938104
public function register(Container $container)
    {
        $this->registerFinder($container);
        $this->registerSections($container);
        $this->registerTemplate($container);
        $this->registerEngine($container);
    }
149391
public function register()
    {
        $this->app->singleton('shield', function (Container $app) {
            $config = $app['config']['shield.users'];

            return new Shield($config);
        });

        $this->app->alias('shield', Shield::class);
    }