Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) 2006, Wygwam
   * All rights reserved.
   * 
   * Redistribution and use in source and binary forms, with or without modification, 
   * are permitted provided that the following conditions are met: 
   * 
   * - Redistributions of source code must retain the above copyright notice, 
   * this list of conditions and the following disclaimer.
  * - Redistributions in binary form must reproduce the above copyright notice, 
  * this list of conditions and the following disclaimer in the documentation and/or 
  * other materials provided with the distribution.
  * - Neither the name of Wygwam nor the names of its contributors may be 
  * used to endorse or promote products derived from this software without 
  * specific prior written permission. 
  * 
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
  * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 package org.docx4j.openpackaging;
 
 import java.net.URI;
 
 
Helper for part and pack URI.

Author(s):
Julien Chable, CDubet
Version:
0.3
 
 public final class URIHelper {
 
 	private static Logger log = LoggerFactory.getLogger(URIHelper.class);	

Package root URI.
 
 	private static URI packageRootUri;

Extension name of a relationship part.
 
 	public static final String RELATIONSHIP_PART_EXTENSION_NAME;

Segment name of a relationship part.
 
 	public static final String RELATIONSHIP_PART_SEGMENT_NAME;

Segment name of the package properties folder.
 
 	public static final String PACKAGE_PROPERTIES_SEGMENT_NAME;

Core package properties art name.
 
 	public static final String PACKAGE_CORE_PROPERTIES_NAME;

Forward slash URI separator.
 
 	public static final char FORWARD_SLASH_CHAR;

Forward slash URI separator.
 
 	public static final String FORWARD_SLASH_STRING;

Package relationships part URI
 
 	public static final URI PACKAGE_RELATIONSHIPS_ROOT_URI;

Package relationships part name.
 
Core properties part URI.
	public static final URI CORE_PROPERTIES_URI;

Core properties partname.
	public static final PartName CORE_PROPERTIES_PART_NAME;

Root package URI.
	public static final URI PACKAGE_ROOT_URI;

Root package part name.
	public static final PartName PACKAGE_ROOT_PART_NAME;
	/* Static initialization */
	static {
		// Make URI
		URI uriPACKAGE_ROOT_URI = null;
		URI uriPACKAGE_RELATIONSHIPS_ROOT_URI = null;
		URI uriPACKAGE_PROPERTIES_URI = null;
		try {
			uriPACKAGE_ROOT_URI = new URI("/");
			uriPACKAGE_RELATIONSHIPS_ROOT_URI = new URI(
			 = new URI("/");
			uriPACKAGE_PROPERTIES_URI = new URI(
catch (URISyntaxException e) {
			// Should never happen in production as all data are fixed
		}
		 = uriPACKAGE_ROOT_URI;
		 = uriPACKAGE_RELATIONSHIPS_ROOT_URI;
		 = uriPACKAGE_PROPERTIES_URI;
		// Make part name from previous URI
		PartName tmpPACKAGE_ROOT_PART_NAME = null;
		PartName tmpPACKAGE_RELATIONSHIPS_ROOT_PART_NAME = null;
		PartName tmpCORE_PROPERTIES_URI = null;
		try {
			tmpPACKAGE_RELATIONSHIPS_ROOT_PART_NAME = createPartName();
			tmpCORE_PROPERTIES_URI = createPartName();
			tmpPACKAGE_ROOT_PART_NAME = new PartName(,
					false);
catch (InvalidFormatException e) {
			// Should never happen in production as all data are fixed
		}
		 = tmpPACKAGE_RELATIONSHIPS_ROOT_PART_NAME;
		 = tmpCORE_PROPERTIES_URI;
		 = tmpPACKAGE_ROOT_PART_NAME;
	}

Gets the URI for the package root.

Returns:
URI of the package root.
	public static URI getPackageRootUri() {
	}


Know if the specified URI is a relationship part name.

Parameters:
partUri URI to check.
Returns:
true if the URI false.
	private static boolean isRelationshipPartURI(URI partUri) {
		if (partUri == null)
			throw new NullPointerException("partUri");
		return partUri.getPath().matches(
	}

Get file name from the specified URI.
	public static String getFilename(URI uri) {
		if (uri != null) {
			String path = uri.getPath();
			int len = path.length();
			int num2 = len;
			while (--num2 >= 0) {
				char ch1 = path.charAt(num2);
					return path.substring(num2 + 1, len);
			}
		}
		return "";
	}

Get the file name without the trailing extension.
	public static String getFilenameWithoutExtension(URI uri) {
		String filename = getFilename(uri);
		int dotIndex = filename.lastIndexOf(".");
		if (dotIndex == -1)
			return filename;
		return filename.substring(0, dotIndex);
	}

Get the directory path from the specified URI.
	public static URI getPath(URI uri) {
		if (uri != null) {
			String path = uri.getPath();
			int len = path.length();
			int num2 = len;
			while (--num2 >= 0) {
				char ch1 = path.charAt(num2);
				if (ch1 == .) {
					try {
						return new URI(path.substring(0, num2));
catch (URISyntaxException e) {
						return null;
					}
				}
			}
		}
		return null;
	}

Combine two URI.

Parameters:
prefix
suffix
Returns:
	public static URI combine(URI prefixURI suffix) {
		URI retUri = null;
		try {
			retUri = new URI(combine(prefix.getPath(), suffix.getPath()));
catch (URISyntaxException e) {
					"Prefix and suffix can't be combined !");
		}
		return retUri;
	}

Combine a string URI with a prefix and a suffix.
	public static String combine(String prefixString suffix) {
		if (!prefix.endsWith("" + )
				&& !suffix.startsWith("" + ))
			return prefix +  + suffix;
		else if ((!prefix.endsWith("" + )
				&& suffix.startsWith("" + ) || (prefix
				.endsWith("" + ) && !suffix.startsWith(""
			return prefix + suffix;
		else
			return "";
	}

Fully relativize the target part URI against the source part URI.

Parameters:
sourceURI The source part URI.
targetURI The target part URI.
Returns:
A fully relativize part name URI ('word/media/image1.gif', '/word/document.xml' => 'media/image1.gif') else null.
	public static URI relativizeURI(URI sourceURIURI targetURI) {
		StringBuilder retVal = new StringBuilder();
		String[] segmentsSource = sourceURI.getPath().split("/", -1);
		String[] segmentsTarget = targetURI.getPath().split("/", -1);
		// If the source URI is empty
		if (segmentsSource.length == 0) {
					"Can't relativize an empty source URI !");
		}
		// If target URI is empty
		if (segmentsTarget.length == 0) {
					"Can't relativize an empty target URI !");
		}
		// If the source is the root, then the relativized
		//  form must actually be an absolute URI
		if(sourceURI.toString().equals("/")) {
			return targetURI;
		}
		// Relativize the source URI against the target URI.
		// First up, figure out how many steps along we can go
		// and still have them be the same
		int segmentsTheSame = 0;
		for (int i = 0; i < segmentsSource.length && i < segmentsTarget.lengthi++) {
			if (segmentsSource[i].equals(segmentsTarget[i])) {
				// Match so far, good
				segmentsTheSame++;
else {
				break;
			}
		}
		// If we didn't have a good match or at least except a first empty element
		if ((segmentsTheSame == 0 || segmentsTheSame == 1) && 
				segmentsSource[0].equals("") && segmentsTarget[0].equals("")) {
			for (int i = 0; i < segmentsSource.length - 2; i++) {
				retVal.append("../");
			}
			for (int i = 0; i < segmentsTarget.lengthi++) {
				if (segmentsTarget[i].equals(""))
					continue;
				retVal.append(segmentsTarget[i]);
				if (i != segmentsTarget.length - 1)
					retVal.append("/");
			}
			try {
				return new URI(retVal.toString());
catch (Exception e) {
				return null;
			}
		}
		// Special case for where the two are the same
		if (segmentsTheSame == segmentsSource.length
				&& segmentsTheSame == segmentsTarget.length) {
			retVal.append("");
else {
			// Matched for so long, but no more
			// Do we need to go up a directory or two from
			// the source to get here?
			// (If it's all the way up, then don't bother!)
			if (segmentsTheSame == 1) {
				retVal.append("/");
else {
				for (int j = segmentsTheSamej < segmentsSource.length - 1; j++) {
					retVal.append("../");
				}
			}
			// Now go from here on down
			for (int j = segmentsTheSamej < segmentsTarget.lengthj++) {
				if (retVal.length() > 0
						&& retVal.charAt(retVal.length() - 1) != '/') {
					retVal.append("/");
				}
				retVal.append(segmentsTarget[j]);
			}
		}
		try {
			return new URI(retVal.toString());
catch (Exception e) {
			return null;
		}
	}


Resolve a target uri against a source.

Parameters:
sourcePartUri The source URI.
targetUri The target URI.
Returns:
The resolved URI.
	public static URI resolvePartUri(URI sourcePartUriURI targetUri) {
//		log.info("source: " + sourcePartUri);
//		log.info("target: " + targetUri);
		URI uri;
		if (sourcePartUri == null || sourcePartUri.isAbsolute()) {
			throw new IllegalArgumentException("sourcePartUri");
		}
		if (targetUri == null) {
			.error("targetUri was null");
			throw new IllegalArgumentException("targetUri");			
else if (targetUri.isAbsolute()) {			
			.error("targetUri " + targetUri.toString() + " is absolute!");
			throw new IllegalArgumentException("targetUri");
		}
		uri = sourcePartUri.resolve(targetUri);
//		log.info("RESULT: " + uri);
		return uri;
	}

Get URI from a string path.
	public static URI getURIFromPath(String path) {
		URI retUri = null;
		try {
			retUri = new URI(path);
catch (URISyntaxException e) {
			throw new IllegalArgumentException("path");
		}
		return retUri;
	}
			URI relationshipPartUri) {
		if (relationshipPartUri == null)
					"The relationshipPart Uri was null !");
		if (!isRelationshipPartURI(relationshipPartUri))
					"L'URI ne doit pas �tre celle d'une partie de type relation.");
		if (relationshipPartUri.compareTo() == 0)
		String filename = relationshipPartUri.getPath();
		String filenameWithoutExtension = getFilenameWithoutExtension(relationshipPartUri);
		filename = filename
				.substring(0, ((filename.length() - filenameWithoutExtension
		filename = filename.substring(0, filename.length()
		filename = combine(filenamefilenameWithoutExtension);
		return getURIFromPath(filename);
	}

Create an OPC compliant part name by throwing an exception if the URI is not valid.

Parameters:
partUri The part name URI to validate.
Returns:
A valid part name object, else null.
Throws:
org.docx4j.openpackaging.exceptions.InvalidFormatException Throws if the specified URI is not OPC compliant.
	public static PartName createPartName(URI partUri)
		if (partUri == null)
			throw new IllegalArgumentException("partName");
		return new PartName(partUritrue);
	}

Create an OPC compliant part name by throwing an exception if the specified name is not valid.

Parameters:
partName The part name to validate.
Returns:
The correspondant part name if valid, else null.
Throws:
org.docx4j.openpackaging.exceptions.InvalidFormatException Throws if the specified part name is not OPC compliant.
See also:
createPartName(java.net.URI)
	public static PartName createPartName(String partName)
		URI partNameURI;
		try {
			partNameURI = new URI(partName);
catch (URISyntaxException e) {
		}
		return createPartName(partNameURI);
	}

Validate a part URI by returning a boolean. ([M1.1],[M1.3],[M1.4],[M1.5],[M1.6]) (OPC Specifications 8.1.1 Part names) : Part Name Syntax The part name grammar is defined as follows: part_name = 1*( "/" segment ) segment = 1*( pchar ) (pchar is defined in RFC 3986)

Parameters:
partUri The URI to validate.
Returns:
true if the URI is valid to the OPC Specifications, else false
See also:
createPartName(java.net.URI)
	public static boolean isValidPartName(URI partUri) {
		if (partUri == null)
			throw new IllegalArgumentException("partUri");
		try {
			return true;
catch (Exception e) {
			return false;
		}
	}

Decode a URI by converting all percent encoded character into a String character.

Parameters:
uri The URI to decode.
Returns:
The specified URI in a String with converted percent encoded characters.
	public static String decodeURI(URI uri) {
		StringBuffer retVal = new StringBuffer();
		String uriStr = uri.toASCIIString();
		char c;
		for (int i = 0; i < uriStr.length(); ++i) {
			c = uriStr.charAt(i);
			if (c == '%') {
				// We certainly found an encoded character, check for length
				// now ( '%' HEXDIGIT HEXDIGIT)
				if (((uriStr.length() - i) < 2)) {
					throw new IllegalArgumentException("The uri " + uriStr
" contain invalid encoded character !");
				}
				// Decode the encoded character
				char decodedChar = (char) Integer.parseInt(uriStr.substring(
						i + 1, i + 3), 16);
				retVal.append(decodedChar);
				i += 2;
				continue;
			}
			retVal.append(c);
		}
		return retVal.toString();
	}
//	/**
//	 * Fully relativize the source part URI against the target part URI.
//	 * 
//	 * @param sourceURI
//	 *            The source part URI.
//	 * @param targetURI
//	 *            The target part URI.
//	 * @return A fully relativize part name URI ('word/media/image1.gif',
//	 *         '/word/document.xml' => 'media/image1.gif') else
//	 *         <code>null</code>.
//	 */
//	public static URI OLDrelativizeURI(URI sourceURI, URI targetURI) {
//		StringBuffer retVal = new StringBuffer();
//		String[] segmentsSource = sourceURI.getPath().split("/");
//		String[] segmentsTarget = targetURI.getPath().split("/");
//
//		// If the source URI is empty
//		if (segmentsSource.length == 0) {
//			return null;
//		}
//
//		// If target URI is empty
//		if (segmentsTarget.length == 0) {
//			if (sourceURI.getPath().startsWith(FORWARD_SLASH_STRING)) {
//				try {
//					return new URI(sourceURI.getPath().substring(1));
//				} catch (Exception e) {
//					return null;
//				}
//			} else
//				return sourceURI;
//		}
//
//		// Relativize the source URI against the target URI.
//		for (short i = 0, j = 0; i < segmentsSource.length
//				&& j < segmentsTarget.length; ++i, ++j) {
//			if (segmentsSource[i].equalsIgnoreCase(segmentsTarget[j])) {
//				if (i < segmentsSource.length - 1) {
//					continue;
//				} else {
//					// We add the last segment whatever it happens
//					retVal.append("/");
//					retVal.append(segmentsTarget[i]);
//					break;
//				}
//			} else {
//				for (; i < segmentsSource.length; ++i) {
//					retVal.append("/");
//					retVal.append(segmentsSource[i]);
//				}
//				break;
//			}
//		}
//		try {
//			PartName retPartName = new PartName(
//					retVal.toString(), true);
//			return new URI(retPartName.getURI().getPath().substring(1));
//		} catch (Exception e) {
//			return null;
//		}
//	}
New to GrepCode? Check out our FAQ X