jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/resource/java/JpaCompilationUnitImpl.java - dali/webtools.dali - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2008 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.core.internal.resource.java;

 import java.util.Iterator;
 import java.util.List;

 import org.eclipse.jdt.core.ElementChangedEvent;
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.IJavaElementDelta;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.core.dom.TypeDeclaration;
 import org.eclipse.jpt.core.JpaAnnotationProvider;
 import org.eclipse.jpt.core.ResourceModelListener;
 import org.eclipse.jpt.core.internal.utility.jdt.JDTTools;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.core.resource.java.JpaCompilationUnit;
 import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.jpt.core.utility.jdt.AnnotationEditFormatter;
 import org.eclipse.jpt.utility.CommandExecutorProvider;
 import org.eclipse.jpt.utility.internal.BitTools;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;

 /**
  *
  */
 public class JpaCompilationUnitImpl
 	extends AbstractJavaResourceNode
 	implements JpaCompilationUnit
 {
 	private final ICompilationUnit compilationUnit;

 	private final JpaAnnotationProvider annotationProvider;

 	private final CommandExecutorProvider modifySharedDocumentCommandExecutorProvider;

 	private final AnnotationEditFormatter annotationEditFormatter;

 	private final ResourceModelListener resourceModelListener;

 	/**
 	 * The primary type of the AST compilation unit. We are not going to handle
 	 * multiple types defined in a single compilation unit. Entities must have
 	 * a public/protected no-arg constructor, and there is no way to access
 	 * the constructor in a package class (which is what all top-level,
 	 * non-primary classes must be).
 	 */
 	protected JavaResourcePersistentType persistentType;


 	// ********** construction **********

 	public JpaCompilationUnitImpl(
 			ICompilationUnit compilationUnit,
 			JpaAnnotationProvider annotationProvider,
 			CommandExecutorProvider modifySharedDocumentCommandExecutorProvider,
 			AnnotationEditFormatter annotationEditFormatter,
 			ResourceModelListener resourceModelListener) {
 		super(null);  // the JPA compilation unit is the root of its sub-tree
 		this.compilationUnit = compilationUnit;
 		this.annotationProvider = annotationProvider;
 		this.modifySharedDocumentCommandExecutorProvider = modifySharedDocumentCommandExecutorProvider;
 		this.annotationEditFormatter = annotationEditFormatter;
 		this.resourceModelListener = resourceModelListener;
 		this.persistentType = this.buildPersistentType();
 	}

 	protected JavaResourcePersistentType buildPersistentType() {
 		this.openCompilationUnit();
 		CompilationUnit astRoot = this.buildASTRoot();
 		this.closeCompilationUnit();
 		return this.buildPersistentType(astRoot);
 	}

 	protected void openCompilationUnit() {
 		try {
 			this.compilationUnit.open(null);
 		} catch (JavaModelException ex) {
 			// do nothing - we just won't have a primary type in this case
 		}
 	}

 	protected void closeCompilationUnit() {
 		try {
 			this.compilationUnit.close();
 		} catch (JavaModelException ex) {
 			// hmmm
 		}
 	}

 	protected JavaResourcePersistentType buildPersistentType(CompilationUnit astRoot) {
 		TypeDeclaration td = this.getPrimaryType(astRoot);
 		return (td == null) ? null : this.buildPersistentType(astRoot, td);
 	}

 	public void initialize(CompilationUnit astRoot) {
 		// never called?
 	}


 	// ********** AbstractJavaResourceNode overrides **********

 	@Override
 	protected boolean requiresParent() {
 		return false;
 	}

 	@Override
 	public JpaCompilationUnit getJpaCompilationUnit() {
 		return this;
 	}

 	@Override
 	public JpaAnnotationProvider getAnnotationProvider() {
 		return this.annotationProvider;
 	}


 	// ********** JavaResourceNode implementation **********

 	public void update(CompilationUnit astRoot) {
 		TypeDeclaration td = this.getPrimaryType(astRoot);
 		if (td == null) {
 			this.persistentType = null;
 		} else {
 			if (this.persistentType == null) {
 				this.persistentType = this.buildPersistentType(astRoot, td);
 			} else {
 				this.persistentType.update(astRoot);
 			}
 		}
 	}

 	public TextRange getTextRange(CompilationUnit astRoot) {
 		return null;
 	}


 	// ********** JpaCompilationUnit implementation **********

 	public ICompilationUnit getCompilationUnit() {
 		return this.compilationUnit;
 	}

 	public Iterator<JavaResourcePersistentType> persistableTypes() {
 		return (this.persistentType == null) ?
 				EmptyIterator.<JavaResourcePersistentType>instance() :
 				this.persistentType.allPersistableTypes();
 	}

 	public void resourceModelChanged() {
 		this.resourceModelListener.resourceModelChanged();
 	}

 	public void resolveTypes() {
 		if (this.persistentType != null) {
 			this.persistentType.resolveTypes(this.buildASTRoot());
 		}
 	}

 	public CommandExecutorProvider getModifySharedDocumentCommandExecutorProvider() {
 		return this.modifySharedDocumentCommandExecutorProvider;
 	}

 	public AnnotationEditFormatter getAnnotationEditFormatter()  {
 		return this.annotationEditFormatter;
 	}


 	// ********** Java changes **********

 	public void javaElementChanged(ElementChangedEvent event) {
 		this.synchWithJavaDelta(event.getDelta());
 	}

 	protected void synchWithJavaDelta(IJavaElementDelta delta) {
 		switch (delta.getElement().getElementType()) {
 			case IJavaElement.JAVA_PROJECT :
 				if (this.classpathHasChanged(delta)) {
 					this.updateFromJava();
 					break;  // no need to check further
 				}
 			case IJavaElement.JAVA_MODEL :
 			case IJavaElement.PACKAGE_FRAGMENT_ROOT :
 			case IJavaElement.PACKAGE_FRAGMENT :
 				this.synchChildrenWithJavaDelta(delta);
 				break;
 			case IJavaElement.COMPILATION_UNIT :
 				if (this.deltaIsRelevant(delta)) {
 					this.updateFromJava();
 				}
 				break;
 			default :
 				break; // the element type is somehow held by a compilation unit (i.e. probably doesn't happen)
 		}
 	}

 	protected void synchChildrenWithJavaDelta(IJavaElementDelta delta) {
 		for (IJavaElementDelta child : delta.getAffectedChildren()) {
 			this.synchWithJavaDelta(child); // recurse
 		}
 	}

 	// 235384 - We need to update all compilation units when a classpath change occurs.
 	// The persistence.jar could have been added to or removed from the
 	// classpath which affects whether we know about the JPA annotations.
 	protected boolean classpathHasChanged(IJavaElementDelta delta) {
 		return BitTools.anyFlagsAreSet(delta.getFlags(), this.getClasspathChangedFlags());
 	}

 	protected int getClasspathChangedFlags() {
 		return CLASSPATH_CHANGED_FLAGS;
 	}

 	protected static final int CLASSPATH_CHANGED_FLAGS =
 			IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED |
 			IJavaElementDelta.F_CLASSPATH_CHANGED;

 	protected boolean deltaIsRelevant(IJavaElementDelta delta) {
 		// ignore changes to/from primary working copy - no content has changed;
 		// and make sure there are no other flags set that indicate *both* a
 		// change to/from primary working copy *and* content has changed
 		if (BitTools.onlyFlagIsSet(delta.getFlags(), IJavaElementDelta.F_PRIMARY_WORKING_COPY)) {
 			return false;
 		}

 		// we get the java notification for removal before we get the resource notification;
 		// we do not need to handle this event and will get exceptions building an astRoot if we try
 		if (delta.getKind() == IJavaElementDelta.REMOVED) {
 			return false;
 		}

 		return delta.getElement().equals(this.compilationUnit);
 	}

 	protected void updateFromJava() {
 		this.update(this.buildASTRoot());
 	}


 	// ********** internal **********

 	protected CompilationUnit buildASTRoot() {
 		return JDTTools.buildASTRoot(this.compilationUnit);
 	}

 	protected JavaResourcePersistentType buildPersistentType(CompilationUnit astRoot, TypeDeclaration typeDeclaration) {
 		return JavaResourcePersistentTypeImpl.newInstance(this, typeDeclaration, astRoot);
 	}

 	/**
 	 * i.e. the type with the same name as the compilation unit;
 	 * return the first class or interface (ignore annotations and enums) with
 	 * the same name as the compilation unit (file);
 	 * NB: this type could be in error if there is an annotation or enum
 	 * with the same name preceding it in the compilation unit
 	 *
 	 * Return null if resolveBinding() on the TypeDeclaration returns null
 	 * This can occur if the project JRE is removed (bug 225332)
 	 */
 	protected TypeDeclaration getPrimaryType(CompilationUnit astRoot) {
 		String primaryTypeName = this.getPrimaryTypeName();
 		for (AbstractTypeDeclaration atd : types(astRoot)) {
 			if ((atd.getNodeType() == ASTNode.TYPE_DECLARATION)
 					&& atd.getName().getFullyQualifiedName().equals(primaryTypeName)) {
 				return (atd.resolveBinding()) != null ? (TypeDeclaration) atd : null;
 			}
 		}
 		return null;
 	}

 	// minimize scope of suppressed warnings
 	@SuppressWarnings("unchecked")
 	protected static List<AbstractTypeDeclaration> types(CompilationUnit astRoot) {
 		return astRoot.types();
 	}

 	/**
 	 * i.e. the name of the compilation unit
 	 */
 	protected String getPrimaryTypeName() {
 		return removeJavaExtension(this.compilationUnit.getElementName());
 	}

 	protected static String removeJavaExtension(String fileName) {
 		int index = fileName.lastIndexOf(".java"); //$NON-NLS-1$
 		return (index == -1) ? fileName : fileName.substring(0, index);
 	}

 	@Override
 	public void toString(StringBuilder sb) {
 		sb.append(this.persistentType.getName());
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2007, 2008 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.core.internal.resource.java;

	import java.util.Iterator;
	import java.util.List;

	import org.eclipse.jdt.core.ElementChangedEvent;
	import org.eclipse.jdt.core.ICompilationUnit;
	import org.eclipse.jdt.core.IJavaElement;
	import org.eclipse.jdt.core.IJavaElementDelta;
	import org.eclipse.jdt.core.JavaModelException;
	import org.eclipse.jdt.core.dom.ASTNode;
	import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
	import org.eclipse.jdt.core.dom.CompilationUnit;
	import org.eclipse.jdt.core.dom.TypeDeclaration;
	import org.eclipse.jpt.core.JpaAnnotationProvider;
	import org.eclipse.jpt.core.ResourceModelListener;
	import org.eclipse.jpt.core.internal.utility.jdt.JDTTools;
	import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
	import org.eclipse.jpt.core.resource.java.JpaCompilationUnit;
	import org.eclipse.jpt.core.utility.TextRange;
	import org.eclipse.jpt.core.utility.jdt.AnnotationEditFormatter;
	import org.eclipse.jpt.utility.CommandExecutorProvider;
	import org.eclipse.jpt.utility.internal.BitTools;
	import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;

	/**
	*
	*/
	public class JpaCompilationUnitImpl
	extends AbstractJavaResourceNode
	implements JpaCompilationUnit
	{
	private final ICompilationUnit compilationUnit;

	private final JpaAnnotationProvider annotationProvider;

	private final CommandExecutorProvider modifySharedDocumentCommandExecutorProvider;

	private final AnnotationEditFormatter annotationEditFormatter;

	private final ResourceModelListener resourceModelListener;

	/**
	* The primary type of the AST compilation unit. We are not going to handle
	* multiple types defined in a single compilation unit. Entities must have
	* a public/protected no-arg constructor, and there is no way to access
	* the constructor in a package class (which is what all top-level,
	* non-primary classes must be).
	*/
	protected JavaResourcePersistentType persistentType;


	// ******** construction ********

	public JpaCompilationUnitImpl(
	ICompilationUnit compilationUnit,
	JpaAnnotationProvider annotationProvider,
	CommandExecutorProvider modifySharedDocumentCommandExecutorProvider,
	AnnotationEditFormatter annotationEditFormatter,
	ResourceModelListener resourceModelListener) {
	super(null); // the JPA compilation unit is the root of its sub-tree
	this.compilationUnit = compilationUnit;
	this.annotationProvider = annotationProvider;
	this.modifySharedDocumentCommandExecutorProvider = modifySharedDocumentCommandExecutorProvider;
	this.annotationEditFormatter = annotationEditFormatter;
	this.resourceModelListener = resourceModelListener;
	this.persistentType = this.buildPersistentType();
	}

	protected JavaResourcePersistentType buildPersistentType() {
	this.openCompilationUnit();
	CompilationUnit astRoot = this.buildASTRoot();
	this.closeCompilationUnit();
	return this.buildPersistentType(astRoot);
	}

	protected void openCompilationUnit() {
	try {
	this.compilationUnit.open(null);
	} catch (JavaModelException ex) {
	// do nothing - we just won't have a primary type in this case
	}
	}

	protected void closeCompilationUnit() {
	try {
	this.compilationUnit.close();
	} catch (JavaModelException ex) {
	// hmmm
	}
	}

	protected JavaResourcePersistentType buildPersistentType(CompilationUnit astRoot) {
	TypeDeclaration td = this.getPrimaryType(astRoot);
	return (td == null) ? null : this.buildPersistentType(astRoot, td);
	}

	public void initialize(CompilationUnit astRoot) {
	// never called?
	}


	// ******** AbstractJavaResourceNode overrides ********

	@Override
	protected boolean requiresParent() {
	return false;
	}

	@Override
	public JpaCompilationUnit getJpaCompilationUnit() {
	return this;
	}

	@Override
	public JpaAnnotationProvider getAnnotationProvider() {
	return this.annotationProvider;
	}


	// ******** JavaResourceNode implementation ********

	public void update(CompilationUnit astRoot) {
	TypeDeclaration td = this.getPrimaryType(astRoot);
	if (td == null) {
	this.persistentType = null;
	} else {
	if (this.persistentType == null) {
	this.persistentType = this.buildPersistentType(astRoot, td);
	} else {
	this.persistentType.update(astRoot);
	}
	}
	}

	public TextRange getTextRange(CompilationUnit astRoot) {
	return null;
	}


	// ******** JpaCompilationUnit implementation ********

	public ICompilationUnit getCompilationUnit() {
	return this.compilationUnit;
	}

	public Iterator<JavaResourcePersistentType> persistableTypes() {
	return (this.persistentType == null) ?
	EmptyIterator.<JavaResourcePersistentType>instance() :
	this.persistentType.allPersistableTypes();
	}

	public void resourceModelChanged() {
	this.resourceModelListener.resourceModelChanged();
	}

	public void resolveTypes() {
	if (this.persistentType != null) {
	this.persistentType.resolveTypes(this.buildASTRoot());
	}
	}

	public CommandExecutorProvider getModifySharedDocumentCommandExecutorProvider() {
	return this.modifySharedDocumentCommandExecutorProvider;
	}

	public AnnotationEditFormatter getAnnotationEditFormatter() {
	return this.annotationEditFormatter;
	}


	// ******** Java changes ********

	public void javaElementChanged(ElementChangedEvent event) {
	this.synchWithJavaDelta(event.getDelta());
	}

	protected void synchWithJavaDelta(IJavaElementDelta delta) {
	switch (delta.getElement().getElementType()) {
	case IJavaElement.JAVA_PROJECT :
	if (this.classpathHasChanged(delta)) {
	this.updateFromJava();
	break; // no need to check further
	}
	case IJavaElement.JAVA_MODEL :
	case IJavaElement.PACKAGE_FRAGMENT_ROOT :
	case IJavaElement.PACKAGE_FRAGMENT :
	this.synchChildrenWithJavaDelta(delta);
	break;
	case IJavaElement.COMPILATION_UNIT :
	if (this.deltaIsRelevant(delta)) {
	this.updateFromJava();
	}
	break;
	default :
	break; // the element type is somehow held by a compilation unit (i.e. probably doesn't happen)
	}
	}

	protected void synchChildrenWithJavaDelta(IJavaElementDelta delta) {
	for (IJavaElementDelta child : delta.getAffectedChildren()) {
	this.synchWithJavaDelta(child); // recurse
	}
	}

	// 235384 - We need to update all compilation units when a classpath change occurs.
	// The persistence.jar could have been added to or removed from the
	// classpath which affects whether we know about the JPA annotations.
	protected boolean classpathHasChanged(IJavaElementDelta delta) {
	return BitTools.anyFlagsAreSet(delta.getFlags(), this.getClasspathChangedFlags());
	}

	protected int getClasspathChangedFlags() {
	return CLASSPATH_CHANGED_FLAGS;
	}

	protected static final int CLASSPATH_CHANGED_FLAGS =
	IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED \|
	IJavaElementDelta.F_CLASSPATH_CHANGED;

	protected boolean deltaIsRelevant(IJavaElementDelta delta) {
	// ignore changes to/from primary working copy - no content has changed;
	// and make sure there are no other flags set that indicate both a
	// change to/from primary working copy and content has changed
	if (BitTools.onlyFlagIsSet(delta.getFlags(), IJavaElementDelta.F_PRIMARY_WORKING_COPY)) {
	return false;
	}

	// we get the java notification for removal before we get the resource notification;
	// we do not need to handle this event and will get exceptions building an astRoot if we try
	if (delta.getKind() == IJavaElementDelta.REMOVED) {
	return false;
	}

	return delta.getElement().equals(this.compilationUnit);
	}

	protected void updateFromJava() {
	this.update(this.buildASTRoot());
	}


	// ******** internal ********

	protected CompilationUnit buildASTRoot() {
	return JDTTools.buildASTRoot(this.compilationUnit);
	}

	protected JavaResourcePersistentType buildPersistentType(CompilationUnit astRoot, TypeDeclaration typeDeclaration) {
	return JavaResourcePersistentTypeImpl.newInstance(this, typeDeclaration, astRoot);
	}

	/**
	* i.e. the type with the same name as the compilation unit;
	* return the first class or interface (ignore annotations and enums) with
	* the same name as the compilation unit (file);
	* NB: this type could be in error if there is an annotation or enum
	* with the same name preceding it in the compilation unit
	*
	* Return null if resolveBinding() on the TypeDeclaration returns null
	* This can occur if the project JRE is removed (bug 225332)
	*/
	protected TypeDeclaration getPrimaryType(CompilationUnit astRoot) {
	String primaryTypeName = this.getPrimaryTypeName();
	for (AbstractTypeDeclaration atd : types(astRoot)) {
	if ((atd.getNodeType() == ASTNode.TYPE_DECLARATION)
	&& atd.getName().getFullyQualifiedName().equals(primaryTypeName)) {
	return (atd.resolveBinding()) != null ? (TypeDeclaration) atd : null;
	}
	}
	return null;
	}

	// minimize scope of suppressed warnings
	@SuppressWarnings("unchecked")
	protected static List<AbstractTypeDeclaration> types(CompilationUnit astRoot) {
	return astRoot.types();
	}

	/**
	* i.e. the name of the compilation unit
	*/
	protected String getPrimaryTypeName() {
	return removeJavaExtension(this.compilationUnit.getElementName());
	}

	protected static String removeJavaExtension(String fileName) {
	int index = fileName.lastIndexOf(".java"); //$NON-NLS-1$
	return (index == -1) ? fileName : fileName.substring(0, index);
	}

	@Override
	public void toString(StringBuilder sb) {
	sb.append(this.persistentType.getName());
	}

	}