Register the router adapter.

@return void
11781
protected function registerRouterAdapter()
    {
        $this->app->singleton('api.router.adapter', function($app) {
            return new DingoRoutingLaravelAdapter($this->cloneLaravelRouter(), $app['router']->getRoutes());
        });
    }
182929
protected function registerPostAdapter()
    {
        $this->app->bind('adapter.post', function ($app) {
            return new Post($app['config']);
        });

        $this->app->alias('adapter.post', Post::class);
    }
617808
public function registerRoutes()
    {
        $this->_route = new Route();
        $this->_config = Config::from('app');

        $router = $this; // MUST KEEP!!!!!!!!!

        require_once $this->_config->from('app')->get('routes');
    }
171355
protected static function registerRoutes()
    {
        parent::routes(function ($router) {
            /* @var \Illuminate\Routing\Router $router */
            $router->get('redis', 'Encore\Admin\RedisManager\RedisController@index')->name('redis-index');
            $router->delete('redis/key', 'Encore\Admin\RedisManager\RedisController@destroy')->name('redis-key-delete');
            $router->get('redis/fetch', 'Encore\Admin\RedisManager\RedisController@fetch')->name('redis-fetch-key');
            $router->get('redis/create', 'Encore\Admin\RedisManager\RedisController@create')->name('redis-create-key');
            $router->post('redis/store', 'Encore\Admin\RedisManager\RedisController@store')->name('redis-store-key');
            $router->get('redis/edit', 'Encore\Admin\RedisManager\RedisController@edit')->name('redis-edit-key');
            $router->put('redis/key', 'Encore\Admin\RedisManager\RedisController@update')->name('redis-update-key');
            $router->delete('redis/item', 'Encore\Admin\RedisManager\RedisController@remove')->name('redis-remove-item');

            $router->get('redis/console', 'Encore\Admin\RedisManager\RedisController@console')->name('redis-console');
            $router->post('redis/console', 'Encore\Admin\RedisManager\RedisController@execute')->name('redis-execute');
        });
    }
1267766
public function register()
    {
        //Load helpers
        Helper::loadModuleHelpers(__DIR__);

        $this->app->singleton(ExceptionHandler::class, config('webed.exception_handler', Handler::class));

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

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

        /**
         * @var Router $router
         */
        $router = $this->app['router'];
        $router->pushMiddlewareToGroup('web', StartSessionMiddleware::class);

        /**
         * Base providers
         */
        $this->app->register(HookServiceProvider::class);
        $this->app->register(ConsoleServiceProvider::class);
        $this->app->register(MiddlewareServiceProvider::class);
        $this->app->register(RouteServiceProvider::class);
        $this->app->register(ValidateServiceProvider::class);
        $this->app->register(ComposerServiceProvider::class);
        $this->app->register(RepositoryServiceProvider::class);
        $this->app->register(CollectiveServiceProvider::class);
        $this->app->register(BootstrapModuleServiceProvider::class);

        /**
         * Other module providers
         */
        $this->app->register(\WebEd\Base\Shortcode\Providers\ModuleProvider::class);
        $this->app->register(\WebEd\Base\Caching\Providers\ModuleProvider::class);
        $this->app->register(\WebEd\Base\ACL\Providers\ModuleProvider::class);
        $this->app->register(\WebEd\Base\ModulesManagement\Providers\ModuleProvider::class);
        $this->app->register(\WebEd\Base\AssetsManagement\Providers\ModuleProvider::class);

        $this->app->register(\WebEd\Base\Hook\Providers\ModuleProvider::class);
        $this->app->register(\WebEd\Base\Menu\Providers\ModuleProvider::class);
        $this->app->register(\WebEd\Base\Settings\Providers\ModuleProvider::class);
        $this->app->register(\WebEd\Base\ThemesManagement\Providers\ModuleProvider::class);
        $this->app->register(\WebEd\Base\Users\Providers\ModuleProvider::class);

        foreach (config('webed.external_core', []) as $item) {
            $this->app->register($item);
        }
    }
374204
protected static function registerRoutes()
    {
        parent::routes(function ($router) {
            /* @var \Illuminate\Routing\Router $router */
            $router->get('scheduling', 'Encore\Admin\Scheduling\SchedulingController@index')->name('scheduling-index');
            $router->post('scheduling/run', 'Encore\Admin\Scheduling\SchedulingController@runEvent')->name('scheduling-run');
        });
    }
50258
protected function registerRouter()
    {
        $this->app->singleton('router', function ($app) {
            return new Router($app['events'], $app['actions'], $app);
        });

        $this->app['actions']->listen('init', function () {
            if (is_admin()) {
                app('url')->forceRootUrl(env('APP_URL'));
            }
        });

        $this->disableRedirectionOnRegisteredRoutes();
    }
957443
public function register()
	{
		$this->app['router'] = $this->app->share(function($app)
		{
			$router = \App::make('SleepingOwl\RoutePriority\Router');
			return $router;
		});
	}
708519
protected function registerMiddlewares()
    {
        if (!$this->app['config']->get('laratrust.middleware.register')) {
            return;
        }

        $router = $this->app['router'];

        if (method_exists($router, 'middleware')) {
            $registerMethod = 'middleware';
        } elseif (method_exists($router, 'aliasMiddleware')) {
            $registerMethod = 'aliasMiddleware';
        } else {
            return;
        }

        foreach ($this->middlewares as $key => $class) {
            $router->$registerMethod($key, $class);
        }
    }
1034745
public function register()
    {
        $this->app->singleton('admin', function ($app) {
            return new Admin($app['config'], $app['auth'], $app['router']);
        });
        
        $this->registerRouteMiddleware($this->app['router']);
    }
513523
public function bindRoutes()
    {
        $loader = new RouteLoader();

        $loader->registerProviders(RouteLoader::$defaultProviders);

        $loader->bindRoutes($this);
        $this->bindPluginRoutes('plugin.controller_providers.root');
    }
762575
public function registerRoute($router)
    {
        if (!$this->app->routesAreCached()) {
            $router->group(
                array_merge(
                    ['namespace' => __NAMESPACE__],
                    config('wangeditor.route.options'
                    )
                ), function ($router) {
                $router->any(
                    config('wangeditor.route.url', '/wangeditor/server'),
                    'WangEditorController@serve'
                );
            });
        }
    }
133124
public function register()
    {
        $source = $this->getConfigPath();
        $this->mergeConfigFrom($source, 'laroute');

        $this->registerGenerator();

        $this->registerCompiler();

        $this->registerCommand();
    }
238307
public function register()
    {
        $config = $this->app->make("config");
        if ($this->app->isInstalled() && $config->get('concrete.api.enabled')) {
            $router = $this->app->make(Router::class);
            $list = new ApiRouteList();
            $list->loadRoutes($router);
            $this->registerAuthorizationServer();
        }
    }
176882
protected function registerAuth()
    {
        $this->app->singleton('api.auth', function ($app) {
            return new Auth($app['Dingo\Api\Routing\Router'], $app, $this->config('auth'));
        });
    }
1069912
public function register()
    {
        // Register our binding resolver in the service container
        $this->binder = new BindingResolver([$this->app, 'make']);
        $this->app->instance('bindingResolver', $this->binder);

        // Create a new FastRoute dispatcher (our extended one)
        // with no routes data at the moment because routes file is not loaded yet
        $this->dispatcher = new FastRouteDispatcher(null);

        // Set binding resolver
        $this->dispatcher->setBindingResolver($this->binder);

        // Set routes resolver (will be called when request is dispatched and the routes file is loaded)
        $this->dispatcher->setRoutesResolver($this->getRoutesResolver());

        // Set our dispatcher to be used by the application instead of the default one
        $this->app->setDispatcher($this->dispatcher);

        // Save the dispatcher in the container in case someone needs it later (you're welcome)
        $this->app->instance('dispatcher', $this->dispatcher);
    }
949400
private function registerMapping()
    {
        /* @var \Swoft\Console\Router\HandlerMapping $route */
        $route = App::getBean('commandRoute');

        $commandMapping = CommandCollector::getCollector();
        $route->register($commandMapping);
    }