ObjectColumn.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.columns;

import java.lang.reflect.Method;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;

import biz.hammurapi.config.Context;
import biz.hammurapi.convert.Converter;
import biz.hammurapi.convert.ConvertingService;
import biz.hammurapi.sql.SQLExceptionEx;


/**
 * @author Pavel Vlasov
 *
 * @version $Revision: 1.13 $
 */
public class ObjectColumn extends Column {
	private Object value;
	
	// Original stuff	

	private Object originalValue;
	private boolean isOriginalValueSet;
	
	public Object getOriginalValue() {
		return isOriginalValueSet ? originalValue : value;
	}
	
	public void parameterizeOriginal(PreparedStatement ps, int idx) throws SQLException {
		Object theOriginalValue=getOriginalValue();
		if (theOriginalValue==null) {
			ps.setNull(idx, sqlType==null ? java.sql.Types.NULL : sqlType.intValue());
		} else {		
			try {
				Method setter = findSetter(theOriginalValue.getClass());
				if ("setObject".equals(setter.getName())) {
					if (sqlType==null) {
						ps.setObject(idx, theOriginalValue);
					} else {
						ps.setObject(idx, theOriginalValue, sqlType.intValue());
					}
				} else {
					setter.invoke(ps, new Object[] {new Integer(idx), theOriginalValue});
				}
				return;
			} catch (SQLException e) {
				throw e;
			} catch (Exception e) {
				throw new SQLExceptionEx("Caused by: "+e, e);
			}
		}
	}
	
	public void setOriginal() {
		originalValue=value;
		isOriginalValueSet=true;
	}
	// End of original stuff

	
	private static final Collection ALL_SETTERS;

	private Integer sqlType;
	
	static {
		Collection allSetters=new LinkedList();
		for (int i=0, mc=PreparedStatement.class.getMethods().length; i<mc; i++) {
			Method m=PreparedStatement.class.getMethods()[i];
			if (m.getParameterTypes().length==2 && m.getParameterTypes()[0].equals(int.class) && m.getName().startsWith("set")) {
				allSetters.add(m);
			}			
		}
		ALL_SETTERS=Collections.unmodifiableCollection(allSetters);
	}


	/**
	 * @return Returns the value.
	 */
	public Object getValue() {
		return value;
	}
	
	/**
	 * @param value The value to set.
	 */
	public void setValue(Object value) {
		if (force || (this.value!=value && (this.value==null || !this.value.equals(value)))) {
			if (clazz!=null && value!=null && !clazz.isInstance(value)) {
				throw new ClassCastException("Invalid class "+value.getClass().getName()+", expected "+clazz.getName());
			}
			this.value = value;
			onChange();
		}
	}
	
	public void setSqlType(int sqlType) {
		this.sqlType=new Integer(sqlType);
	}
	
	/**
	 * @param name
	 * @param clazz Column class, can be null.
	 * @param isPrimaryKey
	 */
	public ObjectColumn(String name, Class clazz, boolean isPrimaryKey) {
		super(name, isPrimaryKey);
		this.clazz=clazz;
	}
	
	public ObjectColumn(String name, Class clazz, boolean isPrimaryKey, Object value) {
		super(name, isPrimaryKey);
		this.clazz=clazz;
		if (clazz!=null && value!=null && !clazz.isInstance(value)) {
			throw new ClassCastException("Invalid class "+value.getClass().getName()+", expected "+clazz.getName());
		}
		this.value=value;
	}
	
	public ObjectColumn(String name, Class clazz, boolean isPrimaryKey, ResultSet rs) throws SQLException {
		super(name, isPrimaryKey);
		this.clazz=clazz;
		ResultSetMetaData metaData = rs.getMetaData();
		for (int i=1, c=metaData.getColumnCount(); i<=c; i++) {
			if (name.equals(metaData.getColumnName(i))) {
				Object value = rs.getObject(i);
				if (clazz!=null && value!=null && !clazz.isInstance(value)) {
					throw new ClassCastException("Invalid class "+value.getClass().getName()+", expected "+clazz.getName());
				}
				this.value=value;
				break;
			}
		}
	}	
	
	private static Map setterMap=new HashMap();
	
	/**
	 * Finds parameter setter for object type
	 * @param type
	 * @return
	 */
	public static Method findSetter(Class type) {
		synchronized (setterMap) {
			String typeName = type.getName();
			Method ret=(Method) setterMap.get(typeName);
			if (ret==null) {
				int dotIdx=typeName.lastIndexOf('.');
				String shortName=typeName.substring(dotIdx+1, dotIdx+2).toUpperCase()+typeName.substring(dotIdx+2);
				
				// Name match

				Iterator it=ALL_SETTERS.iterator();
				while (it.hasNext()) {
					Method m=(Method) it.next();
					if (m.getName().equals("set"+shortName) && m.getParameterTypes()[1].getName().equals(typeName)) {
						setterMap.put(typeName, m);
						return m;
					}
				}
				
				Method candidate=null;
				// Parameter match

				it=ALL_SETTERS.iterator();
				while (it.hasNext()) {
					Method m=(Method) it.next();
					if (m.getParameterTypes()[1].isAssignableFrom(type)) {
						if (candidate==null || candidate.getParameterTypes()[1].isAssignableFrom(m.getParameterTypes()[1])) {
							candidate=m;
						}
					}
				}
								
				setterMap.put(typeName, candidate);
				return candidate;
			}
			
			return ret;
		}
	}

	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.columns.Column#parameterize(java.sql.PreparedStatement, int)
	 */
	protected void parameterizeInternal(PreparedStatement ps, int idx) throws SQLException {
		try {
			if (value==null) {
				ps.setNull(idx, sqlType==null ? java.sql.Types.NULL : sqlType.intValue());
			} else {		
				try {
					Method setter = findSetter(value.getClass());
					if ("setObject".equals(setter.getName())) {
						if (sqlType==null) {
							ps.setObject(idx, value);
						} else {
							ps.setObject(idx, value, sqlType.intValue());
						}
					} else {
						setter.invoke(ps, new Object[] {new Integer(idx), value});
					}
					return;
				} catch (SQLException e) {
					throw e;
				} catch (Exception e) {
					throw new SQLExceptionEx("Could not parameterize "+getName()+": "+e, e);
				}
			}
		} catch (SQLException e) {
			throw new SQLExceptionEx("Cannot parameterize. Value: "+value+", SQL Type: "+sqlType+", Cause: "+e, e);
		}
	}
	
	/**
	 * Parameterizes prepared statement. Automatically finds proper setter.
	 * @param ps
	 * @param value
	 * @param idx
	 * @throws SQLException
	 */
	public static void parameterize(PreparedStatement ps, Object value, int idx) throws SQLException {
		try {
			if (value==null) {
				ps.setNull(idx, java.sql.Types.NULL);
			} else {		
				try {
					Method setter = findSetter(value.getClass());
					if ("setObject".equals(setter.getName())) {
						ps.setObject(idx, value);
					} else {
						setter.invoke(ps, new Object[] {new Integer(idx), value});
					}
					return;
				} catch (SQLException e) {
					throw e;
				} catch (Exception e) {
					throw new SQLExceptionEx("Could not parameterize: "+e, e);
				}
			}
		} catch (SQLException e) {
			throw new SQLExceptionEx("Cannot parameterize. Value: "+value+", Cause: "+e, e);
		}
	}
	
	public Object getObjectValue(boolean ov) {
		if (ov) {
			return isOriginalValueSet ? originalValue : null;
		}
		return value;
	}
	
	public String toString() {
		return getName()+(isModified() ? "*" : "")+"("+(value==null ? "N/A" : value.getClass().getName())+")="+value;
	}
	
    public boolean equals(Object otherColumn) {
        if (!(otherColumn instanceof ObjectColumn)) {
            return false;
        }
        
		Object otherValue=((ObjectColumn) otherColumn).value;
		if (value==null) {
			return otherValue==null;
		}
		
		if (otherValue==null) {
		    return false;
		}
		
		return value.equals(otherValue);
    }
	
	public int hashCode() {
		return getName().hashCode() ^ (value==null ? 0 : value.hashCode());
	}

	public void load(String textValue) {
		if (clazz==null || textValue==null) {
			setValue(textValue);
		} else {
			setValue(ConvertingService.convert(textValue, clazz));
		}
	}
	
	public void clear() {
		setValue(null);
		clearModified();
	}
	
	private Class clazz;
	
	public void configure(Context context, Converter converter) {
		Object o=context.get(getName());
		if (o!=null) {
			setValue(clazz==null ? o : converter.convert(o, clazz, null));
		}		
	}		

	protected String getType() {
		return clazz==null ? "java.lang.Object" : clazz.getName();
	}	

	public void set(Column source) {
		setValue(((ObjectColumn) source).getValue());
	}		
	
    /**
     * Clears modified flag and sets original value to current value.
     */
    public void clearModified() {
    	super.clearModified();
    	originalValue=value;
    }
}