* A URI instance represents that defined by - * RFC3986, + * RFC2396, * with some deviations. *
*@@ -98,57 +98,7 @@ * this that the path sub-part may also not be undefined, so as to ensure * the former. *
- *- * The characters that can be used within a valid URI are restricted. - * There are two main classes of characters which can't be used as is - * within the URI: - *
- *- * The set of valid characters differs depending on the section of the URI: - *
- *- * These definitions reference the following sets of characters: - *
- *
- * The constructors and accessor methods allow the use and retrieval of
- * URI components which contain non-US-ASCII characters directly.
- * They are only escaped when the toASCIIString() method
- * is used. In contrast, illegal characters are always quoted, with the
- * exception of the return values of the non-raw accessors.
- *
- * Returns the string content of the specified group of the supplied - * matcher. The returned value is modified according to the following: - *
- *null is returned to indicate an undefined
- * value. Otherwise, the value is truly the empty string and this is
- * the returned value.- * This method is used for matching against all parts of the URI - * that may be either undefined or empty (i.e. all those but the - * scheme-specific part and the path). In each case, the preceding - * group is the content of the original group, along with some - * additional distinguishing feature. For example, the preceding - * group for the query includes the preceding question mark, - * while that of the fragment includes the hash symbol. The presence - * of these features enables disambiguation between the two cases - * of a completely unspecified value and a simple non-existant value. - * The scheme differs in that it will never return an empty string; - * the delimiter follows the scheme rather than preceding it, so - * it becomes part of the following section. The same is true - * of the user information. - *
- * - * @param match the matcher, which contains the results of the URI - * matched against the URI regular expression. - * @return either the matched content,null for undefined
- * values, or an empty string for a URI part with empty content.
- */
private static String getURIGroup(Matcher match, int group)
{
String matched = match.group(group);
- return matched.length() == 0
- ? ((match.group(group - 1).length() == 0) ? null : "") : matched;
+ return matched.length() == 0 ? null : matched;
}
/**
@@ -359,7 +229,8 @@
*/
private void parseURI(String str) throws URISyntaxException
{
- Matcher matcher = URI_PATTERN.matcher(str);
+ Pattern pattern = Pattern.compile(URI_REGEXP);
+ Matcher matcher = pattern.matcher(str);
if (matcher.matches())
{
@@ -375,9 +246,37 @@
rawFragment = getURIGroup(matcher, FRAGMENT_GROUP);
}
else
- throw new URISyntaxException(str,
- "doesn't match URI regular expression");
- parseServerAuthority();
+ throw new URISyntaxException(str, "doesn't match URI regular expression");
+
+ if (rawAuthority != null)
+ {
+ pattern = Pattern.compile(AUTHORITY_REGEXP);
+ matcher = pattern.matcher(rawAuthority);
+
+ if (matcher.matches())
+ {
+ rawUserInfo = getURIGroup(matcher, AUTHORITY_USERINFO_GROUP);
+ rawHost = getURIGroup(matcher, AUTHORITY_HOST_GROUP);
+
+ String portStr = getURIGroup(matcher, AUTHORITY_PORT_GROUP);
+
+ if (portStr != null)
+ try
+ {
+ port = Integer.parseInt(portStr);
+ }
+ catch (NumberFormatException e)
+ {
+ URISyntaxException use =
+ new URISyntaxException
+ (str, "doesn't match URI regular expression");
+ use.initCause(e);
+ throw use;
+ }
+ }
+ else
+ throw new URISyntaxException(str, "doesn't match URI regular expression");
+ }
// We must eagerly unquote the parts, because this is the only time
// we may throw an exception.
@@ -408,6 +307,8 @@
for (int i = 0; i < str.length(); i++)
{
char c = str.charAt(i);
+ if (c > 127)
+ throw new URISyntaxException(str, "Invalid character");
if (c == '%')
{
if (i + 2 >= str.length())
@@ -444,7 +345,8 @@
*/
private static String quote(String str)
{
- return quote(str, RFC3986_SSP);
+ // FIXME: unimplemented.
+ return str;
}
/**
@@ -462,17 +364,20 @@
{
// Technically, we should be using RFC2396_AUTHORITY, but
// it contains no additional characters.
- return quote(str, RFC3986_REG_NAME);
+ return quote(str, RFC2396_REG_NAME);
}
/**
- * Quotes the characters in the supplied string that are not part of
- * the specified set of legal characters.
+ * Quote characters in str that are not part of legalCharacters.
*
- * @param str the string to quote
- * @param legalCharacters the set of legal characters
+ * Replace illegal characters by encoding their UTF-8
+ * representation as "%" + hex code for each resulting
+ * UTF-8 character.
*
- * @return the quoted string.
+ * @param str The string to quote
+ * @param legalCharacters The set of legal characters
+ *
+ * @return The quoted string.
*/
private static String quote(String str, String legalCharacters)
{
@@ -482,11 +387,23 @@
char c = str.charAt(i);
if (legalCharacters.indexOf(c) == -1)
{
+ String hex = "0123456789ABCDEF";
if (c <= 127)
+ sb.append('%').append(hex.charAt(c / 16)).append(hex.charAt(c % 16));
+ else
{
- sb.append('%');
- sb.append(HEX.charAt(c / 16));
- sb.append(HEX.charAt(c % 16));
+ try
+ {
+ // this is far from optimal, but it works
+ byte[] utf8 = str.substring(i, i + 1).getBytes("utf-8");
+ for (int j = 0; j < utf8.length; j++)
+ sb.append('%').append(hex.charAt((utf8[j] & 0xff) / 16))
+ .append(hex.charAt((utf8[j] & 0xff) % 16));
+ }
+ catch (java.io.UnsupportedEncodingException x)
+ {
+ throw (Error) new InternalError().initCause(x);
+ }
}
}
else
@@ -508,7 +425,8 @@
*/
private static String quoteHost(String str)
{
- return quote(str, RFC3986_HOST);
+ // FIXME: unimplemented.
+ return str;
}
/**
@@ -526,7 +444,7 @@
{
// Technically, we should be using RFC2396_PATH, but
// it contains no additional characters.
- return quote(str, RFC3986_PATH_SEGMENTS);
+ return quote(str, RFC2396_PATH_SEGMENTS);
}
/**
@@ -542,7 +460,8 @@
*/
private static String quoteUserInfo(String str)
{
- return quote(str, RFC3986_USERINFO);
+ // FIXME: unimplemented.
+ return str;
}
/**
@@ -584,6 +503,8 @@
+ (path == null ? "" : quotePath(path))
+ (query == null ? "" : "?" + quote(query))
+ (fragment == null ? "" : "#" + quote(fragment)));
+
+ parseServerAuthority();
}
/**
@@ -663,198 +584,21 @@
/**
* Attempts to parse this URI's authority component, if defined,
- * into user-information, host, and port components. The purpose
- * of this method was to disambiguate between some authority sections,
- * which form invalid server-based authories, but valid registry
- * based authorities. In the updated RFC 3986, the authority section
- * is defined differently, with registry-based authorities part of
- * the host section. Thus, this method is now simply an explicit
- * way of parsing any authority section.
- *
- * @return the URI, with the authority section parsed into user
- * information, host and port components.
- * @throws URISyntaxException if the given string violates RFC 2396
+ * into user-information, host, and port components
+ *
+ * @exception URISyntaxException If the given string violates RFC 2396
*/
public URI parseServerAuthority() throws URISyntaxException
{
- if (rawAuthority != null)
- {
- Matcher matcher = AUTHORITY_PATTERN.matcher(rawAuthority);
-
- if (matcher.matches())
- {
- rawUserInfo = getURIGroup(matcher, AUTHORITY_USERINFO_GROUP);
- rawHost = getURIGroup(matcher, AUTHORITY_HOST_GROUP);
-
- String portStr = getURIGroup(matcher, AUTHORITY_PORT_GROUP);
-
- if (portStr != null)
- try
- {
- port = Integer.parseInt(portStr);
- }
- catch (NumberFormatException e)
- {
- URISyntaxException use =
- new URISyntaxException
- (string, "doesn't match URI regular expression");
- use.initCause(e);
- throw use;
- }
- }
- else
- throw new URISyntaxException(string,
- "doesn't match URI regular expression");
- }
- return this;
+ return null;
}
/**
- * - * Returns a normalized version of the URI. If the URI is opaque, - * or its path is already in normal form, then this URI is simply - * returned. Otherwise, the following transformation of the path - * element takes place: - *
- *- * The resulting URI will be free of `.' and `..' segments, barring those - * that were prepended or which couldn't be paired, respectively. - *
- * - * @return the normalized URI. + * Returns a normalizes versions of the URI */ public URI normalize() { - if (isOpaque() || path.indexOf("/./") == -1 && path.indexOf("/../") == -1) - return this; - try - { - return new URI(scheme, authority, normalizePath(path), query, - fragment); - } - catch (URISyntaxException e) - { - throw (Error) new InternalError("Normalized URI variant could not "+ - "be constructed").initCause(e); - } - } - - /** - *- * Normalize the given path. The following transformation takes place: - *
- *- * The resulting URI will be free of `.' and `..' segments, barring those - * that were prepended or which couldn't be paired, respectively. - *
- * - * @param relativePath the relative path to be normalized. - * @return the normalized path. - */ - private String normalizePath(String relativePath) - { - /* - This follows the algorithm in section 5.2.4. of RFC3986, - but doesn't modify the input buffer. - */ - StringBuffer input = new StringBuffer(relativePath); - StringBuffer output = new StringBuffer(); - int start = 0; - while (start < input.length()) - { - /* A */ - if (input.indexOf("../",start) == start) - { - start += 3; - continue; - } - if (input.indexOf("./",start) == start) - { - start += 2; - continue; - } - /* B */ - if (input.indexOf("/./",start) == start) - { - start += 2; - continue; - } - if (input.indexOf("/.",start) == start - && input.charAt(start + 2) != '.') - { - start += 1; - input.setCharAt(start,'/'); - continue; - } - /* C */ - if (input.indexOf("/../",start) == start) - { - start += 3; - removeLastSegment(output); - continue; - } - if (input.indexOf("/..",start) == start) - { - start += 2; - input.setCharAt(start,'/'); - removeLastSegment(output); - continue; - } - /* D */ - if (start == input.length() - 1 && input.indexOf(".",start) == start) - { - input.delete(0,1); - continue; - } - if (start == input.length() - 2 && input.indexOf("..",start) == start) - { - input.delete(0,2); - continue; - } - /* E */ - int indexOfSlash = input.indexOf("/",start); - while (indexOfSlash == start) - { - output.append("/"); - ++start; - indexOfSlash = input.indexOf("/",start); - } - if (indexOfSlash == -1) - indexOfSlash = input.length(); - output.append(input.substring(start, indexOfSlash)); - start = indexOfSlash; - } - return output.toString(); - } - - /** - * Removes the last segment of the path from the specified buffer. - * - * @param buffer the buffer containing the path. - */ - private void removeLastSegment(StringBuffer buffer) - { - int lastSlash = buffer.lastIndexOf("/"); - if (lastSlash == -1) - buffer.setLength(0); - else - buffer.setLength(lastSlash); + return null; } /** @@ -865,7 +609,7 @@ * @return The resulting URI, or null when it couldn't be resolved * for some reason. * - * @throws NullPointerException if uri is null + * @exception NullPointerException If uri is null */ public URI resolve(URI uri) { @@ -901,15 +645,16 @@ basepath.delete(i + 1, basepath.length()); basepath.append(path); - path = normalizePath(basepath.toString()); + path = basepath.toString(); + // FIXME We must normalize the path here. + // Normalization process omitted. } } return new URI(this.scheme, authority, path, query, fragment); } catch (URISyntaxException e) { - throw (Error) new InternalError("Resolved URI variant could not "+ - "be constructed").initCause(e); + return null; } } @@ -920,9 +665,9 @@ * * @return The resulting URI * - * @throws IllegalArgumentException If the given URI string + * @exception IllegalArgumentException If the given URI string * violates RFC 2396 - * @throws NullPointerException If uri is null + * @exception NullPointerException If uri is null */ public URI resolve(String str) throws IllegalArgumentException { @@ -930,60 +675,25 @@ } /** - *- * Relativizes the given URI against this URI. The following - * algorithm is used: - *
- *
- * Compares the URI with the given object for equality. If the
- * object is not a URI, then the method returns false.
- * Otherwise, the following criteria are observed:
- *
true if the objects are equal, according to
- * the specification above.
+ * Compares the URI with a given object
+ *
+ * @param obj The obj to compare the URI with
*/
public boolean equals(Object obj)
{
- if (!(obj instanceof URI))
- return false;
- URI uriObj = (URI) obj;
- if (scheme == null)
- {
- if (uriObj.getScheme() != null)
- return false;
- }
- else
- if (!(scheme.equalsIgnoreCase(uriObj.getScheme())))
- return false;
- if (rawFragment == null)
- {
- if (uriObj.getRawFragment() != null)
- return false;
- }
- else
- if (!(rawFragment.equalsIgnoreCase(uriObj.getRawFragment())))
- return false;
- boolean opaqueThis = isOpaque();
- boolean opaqueObj = uriObj.isOpaque();
- if (opaqueThis && opaqueObj)
- return rawSchemeSpecificPart.equals(uriObj.getRawSchemeSpecificPart());
- else if (!opaqueThis && !opaqueObj)
- {
- boolean common = rawPath.equalsIgnoreCase(uriObj.getRawPath())
- && ((rawQuery == null && uriObj.getRawQuery() == null)
- || rawQuery.equalsIgnoreCase(uriObj.getRawQuery()));
- if (rawAuthority == null && uriObj.getRawAuthority() == null)
- return common;
- if (host == null)
- return common
- && rawAuthority.equalsIgnoreCase(uriObj.getRawAuthority());
- return common
- && host.equalsIgnoreCase(uriObj.getHost())
- && port == uriObj.getPort()
- && (rawUserInfo == null ?
- uriObj.getRawUserInfo() == null :
- rawUserInfo.equalsIgnoreCase(uriObj.getRawUserInfo()));
- }
- else
- return false;
+ return false;
}
/**
- * Computes the hashcode of the URI
+ * Computes the hascode of the URI
*/
public int hashCode()
{
- return (getScheme() == null ? 0 : 13 * getScheme().hashCode())
- + 17 * getRawSchemeSpecificPart().hashCode()
- + (getRawFragment() == null ? 0 : 21 + getRawFragment().hashCode());
+ return 0;
}
/**
- * Compare the URI with another object that must also be a URI.
- * Undefined components are taken to be less than any other component.
- * The following criteria are observed:
- *
- * toString() for URIs that don't contain any non-US-ASCII
- * characters. Otherwise, the non-US-ASCII characters are replaced
- * by their percent-encoded representations.
- *
- * @return a string representation of the URI, containing only US-ASCII
- * characters.
+ * Returns the URI as US-ASCII string
*/
public String toASCIIString()
{
- String strRep = toString();
- boolean inNonAsciiBlock = false;
- StringBuffer buffer = new StringBuffer();
- StringBuffer encBuffer = null;
- for (int i = 0; i < strRep.length(); i++)
- {
- char c = strRep.charAt(i);
- if (c <= 127)
- {
- if (inNonAsciiBlock)
- {
- buffer.append(escapeCharacters(encBuffer.toString()));
- inNonAsciiBlock = false;
- }
- buffer.append(c);
- }
- else
- {
- if (!inNonAsciiBlock)
- {
- encBuffer = new StringBuffer();
- inNonAsciiBlock = true;
- }
- encBuffer.append(c);
- }
- }
- return buffer.toString();
+ return "";
}
-
- /**
- * Converts the non-ASCII characters in the supplied string
- * to their equivalent percent-encoded representations.
- * That is, they are replaced by "%" followed by their hexadecimal value.
- *
- * @param str a string including non-ASCII characters.
- * @return the string with the non-ASCII characters converted to their
- * percent-encoded representations.
- */
- private static String escapeCharacters(String str)
- {
- try
- {
- StringBuffer sb = new StringBuffer();
- // this is far from optimal, but it works
- byte[] utf8 = str.getBytes("utf-8");
- for (int j = 0; j < utf8.length; j++)
- {
- sb.append('%');
- sb.append(HEX.charAt((utf8[j] & 0xff) / 16));
- sb.append(HEX.charAt((utf8[j] & 0xff) % 16));
- }
- return sb.toString();
- }
- catch (java.io.UnsupportedEncodingException x)
- {
- throw (Error) new InternalError("Escaping error").initCause(x);
- }
- }
-
}