/*******************************************************************************
* Copyright (c) 1998, 2016 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.sdo.helper.extension;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.util.regex.Pattern;
import org.eclipse.persistence.sdo.SDOConstants;
import org.eclipse.persistence.sdo.SDOProperty;
import org.eclipse.persistence.sdo.SDOType;
import org.eclipse.persistence.internal.helper.ClassConstants;
import org.eclipse.persistence.logging.AbstractSessionLog;
/**
* <p><b>Purpose</b>: Common functions in support of SDO.
* <p><b>Responsibilities</b>:
* <ul>
* <li> JAXB 1.0 Name Mangling algorithm functions are provided to support generation of valid class/method names..
* <li> JSR-222 JAXB 2.0 Java Package Name generation algorithm function follows https://jaxb.dev.java.net/spec-download.html
* in section D.5.1 "Mapping from a Namespace URI"
* </ul>
*/
public class SDOUtil {
/** Valid hexadecimal digits */
private static final String HEXADECIMAL_DIGITS = "0123456789abcdefABCDEF";
/** Warning string to signify that the input to the package generator may not be a valid URI */
private static final String INVALID_URI_WARNING = "SDOUtil: The URI [{0}] used for java package name generation is invalid - generating [{1}].";
/** NCName start character class content - used to compose {@link #XML_NCNAME_VALIDATION_PATTERN}. */
private static final String XML_NCNAME_START_CHAR_GROUP =
"A-Z_a-z\\x{C0}-\\x{D6}\\x{D8}-\\x{F6}\\x{F8}-\\x{2FF}\\x{370}-\\x{37D}\\x{37F}-\\x{1FFF}\\x{200C}-\\x{200D}\\x{2070}-\\x{218F}\\x{2C00}-\\x{2FEF}\\x{3001}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFFD}\\x{10000}-\\x{EFFFF}";
/** NCName character class content - used to compose {@link #XML_NCNAME_VALIDATION_PATTERN}. */
private static final String XML_NCNAME_CHAR_GROUP =
"\\-.0-9\\x{B7}\\x{300}-\\x{36F}\\x{203F}-\\x{2040}";
/**
* Pattern for validation of XML non-colonial name (NCName).
* @see <a href="http://www.w3.org/TR/REC-xml-names/#NT-NCName">http://www.w3.org/TR/REC-xml-names/#NT-NCName</a>
*/
private static final Pattern XML_NCNAME_VALIDATION_PATTERN = Pattern.compile(
"^[ " + XML_NCNAME_START_CHAR_GROUP + "][" + XML_NCNAME_START_CHAR_GROUP + XML_NCNAME_CHAR_GROUP + "]*$");
private static final String IS = "is";
private static final String GET = "get";
private static final String SET = "set";
/**
* INTERNAL:
* Search Java reserved name arrays and report (but don't fix) any naming collisions
*/
private static void preProcessJavaReservedNames(String name) {
preProcessReservedNames(name, SDOConstants.javaReservedWordsList, "sdo_type_generation_warning_class_name_violates_java_spec");
}
/**
* INTERNAL:
* Search SDO reserved name arrays and report (but don't fix) any naming collisions
*/
private static void preProcessSDOReservedNames(String name) {
preProcessReservedNames(name, SDOConstants.sdoInterfaceReservedWordsList, "sdo_type_generation_warning_class_name_violates_sdo_spec");
}
/**
* INTERNAL:
* Search reserved name arrays and report (but don't fix) any naming collisions
* @param wordArray
* @param warningLogKey
*/
private static void preProcessReservedNames(String name, String[] wordArray, String warningLogKey) {
// search the reserved words list and recommend alternatives
for(int i=0; i < wordArray.length; i++) {
if(wordArray[i].equalsIgnoreCase(name)) {
AbstractSessionLog.getLog().log(AbstractSessionLog.WARNING, warningLogKey, //
new Object[] { "SDOUtil", name, wordArray[i]});
}
}
}
/** allow _ underscores in class/function names */
private static boolean asWordSeparator = false;
/**
* INTERNAL:
* Get default package name when no targetNamespace URI exists.<br>
* This function follows the JSR-222 JAXB 2.0 algorithm from https://jaxb.dev.java.net/spec-download.html<br>
* @return default Java package name String
*/
public static String getDefaultPackageName() {
return getPackageNameFromURI(SDOConstants.EMPTY_STRING);
}
/**
* INTERNAL:
* Get default package name from a namespace URI.<br>
* This function follows the JSR-222 JAXB 2.0 algorithm from https://jaxb.dev.java.net/spec-download.html.<br>
* @param uriString - a namespace URL or URN
* @return Java package name String
*/
public static String getPackageNameFromURI(String uriString) {
String strToken;
String prefix;
int position = 0;
StringBuffer pkgName = new StringBuffer();
if (null == uriString || uriString.equals(SDOConstants.EMPTY_STRING)) {
AbstractSessionLog.getLog().log(AbstractSessionLog.FINEST, INVALID_URI_WARNING,//
new Object[] { uriString, SDOConstants.JAVA_TYPEGENERATION_DEFAULT_PACKAGE_NAME }, false);
return SDOConstants.JAVA_TYPEGENERATION_DEFAULT_PACKAGE_NAME;
}
/**
* Step 1: (Remove the schema and ":" part)
* An XML namespace is represented by a URI. Since XML Namespace will be
* mapped to a Java package, it is necessary to specify a default mapping from a
* URI to a Java package name. The URI format is described in [RFC2396].
* The following steps describe how to map a URI to a Java package name. The
* example URI, http://example.org/go/file.xsd, is used to
* illustrate each step.
* 1. Remove the scheme and ":" part from the beginning of the URI, if present.
* Since there is no formal syntax to identify the optional URI scheme, restrict
* the schemes to be removed to case insensitive checks for schemes
* "http" and "urn".
* //example.org/go/file.xsd
*/
// Remove only urn: and http: schemes - retain ftp, file, gopher, mail, news, telnet
URI uri;
String originalUriString = uriString;
String schemePrefix;
// Save error state so that we can emit a warning after the URI has been processed
boolean invalidOriginalFormat = false;
// Save whether we are a supported urn or http scheme
boolean invalidScheme = false;
try {
// Creating a URI object and catching a syntax exception may be a performance hit
uri = new URI(uriString);
schemePrefix = uri.getScheme();
// Remove http or urn schemes for valid URI's
if(null != schemePrefix){
if((schemePrefix.equalsIgnoreCase("http") || schemePrefix.equalsIgnoreCase("urn"))) {
uriString = uri.getSchemeSpecificPart();
}else{
invalidScheme = true;
}
}
} catch (NullPointerException npe) {
AbstractSessionLog.getLog().log(AbstractSessionLog.FINEST, INVALID_URI_WARNING,//
new Object[] { "null", SDOConstants.JAVA_TYPEGENERATION_DEFAULT_PACKAGE_NAME }, false);
return SDOConstants.JAVA_TYPEGENERATION_DEFAULT_PACKAGE_NAME;
} catch (URISyntaxException use) {
// Warn that the URI is invalid, but process the string into a valid package anyway
invalidOriginalFormat = true;
// Remove http or urn schemes for invalid URI's
if (uriString.length() > 4) {
prefix = uriString.substring(0, 4);
if (prefix.equalsIgnoreCase("urn:")) {
uriString = uriString.substring(4);
} else {
prefix = uriString.substring(0, 5);
if (prefix.equalsIgnoreCase("http:")) {
uriString = uriString.substring(5);
}
}
}
} finally {
/**
* Step 2: remove trailing file type, one of .?? or .??? or .html.
* //example.org/go/file
* Note: The trailing host fragment will be removed for non http|urn schemes such as file:.
*/
int potentialPathSepIndex = uriString.lastIndexOf('/'); // Don't handle ? param separator on purpose
int potentialHostSepIndex = uriString.indexOf('/');
int potentialFileExtIndex = uriString.lastIndexOf('.');
/**
* When to remove the last .ext or trailing host fragment.
* Valid scheme | has file ext = remove/keep last {.[^.]+} fragment
* 0 | 0 Remove host prefix ie: file://site.com -> file.site
* 0 | 1 Remove file ext ie: file://site.com/file.xsd -> file.com.site
* 1 | 0 Don't remove host prefix ie: urn://site.com -> com.site
* 1 | 1 Remove file ext ie: urn://site.com/file.xsd -> com.site
*/
// Don't Remove trailing host fragment for http|urn schemes
if((invalidScheme && potentialFileExtIndex != -1) || //
((potentialFileExtIndex != -1 && potentialPathSepIndex != -1 && //
potentialHostSepIndex != -1 && (potentialPathSepIndex - potentialHostSepIndex) > 1))) { // -1's are handled
String extension = uriString.substring(potentialFileExtIndex);
if (extension.length() == 3 || extension.length() == 4 || extension.equalsIgnoreCase(".html")) {
uriString = uriString.substring(0, potentialFileExtIndex);
}
}
/**
* Step 3: (split string into word list) 3. Parse the remaining
* String into a list of strings using / and : as separators
* Treat consecutive separators as a single separator.
* {"example.org", "go", "file" }
*/
StringTokenizer aTokenizer = new StringTokenizer(uriString, "/:");
int length = aTokenizer.countTokens();
if (length == 0) {
return SDOConstants.JAVA_TYPEGENERATION_DEFAULT_PACKAGE_NAME;
}
/**
* Step 4: (unescape each escape sequence octet) 4. For each string
* in the list produced by previous step, unescape each escape
* sequence octet. {"example.org", "go", "file" } Generating a
* Java package name 4/19/06 JAXB 2.0 - Final Release 341
*/
ArrayList<String> strings = new ArrayList<String>(length);
while (aTokenizer.hasMoreTokens()) {
strToken = aTokenizer.nextToken();
strings.add(decodeUriHexadecimalEscapeSequence(strToken));
}
/**
* Step 5: replace [-] with [.] if the scheme is a URN 5. If the
* scheme is a urn, replace all dashes, -, occurring in the
* first component with [.].2
*/
/**
* Step 6: Apply algorithm described in Section 7.7 Unique Package
* Names in [JLS] to derive a unique package name from the
* potential internet domain name contained within the first
* component. The internet domain name is reversed, component by
* component. Note that a leading www. is not considered part of
* an internet domain name and must be dropped. If the first
* component does not contain either one of the top-level domain
* names, for example, com, gov, net, org, edu, or one of the
* English two-letter codes identifying countries as specified in
* ISO Standard 3166, 1981, this step must be skipped. {org,
* example, go, file}
*/
strToken = strings.remove(0).toLowerCase();
// Reuse the Tokenizer - tokenize on package separator
aTokenizer = new StringTokenizer(strToken, ".");
// Check for URI's that are composed only of metacharacter package separators
if(aTokenizer.countTokens() < 1) {
AbstractSessionLog.getLog().log(AbstractSessionLog.FINEST, INVALID_URI_WARNING,//
new Object[] { uriString, SDOConstants.JAVA_TYPEGENERATION_DEFAULT_PACKAGE_NAME }, false);
return SDOConstants.JAVA_TYPEGENERATION_DEFAULT_PACKAGE_NAME;
} else {
while (aTokenizer.hasMoreTokens()) {
strToken = aTokenizer.nextToken();
if (!strToken.equals("www")) {
strings.add(0, strToken);
}
}
}
/**
* Step 7: (convert each string to be all lower case) 7. For each
* string in the list, convert each string to be all lower case.
* {org, example, go, file }
*/
position = 0;
for (String aString : strings) {
strings.set(position++, aString.toLowerCase());
}
/**
* Step 8: (convert each string to a valid identifier) 8. For each
* string remaining, the following conventions are adopted from
* [JLS] Section 7.7, Unique Package Names. Follow step 8a-c
* below.
*/
position = 0;
for (String aString : strings) {
StringBuffer buffer = new StringBuffer();
/**
* Step 8a: If the string component contains a hyphen, or any other
* special character not allowed in an identifier, convert it
* into an underscore.
*/
for (int j = 0; j < aString.length(); j++) {
char charToken = aString.charAt(j);
if (Character.isJavaIdentifierPart(charToken)) {
buffer.append(charToken);
} else {
buffer.append('_');
}
}
/**
* Step 8b:
* From the Java Language Specification section 7.7 b. If any of
* the resulting package name components are keywords then
* append underscore to them.
* We are not performing this step here - and are allowing all java reserved keywords to pass
* See the enum com.sun.tools.javac.parser.Token for a list of keywords
*/
/**
* Step 8c: If any of the resulting package name components start with
* a digit, or any other character that is not allowed as an
* initial character of an identifier, have an underscore
* prefixed to the component. {org, example, go, file }
*/
if (!Character.isJavaIdentifierStart(buffer.charAt(0))) {
buffer.insert(0, '_');
}
if (position++ != 0) {
buffer.insert(0, '.');
}
pkgName.append(buffer.toString());
}
if(invalidOriginalFormat) {
AbstractSessionLog.getLog().log(AbstractSessionLog.FINEST,//
INVALID_URI_WARNING, new Object[] { originalUriString, pkgName }, false);
}
}
return pkgName.toString();
}
/**
* INTERNAL:
* Decode Hexadecimal "%hh" escape sequences in a URI.
* All escape codes must be valid 2 digit sequences.
*
* @param uri - URI component
* @return URI component with escape sequence decoded into a
*/
private static String decodeUriHexadecimalEscapeSequence(String uri) {
// This function is used by the Java Package Name generation algorithm that implements JAXB 2.0 D.5.1
StringBuffer sb = new StringBuffer(uri.length());
for (int index = 0; index < uri.length(); index++) {
char c = uri.charAt(index);
// Escape sequence found - get the hex value and convert
if (c == '%') {
if (((index + 2) < uri.length()) && //
HEXADECIMAL_DIGITS.indexOf(uri.charAt(index + 1)) >= 0 &&//
HEXADECIMAL_DIGITS.indexOf(uri.charAt(index + 2)) >= 0) {
// Look ahead 2 digits
String g = uri.substring(index + 1, index + 3);
// Convert base 16 to base 10 to char and append
sb.append((char)Integer.parseInt(g, 16));
/**
* Increase the index by 2 - so we skip the 2 digit hex code after the %
* See JAXB 2.0 spec p.348 section D.5.1.4
* "For each string in the list produced by step 3. Unescape each escape sequence octet.
* IE: North%20America should be "North America" and later in step 8
* "north_america" not "north_20america"
*/
index+=2;
} else {
sb.append(c);
}
} else {
sb.append(c);
}
}
return (sb.toString());
}
/**
* INTERNAL:
* Return a valid Java class name or method name for a given string
* @param s
* @param isClass (flag whether called from a method context)
* @return
*/
public static String className(String s, boolean isClass) {
return className(s, true, isClass, true);
}
/**
* INTERNAL:
* Return a valid Java class name or method name for a given string
* @param s
* @param isClass (flag whether called from a method context)
* @param flag
* @return
*/
public static String className(String s, boolean flag, boolean isClass, boolean logOn) {
// 1) warn if the class conflicts with any Java reserved words
preProcessJavaReservedNames(s);
// 2) warn if the class conflicts with any SDO reserved words
preProcessSDOReservedNames(s);
String[] as = getWordList(s);
StringBuffer stringbuffer = new StringBuffer();
StringBuffer stringbuffer1 = new StringBuffer();
if (as.length == 0) {
return stringbuffer.toString();
}
for (int i = 0; i < as.length; i++) {
char[] ac = as[i].toCharArray();
if (Character.isLowerCase(ac[0])) {
ac[0] = Character.toUpperCase(ac[0]);
}
for (int j = 0; j < ac.length; j++) {
if ((ac[j] >= ' ') && (ac[j] < '\177')) {
if ((ac[j] != '_') || !asWordSeparator) {
stringbuffer.append(ac[j]);
}
continue;
}
if (flag) {
stringbuffer.append(escapeUnicode(stringbuffer1, ac[j]));
} else {
stringbuffer.append(ac[j]);
}
}
}
String normalizedName = stringbuffer.toString();
// report a warning whether we were required to normalize the name (beyond initial capitalization)
if(!s.equals(normalizedName) && logOn) {
// log changes
int logLevel;
// log capitalization-only changes at a lower level
if(!s.equalsIgnoreCase(normalizedName)) {
logLevel = AbstractSessionLog.INFO;
} else {
logLevel = AbstractSessionLog.FINER;
}
// report differently depending on whether the input was a class or function name
if(isClass) {
AbstractSessionLog.getLog().log(logLevel, //
"sdo_type_generation_modified_class_naming_format_to",
new Object[] { "SDOUtil", s, normalizedName});
} else {
AbstractSessionLog.getLog().log(logLevel, //
"sdo_type_generation_modified_function_naming_format_to",
new Object[] { "SDOUtil", s, normalizedName});
}
}
return normalizedName;
}
/**
* INTERNAL:
* Return a valid Java method name for a given string
* @param s
* @return
*/
public static String methodName(String s) {
return methodName(s, true);
}
/**
* INTERNAL:
* Return a valid Java method name for a given string
* @param s
* @param flag
* @return
*/
public static String methodName(String s, boolean flag) {
return className(s, flag, false, true);
}
/**
* INTERNAL:
* Return a valid Java set method name for a given string
* @param s
* @return
*/
public static String setMethodName(String s) {
StringBuffer stringbuffer = new StringBuffer();
stringbuffer.append(SET).append(methodName(s));
return stringbuffer.toString();
}
/**
* INTERNAL:
* Return a valid Java get method name for a given string. This method will check
* the returnType to see if it is a boolean/Boolean: if so, 'is' will be used in
* the method name instead of 'get'.
*
* @param s
* @param returnType
* @return
*/
public static String getMethodName(String s, String returnType) {
StringBuffer stringBuffer = new StringBuffer();
if (returnType.equals(ClassConstants.PBOOLEAN.getName()) || returnType.equals(ClassConstants.BOOLEAN.getName())) {
stringBuffer.append(IS);
} else {
stringBuffer.append(GET);
}
stringBuffer.append(SDOUtil.className(s, true, false, false));
return stringBuffer.toString();
}
/**
* INTERNAL:
* Return a valid Java get method name for a given string. This method will NOT check
* the returnType to see if it is a boolean/Boolean and all method names will start with
* "GET"
*
* @param s
* @param returnType
* @return
*/
public static String getBooleanGetMethodName(String s, String returnType){
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(SDOUtil.GET);
stringBuffer.append(SDOUtil.className(s, true, false, false));
return stringBuffer.toString();
}
/**
* INTERNAL:
* @param s
* @return
*/
public static String constantName(String s) {
StringBuffer stringbuffer = new StringBuffer();
String[] as = getWordList(s);
if (as.length > 0) {
stringbuffer.append(as[0].toUpperCase());
for (int i = 1; i < as.length; i++) {
stringbuffer.append('_');
stringbuffer.append(as[i].toUpperCase());
}
}
return stringbuffer.toString();
}
/**
*
* @param s
* @return
*/
private static String[] getWordList(String s) {
java.util.List arraylist = new ArrayList();
int i = s.length();
int j = 0;
do {
if (j >= i) {
break;
}
for (; (j < i) && isPunct(s.charAt(j)); j++) {
}
if (j >= i) {
break;
}
int k = nextBreak(s, j);
String s1 = (k != -1) ? s.substring(j, k) : s.substring(j);
arraylist.add(escape(s1));
if (k == -1) {
break;
}
j = k;
} while (true);
return (String[])arraylist.toArray(new String[0]);
}
private static boolean isPunct(char c) {
if ((c == '-') || (c == '.') || (c == ':') || (c == '\267') || (c == '\u0387') || (c == '\u06DD') || (c == '\u06DE')) {
return true;
}
return (c == '_') && asWordSeparator;
}
private static boolean isUncased(char c) {
return Character.isLetter(c) && !Character.isUpperCase(c) && !Character.isLowerCase(c);
}
private static int nextBreak(String s, int i) {
int j = s.length();
for (int k = i; k < j; k++) {
char c = s.charAt(k);
if (((c == '_') && !asWordSeparator) || (k >= (j - 1))) {
continue;
}
char c1 = s.charAt(k + 1);
if ((c1 == '_') && !asWordSeparator) {
continue;
}
if (isPunct(c1)) {
return k + 1;
}
if (Character.isDigit(c) && !Character.isDigit(c1)) {
return k + 1;
}
if (!Character.isDigit(c) && Character.isDigit(c1)) {
return k + 1;
}
if (Character.isLowerCase(c) && !Character.isLowerCase(c1)) {
return k + 1;
}
if (k < (j - 2)) {
char c2 = s.charAt(k + 2);
if ((c2 == '_') && !asWordSeparator) {
continue;
}
if (Character.isUpperCase(c) && Character.isUpperCase(c1) && Character.isLowerCase(c2)) {
return k + 1;
}
}
if (Character.isLetter(c) && !Character.isLetter(c1)) {
return k + 1;
}
if (!Character.isLetter(c) && Character.isLetter(c1)) {
return k + 1;
}
if (isUncased(c) && !isUncased(c1)) {
return k + 1;
}
if (!isUncased(c) && isUncased(c1)) {
return k + 1;
}
}
return -1;
}
private static String escape(String s) {
int i = s.length();
for (int j = 0; j < i; j++) {
if (!Character.isJavaIdentifierPart(s.charAt(j))) {
StringBuffer stringbuffer = new StringBuffer(s.substring(0, j));
escape(stringbuffer, s, j);
return stringbuffer.toString();
}
}
return s;
}
private static void escape(StringBuffer stringbuffer, String s, int i) {
int j = s.length();
for (int k = i; k < j; k++) {
char c = s.charAt(k);
if (Character.isJavaIdentifierPart(c)) {
stringbuffer.append(c);
continue;
}
stringbuffer.append("_");
if (c <= '\017') {
stringbuffer.append("000");
} else if (c <= '\377') {
stringbuffer.append("00");
} else if (c <= '\u0FFF') {
stringbuffer.append("0");
}
stringbuffer.append(Integer.toString(c, 16));
}
}
private static String escapeUnicode(StringBuffer stringbuffer, char c) {
String s = Integer.toString(c, 16);
int i = s.length();
stringbuffer.setLength(6);
stringbuffer.setCharAt(0, '\\');
stringbuffer.setCharAt(1, 'u');
int j = 2;
for (int k = i; k < 4;) {
stringbuffer.setCharAt(j, '0');
k++;
j++;
}
stringbuffer.replace(j, 6, s);
return stringbuffer.toString();
}
public static String getJavaTypeForProperty(SDOProperty property) {
if (property.isMany() || property.getType().isXsdList()) {
return "java.util.List";
} else {
SDOType propertyType = property.getType();
if(propertyType.isDataType()) {
Class instanceClass = propertyType.getInstanceClass();
if (ClassConstants.ABYTE.equals(instanceClass)) {
return "Byte[]";
} else if (ClassConstants.APBYTE.equals(instanceClass)) {
return "byte[]";
}
}
return propertyType.getInstanceClassName();
}
}
public static String getBuiltInType(String typeName) {
if ((typeName.equals(ClassConstants.PBOOLEAN.getName())) || (typeName.equals(ClassConstants.BOOLEAN.getName()))) {
return "Boolean";
} else if ((typeName.equals(ClassConstants.PBYTE.getName())) || (typeName.equals(ClassConstants.BYTE.getName()))) {
return "Byte";
} else if (typeName.equals("byte[]") || typeName.equals("Byte[]") || (typeName.equals(ClassConstants.APBYTE.getName())) || (typeName.equals(ClassConstants.ABYTE.getName()))) {
return "Bytes";
} else if ((typeName.equals(ClassConstants.PCHAR.getName())) || (typeName.equals(ClassConstants.CHAR.getName()))) {
return "Char";
} else if ((typeName.equals(ClassConstants.PDOUBLE.getName())) || (typeName.equals(ClassConstants.DOUBLE.getName()))) {
return "Double";
} else if ((typeName.equals(ClassConstants.PFLOAT.getName())) || (typeName.equals(ClassConstants.FLOAT.getName()))) {
return "Float";
} else if ((typeName.equals(ClassConstants.PLONG.getName())) || (typeName.equals(ClassConstants.LONG.getName()))) {
return "Long";
} else if ((typeName.equals(ClassConstants.PSHORT.getName())) || (typeName.equals(ClassConstants.SHORT.getName()))) {
return "Short";
} else if ((typeName.equals(ClassConstants.PINT.getName())) || (typeName.equals(ClassConstants.INTEGER.getName()))) {
return "Int";
} else if (typeName.equals(ClassConstants.STRING.getName())) {
return "String";
} else if (typeName.equals(ClassConstants.BIGINTEGER.getName())) {
return "BigInteger";
} else if (typeName.equals(ClassConstants.BIGDECIMAL.getName())) {
return "BigDecimal";
} else if (typeName.equals(ClassConstants.UTILDATE.getName())) {
return "Date";
} else if (typeName.equals("java.util.List")) {
return "List";
}
return null;
}
/**
* INTERNAL:
* Validates whether given string is a valid XML non-colonial name (NCName).
* @param name string
* @return {@code true} given string is a valid NCName
* @see <a href="http://www.w3.org/TR/REC-xml-names/#NT-NCName">http://www.w3.org/TR/REC-xml-names/#NT-NCName</a>
*/
public static boolean isValidXmlNCName(String name) {
return XML_NCNAME_VALIDATION_PATTERN.matcher(name).matches();
}
}