DispatchingVisitor.java

Violations

Source code

/*
 * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
 */
package biz.hammurapi.util;

import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import biz.hammurapi.config.Command;

/**
 * Dispatching visitor navigates through Visitables hierarchy and
 * invokes visit(<I>Type</I>) method of targets with compatible <I>Type</I>.
 * @author Pavel Vlasov
 * @version $Revision: 1.9 $
 */
public class DispatchingVisitor implements PoliteVisitor, VisitorStackSource, Command {
	private static final String APPROVE = "approve";
	private static final String VERIFY = "verify";
	private static final String LEAVE = "leave";
	private static final String VISIT = "visit";
	private Collection targets;
	private VisitorExceptionSink exceptionSink;
	private Map handlers=new HashMap();
	private Map leaveHandlers=new HashMap();
	private Map verifyHandlers=new HashMap();
	private Map filterHandlers=new HashMap();
	private Collection listeners=new ArrayList();
	private Collection classesOfInterest=new ArrayList();
	private Collection unmodifiableClassesOfInterest=Collections.unmodifiableCollection(classesOfInterest);
	
	private Collection handlerList=new ArrayList();
	private Collection leaveHandlerList=new ArrayList();
	private Collection verifyHandlerList=new ArrayList();
	private Collection filterHandlerList=new ArrayList();
	
	/**
	 * @param clazz
	 * @return  handlers for class.
	 */
	private Collection getHandlers(Class clazz) {
		synchronized (handlers) {
			List ret=(List) handlers.get(clazz);
			if (ret==null) {
				ret=new ArrayList();
				handlers.put(clazz, ret);
				Iterator it=handlerList.iterator();
				while (it.hasNext()) {
					InvocationHandler handler=(InvocationHandler) it.next();
					if (handler.method.getParameterTypes()[0].isAssignableFrom(clazz)) {
						ret.add(handler);
					}
				}
				Collections.sort(ret);
			}
			return ret;
		}		
	}
	
	/**
	 * @param clazz
	 * @return leave handlers for class
	 */
	private Collection getLeaveHandlers(Class clazz) {
		synchronized (leaveHandlers) {
			List ret=(List) leaveHandlers.get(clazz);
			if (ret==null) {
				ret=new ArrayList();
				leaveHandlers.put(clazz, ret);
				Iterator it=leaveHandlerList.iterator();
				while (it.hasNext()) {
					InvocationHandler handler=(InvocationHandler) it.next();
					if (handler.method.getParameterTypes()[0].isAssignableFrom(clazz)) {
						ret.add(handler);
					}
				}
				Collections.sort(ret);
				Collections.reverse(ret);
			}
			return ret;
		}		
	}
	
	/**
	 * @param clazz
	 * @return leave handlers for class
	 */
	private Collection getVerifyHandlers(Class clazz) {
		synchronized (verifyHandlers) {
			List ret=(List) verifyHandlers.get(clazz);
			if (ret==null) {
				ret=new ArrayList();
				verifyHandlers.put(clazz, ret);
				Iterator it=verifyHandlerList.iterator();
				while (it.hasNext()) {
					InvocationHandler handler=(InvocationHandler) it.next();
					if (handler.method.getParameterTypes()[0].isAssignableFrom(clazz)) {
						ret.add(handler);
					}
				}
				Collections.sort(ret);
				Collections.reverse(ret);
			}
			return ret;
		}		
	}
	
	/**
	 * @param clazz
	 * @return  filter handlers for class.
	 */
	private Collection getFilterHandlers(Class clazz) {
		synchronized (filterHandlers) {
			List ret=(List) filterHandlers.get(clazz);
			if (ret==null) {
				ret=new ArrayList();
				filterHandlers.put(clazz, ret);
				Iterator it=filterHandlerList.iterator();
				while (it.hasNext()) {
					InvocationHandler handler=(InvocationHandler) it.next();
					if (handler.method.getParameterTypes()[0].isAssignableFrom(clazz)) {
						ret.add(handler);
					}
				}
			}
			return ret;
		}		
	}
	
	/**
	 * Targets which want to listen to invocations of self should implement
	 * this interface.
	 * @author Pavel Vlasov
	 * @revision $Revision: 1.9 $
	 */
	public interface SelfListener {
		void onInvocation(Method method, Object visitable);		
	}
	
	public interface Listener {
		void onInvocationRegistration(Object target, Method method);
		void onTargetRegistration(Object target);
		void onFilterRegistration(Method filter, Method target);
		void noInvocationsWarning(Object target);
		void onInvocation(Object target, Method method, Object visitable);
		void onVisit(Object target);		
		void onLeave(Object target);
	}
	
	/**
	 * If target implements this insterface then it is used to
	 * filter invocations to other targets. approve() method(s) of
	 * this target, if any, will be invoked before invocation of
	 * visit()/leave() methods of filtered target.
	 *
	 * @author Pavel Vlasov
	 * @version $Revision: 1.9 $
	 */
	public interface Filter {
		Collection getTargets();
	}
	
	public interface Stats {
		long getVisits();
		long getInvocations();
		void reset();
	}
	
	private static class StatsImpl implements Stats {
		private long visits;
		private long invocations;
		
		public long getVisits() {
			return visits;
		}

		public long getInvocations() {
			return invocations;
		}

		public void reset() {
			visits=0;
			invocations=0;
		}
		
		public String toString() {
			return "["+Thread.currentThread()+"] "+visits+" visits, "+invocations+" invocations"; 
		}
		
		synchronized void addVisit() {
			visits++;
		}
		
		synchronized void addInvocation() {
			invocations++;
		}
		
	}
	
	private int handlerCounter;
	private StatsImpl stats=new StatsImpl();
	private ThreadLocal threadStats=new ThreadLocal() {
		protected Object initialValue() {
			return new StatsImpl();
		}
	};
	
	private class InvocationHandler implements Comparable {
		boolean active=true;
		Method method;
		Object object;
		int position=handlerCounter++;
		int order;
		List filtersList=new LinkedList();
		ApproveInvocationHandler[] filters;
		boolean returnsValue;
		
		public String toString() {
			return getClass().getName()+"["+order+" "+method+"]";
		}
		
		void addFilter(ApproveInvocationHandler filter) {
			filtersList.add(filter);	
			Iterator it=listeners.iterator();
			while (it.hasNext()) {
				((Listener) it.next()).onFilterRegistration(filter.method, method);
			}
		}
		
		void commitFilters() {
			filters=null;
			if (!filtersList.isEmpty()) {
				filters=(ApproveInvocationHandler[]) filtersList.toArray(new ApproveInvocationHandler[filtersList.size()]);
			}
		}
		
		InvocationHandler(Method method, Object object) {
			Iterator it=listeners.iterator();
			while (it.hasNext()) {
				((Listener) it.next()).onInvocationRegistration(object, method);
			}
			
			this.method=method;
			this.object=object;
			this.returnsValue=!(void.class.equals(method.getReturnType()) || boolean.class.equals(method.getReturnType()) || Boolean.class.equals(method.getReturnType()));
			
			addClassOfInterest(method.getParameterTypes()[0]);
			
			if (object instanceof OrderedTarget) {
				Integer ret=((OrderedTarget) object).getOrder();
				if (ret!=null) {
					order=ret.intValue();
				}
			}			
			
		}
				
		Object invoke(Object arg) {
			if (active) {
				for (int i=0; filters!=null && i<filters.length; i++) {
					if (Boolean.FALSE.equals(filters[i].invoke(arg))) {
						return null;
					}
				}
				try {
					Iterator it=listeners.iterator();
					while (it.hasNext()) {
						((Listener) it.next()).onInvocation(object, method, arg);
					}
					stats.addInvocation();
					((StatsImpl) threadStats.get()).addInvocation();
					if (object instanceof SelfListener) {
						((SelfListener) object).onInvocation(method, arg);
					}
					
					if (!method.getParameterTypes()[0].isInstance(arg)) {
						System.err.println(method+", "+arg.getClass());
					}
					
					return method.invoke(object, new Object[] {arg});
				} catch (IllegalArgumentException e) {
					if (exceptionSink==null) {
						e.printStackTrace();
					} else {
						exceptionSink.consume(DispatchingVisitor.this, object, method, arg, e);
					}
				} catch (IllegalAccessException e) {
					if (exceptionSink==null) {
						e.printStackTrace();
					} else {
						exceptionSink.consume(DispatchingVisitor.this, object, method, arg, e);
					}
				} catch (InvocationTargetException e) {
					Throwable targetException = e.getTargetException();
					if (targetException instanceof Error) {
						throw (Error) targetException;
					} else if (exceptionSink==null) {
						targetException.printStackTrace();
					} else {
						exceptionSink.consume(DispatchingVisitor.this, object, method, arg, targetException instanceof Exception ? (Exception) targetException : e);
					}
				}
			}
			return null;
		}
		
		public int compareTo(Object o) {
			if (this==o) {
				return 0;
			}
			InvocationHandler ih=(InvocationHandler) o;
			if (order==ih.order) {
				if (position==ih.position) {
					Class c=method.getParameterTypes()[0];
					Class ihc=ih.method.getParameterTypes()[0];
					if (c.equals(ihc)) {
						return method.getDeclaringClass().getName().compareTo(ih.method.getDeclaringClass().getName());
					}
					if (c.isAssignableFrom(ihc)) {
						return -1;
					} else if (ihc.isAssignableFrom(c)) {
						return 1;
					} else {
						int idc=inheritanceDepth(c);
						int ihidc=inheritanceDepth(ihc);
						if (idc==ihidc) {
							return method.getDeclaringClass().getName().compareTo(ih.method.getDeclaringClass().getName());									
						}
						return idc-ihidc;
					}
				}
				return position-ih.position;
			}
			return order==ih.order ? 0 : order>ih.order ? 1 : -1;
		}
	}
	
	private int inheritanceDepth(Class clazz) {
		if (clazz==null || Object.class.equals(clazz)) {
			return 0;
		}
		int ret=0;			
		ret=Math.max(ret, inheritanceDepth(clazz.getSuperclass()));
		for (int i=0, j=clazz.getInterfaces().length; i<j; i++) {
			ret=Math.max(ret, inheritanceDepth(clazz.getInterfaces()[i]));
		}
		return ret+1;
	}
	
	private class ApproveInvocationHandler extends InvocationHandler {
		private Class parameterType;
		
		ApproveInvocationHandler(Method method, Object object) {
			super(method, object);
			parameterType=method.getParameterTypes()[0];
		}
		
		Map results=new IdentityHashMap();
		
		Object invoke(Object arg) {
			if (!parameterType.isInstance(arg)) {
				return null; // Incompatible parameter.

			}
			
			if (results.containsKey(arg)) {
				return results.get(arg);
			}
			Object ret=super.invoke(arg);
			results.put(arg, ret);
			return ret;
		}
		
		void remove(Object key) {
			results.remove(key);
		}
	}
	
	private ThreadLocal visitorStackTL=new ThreadLocal() {
		
		protected Object initialValue() {
			return new VisitorStack();
		}
	};
	
	private int size;
	
	public VisitorStack getVisitorStack() {
		return (VisitorStack) visitorStackTL.get();
	}
	
	public boolean visit(Object target) {
		getVisitorStack().push(target);
		Iterator lit=listeners.iterator();
		while (lit.hasNext()) {
			((Listener) lit.next()).onVisit(target);
		}
		
		if (handlerList.isEmpty()) {
			return false;
		}
		
		stats.addVisit();
		((StatsImpl) threadStats.get()).addVisit();
		
		if (target!=null) {
			// Verify target first.

			Iterator it=getVerifyHandlers(target.getClass()).iterator();
			while (it.hasNext()) {
				if (Boolean.FALSE.equals(((InvocationHandler) it.next()).invoke(target))) {
					return false;
				}
			}			
			
			// Invoke visit methods.

			it=getHandlers(target.getClass()).iterator();
			while (it.hasNext()) {
				InvocationHandler ih=(InvocationHandler) it.next();
				Object ret=ih.invoke(target);
				if (Boolean.FALSE.equals(ret)) {
					return false;
				}
				
				if (ret!=null && ih.returnsValue) {
					processReturnValue(ih.object, ih.method, target, ret);
				}
			}
		}
		
		return true;
	}
	
	public Collection getTargets() {
		return targets;
	}
	
	/**
	 * Passes return values back to visitor.
	 * Arrays and collections are iterated and individual elements are passed to the visitor.
	 * Override this method to process return values in a different way.
	 * @param target - Object which method was invoked
	 * @param method - Method which was invoked
	 * @param argument - Method argument
	 * @param returnValue - Return value
	 */
	protected void processReturnValue(Object target, Method method, Object argument, Object returnValue) {
		if (returnValue instanceof Collection) {
			Iterator it=((Collection) returnValue).iterator();
			while (it.hasNext()) {
				VisitableBase.object2visitor(it.next(), this);
			}
		} else if (returnValue.getClass().isArray()) {
			for (int i=0,l=Array.getLength(returnValue);i<l;i++) {
				VisitableBase.object2visitor(Array.get(returnValue, i), this);
			}
		} else {
			VisitableBase.object2visitor(returnValue, this);
		}
	}
	
	/**
	 *
	 * @return total number of handlers
	 */
	public int size() {
		return size;
	}
	
	public Collection getClassesOfInterest() {
		return unmodifiableClassesOfInterest;
	}
	
	private void addClassOfInterest(Class clazz) {
		Iterator it=classesOfInterest.iterator();
		while (it.hasNext()) {
			Class cls=(Class) it.next();
			if (cls.isAssignableFrom(clazz)) {
				return;
			}
			
			if (clazz.isAssignableFrom(cls)) {
				it.remove();
			}
		}
		classesOfInterest.add(clazz);
	}

	/**
	 * @param targets
	 * @param exceptionSink
	 */
	public DispatchingVisitor(Collection targets, VisitorExceptionSink exceptionSink, Listener listener) {
		if (listener!=null) {
			listeners.add(listener);
		}
		this.targets = Collections.unmodifiableList(new LinkedList(targets));
		this.exceptionSink = exceptionSink;
		Iterator it=targets.iterator();
		while (it.hasNext()) {
			Object target=it.next();
			if (target instanceof DispatcherAware) {
				((DispatcherAware) target).setDispatcher(this);
			}
			
			Iterator lit=listeners.iterator();
			while (lit.hasNext()) {
				((Listener) lit.next()).onTargetRegistration(target);
			}
			
			boolean hasInvocations=false;
			Method[] methods=target.getClass().getMethods();			
			for (int i=0; i<methods.length; i++) {
				if (methods[i].getParameterTypes().length == 1) {
					Class returnType = methods[i].getReturnType();
					if (VISIT.equals(methods[i].getName()) && (void.class.equals(returnType) || boolean.class.equals(returnType))) {
						handlerList.add(new InvocationHandler(methods[i], target));
						hasInvocations=true;
					} else if (LEAVE.equals(methods[i].getName()) && void.class.equals(returnType)) {
						leaveHandlerList.add(new InvocationHandler(methods[i], target));
						hasInvocations=true;
					} else if (boolean.class.equals(returnType) && VERIFY.equals(methods[i].getName())) {
						verifyHandlerList.add(new InvocationHandler(methods[i], target));
						hasInvocations=true;						
					} else if (target instanceof Filter && !((Filter) target).getTargets().isEmpty() && APPROVE.equals(methods[i].getName()) && boolean.class.equals(returnType)) {
						filterHandlerList.add(new ApproveInvocationHandler(methods[i], target));
						hasInvocations=true;
					}
				}
			}			
			
			if (!hasInvocations) {
				lit=listeners.iterator();
				while (lit.hasNext()) {
					((Listener) lit.next()).noInvocationsWarning(target);
				}
			}
			
			if (target instanceof Listener) {
				listeners.add(target);
			}
		}
		
		assignFilters(handlerList);
		assignFilters(leaveHandlerList);
		
		size = handlerList.size()+leaveHandlerList.size();
	}		
	
	/**
	 *
	 */
	private void assignFilters(Collection handlers) {
		Iterator it=handlers.iterator();
		while (it.hasNext()) {
			InvocationHandler handler=(InvocationHandler) it.next();
			Iterator fit=filterHandlerList.iterator();
			while (fit.hasNext()) {
				ApproveInvocationHandler approveHandler=(ApproveInvocationHandler) fit.next();
				if (((Filter) approveHandler.object).getTargets().contains(handler.object)) {
					handler.addFilter(approveHandler);
				}
			}
			handler.commitFilters();
		}
	}

	public DispatchingVisitor(Collection targets, VisitorExceptionSink exceptionSink) {
		this(targets, exceptionSink, null);
	}
		
	/**
	 * @param target
	 * @param exceptionSink
	 */
	public DispatchingVisitor(Object target, VisitorExceptionSink exceptionSink) {
		this(Arrays.asList(new Object[] {target}), exceptionSink);
	}
	
	public DispatchingVisitor(Object target, VisitorExceptionSink exceptionSink, Listener listener) {
		this(Arrays.asList(new Object[] {target}), exceptionSink, listener);
	}
	
	/**
	 * @return Returns visitor statistics.
	 */
	public Stats getStats() {
		return stats;
	}

	public Stats getThreadStats() {
		Stats ret = (Stats) threadStats.get();
		return ret;
	}
		
	public void leave(Object target) {
		Iterator lit=listeners.iterator();
		while (lit.hasNext()) {
			((Listener) lit.next()).onLeave(target);
		}
		
		if (target!=null) {
			Iterator it=getLeaveHandlers(target.getClass()).iterator();
			while (it.hasNext()) {
				InvocationHandler ih=(InvocationHandler) it.next();
				Object ret=ih.invoke(target);
				
				if (ret!=null && ih.returnsValue) {
					processReturnValue(ih.object, ih.method, target, ret);
				}				
			}
			
			it=getFilterHandlers(target.getClass()).iterator();
			while (it.hasNext()) {
				((ApproveInvocationHandler) it.next()).remove(target);
			}
		}
		getVisitorStack().pop(target);
	}
	
	/**
	 * Removes object from targets collection.
	 * @param target
	 */
	public void remove(Object target) {
		Iterator it=handlerList.iterator();
		while (it.hasNext()) {
			InvocationHandler h=(InvocationHandler) it.next();
			if (h.object==target) {
				h.active=false;
			}
		}
		
		it=leaveHandlerList.iterator();
		while (it.hasNext()) {
			InvocationHandler h=(InvocationHandler) it.next();
			if (h.object==target) {
				h.active=false;
			}
		}
		
		it=verifyHandlerList.iterator();
		while (it.hasNext()) {
			InvocationHandler h=(InvocationHandler) it.next();
			if (h.object==target) {
				h.active=false;
			}
		}
	}

	/**
	 * Passes executionContext for visiting.
	 * Subclasses can override this method and
	 * queue object for execution and invoke
	 * accept/visit in a different thread.
	 */
	public void execute(Object executionContext) {
		if (executionContext instanceof Visitable) {
			((Visitable) executionContext).accept(this);
		} else {
			visit(executionContext);
		}
	}
}