/**
  * Initialize the route dispatcher and defined routes.
  */
 protected function initRoutes()
 {
     $this->dispatcher = FastRoute\simpleDispatcher(function (RouteCollector $r) {
         $r->addRoute('GET', '/', 'IndexController@index');
         $r->addRoute('GET', '/{id:\\d+}', 'IndexController@withId');
     });
 }

 /**
  * Router constructor.
  */
 public function __construct()
 {
     $dispatcher = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $collector) {
         $collector->addRoute(['GET'], '/logout', [new \App\Controllers\AdminController(), 'logout']);
         $collector->addRoute(['GET', 'POST'], '/[{table}[/{action}[/{id}]]]', [new \App\Controllers\AdminController(), 'main']);
     });
     $factory = new Abimo\Factory();
     $request = $factory->request();
     $method = $request->method();
     $uri = $request->uri();
     $route = $dispatcher->dispatch($method, $uri);
     switch ($route[0]) {
         case FastRoute\Dispatcher::NOT_FOUND:
             $response = $factory->response();
             $response->header('404', true, 404)->send();
             throw new \ErrorException("Route {$method} {$uri} not found.");
             break;
         case FastRoute\Dispatcher::METHOD_NOT_ALLOWED:
             $response = $factory->response();
             $response->header('405', true, 405)->send();
             throw new \ErrorException("Method {$method} not allowed.");
             break;
         case FastRoute\Dispatcher::FOUND:
             $handler = $route[1];
             $arguments = $route[2];
             call_user_func_array($handler, $arguments);
     }
 }

 /**
  * Create a new server application instance.
  *
  * @param string $path The path to the application files.
  */
 public function __construct(string $path)
 {
     $this->path = $path;
     // Register some routes.
     $this->dispatcher = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
         $r->addRoute('GET', '/', actions\IndexAction::class);
         $r->addRoute('GET', '/blog', actions\BlogAction::class);
         $r->addRoute('GET', '/category/{category}', actions\CategoryAction::class);
         $r->addRoute('GET', '/portfolio', actions\PortfolioAction::class);
         $r->addRoute('GET', '/{year:\\d{4}}/{month:\\d{2}}/{day:\\d{2}}/{name}', actions\ArticleAction::class);
         $r->addRoute('GET', '/{asset:(?:content|assets)/[^?]+}[?{query}]', actions\AssetAction::class);
         // Complicated feed routes :/
         $r->addRoute('GET', '/sitemap.xml', actions\SitemapAction::class);
         $r->addRoute('GET', '/feed[/{category:[a-z]+}]', actions\AtomFeedAction::class);
         $r->addRoute('GET', '/feed.atom', actions\AtomFeedAction::class);
         $r->addRoute('GET', '/feed/{category:[a-z]+}.atom', actions\AtomFeedAction::class);
         $r->addRoute('GET', '/feed.rss', actions\RssFeedAction::class);
         $r->addRoute('GET', '/feed/{category:[a-z]+}.rss', actions\RssFeedAction::class);
     });
     // Create the server object.
     $this->server = new Server(new RequestHandler($this));
     // Create some core services.
     $this->renderer = new Renderer($path . '/templates');
     $this->assetManager = new AssetManager($path . '/static');
     $this->articleStore = new ArticleStore($path . '/articles');
 }

 public function setUp()
 {
     $router = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
         $r->addRoute('GET', '/', ['TestApp\\Controller\\Index', 'index']);
     });
     $this->app = new App($router);
 }

 public function setUp()
 {
     chdir(__DIR__ . '/app/');
     $this->router = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
         $r->addRoute('GET', '/load', ['TestApp\\Controller\\Index', 'loadedParams'], ['name' => 'load']);
     });
 }

 /**
  * Invocation
  *
  * Register routes container and request attributes
  *
  * @param ServerRequestInterface $request Request
  * @param ResponseInterface $response Response
  * @param TornadoHttp $next Next Middleware - TornadoHttp container
  * @return ResponseInterface
  * @throws HttpMethodNotAllowedException
  * @throws HttpNotFoundException
  */
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, TornadoHttp $next)
 {
     /** @var \FastRoute\Dispatcher\GroupCountBased $dispatcher */
     $dispatcher = FastRoute\simpleDispatcher(function (RouteCollector $routeCollector) {
         foreach ($this->routes as $key => $route) {
             $routeCollector->addRoute($route['methods'], $route['path'], $key);
         }
     });
     $method = $request->getMethod();
     $uri = rawurldecode(parse_url($request->getUri(), \PHP_URL_PATH));
     $route = $dispatcher->dispatch($method, $uri);
     $handler = null;
     $vars = null;
     switch ($route[0]) {
         case Dispatcher::NOT_FOUND:
             throw new HttpNotFoundException('Inexistent route for the url ' . $request->getUri());
         case Dispatcher::METHOD_NOT_ALLOWED:
             throw new HttpMethodNotAllowedException('Method not allowed');
         case Dispatcher::FOUND:
             $handler = $route[1];
             $vars = $route[2];
             break;
     }
     $request = $request->withAttribute(Router::REGISTER_KEY, $handler);
     foreach ($vars as $name => $value) {
         $request = $request->withAttribute($name, $value);
     }
     return $next($request, $response);
 }

 public function setUp()
 {
     $config = Loader::load();
     $config['router'] = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
         $r->addRoute('GET', '/', ['TestApp\\Controller\\IndexController', 'index']);
     });
     $this->app = new App(Container\PHPDiFactory::buildContainer($config));
 }

 public function __construct()
 {
     $this->dispatcher = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
         $r->addRoute('GET', '/', 'IndexController');
         $r->addRoute('POST', '/', 'IndexController');
     });
     $this->request = Request::createFromGlobals();
 }

 /**
  * Register necessary routes with route provider
  */
 protected function registerRoutes()
 {
     $this->dispatcher = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $routeCollector) {
         $this->each(function (RouteRequest $routeRequest) use($routeCollector) {
             $routeCollector->addRoute($routeRequest->method, $routeRequest->route, $routeRequest->callable);
         });
     });
 }

 /**
  * Instantiates the router using the routes in the container.
  */
 private function createDispatcher()
 {
     $this->dispatcher = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $collector) {
         foreach ($this->container->get('routes') as $route) {
             $collector->addRoute($route['method'], $route['pattern'], $route['service']);
         }
     });
 }

 public function setUp()
 {
     $this->router = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $manager) {
         $manager->addRoute('GET', '/', ['TestApp\\Controller\\IndexController', 'index'], ['name' => 'index']);
         $manager->addRoute('GET', '/fail', ['TestApp\\Controller\\IndexController', 'none'], ['name' => 'fail']);
         $manager->addRoute('GET', '/dummy', ['TestApp\\Controller\\IndexController', 'dummy'], ['name' => 'dummy']);
     });
 }

 /**
  * @return Dispatcher
  */
 protected function dispatcher()
 {
     return FastRoute\simpleDispatcher(function (RouteCollector $collector) {
         foreach ($this->directory as $request => $action) {
             list($method, $path) = explode(' ', $request, 2);
             $collector->addRoute($method, $this->directory->prefix($path), $action);
         }
     });
 }

 public function setUp()
 {
     chdir(__DIR__ . '/app/');
     $config = Loader::load();
     $config['router'] = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
         $r->addRoute('GET', '/load', ['TestApp\\Controller\\IndexController', 'loadedParams'], ['name' => 'load']);
     });
     $this->container = Container\PHPDiFactory::buildContainer($config);
 }

 public function setUp()
 {
     $config = Loader::load();
     $config['router'] = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
         $r->addRoute('GET', '/', [get_class($this), 'index']);
     });
     $config['dispatcher'] = \Di\object('PennyTest\\Utils\\FastSymfonyDispatcher')->constructor(\Di\get('router'), \Di\get('di'));
     $this->app = new App(Container\PHPDiFactory::buildContainer($config));
 }

 public function setUp()
 {
     $this->router = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $router) {
         $router->addRoute('GET', '/', ['TestApp\\Controller\\Index', 'diTest']);
     });
     $builder = new ContainerBuilder();
     $builder->useAnnotations(true);
     $dic = $builder->build();
     $this->container = $dic;
 }

 public function compile()
 {
     if (!$this->dispatcher) {
         $this->dispatcher = BaseFastRoute\simpleDispatcher(function (BaseFastRoute\RouteCollector $r) {
             foreach ($this->routes as $route) {
                 $r->addRoute($route[0], $route[1], $route[2]);
             }
         });
     }
 }

 /**
  * @return Dispatcher
  */
 protected function dispatcher()
 {
     return FastRoute\simpleDispatcher(function (RouteCollector $collector) {
         foreach ($this->directory as $request => $action) {
             // 'GET /foo' becomes ['GET', '/foo']
             list($method, $path) = explode(' ', $request, 2);
             $collector->addRoute($method, $path, $action);
         }
     });
 }

 /**
  * @return Dispatcher
  */
 protected function getRouteDispatcher()
 {
     $dispatcher = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
         $routes = Routes::$routeRegister;
         foreach ($routes as $route) {
             $r->addRoute($route->getRequestMethod(), $route->getPathPattern(), $route);
         }
     });
     return $dispatcher;
 }

 /**
  * Add routes definition to collector and dispatch it
  * 
  * @param   array   $routes
  * @param   array   $routerOptions
  */
 public function __construct(array $routes, array $routerOptions = [])
 {
     $this->routes = $routes;
     $this->routerOptions = array_merge($this->routerOptions, $routerOptions);
     if (!$this->routerOptions['cacheDisabled']) {
         $this->dispatcher = cachedDispatcher($this->prepareRoutes(), $this->routerOptions);
     } else {
         $this->dispatcher = simpleDispatcher($this->prepareRoutes(), $this->routerOptions);
     }
 }

 /**
  * Initialize a Router.
  *
  * Routes require a 'path' key and may have optional 'methods' and 'defaults' keys.
  *
  * @param array $routeData Array of routes
  */
 public function __construct(array $routeData)
 {
     $this->dispatcher = simpleDispatcher(function ($r) use($routeData) {
         foreach ($routeData as $data) {
             if (is_array($data)) {
                 $data = Route::fromArray($data);
             }
             $r->addRoute($data->getMethods(), $data->getPath(), $data);
         }
     });
 }