Lines Matching defs:scheme
70 * [<i>scheme</i><tt><b>:</b></tt><i></i>]<i>scheme-specific-part</i>[<tt><b>#</b></tt><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><tt><b>:</b></tt>][<tt><b>//</b></tt><i>authority</i>][<i>path</i>][<tt><b>?</b></tt><i>query</i>][<tt><b>#</b></tt><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><tt>String</tt></td></tr>
136 * <tr><td>scheme-specific-part </td><td><tt>String</tt></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
437 * scheme, if any, that it specifies. No lookup of the host, if any, is
438 * performed, and no scheme-dependent stream handler is constructed. Equality,
441 * a structured string that supports the syntactic, scheme-independent
447 * it must always specify a scheme. A URL string is parsed according to its
448 * scheme. A stream handler is always established for a URL, and in fact it is
449 * impossible to create a URL instance for a scheme for which no handler is
450 * available. Equality and hashing depend upon both the scheme and the
484 // Components of all URIs: [<scheme>:]<scheme-specific-part>[#<fragment>]
485 private transient String scheme; // null ==> relative URI
601 * <p> If a scheme is given then the path, if also given, must either be
616 * <li><p> If a scheme is given then it is appended to the result,
657 * @param scheme Scheme name
666 * If both a scheme and a path are given but the path is relative,
671 public URI(String scheme,
676 String s = toString(scheme, null,
679 checkPath(s, scheme, path);
686 * <p> If a scheme is given then the path, if also given, must either be
700 * <li><p> If a scheme is given then it is appended to the result,
732 * @param scheme Scheme name
739 * If both a scheme and a path are given but the path is relative,
744 public URI(String scheme,
749 String s = toString(scheme, null,
752 checkPath(s, scheme, path);
766 * URI}(scheme, null, host, -1, path, null, fragment);
769 * @param scheme Scheme name
778 public URI(String scheme, String host, String path, String fragment)
781 this(scheme, null, host, -1, path, null, fragment);
796 * <li><p> If a scheme is given then it is appended to the result,
799 * <li><p> If a scheme-specific part is given then it is appended. Any
813 * @param scheme Scheme name
821 public URI(String scheme, String ssp, String fragment)
824 new Parser(toString(scheme, ssp,
949 * scheme of <tt>"a"</tt> and a scheme-specific part of <tt>"b/c/d"</tt>.
974 * defined, its path component is empty, and its scheme, authority, and
987 * <li><p> A new URI is constructed with this URI's scheme and the given
1055 * scheme and authority components of the two URIs are not identical, or
1102 * Returns the scheme component of this URI.
1104 * <p> The scheme component of a URI, if defined, only contains characters
1106 * scheme always starts with an <i>alpha</i> character. <p>
1108 * The scheme component of a URI cannot contain escaped octets, hence this
1111 * @return The scheme component of this URI,
1112 * or <tt>null</tt> if the scheme is undefined
1115 return scheme;
1121 * <p> A URI is absolute if, and only if, it has a scheme component. </p>
1126 return scheme != null;
1133 * scheme-specific part does not begin with a slash character ('/').
1134 * An opaque URI has a scheme, a scheme-specific part, and possibly
1144 * Returns the raw scheme-specific part of this URI. The scheme-specific
1147 * <p> The scheme-specific part of a URI only contains legal URI
1150 * @return The raw scheme-specific part of this URI
1159 * Returns the decoded scheme-specific part of this URI.
1166 * @return The decoded scheme-specific part of this URI
1394 * <p> For two opaque URIs to be considered equal, their scheme-specific
1407 * or scheme-specific parts of two URIs for equality, the raw forms rather
1427 if (!equalIgnoringCase(this.scheme, that.scheme)) return false;
1465 int h = hashIgnoringCase(0, scheme);
1504 * with an identical scheme. </p></li>
1507 * to the ordering of their scheme-specific parts. </p></li>
1509 * <li><p> Two opaque URIs with identical schemes and scheme-specific
1555 if ((c = compareIgnoringCase(this.scheme, that.scheme)) != 0)
1796 // If a scheme is given then the path, if given, must be absolute
1798 private static void checkPath(String s, String scheme, String path)
1801 if (scheme != null) {
1907 private String toString(String scheme,
1918 if (scheme != null) {
1919 sb.append(scheme);
1942 if (scheme != null) {
1943 sb.append(scheme);
2025 if ((child.scheme == null) && (child.authority == null)
2033 ru.scheme = base.scheme;
2045 if (child.scheme != null)
2049 ru.scheme = base.scheme;
2093 v.scheme = u.scheme;
2104 // If both URIs are hierarchical, their scheme and authority components are
2114 if (!equalIgnoringCase(base.scheme, child.scheme)
2363 // segment could be parsed as a scheme name, then prepend a "." segment
2420 // Prevent scheme-name confusion
2610 // scheme = alpha *( alpha | digit | "+" | "-" | "." )
3018 // [<scheme>:]<scheme-specific-part>[#<fragment>]
3022 int ssp; // Start of scheme-specific part
3027 failExpecting("scheme name", 0);
3028 checkChar(0, L_ALPHA, H_ALPHA, "scheme name");
3029 checkChars(1, p, L_SCHEME, H_SCHEME, "scheme name");
3030 scheme = substring(0, p);
3038 failExpecting("scheme-specific part", p);