jpa/plugins/org.eclipse.jpt.utility/src/org/eclipse/jpt/utility/internal/NameTools.java - dali/webtools.dali - Git at Google

 /*******************************************************************************
  * 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();
 	}

 }
	/*******************************************************************************
	* 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();
	}

	}