Java tutorial
/******************************************************************************* * Copyright (c) 2001, 2006 IBM Corporation and others. * 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: * IBM Corporation - initial API and implementation *******************************************************************************/ package org.eclipse.jem.internal.adapters.jdom; /* */ import java.util.ArrayList; import java.util.List; import java.util.logging.Level; import org.eclipse.emf.common.notify.Notification; import org.eclipse.emf.common.notify.Notifier; import org.eclipse.jdt.core.*; import org.eclipse.jem.internal.plugin.JavaPlugin; import org.eclipse.jem.util.logger.proxy.Logger; import org.eclipse.jem.workbench.utility.JavaModelListener; /** * Insert the type's description here. * Creation date: (11/1/2000 11:42:05 AM) * @author: Administrator */ public class JavaReflectionSynchronizer extends JavaModelListener { protected JavaJDOMAdapterFactory fAdapterFactory; protected boolean flushedAll = false; protected List flushTypes = new ArrayList(); protected List flushTypePlusInner = new ArrayList(); protected List notifications = new ArrayList(); /** * JavaReflectionSynchronizer constructor comment. */ public JavaReflectionSynchronizer(JavaJDOMAdapterFactory synchronizee) { super(); fAdapterFactory = synchronizee; } /* (non-Javadoc) * @see org.eclipse.jem.internal.adapters.jdom.JavaModelListener#getJavaProject() */ protected IJavaProject getJavaProject() { return getAdapterFactory().getJavaProject(); } /** * Tell the reflection factory to flush the passed IType */ protected Notification doFlush(IType element) { return getAdapterFactory().flushReflectionNoNotification(element.getFullyQualifiedName()); } /* * Flush the compilation unit and any inner classes since we don't if they may or may not of changed. */ protected Notification doFlush(ICompilationUnit element) { return getAdapterFactory().flushReflectionPlusInnerNoNotification(getFullNameFromElement(element)); } protected void flush(IType element) { if (!flushTypes.contains(element)) flushTypes.add(element); } /* * flush the compilation unit. Since we don't know if inner classes may also * of been affected, they to will be flushed. */ protected void flush(ICompilationUnit element) { if (!flushTypePlusInner.contains(element)) flushTypePlusInner.add(element); } protected void flushPackage(String packageName, boolean noFlushIfSourceFound) { notifications.addAll(getAdapterFactory().flushPackageNoNotification(packageName, noFlushIfSourceFound)); } protected JavaJDOMAdapterFactory getAdapterFactory() { return fAdapterFactory; } /** * Handle the change for a single element, children will be handled separately. * */ protected void processJavaElementChanged(ICompilationUnit element, IJavaElementDelta delta) { switch (delta.getKind()) { case IJavaElementDelta.CHANGED: { // A file save had occurred. It doesn't matter if currently working copy or not. // It means something has changed to the file on disk, but don't know what. if ((delta.getFlags() & IJavaElementDelta.F_PRIMARY_RESOURCE) != 0) { flush(element); // Flush everything, including inner classes. } else if ((delta.getFlags() & IJavaElementDelta.F_CONTENT) == 0 && (delta.getFlags() & IJavaElementDelta.F_CHILDREN) != 0) //A type may have been added or removed. processChildren(element, delta); break; } case IJavaElementDelta.REMOVED: case IJavaElementDelta.ADDED: if (!element.isWorkingCopy()) disAssociateSourcePlusInner(getFullNameFromElement(element)); break; } } /** * Handle the change for a single element, children will be handled separately. * */ protected void processJavaElementChanged(IJavaProject element, IJavaElementDelta delta) { if (isInClasspath(element)) { if (delta.getKind() == IJavaElementDelta.REMOVED || (delta.getKind() == IJavaElementDelta.CHANGED && (delta.getFlags() & IJavaElementDelta.F_CLOSED) != 0)) { if (element.equals(getAdapterFactory().getJavaProject())) stopSynchronizer(); else flushAll(); //another dependent project has changed so flush all to be safe return; } else if (delta.getKind() == IJavaElementDelta.ADDED || isClasspathResourceChange(delta)) { flushAll(); return; } processChildren(element, delta); } } /** * Handle the change for a single element, children will be handled separately. */ protected void processJavaElementChanged(IClassFile element, IJavaElementDelta delta) { int kind = delta.getKind(); if (kind == IJavaElementDelta.REMOVED || kind == IJavaElementDelta.ADDED) { // It doesn't matter if totally removed or just moved somewhere else, we will clear out and remove the // adapter because there could be a rename which would be a different class. // Currently the element is already deleted and there is no way to find the types in the unit to remove. // So instead we ask factory to remove all it any that start with it plus for inner classes. disAssociateSourcePlusInner(getFullNameFromElement(element)); return; // Since the classfile was removed we don't need to process the children (actually the children list will be empty } IJavaElementDelta[] children = delta.getAffectedChildren(); for (int ii = 0; ii < children.length; ii++) { processDelta(children[ii]); } } /** * Handle the change for a single element, children will be handled separately. * */ protected void processJavaElementChanged(IPackageFragmentRoot element, IJavaElementDelta delta) { if (flushedAll) return; if (isClassPathChange(delta)) flushAll(); else super.processJavaElementChanged(element, delta); } /* * We will force the flushing of all adaptors for the given package name. * This is necessary if a type was reflected prior to the package existing or * if the package is deleted. * @see org.eclipse.jem.internal.adapters.jdom.JavaModelListener#processJavaElementChanged(org.eclipse.jdt.core.IPackageFragment, org.eclipse.jdt.core.IJavaElementDelta) */ protected void processJavaElementChanged(IPackageFragment element, IJavaElementDelta delta) { switch (delta.getKind()) { case IJavaElementDelta.ADDED: // Even though added there is possibility that package exists in other root but this // one may now take priority, so we will clear the package anyway. flushPackage(delta.getElement().getElementName(), false); break; case IJavaElementDelta.REMOVED: getAdapterFactory().flushPackage(delta.getElement().getElementName(), false); break; default: super.processJavaElementChanged(element, delta); } } /** * Handle the change for a single element, children will be handled separately. * */ protected void processJavaElementChanged(IType element, IJavaElementDelta delta) { int kind = delta.getKind(); if (kind == IJavaElementDelta.REMOVED || kind == IJavaElementDelta.ADDED) { disAssociateSourcePlusInner(element.getFullyQualifiedName()); } else { flush(element); processChildren(element, delta); // Note, if a method element or a field was changed, there may be delta.getAffectedChildren() // that will have to be processed if we are to update the JavaMethod/JavaField JDOMAdaptor s. } } /** * Given that an IType does not exists anymore, assume * that the type's name is package.filename (without the .java) * If we are wrong (if, then a rare case), we will flush. * Next access will induce a reflection attempt. * @deprecated This doesn't look like it is ever called. It someone else calls it, please contact development to see if right method to be called. */ protected void processRemoveOrAdd(ICompilationUnit element) { disAssociateSource(getFullNameFromElement(element)); } protected String getFullNameFromElement(ICompilationUnit cu) { IType primary = cu.findPrimaryType(); if (primary != null) return primary.getFullyQualifiedName(); else { String filename = cu.getElementName(); // Just strip off extension. There is actually a more complicated test for "java like extenstions" but JDT has that hidden\ // so we will just guess and take off the extension. int idx = filename.lastIndexOf('.'); if (idx != -1) filename = filename.substring(0, idx); return ((IPackageFragment) cu.getParent()).getElementName() + '.' + filename; } } protected String getFullNameFromElement(IClassFile cf) { return cf.getType().getFullyQualifiedName(); } protected String getFullNameFromElement(IJavaElement element) { // TODO: may want to throw IllegalArgumentException here? // if (element == null) throw new IllegalArgumentException("Java Element parameter may not be null"); String name = element.getElementName(); if (name.length() <= 5 || !name.substring(name.length() - 5).equals(".java")) { //$NON-NLS-1$ // Should not be here, Logger logger = JavaPlugin.getDefault().getLogger(); if (logger.isLoggingLevel(Level.FINE)) logger.log("Invalid .java file: " + name, Level.FINE); //$NON-NLS-1$ // Make a guess, at worst case, nothing will come out of this. int index = name.lastIndexOf("."); //$NON-NLS-1$ if (index >= 0) name = name.substring(0, index) + ".java"; // rename the extension to .java //$NON-NLS-1$ else name = name + ".java"; //$NON-NLS-1$ } if (element.getParent().getElementName() == null || element.getParent().getElementName().length() == 0) return name.substring(0, name.length() - 5); else return element.getParent().getElementName() + "." + name.substring(0, name.length() - 5); //$NON-NLS-1$ } /** * Stop the synchronizer from listening to any more changes. */ public void stopSynchronizer() { JavaCore.removeElementChangedListener(this); } /** * @see org.eclipse.jem.internal.adapters.jdom.JavaModelListener#elementChanged(ElementChangedEvent) */ public void elementChanged(ElementChangedEvent event) { try { flushTypes.clear(); flushTypePlusInner.clear(); notifications.clear(); super.elementChanged(event); flushTypes(); processNotifications(); } finally { flushedAll = false; flushTypes.clear(); flushTypePlusInner.clear(); notifications.clear(); } } /** * */ private void flushTypes() { if (!flushTypes.isEmpty()) { IType type = null; Notification not; for (int i = 0; i < flushTypes.size(); i++) { type = (IType) flushTypes.get(i); not = doFlush(type); if (not != null) notifications.add(not); } } if (!flushTypePlusInner.isEmpty()) { ICompilationUnit unit = null; Notification not; for (int i = 0; i < flushTypePlusInner.size(); i++) { unit = (ICompilationUnit) flushTypePlusInner.get(i); not = doFlush(unit); if (not != null) notifications.add(not); } } } /** * @param notifications */ private void processNotifications() { Notifier notifier; Notification not; for (int i = 0; i < notifications.size(); i++) { not = (Notification) notifications.get(i); notifier = (Notifier) not.getNotifier(); if (notifier != null) try { notifier.eNotify(not); } catch (Exception e) { JavaPlugin.getDefault().getLogger().log(e); //catch exceptions so all notifications are processed } } } protected void disAssociateSource(String qualifiedName) { Notification not = getAdapterFactory().disAssociateSource(qualifiedName, false); if (not != null) notifications.add(not); } protected void disAssociateSourcePlusInner(String qualifiedName) { Notification not = getAdapterFactory().disAssociateSourcePlusInner(qualifiedName, false); if (not != null) notifications.add(not); } protected void flushAll() { notifications.addAll(getAdapterFactory().flushAllNoNotification()); flushedAll = true; } /** * @see org.eclipse.jem.internal.adapters.jdom.JavaModelListener#processChildren(IJavaElement, IJavaElementDelta) */ protected void processChildren(IJavaElement element, IJavaElementDelta delta) { if (!flushedAll) super.processChildren(element, delta); } /** * @see org.eclipse.jem.internal.adapters.jdom.JavaModelListener#processDelta(IJavaElementDelta) */ public void processDelta(IJavaElementDelta delta) { if (!flushedAll) super.processDelta(delta); } }