Register the application services.

@return void
330958
public function register()
    {
        $this->app->register('ProAI\Datamapper\Providers\MetadataServiceProvider');

        $this->registerEntityScanner();

        $this->registerSchemaBuilder();

        $this->registerModelGenerator();

        $this->registerCommands();
    }
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);
        });
    }
715798
public function register()
    {
        $this->registerConfig();

        $this->app->singleton(PrestashopWebService::class, function () {
            return new PrestashopWebService(
                config('prestashop-webservice.url'),
                config('prestashop-webservice.token'),
                config('prestashop-webservice.debug')
            );
        });
    }
826567
public function register()
    {
        $this->app->singleton('agent', function ($app) {
            return new Agent($app['request']->server());
        });

        $this->app->alias('agent', Agent::class);
    }
61790
public function register()
    {
        $this->container->bind('config', new Repository(
            new FileLoader(
                new Filesystem,
                $this->container->appPath().'/config'
            ),
            new Resolver,
            $this->container->os()
        ));
    }
841305
public function register()
    {
        $this->registerMediaSort();

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

        $this->mergeConfigFrom(
            __DIR__ . '/../config/mediasort.php', 'mediasort'
        );
    }
1150386
public function register()
    {
        $this->registerBindingsServiceProviderMakeCommand();
        $this->registerMakeCommand();
        $this->registerRepositoryInterfaceMakeCommand();
        $this->registerServiceMakeCommand();
        $this->registerTraitMakeCommand();
    }
1051415
public function register()
    {
        $this->app->register(\Netcore\Translator\ServiceProvider::class);

        $this->commands([
            ImportTranslations::class,
            FindTranslations::class,
        ]);
    }
886362
public function register()
    {
        $this->registerConnectionServices();
        $this->registerEloquentFactory();
        $this->registerQueueableEntityResolver();

        Model::setConnectionResolver($this->container['db']);
        Model::setEventDispatcher($this->container['events']);
        Model::clearBootedModels();
        Model::observe(InternalObserve::class);
    }
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');
    }
1259699
public function register()
    {
        $this->registerAuthenticator();

        $this->registerPasswordService();

        $this->registerThrottleService();

        $this->registerUserResolver();

        $this->registerRequestRebindHandler();
    }
893562
public function register()
    {
        $this->registerAddressValidation();
        $this->registerSimpleAddressValidation();
        $this->registerQuantumView();
        $this->registerTracking();
        $this->registerRate();
        $this->registerTimeInTransit();
        $this->registerLocator();
        $this->registerTradeability();
        $this->registerShipping();
    }
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;
    }
967172
public function register()
    {
        $this->app->singleton('command.models.generate', function($app) {
            $db = $app['db.connection'];
            $driverClass = __NAMESPACE__.'\Drivers\\'.ucfirst($db->getDriverName()).'Driver';
            $driver = new $driverClass($db->getPdo());

            $builder = new Builder($app['config'], $driver);

            return new Console\GenerateCommand($builder);
        });

        $this->commands([
            'command.models.generate'
        ]);
    }
140407
public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/../config/config.php', 'litecms.page');

        $this->app->bind('page', function ($app) {
            return $this->app->make('Litecms\Page\Page');
        });

        $this->app->bind(
            'Litecms\Page\Interfaces\PageRepositoryInterface',
            \Litecms\Page\Repositories\Eloquent\PageRepository::class
        );

        $this->app->register(\Litecms\Page\Providers\AuthServiceProvider::class);
        $this->app->register(\Litecms\Page\Providers\EventServiceProvider::class);
        $this->app->register(\Litecms\Page\Providers\RouteServiceProvider::class);
    }
313917
public function register()
    {
        $this->app->register('Laracasts\Flash\FlashServiceProvider');
        $this->app->register('Yajra\Datatables\DatatablesServiceProvider');
        $this->app->register('Cartalyst\Sentinel\Laravel\SentinelServiceProvider');
        $this->app->register('Intervention\Image\ImageServiceProvider');
        $this->app->register('Snowfire\Beautymail\BeautymailServiceProvider');

        $this->mergeConfigFrom(
            __DIR__.'/../config/laravel-modules-base.php', 'laravel-modules-base'
        );

        $this->app->booting(function()
        {
            $loader = \Illuminate\Foundation\AliasLoader::getInstance();
            $loader->alias('Sentinel', 'Cartalyst\Sentinel\Laravel\Facades\Sentinel');
        });

        $router = $this->app['router'];
        $router->middleware('permission',\ErenMustafaOzdal\LaravelModulesBase\Middlewares\Permission::class);
        $router->middleware('nested_model',\ErenMustafaOzdal\LaravelModulesBase\Middlewares\NestedModel::class);
        $router->middleware('related_model',\ErenMustafaOzdal\LaravelModulesBase\Middlewares\RelatedModel::class);

        // register services
        $this->registerCollectionService();
        $this->registerPermissionService();

        $this->app->booting(function() {
            $loader = \Illuminate\Foundation\AliasLoader::getInstance();
            $loader->alias('LMBCollection', 'ErenMustafaOzdal\LaravelModulesBase\Facades\Collection');
            $loader->alias('LMBPermission', 'ErenMustafaOzdal\LaravelModulesBase\Facades\Permission');

            // register validation
            $this->registerValidationRules($this->app['validator']);
        });

        // model binding
        $router->model(config('laravel-modules-base.url.province'),  'App\Province');
        $router->model(config('laravel-modules-base.url.county'),  'App\County');
        $router->model(config('laravel-modules-base.url.district'),  'App\District');
        $router->model(config('laravel-modules-base.url.neighborhood'),  'App\Neighborhood');
        $router->model(config('laravel-modules-base.url.postal_code'),  'App\PostalCode');
    }
1164661
public function register()
    {
        $this->loadRoutesFrom(__DIR__.'/routes/web.php');
        $this->loadViewsFrom(__DIR__.'/resources/views/', 'laravel2step');
        $this->loadMigrationsFrom(__DIR__.'/database/migrations');
        $this->mergeConfigFrom(__DIR__.'/config/laravel2step.php', 'laravel2step');
        $this->publishFiles();
    }