Register the application services.

@return void
15046
public function register()
    {
		$this->mergeConfigFrom(__DIR__.'/Publish/publish.php', 'publish');
        $this->app->singleton('command.mekramy.publisher.command', function ($app) {
            return $app['MEkramy\Publisher\Commands\ConsoleInterface'];
        });
        $this->commands('command.mekramy.publisher.command');
    }
356157
public function register()
    {
        // merge default config
        $this->mergeConfigFrom(
            __DIR__.'/../../config/config.php',
            'httpauth'
        );

        $this->app->singleton('httpauth', function ($app) {
            return new Httpauth($app['config']->get('httpauth'));
        });
    }
52589
public function register()
    {
        $this->registerInstallCommand();
        $this->registerInfoCommand();
        $this->registerSeedCommand();
        $this->registerCacheCommand();
        $this->registerHookCommand();
    }
1052270
public function register()
    {
        $repositories = $this->getRepositories();
        $models = $this->getModelRepositories();

        foreach ($models as $repository => $model) {
            $this->app->singleton($repository, function ($app) use ($repository, $model) {
                return new $repository($app->make($model));
            });
        }

        foreach ($repositories as $interface => $repository) {
            $this->app->singleton($interface, $repository);
        }
    }
349738
public function register()
    {
        $this->registerInstallCommand();
        $this->registerAuthSettingsInstallCommand();
        $this->registerAuthFilesInstallCommand();
        $this->registerAuthModelInstallCommand();
        $this->registerAuthViewsInstallCommand();
        //$this->registerInstallMiddlewareCommand();
    }
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();
    }
440985
public function register()
    {
        $registerConfig = $this->config->getSubConfig(self::REGISTER);
        array_map('register_widget', $registerConfig->getArrayCopy());
    }
1320025
public function register()
    {
        $this->registerPermissions();
        $this->registerConfig();
        $this->registerRenderEngine();
        $this->registerBladeExtensions();

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

        $this->registerSentinel()
             ->registerAuthRepository()
             ->registerCommands()
             ->publishMigrations();
    }
156827
public function register()
    {
        $this->app->booted(function () {
            $this->registerAllThemes();
            $this->setActiveTheme();
            $this->registerActiveThemeVendorNamespaces($this->app['stylist']->current()->getPath());
        });
    }
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);
        }
    }
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;
    }
1317868
public function register()
    {
        $this->bind('logger', function ($server) {
            $name = $server->getProcessName();
            $path = $this->config('runtime_path', '') . '/logs/' . $name . '.log';

            return new Logger($name, $path);
        });
    }
1070733
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/../config/larabug.php', 'larabug');

        $this->app->singleton(LaraBug::SERVICE, function ($app) {
            return new LaraBug;
        });
    }
893562
public function register()
    {
        $this->registerAddressValidation();
        $this->registerSimpleAddressValidation();
        $this->registerQuantumView();
        $this->registerTracking();
        $this->registerRate();
        $this->registerTimeInTransit();
        $this->registerLocator();
        $this->registerTradeability();
        $this->registerShipping();
    }
601122
public function register()
    {
        $config = config('coreplex');

        $this->app->singleton('Coreplex\Core\Contracts\Renderer', function ($app) use ($config) {
            return (new ReflectionClass($config['renderer']['driver']))->newInstanceArgs([$app['view']]);
        });

        $this->app->singleton('Coreplex\Core\Contracts\Session', function ($app) use ($config) {
            return (new ReflectionClass($config['session']['driver']))->newInstanceArgs([$config['session'],
                $app['session.store']]);
        });

        $this->app->alias('Coreplex\Core\Contracts\Renderer', 'coreplex.core.renderer');
        $this->app->alias('Coreplex\Core\Contracts\Session', 'coreplex.core.session');
    }
95575
public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/../config/analytics.php', 'analytics');

        $this->app->bind(AnalyticsClient::class, function () {
            $analyticsConfig = config('analytics');

            return AnalyticsClientFactory::createForConfig($analyticsConfig);
        });

        $this->app->bind(Analytics::class, function () {
            $analyticsConfig = config('analytics');

            $this->guardAgainstInvalidConfiguration($analyticsConfig);

            $client = app(AnalyticsClient::class);

            return new Analytics($client, $analyticsConfig['view_id']);
        });

        $this->app->alias(Analytics::class, 'laravel-analytics');
    }