Register the application services.
424639
public function register()
    {
        // App
        $this->app->singleton(\Appstract\Multisite\Composers\CurrentSiteComposer::class);

        // Config
        $this->mergeConfigFrom(__DIR__.'/../config/multisite.php', 'multisite');
    }
144652
public function register()
    {
        // Registrar binds
        foreach ($this->binds as $bindId => $bindClass)
            $this->app->bind($bindId, $bindClass);

        // Registrar providers
        foreach ($this->providers as $provider => $classServiceProvider)
        {
            $this->app->singleton($provider, function ($app) use ($classServiceProvider) {
                return new $classServiceProvider($app);
            });
        }
    }
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));
        }
    }
843845
public function register()
    {
        //Load helpers
        load_module_helpers(__DIR__);

        //Merge configs
        $configs = split_files_with_basename($this->app['files']->glob(__DIR__ . '/../../config/*.php'));

        foreach ($configs as $key => $row) {
            $this->mergeConfigFrom($row, $key);
        }

        $this->app->register(RouteServiceProvider::class);
        $this->app->register(BootstrapModuleServiceProvider::class);
        $this->app->register(ViewComposerServiceProvider::class);
    }
544972
public function register()
    {
        $this->app->singleton(ServiceCaller::class, function ($app) {
            return new ServiceCaller($app);
        });

        $this->app->alias(
            ServiceCaller::class,
            AbstractServiceCaller::class
        );
    }
1015168
public function registerServices()
    {
        $this['serviceProviders'] = $this->serviceProviders;

        foreach ($this->serviceProviders as $providerArray) {
            list($provider,$enabled) = $providerArray;

            if (!$enabled) {
                continue;
            }

            if (empty($provider) || !class_exists($provider)) {
                continue;
            }

            $provider = new $provider(self::$instance);
            $provider->register();
        }
    }
269710
public function register()
    {
        $this->initializeConfigs();

        $this->registerAppVersionManager();

        $this->registerHelpers();

        $this->registerBlade();

        if ($this->app->runningInConsole()) {
            $this->registerArtisanCommands();
        }
    }
489078
public static function register()
    {
        $namespace = "Vinala\App\Events";

        foreach (get_declared_classes() as $value) {
            if (Strings::contains($value, $namespace)) {
                $name = self::getName($value);

                $events = $value::getEvents();

                if (!is_null($events)) {
                    foreach ($events as $key => $value) {
                        $data[$name.'.'.$key] = $value;
                    }
                }

                self::$listners = array_collapse([$data, self::$listners]);
            }
        }
    }
1124230
public function register()
    {
        $this->bindRouteModel();

        $this->loadAdminAuthConfig();

        $this->registerRouteMiddleware();

        $this->registerPolicies();

        $this->commands($this->commands);
    }
12961
private function registerServices(): void
    {
        $services = ExchangerRegistry::getServices();

        foreach ($services as $name => $class) {
            self::register($name, $class);
        }
    }
623249
public function register()
    {
        if ($this->app instanceof LumenApplication) {
            $this->app->configure('phpsms');
        }
        $this->mergeConfigFrom(__DIR__ . '/../config/phpsms.php', 'phpsms');

        $this->app->singleton('Toplan\\PhpSms\\Sms', function () {
            Sms::scheme(config('phpsms.scheme', []));
            Sms::config(config('phpsms.agents', []));

            return new Sms(false);
        });
    }
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;
        }
    }
422664
public function register()
    {
        // Register 'defaultprofileimage' instance container to our defaultprofileimage object
        $this->app->singleton('defaultprofileimage', function($app)
        {
            return new DefaultProfileImage;
        });

        // Shortcut so developers don't need to add an Alias in app/config/app.php
        $this->app->booting(function()
        {
            $loader = \Illuminate\Foundation\AliasLoader::getInstance();
            $loader->alias('DefaultProfileImage', 'A6digital\Image\Facades\DefaultProfileImage');
        });
    }
749671
public function register()
    {
        $this->app->register('Collective\Html\HtmlServiceProvider');
        $this->app->register('Zofe\Burp\BurpServiceProvider');
        
        Rapyd::setContainer($this->app);
   
        $this->app->booting(function () {
            $loader  =  \Illuminate\Foundation\AliasLoader::getInstance();

            $loader->alias('Input', 'Illuminate\Support\Facades\Input');
            
            $loader->alias('Rapyd'     , 'Zofe\Rapyd\Facades\Rapyd'     );
            
            //deprecated .. and more facade are really needed ?
            $loader->alias('DataSet'   , 'Zofe\Rapyd\Facades\DataSet'   );
            $loader->alias('DataGrid'  , 'Zofe\Rapyd\Facades\DataGrid'  );
            $loader->alias('DataForm'  , 'Zofe\Rapyd\Facades\DataForm'  );
            $loader->alias('DataEdit'  , 'Zofe\Rapyd\Facades\DataEdit'  );
            $loader->alias('DataFilter', 'Zofe\Rapyd\Facades\DataFilter');
            $loader->alias('DataEmbed' , 'Zofe\Rapyd\Facades\DataEmbed');
            $loader->alias('DataTree' , 'Zofe\Rapyd\Facades\DataTree');
            $loader->alias('Documenter', 'Zofe\Rapyd\Facades\Documenter');


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

        //Facade
        $this->app->alias(CoreService::class, 'core-service');
    }
782650
public function register()
    {
        $this->config = ConfigurationLoader::load($this->app);

        $this->registerServices();

        // If we want Laravel's Redis API to use Sentinel, we'll return an
        // instance of the RedisSentinelManager when requesting the "redis"
        // service:
        if ($this->config->shouldOverrideLaravelRedisApi) {
            $this->registerOverrides();
        }
    }
884568
public function register()
    {
        $this->app->bind('maxfactor', Maxfactor::class);
        $this->app->bind('mx-countries', Countries::class);
        $this->app->bind('mx-format', Format::class);
        $this->app->bind('mx-video', Video::class);

        $this->publishConfigs();
    }