VisitableBase.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.Method;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import biz.hammurapi.convert.ConvertingService;


/**
 * Implements Visitable contract. Subclasses shall implement visitChildren() method.
 * @author Pavel Vlasov
 * @version $Revision: 1.4 $
 */
public abstract class VisitableBase implements Visitable, Searchable {
	
	public boolean accept(Visitor visitor) {
		if (visitor==null) {
			return false;
		}
		
		if (visitor.visit(this)) {
			acceptChildren(visitor);
			if (visitor instanceof PoliteVisitor) {
				((PoliteVisitor) visitor).leave(this);
			}
			return true;
		}
		
		return false;
	}
	
	public Object find(final Acceptor acceptor) {
		final Object[] ret = {null};
		accept(new Visitor() {

			public boolean visit(Object target) {
				if (ret[0]!=null) {
					return false;
				}
				
				if (acceptor.accept(target)) {
					ret[0] = target;
					return false;
				}
				return true;
			}
			
		});
		return ret[0];
	}

	public Collection findAll(final Acceptor acceptor) {
		final Collection ret = new ArrayList();
		accept(new Visitor() {

			public boolean visit(Object target) {				
				if (acceptor.accept(target)) {
					ret.add(target);
				}
				return true;
			}
			
		});
		return ret;
	}	

	/**
	 * Override this method to navigate visitor through object constituents.
	 * @param visitor
	 */
	protected void acceptChildren(Visitor visitor) {
		// No functionality

	}
		
	/**
	 * Properly handles passing visitor to a child - takes into account that child is visitable and visitor may
	 * be an instance of PoliteVisitor.
	 * @param target Object to be visited by the visitor.
	 * @param visitor
	 * @param child
	 */
	public static void object2visitor(Object target, Visitor visitor) {
		if (visitor!=null && target!=null) {
			if (target instanceof Visitable) {
				((Visitable) target).accept(visitor);
			} else if (target instanceof Collection) {
				if (visitor.visit(target)) {
					Iterator it = ((Collection) target).iterator();
					while (it.hasNext()) {
						object2visitor(it.next(), visitor);
					}
					if (visitor instanceof PoliteVisitor) {
						((PoliteVisitor) visitor).leave(target);
					}
				}
			} else if (target instanceof Map) {
				if (visitor.visit(target)) {
					Iterator it = ((Map) target).entrySet().iterator();
					while (it.hasNext()) {
						Map.Entry entry = (Map.Entry) it.next();
						if (visitor.visit(entry)) {
							object2visitor(entry.getKey(), visitor);
							object2visitor(entry.getValue(), visitor);
							if (visitor instanceof PoliteVisitor) {
								((PoliteVisitor) visitor).leave(entry);
							}
						}
					}
					if (visitor instanceof PoliteVisitor) {
						((PoliteVisitor) visitor).leave(target);
					}
				}
			} else if (target.getClass().isArray()) {
				if (visitor.visit(target)) {
					for (int i=0, l=Array.getLength(target); i<l; ++i) {
						object2visitor(Array.get(target, i), visitor);
					}
					if (visitor instanceof PoliteVisitor) {
						((PoliteVisitor) visitor).leave(target);
					}
				}				
			} else {
				Visitable converted = (Visitable) ConvertingService.convert(target, Visitable.class);
				if (converted == null) {
					if (visitor.visit(target) && visitor instanceof PoliteVisitor) {
						((PoliteVisitor) visitor).leave(target);
					}
				} else {
					converted.accept(visitor);
				}
			}
		}
	}
	
	/**
	 * Wraps object into instance of Searchable
	 * @param visitor
	 * @param child
	 */
	public static Searchable convert2searchable(final Object object) {
		return new Searchable() {

			public Object find(final Acceptor acceptor) {
				final Object[] ret = {null};
				object2visitor(object, new Visitor() {

					public boolean visit(Object target) {
						if (ret[0]!=null) {
							return false;
						}
						
						if (acceptor.accept(target)) {
							ret[0] = target;
							return false;
						}
						return true;
					}
					
				});
				return ret[0];
			}

			public Collection findAll(final Acceptor acceptor) {
				final Collection ret = new ArrayList();
				object2visitor(object, new Visitor() {

					public boolean visit(Object target) {				
						if (acceptor.accept(target)) {
							ret.add(target);
						}
						return true;
					}
					
				});
				return ret;
			}
			
		};
	}	
	
}