/*
* 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.uima.tools.internal.cde.uima.util;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import org.apache.uima.UIMAFramework;
import org.apache.uima.resource.ResourceManager;
import org.apache.uima.resource.metadata.Import;
import org.apache.uima.resource.metadata.impl.Import_impl;
import org.apache.uima.util.InvalidXMLException;
import org.apache.uima.util.XMLInputSource;
import org.apache.uima.util.XMLParser;
import org.apache.uima.util.XMLizable;
import org.eclipse.core.resources.IFile;
/**
* A uitility class for UIMA's description objects
*
* see CDE AbstractSection
*/
public class UimaDescriptionUtils {
// From CDE AbstractSection
private static URL urlForResourceSpecifierSchema;
static {
try {
urlForResourceSpecifierSchema = new URL("file:resourceSpecifierSchema.xsd");
} catch (MalformedURLException e) {
urlForResourceSpecifierSchema = null;
}
}
// From CDE AbstractSection
public static XMLizable parseDescriptor(XMLInputSource input) throws InvalidXMLException {
// turn off environment variable expansion
XMLParser.ParsingOptions parsingOptions = new XMLParser.ParsingOptions(false);
XMLParser parser = UIMAFramework.getXMLParser();
// disabled - error messages from XML validation not very helpful
// parser.enableSchemaValidation(true);
return parser.parse(input, "http://uima.apache.org/resourceSpecifier",
urlForResourceSpecifierSchema, parsingOptions);
}
/**
* @param location
* @return
* @throws MalformedURLException
*/
static public Import createByLocationImport(IFile parentFile, String location)
throws MalformedURLException {
String sDescriptorRelativePath = getDescriptorRelativePath(parentFile.getLocation().toString(),
location);
// If relative path is not "relative", on Windows might get back
// an absolute path starting with C: or something like it.
// If a path starts with "C:", it must be preceeded by
// file:/ so the C: is not interpreted as a "scheme".
if (sDescriptorRelativePath.indexOf("file:/") == -1 //$NON-NLS-1$
&& sDescriptorRelativePath.indexOf(":/") > -1) { //$NON-NLS-1$
sDescriptorRelativePath = "file:/" + sDescriptorRelativePath; //$NON-NLS-1$
}
Import imp = new Import_impl();
// fails on unix? URL url = new URL("file:/" + getDescriptorDirectory());
// Set relative Path Base
// a version that might work on all platforms
URL url = new File(extractDirectory(parentFile)).toURL();
((Import_impl) imp).setSourceUrl(url);
imp.setLocation(sDescriptorRelativePath);
return imp;
}
static public Import createByNameImport(String fileName, ResourceManager rm) {
if (fileName.endsWith(".xml"))
fileName = fileName.substring(0, fileName.length() - 4);
fileName = fileName.replace('\\', '/');
fileName = fileName.replace('/', '.');
int i = fileName.indexOf(":");
if (i >= 0)
fileName = fileName.substring(i + 1);
if (fileName.charAt(0) == '.')
fileName = fileName.substring(1);
int partStart = 0;
Import imp = UIMAFramework.getResourceSpecifierFactory().createImport();
for (;;) {
imp.setName(fileName.substring(partStart));
try {
imp.findAbsoluteUrl(rm);
} catch (InvalidXMLException e) {
partStart = fileName.indexOf('.', partStart) + 1;
if (0 == partStart)
return imp; // not found -outer code will catch error later
continue;
}
return imp;
}
}
static public String getDescriptorFromImport(Import imp) {
String descr = null;
if (imp != null) {
descr = imp.getLocation();
if (descr == null) {
descr = imp.getName();
}
}
return descr;
}
/** ********************************************************************** */
static public String extractDirectory(IFile file) {
String sDir = file.getParent().getLocation().toString();
if (sDir.charAt(sDir.length() - 1) != '/') {
sDir += '/';
}
return sDir;
}
static public String getDescriptorRelativePath(String sParentFileFullPath,
String aFullOrRelativePath) {
String sFullOrRelativePath = aFullOrRelativePath.replace('\\', '/');
// first, if not in workspace, or if a relative path, not a full path, return path
// String sWorkspacePath =
// TAEConfiguratorPlugin.getWorkspace().getRoot().getLocation().toString();
// if (sFullOrRelativePath.indexOf(sWorkspacePath) == -1) {
// return sFullOrRelativePath;
// }
String sFullPath = sFullOrRelativePath; // rename the var to its semantics
String commonPrefix = getCommonParentFolder(sParentFileFullPath, sFullPath);
if (commonPrefix.length() < 2 || commonPrefix.indexOf(':') == commonPrefix.length() - 2) {
return sFullPath;
}
// now count extra slashes to determine how many ..'s are needed
int nCountBackDirs = 0;
String sRelativePath = ""; //$NON-NLS-1$
for (int i = commonPrefix.length(); i < sParentFileFullPath.length(); i++) {
if (sParentFileFullPath.charAt(i) == '/') {
sRelativePath += "../"; //$NON-NLS-1$
nCountBackDirs++;
}
}
sRelativePath += sFullPath.substring(commonPrefix.length());
return sRelativePath;
}
private static String getCommonParentFolder(String sFile1, String sFile2) {
if (sFile1 == null || sFile2 == null) {
return ""; //$NON-NLS-1$
}
int maxLength = (sFile1.length() <= sFile2.length() ? sFile1.length() : sFile2.length());
int commonPrefixLength = 0;
for (int i = 0; i < maxLength; i++) {
if (sFile1.charAt(i) != sFile2.charAt(i) || (i == maxLength - 1)) { // catch files which have
// same prefix
for (int j = i; j >= 0; j--) {
if (sFile1.charAt(j) == '/' || sFile1.charAt(j) == '\\') {
commonPrefixLength = j + 1;
break;
}
}
break;
}
}
return sFile1.substring(0, commonPrefixLength);
}
}