Lines Matching defs:scheme
70 * [<i>scheme</i><b>{@code :}</b>]<i>scheme-specific-part</i>[<b>{@code #}</b><i>fragment</i>]
76 * <p> An <i>absolute</i> URI specifies a scheme; a URI that is not absolute is
80 * <p> An <i>opaque</i> URI is an absolute URI whose scheme-specific part does
91 * scheme-specific part begins with a slash character, or a relative URI, that
92 * is, a URI that does not specify a scheme. Some examples of hierarchical
105 * [<i>scheme</i><b>{@code :}</b>][<b>{@code //}</b><i>authority</i>][<i>path</i>][<b>{@code ?}</b><i>query</i>][<b>{@code #}</b><i>fragment</i>]
110 * scheme-specific part of a hierarchical URI consists of the characters
111 * between the scheme and fragment components.
133 * <blockquote><table summary="Describes the components of a URI:scheme,scheme-specific-part,authority,user-info,host,port,path,query,fragment">
135 * <tr><td>scheme</td><td>{@code String}</td></tr>
136 * <tr><td>scheme-specific-part </td><td>{@code String}</td></tr>
155 * scheme component. An opaque URI has a scheme, a scheme-specific part, and
157 * has a path (though it may be empty) and a scheme-specific-part (which at
430 * scheme, if any, that it specifies. No lookup of the host, if any, is
431 * performed, and no scheme-dependent stream handler is constructed. Equality,
434 * a structured string that supports the syntactic, scheme-independent
440 * it must always specify a scheme. A URL string is parsed according to its
441 * scheme. A stream handler is always established for a URL, and in fact it is
442 * impossible to create a URL instance for a scheme for which no handler is
443 * available. Equality and hashing depend upon both the scheme and the
472 // Components of all URIs: [<scheme>:]<scheme-specific-part>[#<fragment>]
473 private transient String scheme; // null ==> relative URI
589 * <p> If a scheme is given then the path, if also given, must either be
604 * <li><p> If a scheme is given then it is appended to the result,
645 * @param scheme Scheme name
654 * If both a scheme and a path are given but the path is relative,
659 public URI(String scheme,
664 String s = toString(scheme, null,
667 checkPath(s, scheme, path);
674 * <p> If a scheme is given then the path, if also given, must either be
688 * <li><p> If a scheme is given then it is appended to the result,
720 * @param scheme Scheme name
727 * If both a scheme and a path are given but the path is relative,
732 public URI(String scheme,
737 String s = toString(scheme, null,
740 checkPath(s, scheme, path);
754 * URI}{@code (scheme, null, host, -1, path, null, fragment);}
757 * @param scheme Scheme name
766 public URI(String scheme, String host, String path, String fragment)
769 this(scheme, null, host, -1, path, null, fragment);
784 * <li><p> If a scheme is given then it is appended to the result,
787 * <li><p> If a scheme-specific part is given then it is appended. Any
801 * @param scheme Scheme name
802 * @param ssp Scheme-specific part
809 public URI(String scheme, String ssp, String fragment)
812 new Parser(toString(scheme, ssp,
937 * scheme of {@code "a"} and a scheme-specific part of {@code "b/c/d"}.
962 * defined, its path component is empty, and its scheme, authority, and
975 * <li><p> A new URI is constructed with this URI's scheme and the given
1043 * scheme and authority components of the two URIs are not identical, or
1090 * Returns the scheme component of this URI.
1092 * <p> The scheme component of a URI, if defined, only contains characters
1094 * scheme always starts with an <i>alpha</i> character. <p>
1096 * The scheme component of a URI cannot contain escaped octets, hence this
1099 * @return The scheme component of this URI,
1100 * or {@code null} if the scheme is undefined
1103 return scheme;
1109 * <p> A URI is absolute if, and only if, it has a scheme component. </p>
1114 return scheme != null;
1121 * scheme-specific part does not begin with a slash character ('/').
1122 scheme, a scheme-specific part, and possibly
1132 * Returns the raw scheme-specific part of this URI. The scheme-specific
1135 * <p> The scheme-specific part of a URI only contains legal URI
1138 * @return The raw scheme-specific part of this URI
1147 * Returns the decoded scheme-specific part of this URI.
1154 * @return The decoded scheme-specific part of this URI
1382 * <p> For two opaque URIs to be considered equal, their scheme-specific
1395 * or scheme-specific parts of two URIs for equality, the raw forms rather
1415 if (!equalIgnoringCase(this.scheme, that.scheme)) return false;
1453 int h = hashIgnoringCase(0, scheme);
1492 * with an identical scheme. </p></li>
1495 * to the ordering of their scheme-specific parts. </p></li>
1497 * <li><p> Two opaque URIs with identical schemes and scheme-specific
1543 if ((c = compareIgnoringCase(this.scheme, that.scheme)) != 0)
1810 // If a scheme is given then the path, if given, must be absolute
1812 private static void checkPath(String s, String scheme, String path)
1815 if (scheme != null) {
1921 private String toString(String scheme,
1932 if (scheme != null) {
1933 sb.append(scheme);
1956 if (scheme != null) {
1957 sb.append(scheme);
2041 if ((child.scheme == null) && (child.authority == null)
2049 ru.scheme = base.scheme;
2061 if (child.scheme != null)
2065 ru.scheme = base.scheme;
2126 v.scheme = u.scheme;
2137 // If both URIs are hierarchical, their scheme and authority components are
2147 if (!equalIgnoringCase(base.scheme, child.scheme)
2412 // segment could be parsed as a scheme name, then prepend a "." segment
2477 // Prevent scheme-name confusion
2673 // scheme = alpha *( alpha | digit | "+" | "-" | "." )
3081 // [<scheme>:]<scheme-specific-part>[#<fragment>]
3085 int ssp; // Start of scheme-specific part
3090 failExpecting("scheme name", 0);
3091 checkChar(0, L_ALPHA, H_ALPHA, "scheme name");
3092 checkChars(1, p, L_SCHEME, H_SCHEME, "scheme name");
3093 scheme = substring(0, p);
3101 failExpecting("scheme-specific part", p);
