Lines Matching refs:authority
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>]
113 * <p> The authority component of a hierarchical URI is, if specified, either
114 * <i>server-based</i> or <i>registry-based</i>. A server-based authority
123 * authority component that does not parse in this way is considered to be
129 * specifies an authority is always absolute.
133 * <blockquote><table summary="Describes the components of a URI:scheme,scheme-specific-part,authority,user-info,host,port,path,query,fragment">
137 * <tr><td>authority</td><td><tt>String</tt></td></tr>
159 * authority component is present and is server-based then the host component
386 * slashes before an empty authority (as in <tt>file:///tmp/</tt> ) or a
418 * if <i>u</i> is hierarchical and has either no authority or a server-based
419 * authority.
488 // Hierarchical URI components: [//<authority>]<path>[?<query>]
489 private transient String authority; // Registry or server
491 // Server-based authority: [<userInfo>@]<host>[:<port>]
535 * <li><p> An empty authority component is permitted as long as it is
540 * authority component is empty then the user-information, host, and port
562 * consequence of this deviation is that the authority component of a
564 * authority. </p></li>
579 * the authority component if the authority is registry-based. This
668 * RFC 2396, or if the authority component of the string is
669 * present but cannot be parsed as a server-based authority
703 * <li><p> If an authority is given then the string <tt>"//"</tt> is
704 * appended, followed by the authority. If the authority contains a
733 * @param authority Authority
741 * RFC 2396, or if the authority component of the string is
742 * present but cannot be parsed as a server-based authority
745 String authority,
750 authority, null, null, -1,
867 * Attempts to parse this URI's authority component, if defined, into
870 * <p> If this URI's authority component has already been recognized as
873 * URI has no authority component, this method simply returns this URI.
875 * <p> Otherwise this method attempts once more to parse the authority
877 * an exception describing why the authority component could not be parsed
882 * cannot always distinguish a malformed server-based authority from a
883 * legitimate registry-based authority. It must therefore treat some
884 * instances of the former as instances of the latter. The authority
886 * legal server-based authority but it is legal as a registry-based
887 * authority.
899 * it has an authority component, has a server-based authority with proper
901 * ensures that if the authority could not be parsed in that way then an
905 * @return A URI whose authority field has been parsed
906 * as a server-based authority
909 * If the authority component of this URI is defined
910 * but cannot be parsed as a server-based authority
919 if ((host != null) || (authority == null))
974 * defined, its path component is empty, and its scheme, authority, and
990 * <li><p> If the given URI has an authority component then the new URI's
991 * authority and path are taken from the given URI. </p></li>
993 * <li><p> Otherwise the new URI's authority component is copied from
1055 * scheme and authority components of the two URIs are not identical, or
1176 * Returns the raw authority component of this URI.
1178 * <p> The authority component of a URI, if defined, only contains the
1181 * categories. If the authority is server-based then it is further
1185 * @return The raw authority component of this URI,
1186 * or <tt>null</tt> if the authority is undefined
1189 return authority;
1193 * Returns the decoded authority component of this URI.
1199 * @return The decoded authority component of this URI,
1200 * or <tt>null</tt> if the authority is undefined
1204 decodedAuthority = decode(authority);
1406 * <p> When testing the user-information, path, query, fragment, authority,
1439 if (this.authority == that.authority) return true;
1445 } else if (this.authority != null) {
1447 if (!equal(this.authority, that.authority)) return false;
1448 } else if (this.authority != that.authority) {
1477 h = hash(h, authority);
1514 * according to the ordering of their authority components: </p>
1518 * <li><p> If both authority components are server-based then the URIs
1525 * <li><p> If one or both authority components are registry-based then
1526 * the URIs are ordered according to the ordering of their authority
1532 * authority components are ordered according to the ordering of their
1587 if ((c = compare(this.authority, that.authority)) != 0) return c;
1810 String authority,
1831 } else if (authority != null) {
1833 if (authority.startsWith("[")) {
1834 // authority should (but may not) contain an embedded IPv6 address
1835 int end = authority.indexOf("]");
1836 String doquote = authority, dontquote = "";
1837 if (end != -1 && authority.indexOf(":") != -1) {
1838 // the authority contains an IPv6 address
1839 if (end == authority.length()) {
1840 dontquote = authority;
1843 dontquote = authority.substring(0 , end + 1);
1844 doquote = authority.substring(end + 1);
1852 sb.append(quote(authority,
1861 String authority,
1890 appendAuthority(sb, authority, userInfo, host, port);
1909 String authority,
1923 authority, userInfo, host, port,
1965 } else if (authority != null) {
1967 sb.append(authority);
2025 if ((child.scheme == null) && (child.authority == null)
2034 ru.authority = base.authority;
2054 if (child.authority == null) {
2055 ru.authority = base.authority;
2069 ru.authority = child.authority;
2095 v.authority = u.authority;
2104 // If both URIs are hierarchical, their scheme and authority components are
2115 || !equal(base.authority, child.authority))
2601 // Special case of server authority that represents an IPv6 address
3056 // [//authority]<path>[?<query>]
3058 // DEVIATION from RFC2396: We allow an empty authority component as
3062 // grammar does not permit it. If the authority is empty then the
3080 // DEVIATION: Allow empty authority prior to non-empty
3083 failExpecting("authority", p);
3099 // authority = server | reg_name
3101 // Ambiguity: An authority that is a registry name rather than a server
3103 // the authority component is always followed by '/' or the end of the
3104 // input string to resolve this: If the complete authority did not
3126 // Must be a registry-based authority
3127 authority = substring(p, n);
3132 // Might be (probably is) a server-based authority, so attempt
3134 // as a registry-based authority.
3138 failExpecting("end of authority", q);
3139 authority = substring(p, n);
3146 // If we're insisting upon a server-based authority,
3160 // Registry-based authority
3161 authority = substring(p, n);
3167 fail("Illegal character in authority", q);