| /** |
| * 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.cxf.common.util; |
| |
| import java.lang.reflect.Proxy; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.StringTokenizer; |
| |
| import org.apache.cxf.helpers.JavaUtils; |
| |
| |
| public final class PackageUtils { |
| |
| private PackageUtils() { |
| |
| } |
| |
| static String getPackageName(String className) { |
| int pos = className.lastIndexOf('.'); |
| if (pos != -1) { |
| return className.substring(0, pos); |
| } |
| return ""; |
| } |
| |
| public static String getPackageName(Class<?> clazz) { |
| String className = clazz.getName(); |
| if (className.startsWith("[L")) { |
| className = className.substring(2); |
| } |
| return getPackageName(className); |
| } |
| |
| public static String getSharedPackageName(List<Class<?>> classes) { |
| if (classes.isEmpty()) { |
| return ""; |
| } |
| List<List<String>> lParts = new ArrayList<>(classes.size()); |
| List<String> currentParts = new ArrayList<>(); |
| for (Class<?> cls : classes) { |
| if (!Proxy.isProxyClass(cls)) { |
| lParts.add(Arrays.asList(getPackageName(cls).split("\\."))); |
| } |
| } |
| for (int i = 0; i < lParts.get(0).size(); i++) { |
| int j = 1; |
| for (; j < lParts.size(); j++) { |
| if (i > (lParts.get(j).size() - 1) || !lParts.get(j).get(i).equals(lParts.get(0).get(i))) { |
| break; |
| } |
| } |
| if (j == lParts.size()) { |
| currentParts.add(lParts.get(j - 1).get(i)); |
| } else { |
| break; |
| } |
| } |
| return String.join(".", currentParts); |
| } |
| |
| public static String parsePackageName(String namespace, String defaultPackageName) { |
| return (defaultPackageName != null && !defaultPackageName.trim().isEmpty()) |
| ? defaultPackageName : getPackageNameByNameSpaceURI(namespace.trim()); |
| } |
| |
| public static String getPackageNameByNameSpaceURI(String nameSpaceURI) { |
| int idx = nameSpaceURI.indexOf(':'); |
| boolean urnScheme = false; |
| if (idx >= 0) { |
| final String scheme = nameSpaceURI.substring(0, idx); |
| urnScheme = "urn".equalsIgnoreCase(scheme); |
| if ("http".equalsIgnoreCase(scheme) || urnScheme) { |
| nameSpaceURI = nameSpaceURI.substring(idx + (urnScheme ? 1 : 3)); // |
| } |
| } |
| |
| List<String> tokens = tokenize(nameSpaceURI, "/:"); |
| if (tokens.isEmpty()) { |
| return null; |
| } |
| |
| if (tokens.size() > 1) { |
| String lastToken = tokens.get(tokens.size() - 1); |
| idx = lastToken.lastIndexOf('.'); |
| if (idx > 0) { |
| lastToken = lastToken.replace('.', '_'); |
| tokens.set(tokens.size() - 1, lastToken); |
| } |
| } |
| |
| String domain = tokens.remove(0); |
| List<String> r = tokenize(domain, urnScheme ? ".-" : "."); |
| Collections.reverse(r); |
| if ("www".equalsIgnoreCase(r.get(r.size() - 1))) { |
| // remove leading www |
| r.remove(r.size() - 1); |
| } |
| |
| // replace the domain name with tokenized items |
| tokens.addAll(0, r); |
| |
| // iterate through the tokens and apply xml->java name algorithm |
| for (int i = 0; i < tokens.size(); i++) { |
| |
| // get the token and remove illegal chars |
| String token = tokens.get(i); |
| token = removeIllegalIdentifierChars(token); |
| |
| token = token.toLowerCase(); |
| |
| // this will check for reserved keywords |
| if (JavaUtils.isJavaKeyword(token)) { |
| token = '_' + token; |
| } |
| |
| tokens.set(i, token); |
| } |
| |
| // concat all the pieces and return it |
| return String.join(".", tokens); |
| } |
| |
| private static List<String> tokenize(String str, String sep) { |
| StringTokenizer tokens = new StringTokenizer(str, sep); |
| List<String> r = new ArrayList<>(); |
| |
| while (tokens.hasMoreTokens()) { |
| r.add(tokens.nextToken()); |
| } |
| return r; |
| } |
| |
| private static String removeIllegalIdentifierChars(String token) { |
| StringBuilder newToken = new StringBuilder(); |
| for (int i = 0; i < token.length(); i++) { |
| char c = token.charAt(i); |
| |
| if (i == 0 && !Character.isJavaIdentifierStart(c)) { |
| // prefix an '_' if the first char is illegal |
| newToken.append('_').append(c); |
| } else if (!Character.isJavaIdentifierPart(c)) { |
| // replace the char with an '_' if it is illegal |
| newToken.append('_'); |
| } else { |
| // add the legal char |
| newToken.append(c); |
| } |
| } |
| return newToken.toString(); |
| } |
| |
| public static String getNamespace(String packageName) { |
| if (packageName == null || packageName.isEmpty()) { |
| return null; |
| } |
| final List<String> parts = Arrays.asList(packageName.split("\\.")); |
| Collections.reverse(parts); |
| return "http://" + String.join(".", parts) + '/'; |
| } |
| |
| } |