Set patternUri

@param string $patternUri
@return Route
@throws \LogicException
437134
public function setPatternUri($patternUri)
    {
        if (!is_string($patternUri)) {
            throw new \LogicException(sprintf('Route pattern given "%s" is invalid. String expected.', gettype($patternUri)));
        }
        $this->patternUri = $patternUri;
        
        return $this;
    }
1003181
public function internalRedirect($uri)
    {
        if (is_string($uri)) {

            // make a new URI instance, then make a new request
            $uri = $this->request->getUri()->withPath($uri);
            return $this->request->withUri($uri);

        } elseif ($uri instanceof UriInterface) {

            // get a new request with the specified URI instance
            return $this->request->withUri($uri);

        } else {

            // bad $uri value
            throw new InvalidArgumentException(
                'URI should be a string or instance of Psr\Http\Message\UriInterface'
            );

        }
    }
1374396
static public function escapeUri(string $uri): string {
        self::initSerializer();
        return self::$serializer->serialiseValue(new Resource($uri));
    }
696718
public function setBaseUri($uri) : self
    {
        $this->baseUri = $uri instanceof Uri ? $uri : new Uri($uri);

        return $this;
    }
799454
public function setPattern($patternValue) {
		$this->patternValue = $patternValue;
		if (isset($patternValue['patterns'])) {
			foreach ($patternValue['patterns'] as $patternConfiguration) {
				$requestPattern = $this->objectManager->get($this->requestPatternResolver->resolveRequestPatternClass($patternConfiguration['patternType']));
				$requestPattern->setPattern($patternConfiguration['patternValue']);
				$this->subPatterns[] = $requestPattern;
			}
		}
	}
1250117
public function setUriPattern($uriPattern)
    {
        if (!is_string($uriPattern)) {
            throw new \InvalidArgumentException(sprintf('URI Pattern must be of type string, %s given.', gettype($uriPattern)), 1223499724);
        }
        $this->uriPattern = $uriPattern;
        $this->isParsed = false;
    }
6308
public function create(RedirectUriInterface $redirectUri): RedirectUriInterface
    {
        try {
            $now    = $this->ignoreException(function (): DateTimeImmutable {
                return new DateTimeImmutable();
            });
            $schema = $this->getDatabaseSchema();
            $this->createResource([
                $schema->getRedirectUrisClientIdentityColumn() => $redirectUri->getClientIdentifier(),
                $schema->getRedirectUrisValueColumn()          => $redirectUri->getValue(),
                $schema->getRedirectUrisCreatedAtColumn()      => $now,
            ]);
            $identifier = $this->getLastInsertId();

            $redirectUri->setIdentifier($identifier)->setCreatedAt($now);

            return $redirectUri;
        } catch (RepositoryException $exception) {
            $message = 'Client redirect URI creation failed.';
            throw new RepositoryException($message, 0, $exception);
        }
    }
352346
public static function createFromUri($uri)
    {
        foreach (static::$loaders as $loader) {
            if ($loader::canLoad($uri)) {
                return static::getLoader($loader);
            }
        }

        throw new FailedToLoadConfigException(
            sprintf(
                _('Could not find a suitable loader for URI "%1$s".'),
                $uri
            )
        );
    }
123608
protected static function setURI($uri){
        if(!is_string($uri)){
            throw new InvalidArgumentException(
                '$uri must be a string or null'
            );
        }
        self::$uri = filter_var($uri, FILTER_SANITIZE_URL);
    }
410867
public static function route($pRequestUri = NULL)
    {
        if ($pRequestUri === NULL) {
            $requestUri = (defined('REQUEST_URI')) ? REQUEST_URI : '/';
        } else {
            $requestUri = $pRequestUri;
        }

        $router = new Router($requestUri);
        $router->route();
    }
784094
public function setBaseUrl($uri)
    {
        if (is_string($uri)) {
            $this->baseUrl = Uri::createFromString($uri);
        } else {
            $this->baseUrl = $uri;
        }
        return $this;
    }
901887
public static function create($uri)
    {
        if (($parse = parse_url($uri)) === false) {
            throw new \InvalidArgumentException('Unable to parse URI');
        }

        return new Uri(
            isset($parse[ 'scheme' ])
                ? $parse[ 'scheme' ]
                : '',
            isset($parse[ 'host' ])
                ? $parse[ 'host' ]
                : '',
            isset($parse[ 'path' ])
                ? $parse[ 'path' ]
                : '',
            isset($parse[ 'port' ])
                ? $parse[ 'port' ]
                : '',
            isset($parse[ 'query' ])
                ? $parse[ 'query' ]
                : '',
            isset($parse[ 'fragment' ])
                ? $parse[ 'fragment' ]
                : '',
            isset($parse[ 'user' ])
                ? $parse[ 'user' ]
                : '',
            isset($parse[ 'pass' ])
                ? $parse[ 'pass' ]
                : ''
        );
    }
1012816
public function create($uri)
    {
        list($scheme, $host, $port, $path, $query, $fragment, $user, $pass) = $this->parseUrl($uri);

        return new Uri($scheme, $host, $port, $path, $query, $fragment, $user, $pass);
    }
326498
public function setUri($uri)
	{
		if (filter_var($uri, FILTER_VALIDATE_URL)) {
			$this->uri = $uri;
		} else {
			throw new RuntimeException('Invalid URI setted.');
		}
		
		return $this;
	}
712098
private function _createScopeUri($targetUri)
    {
        $targetUriComponents = parse_url($targetUri);

        $authority = Resources::EMPTY_STRING;
        if ($this->_containsValidAuthority($targetUriComponents)) {
            $authority = $this->_createAuthority($targetUriComponents);
        }

        $scopeUri = 'http://'
            .$authority
            .$targetUriComponents[Resources::PHP_URL_HOST];

        if (array_key_exists(Resources::PHP_URL_PATH, $targetUriComponents)) {
            $scopeUri .= $targetUriComponents[Resources::PHP_URL_PATH];
        }

        return $scopeUri;
    }
1214914
public function setBaseUri($baseUri)
    {
        if (is_string($baseUri)) {
            $baseUri = new Uri($baseUri);
        }

        $this->baseUri = $baseUri;
    }
158367
public function setUri($uri)
    {
        if (null !== $uri && !is_string($uri)) {
            require_once 'Zend/Navigation/Exception.php';
            throw new Zend_Navigation_Exception(
                    'Invalid argument: $uri must be a string or null');
        }

        $this->_uri = $uri;
        return $this;
    }