| /* |
| * Copyright (c) 1998, 2021 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 v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // 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(); |
| } |
| } |
