Register related service providers
964717
private function registerServiceProviders()
    {
        $this->app->register( ArboryTranslationServiceProvider::class );
        $this->app->register( TranslatableServiceProvider::class );
        $this->app->register( ArboryFileServiceProvider::class );
        $this->app->register( ArboryAuthServiceProvider::class );
        $this->app->register( GlideImageServiceProvider::class );
        $this->app->register( AssetServiceProvider::class );
        $this->app->register( SettingsServiceProvider::class );
        $this->app->register( ExcelServiceProvider::class );
        $this->app->register( FileManagerServiceProvider::class );
    }
49633
protected function setupProviders()
    {
        // Register Sentinel Package
        // - Used for authentication, authorization, roles, and permissions.
        $this->app->register(SentinelServiceProvider::class);

        // Register Ekko Package
        // - Used for blade templates to trigger active classes for navigation items.
        $this->app->register(EkkoServiceProvider::class);

        // Register Flash Package
        // - Used for easy flash session notifications and messages.
        $this->app->register(FlashServiceProvider::class);

        // Register Form Package
        // - Used for HTML form building with easy and readable API.
        $this->app->register(FormServiceProvider::class);

        // Register Bootstrap Form Package
        // - Used for HTML form building with easy and readable API (Bootstrap 3).
        $this->app->register(BootFormsServiceProvider::class);
    }
305389
public function registerHookProviders()
    {
        // load only the enabled hooks
        $hooks = $this->app['hooks']->hooks()->where('enabled', true);
        $loader = AliasLoader::getInstance();

        foreach ($hooks as $hook) {
            // load providers
            foreach ($hook->getProviders() as $provider) {
                $this->app->register($provider);
            }

            // set aliases
            foreach ($hook->getAliases() as $alias => $class) {
                $loader->alias($alias, $class);
            }
        }
    }
12961
private function registerServices(): void
    {
        $services = ExchangerRegistry::getServices();

        foreach ($services as $name => $class) {
            self::register($name, $class);
        }
    }
708137
protected function registerServices()
    {
        $this->app->singleton('hashid', function ($app) {
            return new HashidManager($app);
        });
        $this->app->alias('hashid', HashidManager::class);

        foreach ($this->getSingletonDrivers() as $class) {
            $this->app->singleton(
                $key = $this->getBindingKeyForDriver($class),
                function () use ($class) {
                    return new $class;
                }
            );
            $this->app->alias($key, $class);
        }

        foreach ($this->getNonSingletonDrivers() as $class) {
            $this->app->bind($this->getBindingKeyForDriver($class), $class);
        }
    }
1064803
def register(self, service):
        
        if service.name not in self.services.keys():
            logger.debug('StackInABox({0}): Registering Service {1}'
                         .format(self.__id, service.name))
            regex = '^/{0}/'.format(service.name)
            self.services[service.name] = [
                re.compile(regex),
                service
            ]
            service.base_url = StackInABox.__get_service_url(self.base_url,
                                                             service.name)
            logger.debug('StackInABox({0}): Service {1} has url {2}'
                         .format(self.__id, service.name, service.base_url))
        else:
            raise ServiceAlreadyRegisteredError(
                'Service {0} is already registered'.format(service.name))
422366
protected function registerConnectionServices()
    {
        // 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->getContainer()->share('db.factory', ConnectionFactory::class);

        // 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->getContainer()->share('db', DatabaseManager::class)
            ->withArgument(Application::class)
            ->withArgument(ConnectionFactory::class);

        $this->getContainer()->share('db.connection', function () {
            return app('db')->connection();
        });
    }
1349389
protected function registerBaseServices()
    {
        $widget = $this->app->make('antares.widget');
        $this->app->instance('antares.platform.menu', $widget->make('menu.antares'));
        $this->app->instance('antares.platform.acl', $this->app->make('antares.acl')->make('antares'));
        $this->app->instance('app.menu', $widget->make('menu.app'));
    }
24141
protected function registerAdditionalProviders()
    {
        foreach ($this->providers as $provider) {
            if (class_exists($provider)) {
                $this->app->register($provider);
            }
        }
    }
1213158
protected function registerServices()
    {
        foreach (Antvel::bindings() as $key => $value) {
            is_numeric($key)
                ? $this->app->singleton($value)
                : $this->app->singleton($key, $value);
        }
    }
1207491
protected function registerDevProviders()
    {
        // Get Dev providers key.
        $devProviderKey = 'dev-booter.dev_providers_config_keys.'.$this->app->environment();

        // Register All dev providers.
        $this->collectDevServiceProviders($devProviderKey)->each(function ($devServiceProviders) {
            $this->app->register($devServiceProviders);
        });
    }
895581
protected function registerSingletons()
    {
        App::singleton('cms.helper', function () {
            return new \Cms\Helpers\Cms;
        });

        App::singleton('backend.helper', function () {
            return new \Backend\Helpers\Backend;
        });

        App::singleton('backend.menu', function () {
            return \Backend\Classes\NavigationManager::instance();
        });

        App::singleton('backend.auth', function () {
            return \Backend\Classes\AuthManager::instance();
        });
    }
1035876
public function registerConfiguredProviders()
	{
		$manifestPath = $this->getCachedServicesPath();

		(new ProviderRepository($this, new Filesystem, $manifestPath))
					->load($this->config['app.providers']);
	}
390304
public function register()
    {   
        $providers = config('app','core_providers');
        foreach ($providers as $key => $value) {
            $this->getContainer()->add($value);
        }
    }
801462
protected function registerBaseServiceProviders()
    {
        $providers = [
            AliasesServiceProvider::class,
            \Collective\Html\HtmlServiceProvider::class,
            BreadcrumbsServiceProvider::class,
            AdminServiceProvider::class,
        ];

        /* Workaround to allow use ServiceProvider-based configurations in old fashion */
        if (is_file(app_path('Providers/AdminSectionsServiceProvider.php'))) {
            $providers[] = $this->app->getNamespace().'Providers\\AdminSectionsServiceProvider';
        }

        $manifestPath = $this->app->bootstrapPath().'/cache/sleepingowladmin-services.php';

        (new ProviderRepository($this->app, new Filesystem(), $manifestPath))->load($providers);
    }
21761
protected function registerBaseServiceProviders()
    {
        $this->register(ConfigServiceProvider::class);
        $this->register(ServerRequestCreatorServiceProvider::class);
        $this->register(HttpFactoriesServiceProvider::class);
        $this->register(LoggerServiceProvider::class);
        $this->register(RouterServiceProvider::class);
        $this->register(MiddlewaresServiceProvider::class);
        $this->register(ErrorHandlerServiceProvider::class);
    }
586758
protected function registerBaseServiceProviders()
    {
        $this->register(new \Illuminate\Events\EventServiceProvider($this));
        $this->register(new \Illuminate\Log\LogServiceProvider($this));
        $this->register(new \LaraPress\Actions\ActionServiceProvider($this));
        $this->register(new \LaraPress\Filters\FilterServiceProvider($this));
        $this->register(new \LaraPress\Routing\RoutingServiceProvider($this));
    }