plugins/org.eclipse.bpel.model/src/org/eclipse/bpel/model/adapters/AdapterRegistry.java

/*******************************************************************************
 * Copyright (c) 2006 Oracle 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:
 *     Oracle Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.bpel.model.adapters;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.eclipse.core.runtime.IAdapterFactory;
import org.eclipse.core.runtime.IAdapterManager;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.NotificationImpl;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;

/**
 * This is the one place where EMF object adapters can be registered. 
 * 
 * @author Michal Chmielewski (michal.chmielewski@oracle.com)
 * @date Jul 23, 2007
 *
 */

public class AdapterRegistry {

	/**
	 * The singleton instance of this registry.
	 */
	
	static final public AdapterRegistry INSTANCE = new AdapterRegistry();

	/** For every type of EClass or EPackage, register an Adapter Factory 
	 *   This means that a particular EClass or EPackage may have N
	 *    
	 *   Adapter Factories. 
	 */
	
	HashMap<Object,List<AdapterFactory>> fKeyToAdapterFactory ;
	
	/** The current adapter manager */
	IAdapterManager fAdapterManager;
	
	/**
	 * Private constructor.
	 */
	
	AdapterRegistry () {
		fKeyToAdapterFactory = new HashMap<Object,List<AdapterFactory>>();
		
		if (Platform.isRunning()) {
			fAdapterManager = Platform.getAdapterManager();
		} else {
			fAdapterManager = org.eclipse.core.internal.runtime.AdapterManager.getDefault();
		}		
	}
	
	/**
	 * Register adapter factory for the given EClass.
	 * 
	 * @param key
	 * @param factory
	 */
	
	public void registerAdapterFactory (EClass key, AdapterFactory factory) {
		registerFactory (key,factory);
	}

	/**
	 * Register adapter factory for the given EPackage.
	 * 
	 * @param key
	 * @param factory
	 */
	
	public void registerAdapterFactory (EPackage key, AdapterFactory factory) {
		registerFactory (key,factory);
	}

	
	
	/**
	 * Unregister adapter factory for the given object (EClass)
	 * @param key
	 * @param factory
	 */
	
	public void unregisterAdapterFactory (EClass key, AdapterFactory factory) {
		unregisterFactory (key,factory);
	}

	/**
	 * Unregister adapter factory for the given object (EPackage)
	 * @param key
	 * @param factory
	 */
	
	public void unregisterAdapterFactory (EPackage key, AdapterFactory factory) {
		unregisterFactory (key,factory);
	}

	
	/**
	 * Register the factory (internal method, synchronized).
	 * @param key
	 * @param factory
	 */
	synchronized void registerFactory ( Object key, AdapterFactory factory) {
		List<AdapterFactory> list = fKeyToAdapterFactory.get(key);
		
		if (list == null) {
			list = new ArrayList<AdapterFactory>( );
			fKeyToAdapterFactory.put( key, list );
			list.add (factory);
		} else {
			if (list.contains(factory) == false) {
				list.add (factory);
			}
		}
	}
	
	synchronized void unregisterFactory (Object key, AdapterFactory factory) {
		List<AdapterFactory> list = fKeyToAdapterFactory.get(key);
		
		if (list == null) {
			return ;
		}
		list.remove(factory);		
	}
	
	
	Class<?> adapterInterface ( Object type ) {
		
		if (type instanceof Class) {
			return (Class<?>) type;
		}
		
		if (type instanceof String) {
			try {
				return Class.forName((String)type);
			} catch (ClassNotFoundException e) {
				throw new RuntimeException(e);
			}				
		}
		
		throw new RuntimeException("Adapter type " + type + " is not understood.");		 //$NON-NLS-1$ //$NON-NLS-2$
	}
	
	/**
	 * @param <T>
	 * @param target
	 * @param clazz
	 * @return the adapted interface or object
	 */
		
	
	public <T extends Object> T adapt ( Object target,  Class<T> clazz) {
		return adapt (target,clazz,true);
	}
	

	/**
	 * 
	 * @param <T>
	 * @param target
	 * @param clazz
	 * @param checkWSAdapters Check the Workspace adapters as well.
	 * 
	 * @return the adapted interface or object
	 */

	public <T extends Object> T adapt ( Object target,  Class<T> clazz, boolean checkWSAdapters ) {
	
		if (target == null) {
			return null;
		}
		
		if (clazz.isInstance(target)) {
			return clazz.cast(target);
		}
		
		Object adapter = null;		
		
		if (target instanceof EObject) {
			
			EObject eObj = (EObject) target;
			EClass effectiveClass = eObj.eClass();
			
			List<AdapterFactory> list = fKeyToAdapterFactory.get( effectiveClass );
			if (list != null) {
				for(AdapterFactory factory : list) {
					adapter = factory.adapt(target, clazz);
					if (adapter != null && clazz.isInstance(adapter)) {
						return clazz.cast(adapter);
					}
				}
			}
			
			list = fKeyToAdapterFactory.get( effectiveClass.getEPackage() );
			if (list != null) {
				for(AdapterFactory factory : list ) {
					adapter = factory.adapt(target, clazz);
					if (adapter != null && clazz.isInstance(adapter)) {
						return clazz.cast(adapter);
					}
				}					   
			}
		}
				
		if ( checkWSAdapters && fAdapterManager != null ) {
			// otherwise, the object we are adapting is not an EObject, try any other adapters.		
			adapter = fAdapterManager.getAdapter(target, clazz);
			if (adapter != null && clazz.isInstance(adapter)) {
				return clazz.cast(adapter);
			}
		}
		
	    return null;
	}
	
	
	
	/**
	 * This method tries the registered adapter factories one by one, returning
	 * the first non-null result it gets.  If none of the factories can adapt
	 * the result, it returns null.
	 * @param target target object 
	 * @param type type of the adapter to find
	 * @return the adapter for the target.
	 */
	
	public Object adapt (Object target, Object type) {

		if (target == null) {
			return null;
		}		 
		return adapt ( target, adapterInterface(type) );
	}
	
	
	/**
	 * Create an adapter for the given target of the given type. 
	 * In addition, pass a context object to the adapter(s) of the target. 
	 * 
	 * The idea is that some adapters can be stateful and depend not only 
	 * on the objects that they wrap, but also on some other context that is needed
	 * to completely and correctly implement the interface for which the adaptor is
	 * needed.
	 * 
	 * Adapters that are stateless, should ignore any notifications sent to them.
	 *  
	 * @param target the target object
	 * @param type the type it wants to adapt to
	 * @param context the context object
	 * 
	 * @return the adapter
	 */
	public Object adapt (Object target, Object type, Object context) {
		
		Object adapter = adapt (target,type);
		if (adapter == null) {
			return adapter;
		}
		
		if (target instanceof EObject) {				
			EObject eObject = (EObject) target;		
			Notification n = new NotificationImpl(AbstractAdapter.CONTEXT_UPDATE_EVENT_TYPE, null, context);		
			eObject.eNotify(n);
		}
		
		return adapter;
	}

	public void registerAdapterFactory (IAdapterFactory factory) {
		registerAdapterFactory(factory, Object.class);
	}
	
	/**
	 * @param factory
	 * @param class1
	 */
	public void registerAdapterFactory(IAdapterFactory factory,	Class<?> clazz) {
		fAdapterManager.registerAdapters(factory, clazz);		
	}


}