Get the object route matching the URI path.

@return \Charcoal\Object\ObjectRouteInterface
974926
protected function getObjectRouteFromPath()
    {
        if ($this->objectRoute === null) {
            $this->objectRoute = $this->loadObjectRouteFromPath();
        }

        return $this->objectRoute;
    }
97369
protected function getRoute()
    {
        $request = Yii::$app->request;
        if ($this->isRouteAllowed() && $request->get('route', false)) {
            return Html::encode($request->get('route'));
        }

        return Yii::$app->request->pathInfo;
    }
1328592
public function path()
    {
        $pos = strpos($_SERVER['REQUEST_URI'], '?');

        if ($pos) {
            $uri = substr($_SERVER['REQUEST_URI'], 0, $pos);
        } else {
            $uri = $_SERVER['REQUEST_URI'];
        }

        return $uri;
    }
220175
public function getRepositoryPath() : string
    {
        if (empty($this->repositoryPath)) {
            $this->repositoryPath = (string) getcwd();
        }
        return $this->repositoryPath;
    }
686315
public function getUrl()
    {
        if ($this->findDocumentRootInScriptFileName() === $this->removeLastSlash($this->root)) {
            return $this->getRequestUri();
        }
        $path = $this->server->get('PATH_INFO');

        return $path;
    }
835911
public function getRoute()
    {
        foreach ($this->routes as $route) {

            // Is the route array valid
            if (false == ($cleansed = $this->isValidRoute($route))) {
                continue;
            }

            $route = $cleansed;

            // Does request method match
            if (!$this->methodMatches($route)) {
                continue;
            }

            if (false === $this->isAllowedByIp($route)) {
                continue;
            }

            if (false === $this->isAllowedByRole($route)) {
                // @codeCoverageIgnoreStart
                continue;
                // @codeCoverageIgnoreEnd
            }

            if (false != ($match = $this->isDirectMatch($route))) {
                return $match;
            }

            if (false != ($match = $this->isParameterisedMatch($route))) {
                return $match;
            }
        }

        $e = new RouteNotFoundException('Route for path not found.');
        $e->setAdditionalData('Path: ', $this->path);
        throw $e;
    }
67730
private function FindRouteMatch() {
        $route = new Route();
        $route->setDefaultUrl(Config::Init($this->app)->Get(\Puzzlout\Framework\Enums\AppSettingKeys::DefaultUrl));
        $this->getRoute($route, $this->url);
        return $route;
    }
50213
public function getCurrentRoute()
    {
        if (isset($this->currentRoute)) {
            return $this->currentRoute;
        } elseif (! $this->hasDispatchedRoutes() || ! $route = $this->container['request']->route()) {
            return;
        }

        // We need to recompile the route, adding the where clause (for pattern restrictions) and check again.
        if ($route instanceof IlluminateRoute) {
            $route->compiled = false;
            $this->addWhereClausesToRoute($route);

            // If the matching fails, it would be due to a parameter format validation check fail.
            if (! $route->matches($this->container['request'])) {
                throw new NotFoundHttpException('Not Found!');
            }
        }

        return $this->currentRoute = $this->createRoute($route);
    }
1207376
protected function getUris()
    {
        $uris = $this->laravel['config']->get('criticalcss.routes');

        // If null, return all 'GET' routes.
        if (is_null($uris)) {
            $uris = [];
            $router = $this->laravel['router'];

            foreach ($router->getRoutes() as $route) {
                if ($route->getMethods()[0] === 'GET') {
                    $uris[] = $route->getUri();
                }
            }
        }

        return $uris;
    }
1138582
public function getListRoute()
    {
        if (null === $this->listRoute) {
            $route = rtrim($this->getBaseRoute(), '/') . '/' . $this->getListSuffix();
            $this->setListRoute($route);
        }

        return $this->listRoute;
    }
455800
public function getUrl()
    {
        if (empty($this->url)) {
            $url = $this->httpRequest()->getCurrentUrl(true)->getPath();
            // we need to have the trailing slash because of the match inside matchRequest
            // and also when matching the default method, we can do an incorrect match if we don't have the start and end slash
            $this->url = $this->str($url)->trimRight('/')->val() . '/';
        }

        return $this->url;
    }
729859
private function getPath()
    {
        $path = "";
        if(strlen($this->path) > 0) {
            $path = $this->path;    
        } else {
            $path = $this->route;
        }

        if(substr($path, -1) !== "/") {
            $path .= "/";
        }

        $this->path = $path;
    }
832355
protected function getPath()
    {
        if (null === $this->parent) {
            return null;
        }
        if (null !== ( $pPath = $this->parent->getPath() )) {
            return $pPath . '.' . $this->handle;
        }else {
            return $this->handle;
        }
    }
1035014
public function getPath()
    {
        if ($this->requestTarget === null) {
            return $this->uri->getPath();
        }

        list($path) = explode('?', $this->requestTarget);

        return $path;
    }
107894
public function getUri()
    {
        if (!$this->_uri instanceof UriInterface) {
            if ($this->_uri === null) {
                $uri = new Uri(['string' => $this->getAbsoluteUrl()]);
            } elseif ($this->_uri instanceof \Closure) {
                $uri = call_user_func($this->_uri, $this);
            } else {
                $uri = $this->_uri;
            }

            $this->_uri = Instance::ensure($uri, UriInterface::class);
        }
        return $this->_uri;
    }
400561
private function getCurrentPath()
    {
        if (is_null($this->currentPath)) {
            $this->currentPath = $this->str($this->httpRequest()->getCurrentUrl(true)->getPath());
        }

        return $this->currentPath;
    }
309231
protected function getUrl()
    {
        $url = $this->path['url'];

        $uri    = is_array($url) ? $url[0] : $url;
        $params = is_array($url) ? array_slice($url, 1) : null;

        if (Utils::isAbsoluteUrl($uri)) {
            return $uri;
        }

        return url($uri, $params);
    }