Register the service provider.
507736
public function register()
    {
        $this->app->singleton('server.factory', function ($app) {
            return new ServerFactory($app);
        });

        // By default, the server manager creates a server instance based on the
        // 'server' configuration. We can easily get it through the IoC container
        // or the server facade.
        $this->app->singleton('server', function ($app) {
            return new ServerManager($app, $app['server.factory'], $app['config']['server']);
        });

        // We can get a Swoole server instance from server, this allows us to easily
        // perform in-depth operations.
        $this->app->singleton('server.swoole', function ($app) {
            return $app['server']->getSwooleServer();
        });

        $this->registerCommands($this->commands);
    }
470498
public function register()
    {
        //Config
        $this->app->singleton(CoreConfig::class, function ($app) {
            return new CoreConfig();
        });

        //Facade
        $this->app->alias(CoreService::class, 'core-service');
    }
804318
public function register()
    {
        parent::register();

        $this->registerConfig();

        $this->registerLogViewer();
        $this->registerAliases();

        $this->registerProviders([
            Providers\UtilitiesServiceProvider::class,
            Providers\RouteServiceProvider::class,
        ]);
        $this->registerConsoleServiceProvider(Providers\CommandsServiceProvider::class);
    }
842388
public function register()
    {
        $this->registerSessionStore();
        $this->registerTranslator();
        $this->registerFlasher();
        $this->registerFlash();
        $this->registerFlashAlias();
    }
849393
public function register()
    {
        $this->resolveDirectories();

        $this->tryRequireHelpers(self::ON_REGISTER);
        $this->tryRegisterProviders(self::ON_REGISTER);

        if (method_exists($this, $this->bootingMethod)) {
            $this->app->booting(function (Application $app) {
                $app->call([$this, $this->bootingMethod]);
            });
        }

        if (method_exists($this, $this->bootedMethod)) {
            $this->app->booted(function (Application $app) {
                $app->call([$this, $this->bootedMethod]);
            });
        }

        // Config
        $this->registerConfigFiles();

        // Middlewares
        if (!$this->app->runningInConsole()) {
            $router = $this->app->make('router');
            $kernel = $this->app->make('Illuminate\Contracts\Http\Kernel');

            foreach ($this->prependMiddleware as $middleware) {
                $kernel->prependMiddleware($middleware);
            }

            foreach ($this->middleware as $middleware) {
                $kernel->pushMiddleware($middleware);
            }

            foreach ($this->routeMiddleware as $key => $middleware) {
                $router->middleware($key, $middleware);
            }
        }

        // Container bindings and aliases
        foreach ($this->bindings as $binding => $class) {
            $this->app->bind($binding, $class);
        }

        foreach ($this->weaklings as $binding => $class) {
            $this->bindIf($binding, $class);
        }

        foreach (['share' => $this->share, 'shared' => $this->shared] as $type => $bindings) {
            foreach ($bindings as $binding => $class) {
                $this->share($binding, $class, [], $type === 'shared');
            }
        }

        foreach ($this->singletons as $binding => $class) {
            if ($this->strict && !class_exists($class) && !interface_exists($class)) {
                throw new \Exception(get_called_class().": Could not find alias class [{$class}]. This exception is only thrown when \$strict checking is enabled");
            }
            $this->app->singleton($binding, $class);
        }

        foreach ($this->aliases as $alias => $full) {
            if ($this->strict && !class_exists($full) && !interface_exists($full)) {
                throw new \Exception(get_called_class().": Could not find alias class [{$full}]. This exception is only thrown when \$strict checking is enabled");
            }
            $this->app->alias($alias, $full);
        }

        // Commands
        if ($this->app->runningInConsole()) {
            foreach ($this->findCommands as $path) {
                $dir = path_get_directory((new ReflectionClass(get_called_class()))->getFileName());
                $classes = $this->findCommandsIn(path_join($dir, $path), $this->findCommandsRecursive);

                $this->commands = array_merge($this->commands, $classes);
            }
            if (is_array($this->commands) && count($this->commands) > 0) {
                $commands = [];
                foreach ($this->commands as $k => $v) {
                    if (is_string($k)) {
                        $this->app[ $this->commandPrefix.$k ] = $this->app->share(function ($app) use ($k, $v) {
                            return $app->build($v);
                        });

                        $commands[] = $this->commandPrefix.$k;
                    } else {
                        $commands[] = $v;
                    }
                }
                $this->commands($commands);
            }
        }
        // Facades
        if (class_exists('Illuminate\Foundation\AliasLoader')) {
            \Illuminate\Foundation\AliasLoader::getInstance($this->facades)->register();
        }

        // Helpers
        $this->tryRequireHelpers(self::ON_REGISTERED);

        $this->tryRegisterProviders(self::ON_REGISTERED);

        return $this->app;
    }
639039
public function register()
    {
        $this->registerLockdownConfiguration();
        $this->registerLockdownFacade();
        $this->registerUserProvider();
        $this->registerRoleProvider();
        $this->registerPermissionProvider();
        $this->registerLockdown();
        $this->registerLockdownGuard();
        $this->registerCommands();
    }
30117
public function register()
    {
        $this->app->register(\TwigBridge\ServiceProvider::class);
        AliasLoader::getInstance()->alias('Twig', \TwigBridge\Facade\Twig::class);
    }
677248
public function register()
    {
        $this->instances = [];

        foreach ($this->providers as $provider) {
            Zilf::$container->register($provider, $provider);
            $this->instances[] = Zilf::$container->get($provider)->register();
        }
    }
978879
public function register()
  {
    $middleware = ($this->middleware !== null) ? ['middleware' => $this->middleware] : [];
    $prefix     = ($this->prefix !== null) ? ['prefix' => $this->prefix] : [];
    $domain     = ($this->domain !== null) ? ['domain' => $this->domain] : [];

    Swish::group(array_merge($domain, $middleware, $prefix), function() {
      startphp($this->file);
    });
  }
1093098
public function register()
    {
        parent::register();

        $this->registerConfig();
        $this->registerSidebarItems();
        $this->registerProviders([
            Providers\AuthorizationServiceProvider::class,
            Providers\RouteServiceProvider::class,
        ]);
        $this->registerConsoleServiceProvider(Providers\ConsoleServiceProvider::class);

        $this->syncFilesystemConfig();
        $this->registerMediaManager();
    }
719980
public function register()
    {
        $bindings = $this->bindings();
        count($bindings) > 0 && App::bind($bindings);

        $providers = $this->providers();
        count($providers) > 0 && App::register($providers);

        $config = $this->config();
        count($config) > 0 && Config::push($config);

        $subscribers = $this->subscribers();
        count($subscribers) > 0 && Event::register($subscribers);

        $this->routes();
    }
464253
public function register()
    {
        $this->registerRepository();
        $this->registerMigrator();
        $this->registerTranslation();
        // for create migration
        $this->registerCreator();
        // for create migration

        // add commands
        $this->registerCommands();


    }
340319
public function register()
    {
        $this->registerAliases();

        $this->registerProviders();

        if ($this->isLoadFilesOnBoot() === false) {
            $this->registerFiles();
        }

        $this->fireEvent('register');
    }
177595
public function register()
    {
        $this->app->singleton(Client\ApiClient::class, function () {

            $kollusApiClient = new Client\ApiClient(
                config('kollus.domain'),
                config('kollus.api_version'),
                config('kollus.language')
            );

            $serviceAccount = new Container\ServiceAccount([
                'key' => config('kollus.service_account.key'),
                'api_access_token' => config('kollus.service_account.api_access_token')
            ]);

            $kollusApiClient->setServiceAccount($serviceAccount);
            $kollusApiClient->connect();
            if (config('kollus.use_https')) {
                $kollusApiClient->setSchema('https');
            }

            return $kollusApiClient;
        });

        $this->app->singleton(Client\VideoGatewayClient::class, function () {

            $kollusVideoGatewayClient = new Client\VideoGatewayClient(
                config('kollus.domain'),
                config('kollus.api_version'),
                config('kollus.language')
            );

            $serviceAccount = new Container\ServiceAccount([
                'key' => config('kollus.service_account.key'),
                'custom_key' => config('kollus.service_account.custom_key'),
                'security_key' => config('kollus.service_account.security_key', null),
            ]);
            if (config('kollus.use_https')) {
                $kollusVideoGatewayClient->setSchema('https');
            }

            $kollusVideoGatewayClient->setServiceAccount($serviceAccount);
            $kollusVideoGatewayClient->connect();

            return $kollusVideoGatewayClient;
        });

        $this->app->singleton(Callback::class, function () {

            $serviceAccount = new Container\ServiceAccount([
                'key' => config('kollus.service_account.key'),
                'custom_key' => config('kollus.service_account.custom_key'),
                'security_key' => config('kollus.service_account.security_key'),
            ]);

            $kollusCallback = new Callback($serviceAccount);

            return $kollusCallback;
        });
    }
363418
public function register()
    {
        if (! $this->config->shouldIntegrateHorizon) {
            return;
        }

        $this->config->loadHorizonConfiguration();

        $this->registerServices();

        if ($this->shouldRebindHorizonRedisFactory()) {
            $this->rebindHorizonRedisFactory();
        }
    }
546006
public function register()
    {
        $this->registerConfig();
        $this->registerEventLoop();
        $this->registerConnector();
        $this->registerFactory();
        $this->registerDongleUssd();
        $this->registerAmiListen();
        $this->registerAmiAction();
        $this->registerDongleSms();
        $this->registerAmiCli();
        $this->commands([
            'command.ami.dongle.ussd',
            'command.ami.dongle.sms',
            'command.ami.listen',
            'command.ami.action',
            'command.ami.cli',
        ]);
    }
248680
public function register()
    {
        parent::register();

        $this->registerConfig();

        $this->registerProvider(Providers\UtilityServiceProvider::class);

        $this->singleton(Contracts\SeoHelper::class, SeoHelper::class);
    }