| /******************************************************************************* |
| * Copyright (c) 2001, 2005 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.*; |
| |
| import org.eclipse.emf.common.notify.*; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.notify.Notifier; |
| import org.eclipse.jdt.core.*; |
| import org.eclipse.jem.internal.java.adapters.*; |
| import org.eclipse.jem.internal.java.adapters.JavaReflectionAdapterFactory; |
| import org.eclipse.jem.internal.java.adapters.ReflectionAdaptor; |
| /** |
| * Insert the type's description here. |
| * Creation date: (6/13/2000 1:20:31 PM) |
| * @author: Administrator |
| */ |
| public class JavaJDOMAdapterFactory extends JavaReflectionAdapterFactory { |
| |
| protected JavaReflectionSynchronizer synchronizer; |
| protected IJavaProject javaProject; |
| /** |
| * JavaJDOMAdapterFactory constructor comment. |
| */ |
| public JavaJDOMAdapterFactory() { |
| super(); |
| } |
| /** |
| * JavaJDOMAdapterFactory constructor comment. |
| */ |
| public JavaJDOMAdapterFactory(IJavaProject aJavaProject) { |
| this(); |
| setJavaProject(aJavaProject); |
| } |
| protected ReflectionAdaptor createJavaClassAdaptor(Notifier target) { |
| return new JavaClassJDOMAdaptor(target, getJavaProject(), this); |
| } |
| protected ReflectionAdaptor createJavaFieldAdaptor(Notifier target) { |
| return new JavaFieldJDOMAdaptor(target, getJavaProject()); |
| } |
| protected ReflectionAdaptor createJavaMethodAdaptor(Notifier target) { |
| return new JavaMethodJDOMAdaptor(target, getJavaProject()); |
| } |
| /** |
| * Flush ALL adapters, worst case |
| * We also want to ensure that the source types are also cleared |
| * in this worst case scenario. |
| */ |
| public void flushAll() { |
| doFlush(reflected.values(),true, true); |
| } |
| |
| public List flushAllNoNotification() { |
| return doFlush(reflected.values(),true, false); |
| } |
| |
| public void flushPackage(String packageName, boolean noFlushIfSourceFound) { |
| List adaptors = getReflectedForPackage(packageName, noFlushIfSourceFound); |
| doFlush(adaptors, true, true); |
| } |
| public List flushPackageNoNotification(String packageName, boolean noFlushIfSourceFound) { |
| List adaptors = getReflectedForPackage(packageName, noFlushIfSourceFound); |
| return doFlush(adaptors, true, false); |
| } |
| /** |
| * Return a List of reflection adaptors that belong to |
| * the packageName. |
| * @param packageName |
| * @return |
| */ |
| private List getReflectedForPackage(String packageName, boolean filterFoundTypes) { |
| if (packageName != null && !reflected.isEmpty()) { |
| isBusyIteratingReflected = true; |
| List result = null; |
| try { |
| Iterator it = reflected.entrySet().iterator(); |
| Map.Entry entry; |
| String key; |
| JavaClassJDOMAdaptor adaptor; |
| while (it.hasNext()) { |
| entry = (Map.Entry) it.next(); |
| adaptor = (JavaClassJDOMAdaptor) entry.getValue(); |
| /* |
| * Ensure that the the adaptor is only filtered out if it has |
| * actually reflected the content. It is not good enough just |
| * to test for the sourceType. |
| */ |
| if (filterFoundTypes && adaptor.hasValidReflection()) |
| continue; |
| key = (String) entry.getKey(); |
| if (key.startsWith(packageName) && key.indexOf('.', packageName.length() + 1) < 0) { |
| if (result == null) |
| result = new ArrayList(); |
| result.add(entry.getValue()); |
| } |
| } |
| } finally { |
| finishedIteratingReflected(); |
| } |
| if (result != null) |
| return result; |
| } |
| return Collections.EMPTY_LIST; |
| } |
| private List doFlush(Collection adaptors, boolean clearSourceType, boolean doNotify) { |
| if (!adaptors.isEmpty()) { |
| isBusyIteratingReflected = true; |
| List notifications = doNotify ? null : new ArrayList(adaptors.size()); |
| try { |
| Notification notification; |
| Iterator i = adaptors.iterator(); |
| JDOMAdaptor adaptor; |
| while (i.hasNext()) { |
| adaptor = (JDOMAdaptor) i.next(); |
| if (doNotify) |
| adaptor.flushReflectedValuesIfNecessary(clearSourceType); |
| else { |
| notification = adaptor.flushReflectedValuesIfNecessaryNoNotification(clearSourceType); |
| if (notification != null) |
| notifications.add(notification); |
| } |
| } |
| } finally { |
| finishedIteratingReflected(); |
| } |
| return notifications; |
| } |
| return Collections.EMPTY_LIST; |
| } |
| // Flush the adapter for a source object |
| public void flushReflection(String source) { |
| JDOMAdaptor a = (JDOMAdaptor) reflected.get(source); |
| if (a != null) |
| a.flushReflectedValuesIfNecessary(); |
| } |
| public Notification flushReflectionNoNotification(String source) { |
| JDOMAdaptor a = (JDOMAdaptor) reflected.get(source); |
| if (a != null) |
| return a.flushReflectedValuesIfNecessaryNoNotification(false); |
| return null; |
| } |
| |
| public Notification flushReflectionPlusInnerNoNotification(String source) { |
| isBusyIteratingReflected = true; |
| Notification notification = null; |
| try { |
| String innerName = source + '$'; |
| Iterator it = reflected.entrySet().iterator(); |
| Map.Entry entry; |
| String key; |
| JavaReflectionAdaptor adaptor; |
| while (it.hasNext()) { |
| entry = (Map.Entry) it.next(); |
| key = (String) entry.getKey(); |
| if (key.equals(source) || key.startsWith(innerName)) { |
| adaptor = (JavaReflectionAdaptor) reflected.get(key); |
| if (adaptor != null) { |
| if (notification == null) |
| notification = adaptor.flushReflectedValuesIfNecessaryNoNotification(false); |
| else |
| ((NotificationChain) notification).add(adaptor.flushReflectedValuesIfNecessaryNoNotification(false)); |
| } |
| } |
| } |
| } finally { |
| finishedIteratingReflected(); |
| } |
| return notification; |
| |
| } |
| /** |
| * Insert the method's description here. |
| * Creation date: (11/2/2000 3:02:31 PM) |
| * @return org.eclipse.jdt.core.api.IJavaProject |
| */ |
| public IJavaProject getJavaProject() { |
| return javaProject; |
| } |
| /** |
| * Create a Java Model listener which will flush invalidated adaptors. |
| * This will cause those adapters to re-reflect their target object's contents. |
| */ |
| protected void initializeSynchronizer() { |
| synchronizer = new JavaReflectionSynchronizer(this); |
| } |
| /** |
| * Notify all JDOMAdapters which use the same target ICompilationUnit |
| * Creation date: (8/17/2001 4:45:43 PM) |
| */ |
| public void notifyContentChanged(ICompilationUnit targetCU) { |
| |
| if (targetCU == null || reflected.values()==null) return ; |
| isBusyIteratingReflected = true; |
| try { |
| Iterator i = reflected.values().iterator(); |
| while (i.hasNext()) { |
| Object a = i.next() ; |
| if (a instanceof JDOMAdaptor) { |
| JDOMAdaptor adaptor = (JDOMAdaptor) a; |
| IMember reflectionSource = (IMember) adaptor.getReflectionSource(); |
| ICompilationUnit adapterCU = null ; |
| if (reflectionSource != null) { |
| try { |
| adapterCU = reflectionSource.getCompilationUnit(); |
| } catch (Exception e) {} |
| } |
| if (adapterCU != null && targetCU.equals(adapterCU)) { |
| adaptor.contentChanged(); |
| } |
| } |
| } |
| } finally { |
| finishedIteratingReflected(); |
| } |
| } |
| /** |
| * Insert the method's description here. |
| * Creation date: (11/2/2000 3:02:31 PM) |
| * @param newJavaProject org.eclipse.jdt.core.IJavaProject |
| */ |
| public void setJavaProject(IJavaProject newJavaProject) { |
| javaProject = newJavaProject; |
| if (newJavaProject != null && synchronizer == null) |
| initializeSynchronizer(); |
| } |
| } |