Initializes a path object given the scheme, authority and path string.

@param scheme
the scheme string.
@param authority
the authority string.
@param path
the path string.
346644
private void initialize(String scheme, String authority, String path) {
		try {
			this.uri = new URI(scheme, authority, normalizePath(path), null, null).normalize();
		} catch (URISyntaxException e) {
			throw new IllegalArgumentException(e);
		}
	}
205809
private URI toUri(final String path) {
        try {
            return new URI(null, null, path, null);
        } catch (URISyntaxException e) {
            throw new IllegalArgumentException(e);
        }
    }
952419
void configureFiles(String path) {

        // If the property is set, reload from a local directory:
        if (StringUtils.isNotBlank(path)) {
            configureFilesReloadable(path);
        } else {
            configureFilesResource();
        }
        filesReloadable = filesUrl != null;

        // Communicate:
        showFilesConfiguration();
    }
434296
public void setPath(String path) {

        if (CmsStringUtil.isEmpty(path) || !path.trim().equals(path)) {
            throw new CmsIllegalArgumentException(Messages.get().container(Messages.ERR_BAD_FILE_NAME_1, path));
        }
        m_path = path;
    }
669669
def isabspath(self):
        """"""
        return (self.scheme is None and self.authority is None and
                self.path.startswith(self.SLASH))
1338858
public void initializeRelativePath(ServletRequest request, String relativeTo) 
    {
        if ( relativeTo == null )
        {
            relativeTo = _relativeTo;
        }

        if ( relativeTo == null ) return;

        assert ! relativeTo.endsWith("/") : relativeTo;
        String path = getPath();
         
        // If this is a local (relative) path, prefix it with the given 'relativeTo' path, and save a flag.
        // We save this flag in a local variable because the Forward object may be saved/restored for use again.
        if (! getContextRelative() && ! FileUtils.isAbsoluteURI(path)) {
            assert path.startsWith("/") : path;
            setPath(relativeTo + path);
            setContextRelative(true);
            _outsidePageFlowDirectory = true;
        }
        
        // Store a flag in the request that will prevent another page flow from being initialized implicitly because
        // we're hitting a path within it.  We want to stay in the context of the current page flow.
        if (_outsidePageFlowDirectory) {
            PageFlowRequestWrapper.get(request).setStayInCurrentModule(true);
        }
    }
1169926
public static String authoritySafePath(String authority, String path) {
        if (authority != null && !authority.isEmpty() && !path.isEmpty() && !path.startsWith("/")) {
            return "/" + path;
        }
        return path;
    }
787246
public void setPath(List<? extends S> path, Direction1D direction) {
		this.path = path == null || path.isEmpty() ? null : new ArrayList<>(path);
		this.firstSegmentDirection = detectFirstSegmentDirection(direction);
	}
939669
public void addInInclusionChain(final URI path, final String pointer)
            throws XIncludeFatalException
    {
        final String xincludePath = path.toASCIIString() + ((null != pointer) ? ('#' + pointer) : "");
        if (this.xincludeDeque.contains(xincludePath))
        {
            throw new XIncludeFatalException("Inclusion Loop on path: " + xincludePath);
        }
        this.xincludeDeque.addLast(xincludePath);
    }
790967
@Override
  public void initialize(URI path, Configuration config) throws IOException {
    initialize(path, config, /* initSuperclass= */ true);
  }
561631
public void addAuthInfo(final String scheme, final byte[] auth) {
        retryUntilConnected(new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                _connection.addAuthInfo(scheme, auth);
                return null;
            }
        });
    }
301673
@ConfigArg(0)
  public void setPath(PathImpl path)
  {
    _classDir = path;

    if (_sourceDir == null) {
      _sourceDir = path;
    }
  }
1285979
public static String buildURIAsString(String scheme, String authority, String path,
            String query, String fragment) throws URISyntaxException {
        URI helperURI;
        try {
            helperURI = new URI(scheme, authority, path, query, fragment);
        } catch (URISyntaxException e) {
            return NetworkInterfaceURI.buildURIToString(scheme, authority, path, query, fragment);
        }
        return helperURI.toString();
    }
1232419
public void setRequestPath(String mapping, String path) {
		this.requestPath = path;
		int paramStartIdx = requestPath.indexOf("?");
		if(StringUtils.isEmpty(mapping)){
			if(paramStartIdx != -1){
				this.servletPath = requestPath.substring(0, paramStartIdx);
			}else{
				this.servletPath = requestPath;
			}
		}else{
			this.servletPath = PathNormalizer.asPath(mapping);
			String pathInfo = removeServletMappingFromPath(path, mapping);
			this.pathInfo = pathInfo;
		}
		
		// Sets the request URI
		if(paramStartIdx == -1){
			this.requestURI = requestPath;
		}else{
			this.requestURI = requestPath.substring(0, paramStartIdx);
		}
		
		initParameters();
		
	}
320329
public void setValue(List<P> path, V value) {

        ensureNode(path).setValue(value);

    }
45436
def isrelpath(self):
        """"""
        return (self.scheme is None and self.authority is None and
                not self.path.startswith(self.SLASH))
670886
def wrap(self, path, args=(), kws={}, scheme='', authority=''):
        
        # build dict of argument name+value
        AV = {}
        AV.update([A for A in kws.items() if A[1] is not None])
        AV.update([(N, V) for (N, _T), V in zip(self._args, args)])

        # list of argument name+type tuples for which a value was provided
        AT = [A for A in self._args if A[0] in AV]

        T = self.buildType(AT)
        try:
            return Value(T, {
                'scheme': scheme,
                'authority': authority,
                'path': path,
                'query': AV,
            })
        except Exception as e:
            raise ValueError('Unable to initialize NTURI %s from %s using %s' % (AT, AV, self._args))