Register service bindings.
193560
private function registerServiceBindings()
    {
        $this->set(KernelInterface::class, \DI\object(Kernel::class));
        $this->set(ConfigurationHandler::class, \DI\object(SharedConfiguration::class));
    }
695798
protected function registerServices()
    {
        $services = array_filter($this->config->get('app.services'), function ($service) {
            return class_exists($service);
        });

        foreach ($services as $service) {
            /** @var \Fyuze\Kernel\Service $obj */
            $obj = new $service($this->container);
            $obj->services();

            $this->services[] = $obj;
        }
    }
770096
protected function registerBindings()
    {
        $this->app->singleton('assetLoader', 'Monarkee\Bumble\Repositories\FieldAssetRepository');

        $this->app->singleton('bumblestr', function ()
        {
            return $this->app->make('Monarkee\Bumble\Support\BumbleStr');
        });

        $this->app->singleton('bumble-gravatar', function ()
        {
            return $this->app->make('Monarkee\Bumble\Support\Gravatar');
        });

        $this->app->bind('Monarkee\Bumble\Repositories\ModelRepository', 'Monarkee\Bumble\Repositories\ArrayConfigModelRepository');
    }
234360
protected function registerBindings()
    {
        $this->app->bind(
            \LaravelFlare\Flare\Contracts\Permissions\Permissionable::class,
            \Flare::config('permissions')
        );
    }
607174
protected function registerServiceProviders()
    {
        foreach ($this->serviceProviders[$this->flare->compatibility()] as $class) {
            $this->app->register($class);
        }
    }
12961
private function registerServices(): void
    {
        $services = ExchangerRegistry::getServices();

        foreach ($services as $name => $class) {
            self::register($name, $class);
        }
    }
835486
public function register()
    {
        $this->registerBindings();
        $this->app['events']->listen(BuildingSidebar::class, RegisterThemeSidebar::class);

        $this->app['events']->listen(LoadingBackendTranslations::class, function (LoadingBackendTranslations $event) {
            // append translations
        });
    }
20428
protected function registerServicesAliases()
    {
        foreach (Antvel::alias() as $key => $value) {
            $this->app->alias($value, $key);
        }
    }
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);
    }
184941
def register_service_functions(self, *funcs):
        
        for func in funcs:
            self.namespace[func.__name__] = func
1213158
protected function registerServices()
    {
        foreach (Antvel::bindings() as $key => $value) {
            is_numeric($key)
                ? $this->app->singleton($value)
                : $this->app->singleton($key, $value);
        }
    }
469800
public function register()
    {
        $this->bindContracts();
        $this->bindConfig();
        $this->bindSender();
        $this->bindResolver();
        $this->bindNotifynder();

        $this->registerSenders();
    }
1143199
public final void register() {
        synchronized (this) {
            if (filterFactoryServiceRegistration != null) {
                throw new IllegalStateException(String.format("%s [%s] has been registered.", getClass()
                    .getSimpleName(), this));
            }
            filterFactoryServiceRegistration = bundleContext.registerService(SERVICE_CLASSES, this, properties);
            LOGGER.info("Registered filterFactory for application {} with priority {}", getApplicationName(),
                getPriority());
        }
    }
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);
    }
935060
protected function registerServices()
    {
        $this->app->bindIf('redis-sentinel', function ($app) {
            return VersionedManagerFactory::make($this->app, $this->config);
        }, true);

        $this->app->bindIf('redis-sentinel.manager', function ($app) {
            return $app->make('redis-sentinel')->getVersionedManager();
        }, true);
    }
560018
protected function registerServices()
    {
        $this->app->singleton('modules', function ($app) {
            $path = $app['config']->get('modules.paths.modules');

            return new Repository($app, $path);
        });
    }
201298
protected void registerSelf() {
        publishSelf();
        serviceRegistry.get().registerService(getServiceDescription());
        serviceRegistry.get().subscribe((pair, err) -> {
            serviceEvent(pair.car(), pair.cdr(), err);
        });
        heartBeat();
        Log.Info(this, "registered at serviceRegistry.");
    }