Register the services.
763458
public function register()
    {
        $loader = AliasLoader::getInstance();

        $loader->alias('Cms', \Grafite\Cms\Facades\CmsServiceFacade::class);
        $loader->alias('PageService', \Grafite\Cms\Facades\PageServiceFacade::class);
        $loader->alias('EventService', \Grafite\Cms\Facades\EventServiceFacade::class);
        $loader->alias('CryptoService', \Grafite\Cms\Facades\CryptoServiceFacade::class);
        $loader->alias('ModuleService', \Grafite\Cms\Facades\ModuleServiceFacade::class);
        $loader->alias('BlogService', \Grafite\Cms\Facades\BlogServiceFacade::class);
        $loader->alias('FileService', \Grafite\Cms\Services\FileService::class);

        $this->app->bind('CmsService', function ($app) {
            return new CmsService();
        });

        $this->app->bind('PageService', function ($app) {
            return new PageService();
        });

        $this->app->bind('EventService', function ($app) {
            return App::make(EventService::class);
        });

        $this->app->bind('CryptoService', function ($app) {
            return new CryptoService();
        });

        $this->app->bind('ModuleService', function ($app) {
            return new ModuleService();
        });

        $this->app->bind('BlogService', function ($app) {
            return new BlogService();
        });
    }
635503
public function register()
    {
        $this->container['config']->addLocation($this->container->basePath().'/dev/config');

        foreach ($this->container['config']->get('app.providers') as $provider) {
            $this->container->addProvider($provider);
        }
    }
550315
public function register()
  {
    $listeners = $this->app['config']->get('commander::listeners');
    $namespace = $this->app['config']->get('commander::listener_namespace');

    foreach($listeners as $listener)
    {
      $this->app['events']->listen($namespace . '.*', $listener);
    }
  }
858100
public function register()
    {
        $this->setupConfig();

        $services = config('microservice.services');
        $currentEnv = app()->environment();

        /** @var array $services */
        foreach ($services as $service) {
            if ($service['enabled'] && $this->isInCurrentEnv($currentEnv, $service['environments'])) {
                if (array_get($service, 'config')) {
                    $this->app->configure($service['config']);
                }

                $this->app->register($service['provider']);
            }
        }

        app()->middleware(ConvertEmptyStringsToNull::class);
    }
272983
public function register()
    {
        $this->core = app(Component::CORE);

        $this->registerSentinel()
             ->registerAuthRepository()
             ->registerCommands()
             ->publishMigrations();
    }
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.");
    }
1091213
protected function registerBaseServices(): void
    {
        $this->services['acl'] = $this->app->make('orchestra.acl')->make('orchestra');
        $this->app->instance('orchestra.platform.acl', $this->services['acl']);

        $this->services['menu'] = $this->widget('menu');
        $this->app->instance('orchestra.platform.menu', $this->services['menu']);
    }
841305
public function register()
    {
        $this->registerMediaSort();

        if ($this->app->runningInConsole()) {
            $this->registerResources();
            $this->registerCommands();
        }

        $this->mergeConfigFrom(
            __DIR__ . '/../config/mediasort.php', 'mediasort'
        );
    }
1255182
public function register()
    {
        if (class_exists('\\TastPHP\\Service\\ServiceKernel')) {
            $this->app['serviceKernel'] = \TastPHP\Service\ServiceKernel::instance();
            $this->app['serviceKernel']->setContainer($this->app);
            $this->app['serviceKernel']->setConnection($this->app['dbs']);
            if (!empty($this->app['serviceKernel']->getConnection()['master'])) {
                $this->app['serviceKernel']->getConnection()['master']->exec("SET names utf8mb4");
            }
        }
    }
412963
public function register()
    {
        $this->shareWithApp();
        $this->setPublishGroups();
        $this->registerAliases();
        $this->registerViews();
        $this->registerArtisanCommands();
    }
618084
public function register()
    {
        parent::register();

        $this->registerConfig();
        $this->registerArcanesoftDatabase();
        $this->registerProviders([
            Providers\AuthorizationServiceProvider::class,
            Providers\RouteServiceProvider::class,
            Providers\PackagesServiceProvider::class,
        ]);
    }
474954
public function register()
    {
        $commands = array(
            'PackageList',
            'PackageMigrate',
            'PackageMigrateRefresh',
            'PackageMigrateReset',
            'PackageMigrateRollback',
            'PackageMigrateStatus',
            'PackageSeed',
            'PackageOptimize',

            //
            'PackageMake',
            'ConsoleMake',
            'ControllerMake',
            'EventMake',
            'JobMake',
            'ListenerMake',
            'MiddlewareMake',
            'ModelMake',
            'NotificationMake',
            'PolicyMake',
            'ProviderMake',
            'MigrationMake',
            'RequestMake',
            'SeederMake',
        );

        foreach ($commands as $command) {
            $method = 'register' .$command .'Command';

            call_user_func(array($this, $method));
        }
    }
363418
public function register()
    {
        if (! $this->config->shouldIntegrateHorizon) {
            return;
        }

        $this->config->loadHorizonConfiguration();

        $this->registerServices();

        if ($this->shouldRebindHorizonRedisFactory()) {
            $this->rebindHorizonRedisFactory();
        }
    }
1249297
protected function registerServices()
    {
        $this->app->bindShared('modules', function ($app) {
            $path = $app['config']->get('modules.paths.modules');

            return new Repository($app, $path);
        });
    }
224132
public function register() : void
    {
        $environment = $this->app->environment();

        $providers = $this->app['config']->get('app.' . $environment . '_providers', []);

        foreach ($providers as $provider) {
            $this->app->register($provider);
        }

        $facades = $this->app['config']->get('app.' . $environment . '_aliases', []);

        foreach ($facades as $class => $name) {
            AliasLoader::getInstance()->alias($class, $name);
        }
    }
61790
public function register()
    {
        $this->container->bind('config', new Repository(
            new FileLoader(
                new Filesystem,
                $this->container->appPath().'/config'
            ),
            new Resolver,
            $this->container->os()
        ));
    }
887940
public function register()
    {
        $this->registerConfig();

        $this->registerClassAliases();

        $this->app->register(RoutingServiceProvider::class);

        $this->app->register(HttpServiceProvider::class);

        $this->registerExceptionHandler();

        $this->registerDispatcher();

        $this->registerAuth();

        $this->registerTransformer();

        $this->registerDocsCommand();
    }