jdk8-mips64-public/jaxws: comparison src/share/jaxws_classes/com/sun/xml/internal/bind/api/impl/NameUtil.java

--1:000000000000
+:373ffda63c9a
+/*
+* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
+* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+*
+* This code is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 2 only, as
+* published by the Free Software Foundation.  Oracle designates this
+* particular file as subject to the "Classpath" exception as provided
+* by Oracle in the LICENSE file that accompanied this code.
+*
+* This code is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+* version 2 for more details (a copy is included in the LICENSE file that
+* accompanied this code).
+*
+* You should have received a copy of the GNU General Public License version
+* 2 along with this work; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+* or visit www.oracle.com if you need additional information or have any
+* questions.
+*/
+package com.sun.xml.internal.bind.api.impl;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+/**
+* Methods that convert strings into various formats.
+*
+* <p>
+* What JAX-RPC name binding tells us is that even such basic method
+* like "isLetter" can be different depending on the situation.
+*
+* For this reason, a whole lot of methods are made non-static,
+* even though they look like they should be static.
+*/
+class NameUtil {
+protected boolean isPunct(char c) {
+return c == '-' || c == '.' || c == ':' || c == '_' || c == '\u00b7' || c == '\u0387' || c == '\u06dd' || c == '\u06de';
+}
+protected static boolean isDigit(char c) {
+return c >= '0' && c <= '9' || Character.isDigit(c);
+}
+protected static boolean isUpper(char c) {
+return c >= 'A' && c <= 'Z' || Character.isUpperCase(c);
+}
+protected static boolean isLower(char c) {
+return c >= 'a' && c <= 'z' || Character.isLowerCase(c);
+}
+protected boolean isLetter(char c) {
+return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || Character.isLetter(c);
+}
+private String toLowerCase(String s)
+{
+return s.toLowerCase(Locale.ENGLISH);
+}
+private String toUpperCase(char c)
+{
+return String.valueOf(c).toUpperCase(Locale.ENGLISH);
+}
+private String toUpperCase(String s)
+{
+return s.toUpperCase(Locale.ENGLISH);
+}
+/**
+* Capitalizes the first character of the specified string,
+* and de-capitalize the rest of characters.
+*/
+public String capitalize(String s) {
+if (!isLower(s.charAt(0)))
+return s;
+StringBuilder sb = new StringBuilder(s.length());
+sb.append(toUpperCase(s.charAt(0)));
+sb.append(toLowerCase(s.substring(1)));
+return sb.toString();
+}
+// Precondition: s[start] is not punctuation
+private int nextBreak(String s, int start) {
+int n = s.length();
+char c1 = s.charAt(start);
+int t1 = classify(c1);
+for (int i=start+1; i<n; i++) {
+// shift (c1,t1) into (c0,t0)
+// char c0 = c1;  --- conceptually, but c0 won't be used
+int t0 = t1;
+c1 = s.charAt(i);
+t1 = classify(c1);
+switch(actionTable[t0*5+t1]) {
+case ACTION_CHECK_PUNCT:
+if(isPunct(c1)) return i;
+break;
+case ACTION_CHECK_C2:
+if (i < n-1) {
+char c2 = s.charAt(i+1);
+if (isLower(c2))
+return i;
+}
+break;
+case ACTION_BREAK:
+return i;
+}
+}
+return -1;
+}
+// the 5-category classification that we use in this code
+// to find work breaks
+static protected final int UPPER_LETTER = 0;
+static protected final int LOWER_LETTER = 1;
+static protected final int OTHER_LETTER = 2;
+static protected final int DIGIT = 3;
+static protected final int OTHER = 4;
+/**
+* Look up table for actions.
+* type0*5+type1 would yield the action to be taken.
+*/
+private static final byte[] actionTable = new byte[5*5];
+// action constants. see nextBreak for the meaning
+static private final byte ACTION_CHECK_PUNCT = 0;
+static private final byte ACTION_CHECK_C2 = 1;
+static private final byte ACTION_BREAK = 2;
+static private final byte ACTION_NOBREAK = 3;
+/**
+* Decide the action to be taken given
+* the classification of the preceding character 't0' and
+* the classification of the next character 't1'.
+*/
+private static byte decideAction( int t0, int t1 ) {
+if(t0==OTHER && t1==OTHER)  return ACTION_CHECK_PUNCT;
+if(!xor(t0==DIGIT,t1==DIGIT))  return ACTION_BREAK;
+if(t0==LOWER_LETTER && t1!=LOWER_LETTER)    return ACTION_BREAK;
+if(!xor(t0<=OTHER_LETTER,t1<=OTHER_LETTER)) return ACTION_BREAK;
+if(!xor(t0==OTHER_LETTER,t1==OTHER_LETTER)) return ACTION_BREAK;
+if(t0==UPPER_LETTER && t1==UPPER_LETTER)    return ACTION_CHECK_C2;
+return ACTION_NOBREAK;
+}
+private static boolean xor(boolean x,boolean y) {
+return (x&&y) || (!x&&!y);
+}
+static {
+// initialize the action table
+for( int t0=0; t0<5; t0++ )
+for( int t1=0; t1<5; t1++ )
+actionTable[t0*5+t1] = decideAction(t0,t1);
+}
+/**
+* Classify a character into 5 categories that determine the word break.
+*/
+protected int classify(char c0) {
+switch(Character.getType(c0)) {
+case Character.UPPERCASE_LETTER:        return UPPER_LETTER;
+case Character.LOWERCASE_LETTER:        return LOWER_LETTER;
+case Character.TITLECASE_LETTER:
+case Character.MODIFIER_LETTER:
+case Character.OTHER_LETTER:            return OTHER_LETTER;
+case Character.DECIMAL_DIGIT_NUMBER:    return DIGIT;
+default:                                return OTHER;
+}
+}
+/**
+* Tokenizes a string into words and capitalizes the first
+* character of each word.
+*
+* <p>
+* This method uses a change in character type as a splitter
+* of two words. For example, "abc100ghi" will be splitted into
+* {"Abc", "100","Ghi"}.
+*/
+public List<String> toWordList(String s) {
+ArrayList<String> ss = new ArrayList<String>();
+int n = s.length();
+for (int i = 0; i < n;) {
+// Skip punctuation
+while (i < n) {
+if (!isPunct(s.charAt(i)))
+break;
+i++;
+}
+if (i >= n) break;
+// Find next break and collect word
+int b = nextBreak(s, i);
+String w = (b == -1) ? s.substring(i) : s.substring(i, b);
+ss.add(escape(capitalize(w)));
+if (b == -1) break;
+i = b;
+}
+//      we can't guarantee a valid Java identifier anyway,
+//      so there's not much point in rejecting things in this way.
+//        if (ss.size() == 0)
+//            throw new IllegalArgumentException("Zero-length identifier");
+return ss;
+}
+protected String toMixedCaseName(List<String> ss, boolean startUpper) {
+StringBuilder sb = new StringBuilder();
+if(!ss.isEmpty()) {
+sb.append(startUpper ? ss.get(0) : toLowerCase(ss.get(0)));
+for (int i = 1; i < ss.size(); i++)
+sb.append(ss.get(i));
+}
+return sb.toString();
+}
+protected String toMixedCaseVariableName(String[] ss,
+boolean startUpper,
+boolean cdrUpper) {
+if (cdrUpper)
+for (int i = 1; i < ss.length; i++)
+ss[i] = capitalize(ss[i]);
+StringBuilder sb = new StringBuilder();
+if( ss.length>0 ) {
+sb.append(startUpper ? ss[0] : toLowerCase(ss[0]));
+for (int i = 1; i < ss.length; i++)
+sb.append(ss[i]);
+}
+return sb.toString();
+}
+/**
+* Formats a string into "THIS_KIND_OF_FORMAT_ABC_DEF".
+*
+* @return
+*      Always return a string but there's no guarantee that
+*      the generated code is a valid Java identifier.
+*/
+public String toConstantName(String s) {
+return toConstantName(toWordList(s));
+}
+/**
+* Formats a string into "THIS_KIND_OF_FORMAT_ABC_DEF".
+*
+* @return
+*      Always return a string but there's no guarantee that
+*      the generated code is a valid Java identifier.
+*/
+public String toConstantName(List<String> ss) {
+StringBuilder sb = new StringBuilder();
+if( !ss.isEmpty() ) {
+sb.append(toUpperCase(ss.get(0)));
+for (int i = 1; i < ss.size(); i++) {
+sb.append('_');
+sb.append(toUpperCase(ss.get(i)));
+}
+}
+return sb.toString();
+}
+/**
+* Escapes characters is the given string so that they can be
+* printed by only using US-ASCII characters.
+*
+* The escaped characters will be appended to the given
+* StringBuffer.
+*
+* @param sb
+*      StringBuffer that receives escaped string.
+* @param s
+*      String to be escaped. <code>s.substring(start)</code>
+*      will be escaped and copied to the string buffer.
+*/
+public static void escape(StringBuilder sb, String s, int start) {
+int n = s.length();
+for (int i = start; i < n; i++) {
+char c = s.charAt(i);
+if (Character.isJavaIdentifierPart(c))
+sb.append(c);
+else {
+sb.append('_');
+if (c <= '\u000f') sb.append("000");
+else if (c <= '\u00ff') sb.append("00");
+else if (c <= '\u0fff') sb.append('0');
+sb.append(Integer.toString(c, 16));
+}
+}
+}
+/**
+* Escapes characters that are unusable as Java identifiers
+* by replacing unsafe characters with safe characters.
+*/
+private static String escape(String s) {
+int n = s.length();
+for (int i = 0; i < n; i++)
+if (!Character.isJavaIdentifierPart(s.charAt(i))) {
+StringBuilder sb = new StringBuilder(s.substring(0, i));
+escape(sb, s, i);
+return sb.toString();
+}
+return s;
+}
+}

Mercurial > jdk8-mips64-public > jaxws / file comparison

comparison: src/share/jaxws_classes/com/sun/xml/internal/bind/api/impl/NameUtil.java

src/share/jaxws_classes/com/sun/xml/internal/bind/api/impl/NameUtil.java