/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed 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.axis.wsdl.toJava;
import org.apache.axis.utils.JavaUtils;
import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.Vector;
/**
* This class is essentially a HashMap of <namespace, package name> pairs with
* a few extra wizzbangs.
*/
public class Namespaces extends HashMap {
/** Field root */
private String root;
/** Field defaultPackage */
private String defaultPackage = null;
/** Toknens in a namespace that are treated as package name part separators. */
private static final char[] pkgSeparators = {'.', ':'};
/** Field javaPkgSeparator */
private static final char javaPkgSeparator = pkgSeparators[0];
/** Field pkg2Namespaces : reverse mapping of Namespaces */
private Map pkg2NamespacesMap = new HashMap();
/**
* Method normalizePackageName
*
* @param pkg
* @param separator
* @return
*/
private static String normalizePackageName(String pkg, char separator) {
for (int i = 0; i < pkgSeparators.length; i++) {
pkg = pkg.replace(pkgSeparators[i], separator);
}
return pkg;
}
/**
* Instantiate a Namespaces object whose packages will all reside under root.
*
* @param root
*/
public Namespaces(String root) {
super();
this.root = root;
} // ctor
/**
* Instantiate a clone of an existing Namespaces object.
*
* @param clone
*/
private Namespaces(Namespaces clone) {
super(clone);
this.root = clone.root;
this.defaultPackage = clone.defaultPackage;
} // ctor
/**
* Instantiate a clone of this Namespaces object.
*
* @return
*/
public Object clone() {
return new Namespaces(this);
} // clone
/**
* Get the package name for the given namespace. If there is no entry in the HashMap for
* this namespace, create one.
*
* @param key
* @return
*/
public String getCreate(String key) {
return getCreate(key, true);
} // getCreate
/**
* Get the package name for the given namespace. If there is no entry in the HashMap for
* this namespace, create one if create flag is on, return <tt>null</tt> otherwise.
*
* @param key
* @param create
* @return
*/
String getCreate(String key, boolean create) {
if (defaultPackage != null) {
put(key, defaultPackage);
return defaultPackage;
}
String value = (String) super.get(key);
if ((value == null) && create) {
value = normalizePackageName((String) Utils.makePackageName(key),
javaPkgSeparator);
put(key, value);
}
return (String) value;
} // getCreate
/**
* Get the package name in directory format (dots replaced by slashes). If the package name
* doesn't exist in the HashMap, return "".
*
* @param key
* @return
*/
public String getAsDir(String key) {
if (defaultPackage != null) {
return toDir(defaultPackage);
}
String pkg = (String) get(key);
return toDir(pkg);
} // getAsDir
/**
* Return the given package name in directory format (dots replaced by slashes). If pkg is null,
* "" is returned.
*
* @param pkg
* @return
*/
public String toDir(String pkg) {
String dir = null;
if (pkg != null) {
pkg = normalizePackageName(pkg, File.separatorChar);
}
if (root == null) {
dir = pkg;
} else {
dir = root + File.separatorChar + pkg;
}
return (dir == null)
? ""
: dir + File.separatorChar;
} // toDir
/**
* Like HashMap's putAll, this adds the given map's contents to this map. But it
* also makes sure the value strings are javified.
*
* @param map
*/
public void putAll(Map map) {
Iterator i = map.entrySet().iterator();
while (i.hasNext()) {
Map.Entry entry = (Map.Entry) i.next();
Object key = entry.getKey();
String pkg = (String) entry.getValue();
pkg = javify(pkg);
put(key, pkg);
}
} // putAll
/**
* Make sure each package name doesn't conflict with a Java keyword.
* Ie., org.apache.import.test becomes org.apache.import_.test.
*
* @param pkg
* @return
*/
private String javify(String pkg) {
StringTokenizer st = new StringTokenizer(pkg, ".");
pkg = "";
while (st.hasMoreTokens()) {
String token = st.nextToken();
if (JavaUtils.isJavaKeyword(token)) {
token = JavaUtils.makeNonJavaKeyword(token);
}
pkg = pkg + token;
if (st.hasMoreTokens()) {
pkg = pkg + '.';
}
}
return pkg;
} // javify
/**
* Make a directory for the given package under root.
*
* @param pkg
*/
public void mkdir(String pkg) {
String pkgDirString = toDir(pkg);
File packageDir = new File(pkgDirString);
packageDir.mkdirs();
} // mkdir
/**
* Set a package name that overrides the namespace map
*
* @param defaultPackage a java package name (e.g. com.foo)
*/
public void setDefaultPackage(String defaultPackage) {
this.defaultPackage = defaultPackage;
}
public Object put(Object key, Object value) {
// Store pakcage->namespaces vector mapping
Vector v = null;
if (!pkg2NamespacesMap.containsKey(value)) {
v = new Vector();
} else {
v = (Vector)pkg2NamespacesMap.get(value);
}
// NOT need to add an input key (namespace value) to v (package vector)
if (!v.contains(key)) {
v.add(key);
}
pkg2NamespacesMap.put(value, v);
return super.put(key, value);
}
public Map getPkg2NamespacesMap() {
return pkg2NamespacesMap;
}
} // class Namespaces
|
