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

/*******************************************************************************
 * Copyright (c) 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.bpel.model.adapters;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;

/**
* Abstract adapter has basic adapter functionality and it has some
* logic to decide whether adapters are stateful or stateless. 
* 
* @author Michal Chmielewski (michal.chmielewski@oracle.com)
* @date Sep 15, 2006
*
*/

public class AbstractAdapter implements Adapter {
	
	/** The event type that we will consume that indicates a context update */
	static public final int CONTEXT_UPDATE_EVENT_TYPE = 101;
		
	/** Makes sense only when adapters are statefull */
	// Bugzilla 330519
	// need access to this in MarkerDelegateAdapter
	protected Object target = null;
	
	/** additional context that is needed by the adapter to wrap the object */
	private Object context = null;	
	

	/**
	 * Allow the adapter to store new context information. This
	 * only works if the adapter is stateful.
	 * 
	 * 
	 * @param notification the notification to process.
	 */
	public void notifyChanged (Notification notification) {
		
		if (notification.getEventType() == CONTEXT_UPDATE_EVENT_TYPE && isStatefull() ) {
			context = notification.getNewValue();
		}
	}

	
	/**
	 * Return the target. This will always be null in case the 
	 * adapter is stateless.
	 * 
	 * @return the target
	 */
	
	public Notifier getTarget() {
		return getTarget(target,Notifier.class);
	}
	
	/**
	 * Set the target element, only if the adapter is stateless.
	 * 
	 * @param newTarget the target to set
	 */
	
	public void setTarget(Notifier newTarget) {		
		if ( isStatefull() ) {
			target = newTarget;
		}		 		
	}

	
	/**
	 * 
	 * @param newTarget
	 */
	
	public void setTarget (Object newTarget) {
		if (isStatefull()) {
			target = newTarget;
		}
	}
	
	
	/**
	 * Answer true if we are an adapter for the type given
	 * @param type the object type to check. 
	 * @return true if so, false if not 
	 */
	
	public boolean isAdapterForType (Object type) {
		Class<?> clazz = null;
		// what is type ? (an interface)
		if (type instanceof Class) {
			clazz = (Class) type;
			return clazz.isInstance(this);
		}
		// what else could it be ?
		return false;
	}
	
	/**
	 * Return any context object that the adapter is holding.
	 * @return the context object
	 */
	
	public Object getContext () {
		return context;
	}
	
	/**
	 * Answer if we are a stateful adapter or not.
	 * 
	 * @return true if stateful, false if stateless.
	 */
	
	public boolean isStatefull () {
		return IStatefullAdapter.class.isInstance(this);
	}
	
	
	/**
	 * Some adapters rely on interfaces that are stateless, where the target
	 * is passed as an argument to the adapter. This is not necessarily true for
	 * some interfaces we cannot control (like IContentProposal).
	 *  
	 * @param <T> The type class
	 * @param obj the object which might be the adapted target
	 * @param clazz the class that the target must be an instance of. 
	 * @return the target object
	 */
	
	@SuppressWarnings("unchecked")	
	public <T extends Object> T getTarget ( Object obj , Class<T> clazz ) {

		if (obj != null) {
			if (clazz.isInstance(obj)) {
				return (T) obj;
			}
			if (target != null) {
				if (clazz.isInstance(target)) {
					return (T) target;
				}
			}
			// problem !
			throw new RuntimeException("Object is not of type " + clazz.getName()); //$NON-NLS-1$
		}
				
		/** Target is never set unless the object is statefull. */
		
		if (target != null) {			
			if (clazz.isInstance(target)) {
				return (T) target;
			}
			// problem !
			throw new RuntimeException("Target is not of type " + clazz.getName()); //$NON-NLS-1$
		}		

		return null;
			
	
		
	}

}