diff options
Diffstat (limited to 'jpa/plugins/org.eclipse.jpt.utility/src/org/eclipse/jpt/utility/internal/NameTools.java')
-rw-r--r-- | jpa/plugins/org.eclipse.jpt.utility/src/org/eclipse/jpt/utility/internal/NameTools.java | 305 |
1 files changed, 0 insertions, 305 deletions
diff --git a/jpa/plugins/org.eclipse.jpt.utility/src/org/eclipse/jpt/utility/internal/NameTools.java b/jpa/plugins/org.eclipse.jpt.utility/src/org/eclipse/jpt/utility/internal/NameTools.java deleted file mode 100644 index be13c70dcf..0000000000 --- a/jpa/plugins/org.eclipse.jpt.utility/src/org/eclipse/jpt/utility/internal/NameTools.java +++ /dev/null @@ -1,305 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2005, 2007 Oracle. All rights reserved. - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0, which accompanies this distribution - * and is available at http://www.eclipse.org/legal/epl-v10.html. - * - * Contributors: - * Oracle - initial API and implementation - ******************************************************************************/ -package org.eclipse.jpt.utility.internal; - -import java.util.Collection; -import java.util.HashSet; -import java.util.Iterator; -import java.util.Set; -import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; - - -/** - * Various helper methods for generating names. - */ -public final class NameTools { - - /** - * Given a "root" name and a set of existing names, generate a unique, - * Java-legal name that is either the "root" name or some variation on - * the "root" name (e.g. "root2", "root3",...). - * The names are case-sensitive. - */ - public static String uniqueJavaNameFor(String rootName, Iterator<String> existingNames) { - Collection<String> existingNames2 = CollectionTools.set(existingNames); - existingNames2.addAll(JAVA_RESERVED_WORDS_SET); - return uniqueNameFor(rootName, existingNames2, rootName); - } - - /** - * Given a "root" name and a set of existing names, generate a unique, - * Java-legal name that is either the "root" name or some variation on - * the "root" name (e.g. "root2", "root3",...). - * The names are case-sensitive. - */ - public static String uniqueJavaNameFor(String rootName, Collection<String> existingNames) { - Collection<String> existingNames2 = new HashSet<String>(existingNames); - existingNames2.addAll(JAVA_RESERVED_WORDS_SET); - return uniqueNameFor(rootName, existingNames2, rootName); - } - - /** - * Given a "root" name and a set of existing names, generate a unique - * name that is either the "root" name or some variation on the "root" - * name (e.g. "root2", "root3",...). The names are case-sensitive. - */ - public static String uniqueNameFor(String rootName, Iterator<String> existingNames) { - return uniqueNameFor(rootName, CollectionTools.set(existingNames)); - } - - /** - * Given a "root" name and a set of existing names, generate a unique - * name that is either the "root" name or some variation on the "root" - * name (e.g. "root2", "root3",...). The names are case-sensitive. - */ - public static String uniqueNameFor(String rootName, Collection<String> existingNames) { - return uniqueNameFor(rootName, existingNames, rootName); - } - - /** - * Given a "root" name and a set of existing names, generate a unique - * name that is either the "root" name or some variation on the "root" - * name (e.g. "root2", "root3",...). The names are NOT case-sensitive. - */ - public static String uniqueNameForIgnoreCase(String rootName, Iterator<String> existingNames) { - return uniqueNameForIgnoreCase(rootName, CollectionTools.set(existingNames)); - } - - /** - * Given a "root" name and a set of existing names, generate a unique - * name that is either the "root" name or some variation on the "root" - * name (e.g. "root2", "root3",...). The names are NOT case-sensitive. - */ - public static String uniqueNameForIgnoreCase(String rootName, Collection<String> existingNames) { - return uniqueNameFor(rootName, convertToLowerCase(existingNames), rootName.toLowerCase()); - } - - /** - * use the suffixed "template" name to perform the comparisons, but RETURN - * the suffixed "root" name; this allows case-insensitive comparisons - * (i.e. the "template" name has been morphed to the same case as - * the "existing" names, while the "root" name has not, but the "root" name - * is what the client wants morphed to be unique) - */ - private static String uniqueNameFor(String rootName, Collection<String> existingNames, String templateName) { - if ( ! existingNames.contains(templateName)) { - return rootName; - } - String uniqueName = templateName; - for (int suffix = 2; true; suffix++) { - if ( ! existingNames.contains(uniqueName + suffix)) { - return rootName.concat(String.valueOf(suffix)); - } - } - } - - /** - * Convert the specified collection of strings to a collection of the same - * strings converted to lower case. - */ - private static Collection<String> convertToLowerCase(Collection<String> strings) { - Collection<String> result = new HashBag<String>(strings.size()); - for (String string : strings) { - result.add(string.toLowerCase()); - } - return result; - } - - /** - * Build a fully-qualified name for the specified database object. - * Variations: - * catalog.schema.name - * catalog..name - * schema.name - * name - */ - public static String buildQualifiedDatabaseObjectName(String catalog, String schema, String name) { - if (name == null) { - throw new IllegalArgumentException(); - } - if ((catalog == null) && (schema == null)) { - return name; - } - - StringBuffer sb = new StringBuffer(100); - if (catalog != null) { - sb.append(catalog); - sb.append('.'); - } - if (schema != null) { - sb.append(schema); - } - sb.append('.'); - sb.append(name); - return sb.toString(); - } - - /** - * The set of reserved words in the Java programming language. - * These words cannot be used as identifiers (i.e. names). - * http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html - */ - public static final String[] JAVA_RESERVED_WORDS = new String[] { - "abstract", - "assert", // jdk 1.4 - "boolean", - "break", - "byte", - "case", - "catch", - "char", - "class", - "const", // unused - "continue", - "default", - "do", - "double", - "else", - "enum", // jdk 5.0 - "extends", - "false", - "final", - "finally", - "float", - "for", - "goto", // unused - "if", - "implements", - "import", - "instanceof", - "int", - "interface", - "long", - "native", - "new", - "null", - "package", - "private", - "protected", - "public", - "return", - "short", - "static", - "strictfp", // jdk 1.2 - "super", - "switch", - "synchronized", - "this", - "throw", - "throws", - "transient", - "true", - "try", - "void", - "volatile", - "while" - }; - - /** - * The set of reserved words in the Java programming language. - * These words cannot be used as identifiers (i.e. names). - * http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html - */ - public static final Set<String> JAVA_RESERVED_WORDS_SET = CollectionTools.set(JAVA_RESERVED_WORDS); - - /** - * Return the set of Java programming language reserved words. - * These words cannot be used as identifiers (i.e. names). - * http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html - */ - public static Iterator<String> javaReservedWords() { - return new ArrayIterator<String>(JAVA_RESERVED_WORDS); - } - - /** - * Convert the specified string to a valid Java identifier - * by substituting an underscore '_' for any invalid characters - * in the string and capitalizing the string if it is a Java - * reserved word. - */ - public static String convertToJavaIdentifier(String string) { - return convertToJavaIdentifier(string, '_'); - } - - /** - * Convert the specified string to a valid Java identifier - * by substituting the specified character for any invalid characters - * in the string and capitalizing the string if it is a Java - * reserved word. - */ - public static String convertToJavaIdentifier(String string, char c) { - if (string.length() == 0) { - return string; - } - if (JAVA_RESERVED_WORDS_SET.contains(string)) { - // a reserved words is a valid identifier, we just need to tweak it a bit - return StringTools.capitalize(string); - } - return new String(convertToJavaIdentifierInternal(string.toCharArray(), c)); - } - - /** - * Convert the specified string to a valid Java identifier - * by substituting an underscore '_' for any invalid characters - * in the string and capitalizing the string if it is a Java - * reserved word. - */ - public static char[] convertToJavaIdentifier(char[] string) { - return convertToJavaIdentifier(string, '_'); - } - - /** - * Convert the specified string to a valid Java identifier - * by substituting the specified character for any invalid characters - * in the string and capitalizing the string if it is a Java - * reserved word. - */ - public static char[] convertToJavaIdentifier(char[] string, char c) { - int length = string.length; - if (length == 0) { - return string; - } - if (JAVA_RESERVED_WORDS_SET.contains(new String(string))) { - // a reserved words is a valid identifier, we just need to tweak it a bit - return StringTools.capitalize(string); - } - return convertToJavaIdentifierInternal(string, c); - } - - private static char[] convertToJavaIdentifierInternal(char[] string, char c) { - if ( ! Character.isJavaIdentifierStart(string[0])) { - if ( ! Character.isJavaIdentifierStart(c)) { - throw new IllegalArgumentException("invalid Java identifier start char: '" + c + "'"); - } - string[0] = c; - } - if ( ! Character.isJavaIdentifierPart(c)) { - throw new IllegalArgumentException("invalid Java identifier part char: '" + c + "'"); - } - for (int i = string.length; i-- > 1; ) { // NB: end with 1 - if ( ! Character.isJavaIdentifierPart(string[i])) { - string[i] = c; - } - } - return string; - } - - - // ********** constructor ********** - - /** - * Suppress default constructor, ensuring non-instantiability. - */ - private NameTools() { - super(); - throw new UnsupportedOperationException(); - } - -} |