BeanVisitable.java

Violations

Source code

package biz.hammurapi.util;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;

/**
 * Wraps bean into visitable. Children are inferred from: <UL> <LI>getXXX methods which <UL><LI>Are declared in classes which belong to one of root packages or its sub-packages
 * </LI><LI>Have return type either collection or class (including arrays) belonging to one of root packages or its subpackages.</LI></UL>
 * <LI>Public fields of type belonging to one of root packages or subpackages (including arrays) or of collection type.</LI></UL>
 * @author Pavel Vlasov
 */
public class BeanVisitable implements Visitable {
	
	private Object bean;
	private String[] rootPackages;
	private Map trace;
	private Map parentMap;
	private Integer identity;
	
	public BeanVisitable(Object bean) {
		this(bean, packageName(bean.getClass()));
	}

	private static String packageName(Class clazz) {
		int idx = clazz.getName().lastIndexOf(".");
		return idx==-1 ? "" : clazz.getName().substring(0, idx);
	}

	/**
	 * @param bean Bean to visit
	 * @param rootPackage Package for child classes to visit.
	 */
	public BeanVisitable(Object bean, String rootPackage) {
		this(bean, new String[] {rootPackage});
	}
	
	/**
	 * @param bean Bean to visit
	 * @param rootPackages Packages for child classes to visit.
	 */
	public BeanVisitable(Object bean, String[] rootPackages) {
		this(bean, rootPackages, new HashMap(), new HashMap());
	}
	
	/**
	 * This constructor is used by BeanVisitable itself to wrap children into visitable.
	 * @param bean Bean to visit
	 * @param rootPackages Package for child classes to visit.
	 */
	protected BeanVisitable(Object bean, String[] rootPackages, Map trace, Map parentMap) {
		this.bean = bean;
		this.rootPackages = rootPackages;
		this.trace = trace;
		this.parentMap = parentMap;
		this.identity = new Integer(System.identityHashCode(bean));
	}
	
	protected boolean inTheRightPackage(Class clazz) {
		String name = clazz.getName();
		for (int i=0; i<rootPackages.length; ++i) {
			if (clazz.isArray()) {
				if (name.startsWith("[L"+rootPackages[i]+".")) {
					return true;
				}				
			} else {
				if (name.startsWith(rootPackages[i]+".")) {
					return true;
				}
			}
		}
		return false;
	}
	
	public boolean accept(Visitor visitor) {
		if (trace.containsKey(identity)) {
			return false;
		}
		trace.put(identity, bean);
		if (visitor.visit(bean)) {
		    Class beanClass=bean.getClass();
			final Object[] args = new Object[] {};
		    Method[] methods = beanClass.getMethods();
		    for (int i=0; i<methods.length; i++) {
		    	// getXXX() methods. Object.getClass() is not included.

		    	Method method = methods[i];
				if (!(void.class.equals(method.getReturnType()))
						&& (inTheRightPackage(method.getReturnType()) || Collection.class.isAssignableFrom(method.getReturnType()))
						&& inTheRightPackage(method.getDeclaringClass())
						&& Modifier.isPublic(method.getModifiers())
		    			&& !Modifier.isAbstract(method.getModifiers())
		    			&& !(method.getDeclaringClass().equals(Object.class)) 
		    			&& !Modifier.isStatic(method.getModifiers()) 
		    			&& method.getName().startsWith("get") 
		    			&& method.getParameterTypes().length==0) {
		    		try {
						Object value = method.invoke(bean, args);
						if (value instanceof Collection) {
							Iterator it = ((Collection) value).iterator();
							while (it.hasNext()) {
								wrap(it.next()).accept(visitor);
							}
						} else if (value.getClass().isArray()) {
							Iterator it = (Arrays.asList((Object[]) value)).iterator();
							while (it.hasNext()) {
								wrap(it.next()).accept(visitor);
							}							
						} else {
							wrap(value).accept(visitor);
						}						
					} catch (Exception e) {
				        handleAccessError(method, e);
					}
		    	}					    						    	
		    }
				    
		    Field[] fields = beanClass.getFields();
		    for (int i=0; i<fields.length; i++) {
		    	Field field = fields[i];
				if (!Modifier.isStatic(field.getModifiers()) 
						&& Modifier.isPublic(field.getModifiers())
						&& inTheRightPackage(field.getDeclaringClass())
						&& (inTheRightPackage(field.getType()) || Collection.class.isAssignableFrom(field.getType()))) {
		    		try {
						Object value = field.get(bean);
						if (value instanceof Collection) {
							Iterator it = ((Collection) value).iterator();
							while (it.hasNext()) {
								wrap(it.next()).accept(visitor);
							}
						} else if (value.getClass().isArray()) {
							Iterator it = (Arrays.asList((Object[]) value)).iterator();
							while (it.hasNext()) {
								wrap(it.next()).accept(visitor);
							}							
						} else {
							wrap(value).accept(visitor);
						}						
					} catch (Exception e) {
				        handleAccessError(fields[i], e);
					}
		    	}
		    }
		    
		    if (visitor instanceof PoliteVisitor) {
		    	((PoliteVisitor) visitor).leave(bean);
		    }
		}
		return false;
	}

	/**
	 * Prints stack trace to System.err. Override if necessary
	 * @param field
	 * @param e
	 */
	protected void handleAccessError(Field field, Exception e) {
		System.err.println("Error accessing field "+field);
		e.printStackTrace();		
	}

	/**
	 * Prints stack trace to System.err. Override if necessary
	 * @param method
	 * @param e
	 */
	protected void handleAccessError(Method method, Exception e) {
		System.err.println("Error accessing method "+method);
		e.printStackTrace();		
	}
	
	/**
	 * Wraps child into Visitable and updates path.
	 * If child is already instance of Visitable it is returned as is and path is not
	 * updated.
	 * @param child
	 * @return
	 */
	protected Visitable wrap(Object child) {
		if (child instanceof Visitable) {
			return (Visitable) child;
		}
		
		BeanVisitable ret = new BeanVisitable(child, rootPackages, trace, parentMap);
		parentMap.put(ret.identity, identity);
		return ret;
	}
	
	/**
	 * @return Path from given object to the root of the model, the given object included.
	 */
	public Object[] getPath(Object obj) {
		LinkedList path = new LinkedList();
		fillPath(path, obj);
		return path.toArray();		
	}

	private void fillPath(LinkedList path, Object obj) {
		path.addFirst(obj);
		Object parentKey = parentMap.get(new Integer(System.identityHashCode(obj)));
		if (parentKey!=null) {
			Object parent = trace.get(parentKey);
			if (parent!=null) {
				fillPath(path, parent);
			}
		}
		
	}
	
	/**
	 * @return System hash code of underlying bean
	 */
	public Integer getIdentity() {
		return identity;
	}

}