Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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.axis2.jaxws.utility;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
/** Common Java Utilites */
public class JavaUtils extends org.apache.axis2.util.JavaUtils {
private static Log log = LogFactory.getLog(JavaUtils.class);
/** Private Constructor...All methods of this class are static */
private JavaUtils() {
}
/**
* @param namespace
* @return List of String containing 1 or 2 packages
*/
public static List getPackagesFromNamespace(String namespace) {
List list = new ArrayList();
// Get a package using JAXB Rules
String jaxbPkg = getPackageFromNamespace(namespace, true);
list.add(jaxbPkg);
if (jaxbPkg.contains("_")) {
if (log.isDebugEnabled()) {
log.debug("Calling getPackageFromNamespace with wsimport rule:" + namespace);
}
String altPkg = getPackageFromNamespace(namespace, false); // Using wsimport rule
list.add(altPkg);
}
return list;
}
/**
* Namespace 2 Package algorithm as defined by the JAXB Specification
*
* @param Namespace
* @return String representing Namespace
* @see getPackagesFromNamespace
*/
public static String getPackageFromNamespace(String namespace) {
return getPackageFromNamespace(namespace, true);
}
/**
* @param Namespace
* @param apend underscore to keyword
* @return String representing Namespace
*/
public static String getPackageFromNamespace(String namespace,
boolean appendUnderscoreToKeyword) {
// The following steps correspond to steps described in the JAXB Specification
if (log.isDebugEnabled()) {
log.debug("namespace (" +namespace +")");
}
// Step 1: Scan off the host name
String hostname = null;
String path = null;
try {
URL url = new URL(namespace);
hostname = url.getHost();
path = url.getPath();
}
catch (MalformedURLException e) {
// No FFDC code needed
// If a MalformedURLException occurs, then
// just simply get one string and put it in the hostname.
// In such cases the path will remain empty.
// This code is necessary so that we can process namespaces
// like "urn:acme" or simply "sampleNamespace"
if (namespace.indexOf(":") > -1) {
// Brain-dead code to skip over the protocol
hostname = namespace.substring(namespace.indexOf(":") + 1);
} else {
hostname = namespace;
}
}
if (log.isDebugEnabled()) {
log.debug("hostname (" +hostname +")");
log.debug("path (" +path +")");
}
// Step 3: Tokenize the host name using ":" and "/"
StringTokenizer st = new StringTokenizer(hostname, ":/");
ArrayList wordList = new ArrayList();
//Read Hostname first.
while (st != null && st.hasMoreTokens()) {
wordList.add(st.nextToken());
}
//Read rest Of the path now
if (path != null) {
StringTokenizer pathst = new StringTokenizer(path, "/");
while (pathst != null && pathst.hasMoreTokens()) {
wordList.add(pathst.nextToken());
}
}
String[] words = wordList.toArray(new String[0]);
// Now do step 2: Strip off the trailing "." (i.e. strip off .html)
if (words != null && words.length > 1) {
String lastWord = words[words.length - 1];
int index = lastWord.lastIndexOf('.');
if (index > 0) {
words[words.length - 1] = lastWord.substring(0, index);
}
}
// Step 4: Unescape each escape sequence
// TODO I don't know what to do here.
// Step 5: If protocol is urn, replace - with . in the first word
if (namespace.startsWith("urn:")) {
words[0] = replace(words[0], "-", ".");
}
// Step 6: Tokenize the first word with "." and reverse the order. (the www is also removed).
// TODO This is not exactly equivalent to the JAXB Rule.
ArrayList list = new ArrayList();
if (words.length > 0) {
StringTokenizer st2 = new StringTokenizer(words[0], ".");
while (st2.hasMoreTokens()) {
// Add the strings so they are in reverse order
list.add(0, st2.nextToken());
}
}
// Remove www
if (list.size() > 0) {
String last = list.get(list.size() - 1);
if (last.equals("www")) {
list.remove(list.size() - 1);
}
}
// Now each of words is represented by list
for (int i = 1; i < words.length; i++) {
list.add(words[i]);
}
// Step 7: lowercase each word
for (int i = 0; i < list.size(); i++) {
String word = list.remove(i);
word = word.toLowerCase();
list.add(i, word);
}
// Step 8: make into and an appropriate java word
for (int i = 0; i < list.size(); i++) {
String word = list.get(i);
// 8a: Convert special characters to underscore
// Convert non-java words to underscore.
// TODO: Need to do this for all chars..not just hyphens
word = replace(word, "-", "_");
// 8b: Append _ to java keywords
if (JavaUtils.isJavaKeyword(word)) {
if (appendUnderscoreToKeyword) {
word = word + "_"; // This is defined by the JAXB Spec
} else {
word = "_" +word; // Apparently wsimport can generate this style
}
}
// 8c: prepend _ if first character cannot be the first character of a java identifier
if (!Character.isJavaIdentifierStart(word.charAt(0))) {
word = "_" + word;
}
list.set(i, word);
}
// Step 9: Concatenate and return
String name = "";
for (int i = 0; i < list.size(); i++) {
if (i == 0) {
name = list.get(0);
} else {
name = name + "." + list.get(i);
}
}
if (log.isDebugEnabled()) {
log.debug("package name (" +name +")");
}
return name;
}
/**
* Get a string containing the stack of the current location
*
* @return String
*/
public static String stackToString() {
return stackToString(new RuntimeException());
}
/**
* Get a string containing the stack of the specified exception
*
* @param e
* @return
*/
public static String stackToString(Throwable e) {
java.io.StringWriter sw = new java.io.StringWriter();
java.io.BufferedWriter bw = new java.io.BufferedWriter(sw);
java.io.PrintWriter pw = new java.io.PrintWriter(bw);
e.printStackTrace(pw);
pw.close();
String text = sw.getBuffer().toString();
// Jump past the throwable
text = text.substring(text.indexOf("at"));
text = replace(text, "at ", "DEBUG_FRAME = ");
return text;
}
/**
* Get checked exception
* @param throwable Throwable
* @param method Method
* @return Class of the checked exception or null
*/
public static Class getCheckedException(Throwable throwable, Method method) {
if (method == null) {
return null;
}
Class[] exceptions = method.getExceptionTypes();
if (exceptions != null) {
for (int i=0; i< exceptions.length; i++ ) {
if (exceptions[i].isAssignableFrom(throwable.getClass())) {
return exceptions[i];
}
}
}
return null;
}
/**
* Convert a String to a URI, handling special characters in the String such as
* spaces.
*
* @param pathString The String to be converted to a URI
* @return a URI or null if the String can't be converted.
*/
public static URI createURI(String pathString) {
URI pathURI = null;
if (pathString == null || "".equals(pathString)) {
if (log.isDebugEnabled()) {
log.debug("Path string argument is invalid [" + pathString + "]; returning null");
}
return null;
}
try {
pathURI = new URI(pathString);
}
catch (URISyntaxException ex1) {
if (log.isDebugEnabled()) {
log.debug("Unable to create URI from [" + pathString +
"], trying alternative approach");
}
/*
* The URI creation requires special characters, such as spaces, be escaped or
* converted. The 5 argument constuctor will do that for us.
*/
try {
pathURI = new URI(null, null, pathString, null);
} catch (URISyntaxException ex2) {
if (log.isTraceEnabled()) {
log.trace("Unable to create URI using alternative approach; returning null. Exception caught during inital attempt: "
+ JavaUtils.stackToString(ex1));
log.trace("Exception caught during alternet attemt "
+ JavaUtils.stackToString(ex2));
}
log.error(ex2.toString(), ex2);
}
}
return pathURI;
}
}
