InterfaceProjector.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.sql;

import java.io.Serializable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.w3c.dom.Element;

import biz.hammurapi.convert.ConvertingService;

/**
 * @author Pavel Vlasov
 * @version $Revision: 1.5 $
 */
public class InterfaceProjector extends BaseReflectionProjector implements Projector {
	private Class theInterface;
	private Object delegate;

	/**
	 * @param typeMap
	 * @param theInterface Iterface projected object should implement.
	 */
	public InterfaceProjector(Class theInterface, Map typeMap) {
		super(typeMap);
		this.theInterface=theInterface;
	}

	/**
	 * @param typeMap
	 * @param delegate Object to delegate unmatched calls to.
	 * @param theInterface Iterface projected object should implement.
	 */
	public InterfaceProjector(Class theInterface, Object delegate, Map typeMap) {
		super(typeMap);
		this.theInterface=theInterface;
		this.delegate=delegate;
	}
	
	private static Map primitivesMap=new HashMap();
	
	static {
		primitivesMap.put(int.class, java.lang.Integer.class);
		primitivesMap.put(boolean.class, java.lang.Boolean.class);
		primitivesMap.put(byte.class, java.lang.Byte.class);
		primitivesMap.put(char.class, java.lang.Character.class);
		primitivesMap.put(double.class, java.lang.Double.class);
		primitivesMap.put(float.class, java.lang.Float.class);
		primitivesMap.put(long.class, java.lang.Long.class);
		primitivesMap.put(short.class, java.lang.Short.class);
	}
	
	class ResultSetInvocationHandler implements InvocationHandler, Serializable {
		/**
		 * Comment for <code>serialVersionUID</code>
		 */
		private static final long serialVersionUID = -971624963614852201L;
		Map fieldMap;
		
		public ResultSetInvocationHandler(Map fieldMap) {
			this.fieldMap=fieldMap;
		}
		
		
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			if (method.getName().length()>3) {
				String key = method.getName().substring(3);
				if (method.getName().startsWith("get") && method.getParameterTypes().length==0 && fieldMap.containsKey(key)) {
					Class prt=(Class) primitivesMap.get(method.getReturnType());										
					Object value = fieldMap.get(key);
					if (value==null) {
						if (prt==null) {
							return null;
						}
						
						throw new IllegalArgumentException("Cannot convert 'null' to "+method.getReturnType());
					}
					
					Object ret = ConvertingService.convert(value, method.getReturnType());
					if (ret==null && prt!=null) {
						ret = ConvertingService.convert(value, prt);
					}
					
					if (ret==null) {
						throw new IllegalArgumentException(
								"Cannot convert " + 
								(value==null ? "null" : value.getClass()+" '"+value+"'") + 
								" to " + 
								method.getReturnType().getName());
					}
					
					return ret;
				} else if (method.getName().startsWith("set") && method.getParameterTypes().length==1 && fieldMap.containsKey(key)) {
					fieldMap.put(key, args[0]);
					return null;
				}
			}
			
			if ("toString".equals(method.getName()) && method.getParameterTypes().length==0) {
				StringBuffer ret=new StringBuffer(theInterface.getName());
				ret.append(" [");
				List fields=new ArrayList(fieldMap.keySet());
				Collections.sort(fields);
				Iterator it=fields.iterator();
				while (it.hasNext()) {
					ret.append(" ");
					String key=(String) it.next();
					ret.append(key);
					ret.append(" = ");
					ret.append(fieldMap.get(key));
					if (it.hasNext()) {
						ret.append(";");
					}
				}
				return ret.append(" ]").toString();
			}
			
			if ("toDom".equals(method.getName()) && method.getParameterTypes().length==1 && Element.class.isAssignableFrom(method.getParameterTypes()[0])) {
				Element holder=(Element) args[0];
				Iterator it=fieldMap.entrySet().iterator();
				while (it.hasNext()) {
					Map.Entry entry=(Entry) it.next();
					Element fieldElement=holder.getOwnerDocument().createElement((String) entry.getKey());
					holder.appendChild(fieldElement);
					if (entry.getValue()!=null) {
						fieldElement.setAttribute("type", entry.getValue().getClass().getName());
						fieldElement.appendChild(fieldElement.getOwnerDocument().createTextNode(entry.getValue().toString()));
					}
				}				
			}
			
			return (delegate==null ? fieldMap : delegate).getClass().getMethod(method.getName(), method.getParameterTypes()).invoke(delegate, args);
		}
		
	}	

	public Object project(ResultSet rs) throws SQLException {
		final Map fieldMap=new HashMap();
		for (int i=1, c=rs.getMetaData().getColumnCount(); i<=c; i++) {
			fieldMap.put(accessorName(rs.getMetaData().getColumnName(i)).substring(3), rs.getObject(i));
		}
				
		return Proxy.newProxyInstance(theInterface.getClassLoader(), new Class[] {theInterface}, new ResultSetInvocationHandler(fieldMap));
	}
}