path: root/common/plugins/org.eclipse.jpt.common.core/src/org/eclipse/jpt/common/core/utility/BodySourceWriter.java

/*******************************************************************************
 * Copyright (c) 2009, 2010 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.common.core.utility;

import java.io.Serializable;
import java.io.StringWriter;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeSet;

import org.eclipse.jpt.common.utility.Filter;
import org.eclipse.jpt.common.utility.IndentingPrintWriter;
import org.eclipse.jpt.common.utility.internal.CollectionTools;
import org.eclipse.jpt.common.utility.internal.StringTools;
import org.eclipse.jpt.common.utility.internal.Transformer;
import org.eclipse.jpt.common.utility.internal.iterables.FilteringIterable;
import org.eclipse.jpt.common.utility.internal.iterables.TransformationIterable;

import com.ibm.icu.text.Collator;

/**
 * Extend {@link IndentingPrintWriter} with some methods that facilitate
 * building class source code.
 */
@SuppressWarnings("nls")
public class BodySourceWriter
	extends IndentingPrintWriter
{
	protected final String packageName;
	protected final String className;
	// key = short class name; value = import package
	protected final HashMap<String, ImportPackage> imports = new HashMap<String, ImportPackage>();

	public BodySourceWriter(String packageName, String className) {
		super(new StringWriter(2000));
		this.packageName = packageName;
		this.className = className;
	}

	public String getSource() {
		return this.out.toString();
	}

	public int getLength() {
		return ((StringWriter) this.out).getBuffer().length();
	}

	protected void printVisibility(String visibilityModifier) {
		if (visibilityModifier.length() != 0) {
			this.print(visibilityModifier);
			this.print(' ');
		}
	}

	public void printAnnotation(String annotationName) {
		this.print('@');
		this.printTypeDeclaration(annotationName);
	}

	public void printTypeDeclaration(String typeDeclaration) {
		this.print(this.buildImportedTypeDeclaration(typeDeclaration));
	}

	protected void printField(String fieldName, String typeDeclaration, String visibility) {
		this.printVisibility(visibility);
		this.printTypeDeclaration(typeDeclaration);
		this.print(' ');
		this.print(fieldName);
		this.print(';');
		this.println();
		this.println();
	}

	protected void printParameterizedField(String fieldName, String typeDeclaration, String parameterTypeDeclaration, String visibility) {
		this.printVisibility(visibility);
		this.printTypeDeclaration(typeDeclaration);
		this.print('<');
		this.printTypeDeclaration(parameterTypeDeclaration);
		this.print('>');
		this.print(' ');
		this.print(fieldName);
		this.print(';');
		this.println();
		this.println();
	}

	/**
	 * Convert the specified string to a <em>String Literal</em> and print it,
	 * adding the surrounding double-quotes and escaping characters
	 * as necessary.
	 */
	public void printStringLiteral(String string) {
		StringTools.convertToJavaStringLiteralOn(string, this);
	}


	// ********** imports **********

	// ***** writing
	/**
	 * Return the specified class's "imported" name.
	 * The class declaration must be of the form:
	 *     "int"
	 *     "int[]" (not "[I")
	 *     "java.lang.Object"
	 *     "java.lang.Object[]" (not "[Ljava.lang.Object;")
	 *     "java.util.Map.Entry" (not "java.util.Map$Entry")
	 *     "java.util.Map.Entry[][]" (not "[[Ljava.util.Map$Entry;")
	 *     
	 * To really do this right, we would need to gather all the types from
	 * the "unamed" (default) package that were referenced in the
	 * compilation unit beforehand. *Any* collisions with one of these
	 * types would have to be fully qualified (whether it was from
	 * 'java.lang' or the same package as the current compilation unit).
	 * In other words, if we have any types from the "unnamed" package,
	 * results are unpredictable....
	 */
	protected String buildImportedTypeDeclaration(String typeDeclaration) {
		if (this.typeDeclarationIsMemberClass(typeDeclaration)) {
			// no need for an import, just return the partially-qualified name
			return this.buildMemberClassTypeDeclaration(typeDeclaration);
		}
		int last = typeDeclaration.lastIndexOf('.');
		String currentPackageName = (last == -1) ? "" : typeDeclaration.substring(0, last);
		String shortTypeDeclaration = typeDeclaration.substring(last + 1);
		String shortElementTypeName = shortTypeDeclaration;
		while (shortElementTypeName.endsWith("[]")) {
			shortElementTypeName = shortElementTypeName.substring(0, shortElementTypeName.length() - 2);
		}
		ImportPackage prev = this.imports.get(shortElementTypeName);
		if (prev == null) {
			// this is the first class with this short element type name
			this.imports.put(shortElementTypeName, new ImportPackage(currentPackageName));
			return shortTypeDeclaration;
		}
		if (prev.packageName.equals(currentPackageName)) {
			// this element type has already been imported
			return shortTypeDeclaration;
		}
		if (currentPackageName.equals(this.packageName) &&
				prev.packageName.equals("java.lang")) {
			// we force the 'java.lang' class to be explicitly imported
			prev.collision = true;
		}
		// another class with the same short element type name has been
		// previously imported, so this one must be used fully-qualified
		return typeDeclaration;
	}

	/**
	 * e.g. "foo.bar.Employee.PK" will return true
	 */
	protected boolean typeDeclarationIsMemberClass(String typeDeclaration) {
		return (typeDeclaration.length() > this.className.length())
				&& typeDeclaration.startsWith(this.className)
				&& (typeDeclaration.charAt(this.className.length()) == '.');
	}

	/**
	 * e.g. "foo.bar.Employee.PK" will return "Employee.PK"
	 * this prevents collisions with other imported classes (e.g. "joo.jar.PK")
	 */
	protected String buildMemberClassTypeDeclaration(String typeDeclaration) {
		int index = this.packageName.length();
		if (index != 0) {
			index++;  // bump past the '.'
		}
		return typeDeclaration.substring(index);
	}

	// ***** reading
	public Iterable<String> getImports() {
		return this.getSortedRequiredImports();
	}

	/**
	 * transform our map entries to class names
	 */
	protected Iterable<String> getSortedRequiredImports() {
		return new TransformationIterable<Map.Entry<String, ImportPackage>, String>(this.getSortedRequiredImportEntries(), this.buildImportEntriesTransformer());
	}

	protected Transformer<Map.Entry<String, ImportPackage>, String> buildImportEntriesTransformer() {
		return IMPORT_ENTRIES_TRANSFORMER;
	}

	protected static final Transformer<Map.Entry<String, ImportPackage>, String> IMPORT_ENTRIES_TRANSFORMER = new ImportEntriesTransformer();

	protected static class ImportEntriesTransformer
		implements Transformer<Map.Entry<String, ImportPackage>, String>
	{
		public String transform(Entry<String, ImportPackage> importEntry) {
			String pkg = importEntry.getValue().packageName;
			String type = importEntry.getKey();
			StringBuilder sb = new StringBuilder(pkg.length() + 1 + type.length());
			sb.append(pkg);
			sb.append('.');
			sb.append(type);
			return sb.toString();
		}
	}

	/**
	 * sort by package first, then class (*not* by fully-qualified class name)
	 */
	protected Iterable<Map.Entry<String, ImportPackage>> getSortedRequiredImportEntries() {
		TreeSet<Map.Entry<String, ImportPackage>> sortedEntries = new TreeSet<Map.Entry<String, ImportPackage>>(this.buildImportEntriesComparator());
		CollectionTools.addAll(sortedEntries, this.getRequiredImportEntries());
		return sortedEntries;
	}

	protected Comparator<Map.Entry<String, ImportPackage>> buildImportEntriesComparator() {
		return IMPORT_ENTRIES_COMPARATOR;
	}

	protected static final Comparator<Map.Entry<String, ImportPackage>> IMPORT_ENTRIES_COMPARATOR = new ImportEntriesComparator();

	protected static class ImportEntriesComparator
		implements Comparator<Map.Entry<String, ImportPackage>>, Serializable
	{
		public int compare(Map.Entry<String, ImportPackage> e1, Map.Entry<String, ImportPackage> e2) {
			Collator collator = Collator.getInstance();
			int pkg = collator.compare(e1.getValue().packageName, e2.getValue().packageName);
			return (pkg == 0) ? collator.compare(e1.getKey(), e2.getKey()) : pkg;
		}
	}

	/**
	 * strip off any non-required imports (e.g. "java.lang.Object')
	 */
	protected Iterable<Map.Entry<String, ImportPackage>> getRequiredImportEntries() {
		return new FilteringIterable<Map.Entry<String, ImportPackage>>(this.imports.entrySet(), this.buildRequiredImportEntriesFilter());
	}

	protected Filter<Map.Entry<String, ImportPackage>> buildRequiredImportEntriesFilter() {
		return new RequiredImportEntriesFilter();
	}

	protected class RequiredImportEntriesFilter
		implements Filter<Map.Entry<String, ImportPackage>>
	{
		public boolean accept(Map.Entry<String, ImportPackage> importEntry) {
			return this.packageMustBeImported(importEntry.getValue());
		}

		protected boolean packageMustBeImported(ImportPackage importPackage) {
			String pkg = importPackage.packageName;
			if (pkg.equals("")) {
				// cannot import a type from the "unnamed" package
				return false;
			}
			if (pkg.equals("java.lang")) {
				// we must import from 'java.lang' if we also have a class in the same package
				return importPackage.collision;
			}
			if (pkg.equals(BodySourceWriter.this.packageName)) {
				// we never need to import a class from the same package
				return false;
			}
			return true;
		}
	}

	/**
	 * We need a 'collision' flag for when we encounter a class from
	 * 'java.lang' followed by a class from the current compilation unit's
	 * package. We will need to include the explicit import of the
	 * 'java.lang' class and all the references to the other class will
	 * have to be fully-qualified.
	 * 
	 * If the classes are encountered in the opposite order (i.e. the class
	 * from the current compilation unit's package followed by the class
	 * from 'java.lang'), we do *not* need to import the first class while
	 * all the references to the 'java.lang' class will be fully-qualified.
	 * 
	 * Unfortunately, we still have a problem: if we reference a class from
	 * 'java.lang' and there is a conflicting class from the current
	 * compilation unit's package (but that class is *not* revealed to us
	 * here), the simple name will be resolved to the non-'java.lang' class.
	 * Unless we simply force an import of *all* 'java.lang' classes.... :-(
	 * 
	 * This shouldn't happen very often. :-)
	 */
	protected static class ImportPackage {
		protected final String packageName;
		protected boolean collision = false;

		protected ImportPackage(String packageName) {
			super();
			this.packageName = packageName;
		}
	}

}