Resolves Route

@return Route
766506
public function resolveRoute($source = null)
    {
        return $this
            ->matcher
                ->match($this->getRouteCollection($source), $this->request);
    }
768678
public function getRoute(): ?RouteInterface
    {
        if (!is_null($this->getApp())) {
            return $this->getApp()->getService('routing')->getCurrentRoute();
        }

        return null;
    }
1363889
public function resolve()
    {
        if (!empty($this->resolvedParameters)) {
            return $this->attributes;
        }
        $this->evaluateRequirements($this->attributes);
        $this->resolveAllParameters();

        return $this->attributes;
    }
818360
public static function resolve()
    {
        // Get current URL
        $oRequest = new Request();
        $sUrl = $oRequest->url();
        // Set default separator
        if (Configuration::check('routing.default_separator') === true) {
            $cDefaultSeparator = Configuration::read('routing.default_separator');
            RouteCollection::setDefaultSeparator($cDefaultSeparator);
        }
        // Remove last char of URL if it's a separator
        $sUrl = self::removeLastSeparator($sUrl);
        // Get list of separator for this URL
        $arcUrlSeparator = self::listSeparator($sUrl);
        // Get list of value of this URL
        $arsUrlValue = self::listValue($sUrl);
        // Check route
        $bCheckResult = self::checkRoute($arcUrlSeparator, $arsUrlValue);
        if ($bCheckResult === false && Configuration::read('routing.auto') === true) {
            self::autoResolve($arsUrlValue);
        }
        self::checkController();
        self::setParameterInGlobal();
    }
1286483
protected function resolveModuleName()
    {
        if (!isset($this->routeGroup)) {
            return '';
        }
        return join('.', [str_replace('/', '.', $this->routeGroup), self::$withSuffix]);
    }
1162080
public function resolve()
    {
        foreach ($this->sidebars as $name) {
            $sidebar = $this->resolver->resolve($name);

            $this->container->singleton($name, function () use ($sidebar) {
                return $sidebar;
            });
        }
    }
793132
public function route()
    {
        global $logger;
        try {
            // TODO : Refactor Code :
            // $url    = URLParser::parse();
            // $route  = RouteMapper::getRoute($url['route']);
            // $router = new Router();
            // $router->route($route);
            $urlInterpreter = new UrlInterpreter();
            $command        = $urlInterpreter->getCommand();
            $router         = new Router($command);
            $logger->debug('Routing to : '.$command->getControllerName());
            $router->route();
        } catch (Exception $e) {
            throw new RouteNotFoundException();	
        }
    }
866373
public function getRoute() {
        if (is_null($this->route)) {
            $this->route = Yii::$app->request->getHostInfo() . '/' . Yii::$app->request->getPathInfo();
        }
        return $this->route;
    }
64507
public function getResolver()
    {
        if ($this->resolver === null) {
            $this->resolver = new $this->resolverClass(UrlRedirect::resolve($this->buildUrl()), $this->resolverConfig);
            $this->parseUrl($this->resolver->getUrl());
        }

        return $this->resolver;
    }
1340083
public function compile()
    {
        if($this->isNull($this->compiledRoute)) {
            $this->compiledRoute = RouteCompiler::compile($this);
        }

        return $this->compiledRoute;
    }
1043337
private function resolveURL() {

		// Retrieve the current request URL segments.

		$request = $this->getRequest();
		$URL = $request->getURL();
		$holder = substr($URL, 0, strpos($URL, '/'));
		$page = substr($URL, strrpos($URL, '/') + 1);

		// Determine whether a media page child once existed.

		$resolution = self::find_old_page(array(
			$holder,
			$page
		));
		$comparison = trim($resolution, '/');

		// Make sure the current request URL doesn't match the resolution.

		if($resolution && ($page !== substr($comparison, strrpos($comparison, '/') + 1))) {

			// Retrieve the current request parameters.

			$parameters = $request->getVars();
			unset($parameters['url']);

			// Appropriately redirect towards the updated media page URL.

			$response = new HTTPResponse();
			return $response->redirect(self::join_links($resolution, !empty($parameters) ? '?' . http_build_query($parameters) : null), 301);
		}
		else {

			// The media page child doesn't resolve.

			return null;
		}
	}
1258833
public function resolveHost()
    {
        $host = $this->getHost();

        if ($host == null) {
            //check to see if there is an AuthenticationToken from which to retrieve it:
            $token = $this->getAuthenticationToken();
            //if ($token instanceof $HostAuthenticationToken) {
            if($token)
                $host = 'API Services';
            //}
        }

        if ($host == null) {
            $session = $this->resolveSession();
            if ($session != null) {
                $host = $session->getHost();
            }
        }

        return $host;

    }
454861
public function resolveNotFoundRoute()
    {
        // Try to resolve 404 route. If such route don't
        // exist just redirect to the homepage.
        try {
            if ($notFoundRoute = $this->routes->get('404')) {
                return $notFoundRoute->run();
            }
        } catch (RoutingException $e) {
            if (wp_redirect(home_url())) {
                // WordPress requires to call exit after wp_redirect.
                // We cannot test it, so ignore this single line.
                // @codeCoverageIgnoreStart
                exit();
                // @codeCoverageIgnoreEnd
            }
        }
    }
749322
public function dispatch(Route $route)
    {
        $callback = $route->getCallback();
        $params = array_values($route->getData());

        if ($callback instanceof Closure) {
            return $this->container->resolveClosure($callback, $params);
        }

        $class = $this->container->make($callback[0]);
        return $this->container->resolveMethod($class, $callback[1], $params);
    }
309658
public function getCurrentRoute()
    {
        if (isset($this->currentRoute)) {
            return $this->currentRoute;
        } elseif (! $this->hasDispatchedRoutes()) {
            return null;
        }

        $request = $this->container['request'];

        return $this->currentRoute = $this->createRoute($request->route());
    }
629424
protected function getRouteCode()
    {
        $type = $this->option('type');
        $class = isset(static::$lookup[$type])
            ? static::$lookup[$type]
            : RegularRoute::class;
        /** @var GeneratesCode $route */
        $route = new $class($this->compiler, $this->filesystem);
        $route->setReplacements([
            undot_path($this->argument('link')),
            $this->action(),
            $this->method()
        ]);
        return $route->code();
    }
821050
public static function resolveForRoute($container, $route)
    {
        $parameters = $route->parameters();

        foreach ($route->signatureParameters(UrlRoutable::class) as $parameter) {
            if (! $parameterName = static::getParameterName($parameter->name, $parameters)) {
                continue;
            }

            $parameterValue = $parameters[$parameterName];

            if ($parameterValue instanceof UrlRoutable) {
                continue;
            }

            $instance = $container->make($parameter->getClass()->name);

            if (! $model = $instance->resolveRouteBinding($parameterValue)) {
                throw (new ModelNotFoundException)->setModel(get_class($instance));
            }

            $route->setParameter($parameterName, $model);
        }
    }