Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.vfs2.provider; import org.apache.commons.vfs2.FileName; import org.apache.commons.vfs2.FileSystemException; import org.apache.commons.vfs2.FileType; import org.apache.commons.vfs2.VFS; import org.apache.commons.vfs2.util.Os; /** * Utilities for dealing with URIs. See RFC 2396 for details. * * 2005) $ */ public final class UriParser { /** * The set of valid separators. These are all converted to the normalized * one. Does <i>not</i> contain the normalized separator */ // public static final char[] separators = {'\\'}; public static final char TRANS_SEPARATOR = '\\'; /** * The normalised separator to use. */ private static final char SEPARATOR_CHAR = FileName.SEPARATOR_CHAR; private static final int HEX_BASE = 16; private static final int BITS_IN_HALF_BYTE = 4; private static final char LOW_MASK = 0x0F; private UriParser() { } /** * Extracts the first element of a path. * @param name StringBuilder containing the path. * @return The first element of the path. */ public static String extractFirstElement(final StringBuilder name) { final int len = name.length(); if (len < 1) { return null; } int startPos = 0; if (name.charAt(0) == SEPARATOR_CHAR) { startPos = 1; } for (int pos = startPos; pos < len; pos++) { if (name.charAt(pos) == SEPARATOR_CHAR) { // Found a separator final String elem = name.substring(startPos, pos); name.delete(startPos, pos + 1); return elem; } } // No separator final String elem = name.substring(startPos); name.setLength(0); return elem; } /** * Normalises a path. Does the following: * <ul> * <li>Removes empty path elements. * <li>Handles '.' and '..' elements. * <li>Removes trailing separator. * </ul> * * Its assumed that the separators are already fixed. * * @param path The path to normalize. * @return The FileType. * @throws FileSystemException if an error occurs. * * @see #fixSeparators */ public static FileType normalisePath(final StringBuilder path) throws FileSystemException { FileType fileType = FileType.FOLDER; if (path.length() == 0) { return fileType; } if (path.charAt(path.length() - 1) != '/') { fileType = FileType.FILE; } // Adjust separators // fixSeparators(path); // Determine the start of the first element int startFirstElem = 0; if (path.charAt(0) == SEPARATOR_CHAR) { if (path.length() == 1) { return fileType; } startFirstElem = 1; } // Iterate over each element int startElem = startFirstElem; int maxlen = path.length(); while (startElem < maxlen) { // Find the end of the element int endElem = startElem; for (; endElem < maxlen && path.charAt(endElem) != SEPARATOR_CHAR; endElem++) { } final int elemLen = endElem - startElem; if (elemLen == 0) { // An empty element - axe it path.delete(endElem, endElem + 1); maxlen = path.length(); continue; } if (elemLen == 1 && path.charAt(startElem) == '.') { // A '.' element - axe it path.delete(startElem, endElem + 1); maxlen = path.length(); continue; } if (elemLen == 2 && path.charAt(startElem) == '.' && path.charAt(startElem + 1) == '.') { // A '..' element - remove the previous element if (startElem == startFirstElem) { // Previous element is missing throw new FileSystemException("vfs.provider/invalid-relative-path.error"); } // Find start of previous element int pos = startElem - 2; for (; pos >= 0 && path.charAt(pos) != SEPARATOR_CHAR; pos--) { } startElem = pos + 1; path.delete(startElem, endElem + 1); maxlen = path.length(); continue; } // A regular element startElem = endElem + 1; } // Remove trailing separator if (!VFS.isUriStyle()) { if (maxlen > 0 && path.charAt(maxlen - 1) == SEPARATOR_CHAR && maxlen > 1) { path.delete(maxlen - 1, maxlen); } } return fileType; } /** * Normalises the separators in a name. * @param name The StringBuilder containing the name * @return true if the StringBuilder was modified. */ public static boolean fixSeparators(final StringBuilder name) { boolean changed = false; final int maxlen = name.length(); for (int i = 0; i < maxlen; i++) { final char ch = name.charAt(i); if (ch == TRANS_SEPARATOR) { name.setCharAt(i, SEPARATOR_CHAR); changed = true; } } return changed; } /** * Extracts the scheme from a URI. * * @param uri The URI. * @return The scheme name. Returns null if there is no scheme. */ public static String extractScheme(final String uri) { return extractScheme(uri, null); } /** * Extracts the scheme from a URI. Removes the scheme and ':' delimiter from * the front of the URI. * * @param uri The URI. * @param buffer Returns the remainder of the URI. * @return The scheme name. Returns null if there is no scheme. */ public static String extractScheme(final String uri, final StringBuilder buffer) { if (buffer != null) { buffer.setLength(0); buffer.append(uri); } final int maxPos = uri.length(); for (int pos = 0; pos < maxPos; pos++) { final char ch = uri.charAt(pos); if (ch == ':') { // Found the end of the scheme final String scheme = uri.substring(0, pos); if (scheme.length() <= 1 && Os.isFamily(Os.OS_FAMILY_WINDOWS)) { // This is not a scheme, but a Windows drive letter return null; } if (buffer != null) { buffer.delete(0, pos + 1); } return scheme.intern(); } if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) { // A scheme character continue; } if (pos > 0 && ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')) { // A scheme character (these are not allowed as the first // character of the scheme, but can be used as subsequent // characters. continue; } // Not a scheme character break; } // No scheme in URI return null; } /** * Removes %nn encodings from a string. * @param encodedStr The encoded String. * @return The decoded String. * @throws FileSystemException if an error occurs. */ public static String decode(final String encodedStr) throws FileSystemException { if (encodedStr == null) { return null; } if (encodedStr.indexOf('%') < 0) { return encodedStr; } final StringBuilder buffer = new StringBuilder(encodedStr); decode(buffer, 0, buffer.length()); return buffer.toString(); } /** * Removes %nn encodings from a string. * @param buffer StringBuilder containing the string to decode. * @param offset The position in the string to start decoding. * @param length The number of characters to decode. * @throws FileSystemException if an error occurs. */ public static void decode(final StringBuilder buffer, final int offset, final int length) throws FileSystemException { int index = offset; int count = length; for (; count > 0; count--, index++) { final char ch = buffer.charAt(index); if (ch != '%') { continue; } if (count < 3) { throw new FileSystemException("vfs.provider/invalid-escape-sequence.error", buffer.substring(index, index + count)); } // Decode final int dig1 = Character.digit(buffer.charAt(index + 1), HEX_BASE); final int dig2 = Character.digit(buffer.charAt(index + 2), HEX_BASE); if (dig1 == -1 || dig2 == -1) { throw new FileSystemException("vfs.provider/invalid-escape-sequence.error", buffer.substring(index, index + 3)); } final char value = (char) (dig1 << BITS_IN_HALF_BYTE | dig2); // Replace buffer.setCharAt(index, value); buffer.delete(index + 1, index + 3); count -= 2; } } /** * Encodes and appends a string to a StringBuilder. * @param buffer The StringBuilder to append to. * @param unencodedValue The String to encode and append. * @param reserved characters to encode. */ public static void appendEncoded(final StringBuilder buffer, final String unencodedValue, final char[] reserved) { final int offset = buffer.length(); buffer.append(unencodedValue); encode(buffer, offset, unencodedValue.length(), reserved); } /** * Encodes a set of reserved characters in a StringBuilder, using the URI %nn * encoding. Always encodes % characters. * @param buffer The StringBuilder to append to. * @param offset The position in the buffer to start encoding at. * @param length The number of characters to encode. * @param reserved characters to encode. */ public static void encode(final StringBuilder buffer, final int offset, final int length, final char[] reserved) { int index = offset; int count = length; for (; count > 0; index++, count--) { final char ch = buffer.charAt(index); boolean match = ch == '%'; if (reserved != null) { for (int i = 0; !match && i < reserved.length; i++) { if (ch == reserved[i]) { match = true; } } } if (match) { // Encode final char[] digits = { Character.forDigit(((ch >> BITS_IN_HALF_BYTE) & LOW_MASK), HEX_BASE), Character.forDigit((ch & LOW_MASK), HEX_BASE) }; buffer.setCharAt(index, '%'); buffer.insert(index + 1, digits); index += 2; } } } /** * Removes %nn encodings from a string. * @param decodedStr The decoded String. * @return The encoded String. */ public static String encode(final String decodedStr) { return encode(decodedStr, null); } /** * Converts "special" characters to their %nn value. * @param decodedStr The decoded String. * @param reserved Characters to encode. * @return The encoded String */ public static String encode(final String decodedStr, final char[] reserved) { if (decodedStr == null) { return null; } final StringBuilder buffer = new StringBuilder(decodedStr); encode(buffer, 0, buffer.length(), reserved); return buffer.toString(); } /** * Encode an array of Strings. * @param strings The array of Strings to encode. * @return An array of encoded Strings. */ public static String[] encode(final String[] strings) { if (strings == null) { return null; } for (int i = 0; i < strings.length; i++) { strings[i] = encode(strings[i]); } return strings; } /** * Decodes the String. * @param uri The String to decode. * @throws FileSystemException if an error occurs. */ public static void checkUriEncoding(final String uri) throws FileSystemException { decode(uri); } public static void canonicalizePath(final StringBuilder buffer, final int offset, final int length, final FileNameParser fileNameParser) throws FileSystemException { int index = offset; int count = length; for (; count > 0; count--, index++) { final char ch = buffer.charAt(index); if (ch == '%') { if (count < 3) { throw new FileSystemException("vfs.provider/invalid-escape-sequence.error", buffer.substring(index, index + count)); } // Decode final int dig1 = Character.digit(buffer.charAt(index + 1), HEX_BASE); final int dig2 = Character.digit(buffer.charAt(index + 2), HEX_BASE); if (dig1 == -1 || dig2 == -1) { throw new FileSystemException("vfs.provider/invalid-escape-sequence.error", buffer.substring(index, index + 3)); } final char value = (char) (dig1 << BITS_IN_HALF_BYTE | dig2); final boolean match = value == '%' || fileNameParser.encodeCharacter(value); if (match) { // this is a reserved character, not allowed to decode index += 2; count -= 2; continue; } // Replace buffer.setCharAt(index, value); buffer.delete(index + 1, index + 3); count -= 2; } else if (fileNameParser.encodeCharacter(ch)) { // Encode final char[] digits = { Character.forDigit(((ch >> BITS_IN_HALF_BYTE) & LOW_MASK), HEX_BASE), Character.forDigit((ch & LOW_MASK), HEX_BASE) }; buffer.setCharAt(index, '%'); buffer.insert(index + 1, digits); index += 2; } } } /** * Extract the query String from the URI. * @param name StringBuilder containing the URI. * @return The query string, if any. null otherwise. */ public static String extractQueryString(final StringBuilder name) { for (int pos = 0; pos < name.length(); pos++) { if (name.charAt(pos) == '?') { final String queryString = name.substring(pos + 1); name.delete(pos, name.length()); return queryString; } } return null; } }