Lines Matching defs:that
9 * by Oracle in the LICENSE file that accompanied this code.
11 * This code is distributed in the hope that it will be useful, but WITHOUT
14 * version 2 for more details (a copy is included in the LICENSE file that
76 * <p> An <i>absolute</i> URI specifies a scheme; a URI that is not absolute is
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
123 * authority component that does not parse in this way is considered to be
128 * relative. The path of a hierarchical URI that is either absolute or
150 * empty string as its value; this is not equivalent to that component being
224 * that must be made relative to the base URI of the document wherever
244 * which are taken from that specification, are used below to describe these
266 * <td>Escaped octets, that is, triplets consisting of the percent
271 * <td>The Unicode characters that are not in the US-ASCII character set,
296 * <li><p> To <i>quote</i> characters that are otherwise illegal in a
308 * with the sequence of escaped octets that represent that character in the
322 * replacing it with the sequence of characters that it represents in the
324 * effect of de-quoting any quoted US-ASCII characters as well as that of
339 * quoted and preserves any escaped octets and <i>other</i> characters that
371 * quoted and encoded URI string that does not contain any <i>other</i>
379 * For any URI <i>u</i>, it is always the case that
385 * For any URI <i>u</i> that does not contain redundant syntax such as two
388 * <tt>http://java.sun.com:</tt> ), and that does not encode characters
389 * except those that must be quoted, the following identities also hold:
437 * scheme, if any, that it specifies. No lookup of the host, if any, is
441 * a structured string that supports the syntactic, scheme-independent
446 * to access the resource that it describes. A URL must be absolute, that is,
452 * words, a URL is a structured string that supports the syntactic operation of
545 * primary consequence of this deviation is that a standalone fragment
557 * <li> <p> Hostnames in host components that comprise only a single
562 * consequence of this deviation is that the authority component of a
577 * RFC 2396 permits <i>escaped</i> octets, that is, in the
642 * (<tt>'?'</tt>) is appended, followed by the query. Any character that
648 * that is not a legal URI character is quoted. </p></li>
717 * (<tt>'?'</tt>) is appended, followed by the query. Any character that
723 * that is not a legal URI character is quoted. </p></li>
800 * character that is not a <a href="#legal-chars">legal URI character</a>
805 * Any character that is not a legal URI character is quoted. </p></li>
838 * <p> This method is provided for use in situations where it is known that
843 * URI is being constructed from user input or from some other source that
878 * in that way.
889 * <p> In many common situations, for example when working URIs that are
898 * <p> can be used to ensure that <i>u</i> always refers to a URI that, if
901 * ensures that if the authority could not be parsed in that way then an
903 * that is thrown. </p>
917 // exception thrown during the original parse, but that would require
930 * then this URI is returned. Otherwise a new URI is constructed that is
931 * identical to this URI except that its path is computed by normalizing
934 * section 5.2, step 6, sub-steps c through f; that is:
983 * section 5.2; that is: </p>
1081 * first checking that this URI is absolute. </p>
1161 * <p> The string returned by this method is equal to that returned by the
1163 * except that all sequences of escaped octets are <a
1195 * <p> The string returned by this method is equal to that returned by the
1196 * {@link #getRawAuthority() getRawAuthority} method except that all
1225 * <p> The string returned by this method is equal to that returned by the
1226 * {@link #getRawUserInfo() getRawUserInfo} method except that all
1309 * <p> The string returned by this method is equal to that returned by the
1310 * {@link #getRawPath() getRawPath} method except that all sequences of
1338 * <p> The string returned by this method is equal to that returned by the
1339 * {@link #getRawQuery() getRawQuery} method except that all sequences of
1367 * <p> The string returned by this method is equal to that returned by the
1368 * {@link #getRawFragment() getRawFragment} method except that all
1389 * <p> For two URIs to be considered equal requires that either both are
1417 * @return <tt>true</tt> if, and only if, the given object is a URI that
1425 URI that = (URI)ob;
1426 if (this.isOpaque() != that.isOpaque()) return false;
1427 if (!equalIgnoringCase(this.scheme, that.scheme)) return false;
1428 if (!equal(this.fragment, that.fragment)) return false;
1432 return equal(this.schemeSpecificPart, that.schemeSpecificPart);
1435 if (!equal(this.path, that.path)) return false;
1436 if (!equal(this.query, that.query)) return false;
1439 if (this.authority == that.authority) return true;
1442 if (!equal(this.userInfo, that.userInfo)) return false;
1443 if (!equalIgnoringCase(this.host, that.host)) return false;
1444 if (this.port != that.port) return false;
1447 if (!equal(this.authority, that.authority)) return false;
1448 } else if (this.authority != that.authority) {
1492 * String.compareTo} method. String components that are subject to
1543 * @param that
1552 public int compareTo(URI that) {
1555 if ((c = compareIgnoringCase(this.scheme, that.scheme)) != 0)
1559 if (that.isOpaque()) {
1562 that.schemeSpecificPart)) != 0)
1564 return compare(this.fragment, that.fragment);
1567 } else if (that.isOpaque()) {
1572 if ((this.host != null) && (that.host != null)) {
1574 if ((c = compare(this.userInfo, that.userInfo)) != 0)
1576 if ((c = compareIgnoringCase(this.host, that.host)) != 0)
1578 if ((c = this.port - that.port) != 0)
1587 if ((c = compare(this.authority, that.authority)) != 0) return c;
1590 if ((c = compare(this.path, that.path)) != 0) return c;
1591 if ((c = compare(this.query, that.query)) != 0) return c;
1592 return compare(this.fragment, that.fragment);
1620 * this method works as if by invoking that method and then <a
1624 * so that it only contains characters in the US-ASCII
2019 // check if child if opaque first so that NPE is thrown
2106 // return a relative URI that, when resolved against the base, yields the
2110 // check if child if opaque first so that NPE is thrown
2156 // This method takes a string argument rather than a char array so that
2341 // If there is a preceding non-".." segment, remove both that
2380 // in which case we already know that no leading "." is needed
2389 // At this point we know that the first segment is unused,
2390 // hence we can insert a "." segment at that position
2399 // segments equal to ".." that are preceded by a segment not equal to "..".
2445 // precompiling the mask information so that a character's presence in a
2553 // The zero'th bit is used to indicate that escape pairs and non-US-ASCII
2601 // Special case of server authority that represents an IPv6 address
2652 // Quote any characters in s that are not permitted
2689 // assuming that s is otherwise legal
2741 // that escapes are well-formed syntactically, i.e., of the form %XX. If a
2854 // assuming that p < input.length()
2887 // The various scan and parse methods that follow use a uniform
2944 // This method assumes that if escapes are allowed then visible
2969 // Scan chars that match the given mask pair
2993 // Check that each of the chars in [start, end) matches the given mask
3005 // Check that the char at position p matches the given mask
3060 // fragment component. This is so that URIs such as "file:///foo/bar"
3067 // The primary consequence of this deviation is that "#f" parses as a
3101 // Ambiguity: An authority that is a registry name rather than a server
3102 // might have a prefix that parses as a server. We use the fact that
3255 // If the strict argument is true then we require that the given
3257 // then we only require that it start with an IPv4 address.
3261 // immediately; otherwise we insist that these characters parse as a
3264 // We assume that any string of decimal digits and dots must be an IPv4
3265 // address. It won't parse as a hostname anyway, so making that
3321 // IPv4 address is followed by something - check that
3373 // for a fully qualified hostname check that the rightmost