Variant.java

Violations

Source code

package biz.hammurapi.sql;

import java.io.Serializable;
import java.lang.reflect.Method;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import biz.hammurapi.sql.columns.ObjectColumn;

/**
 * Wrapper for different types.
 * @author Pavel
 */
public class Variant implements Parameterizer, Serializable {
	
	private static final int TYPE_BOOLEAN = 0;
	private static final int TYPE_BYTE = 1;
	private static final int TYPE_CHAR = 2;
	private static final int TYPE_DOUBLE = 3;
	private static final int TYPE_FLOAT = 4;
	private static final int TYPE_INT = 5;
	private static final int TYPE_LONG = 6;
	private static final int TYPE_STRING = 7;
	private static final int TYPE_OBJECT = 8;
	private static final int TYPE_TYPED_OBJECT = 9;
	private static final int TYPE_SHORT = 10;

	private int type;
	
	private boolean booleanValue;
	private byte byteValue;
	private char charValue;
	private double doubleValue;
	private float floatValue;
	private int intValue;
	private long longValue;
	private String stringValue;
	private Object objectValue;
	private int sqlType;
	private short shortValue;
	
	public Variant(boolean value) {
		type = TYPE_BOOLEAN;
		this.booleanValue = value;
	}

	public Variant(byte value) {
		type = TYPE_BYTE;
		this.byteValue = value;
	}

	public Variant(char value) {
		type = TYPE_CHAR;
		this.charValue = value;
	}

	public Variant(double value) {
		type = TYPE_DOUBLE;
		this.doubleValue = value;
	}

	public Variant(float value) {
		type = TYPE_FLOAT;
		this.floatValue = value;
	}

	public Variant(int value) {
		type = TYPE_INT;
		this.intValue = value;
	}

	public Variant(long value) {
		type = TYPE_LONG;
		this.longValue = value;
	}

	public Variant(String value) {
		type = TYPE_STRING;
		this.stringValue = value;
	}

	public Variant(Object value) {
		type = TYPE_OBJECT;
		this.objectValue = value;
	}

	public Variant(Object value, int sqlType) {
		type = TYPE_TYPED_OBJECT;
		this.objectValue = value;
		this.sqlType = sqlType;
	}
	
	public Variant(short value) {
		type = TYPE_SHORT;
		this.shortValue = value;
	}
	
	public int parameterize(PreparedStatement ps, int idx) throws SQLException {
		switch (type) {
			case TYPE_BOOLEAN:
				ps.setBoolean(idx++, booleanValue);
				break;				
			case TYPE_BYTE:
				ps.setByte(idx++, byteValue);
				break;				
			case TYPE_CHAR:
				ps.setString(idx++, ""+charValue);
				break;				
			case TYPE_DOUBLE:
				ps.setDouble(idx++, doubleValue);
				break;				
			case TYPE_FLOAT:
				ps.setFloat(idx++, floatValue);
				break;				
			case TYPE_INT:
				ps.setInt(idx++, intValue);
				break;				
			case TYPE_LONG:
				ps.setLong(idx++, longValue);
				break;				
			case TYPE_STRING:
				ps.setString(idx++, stringValue);
				break;				
			case TYPE_OBJECT:
				Method setter = ObjectColumn.findSetter(objectValue.getClass());
				if ("setObject".equals(setter.getName())) {
					ps.setObject(idx++, objectValue);
				} else {
					try {
						setter.invoke(ps, new Object[] {new Integer(idx++), objectValue});
					} catch (Exception e) {
						Throwable cause = e;
						while (cause.getCause()!=null && cause.getCause()!=cause) {
							cause = cause.getCause();
						}
						if (cause instanceof SQLException) {
							throw (SQLException) cause;
						} else {
							throw new SQLRuntimeException(e);
						}
					}
				}
				break;				
			case TYPE_TYPED_OBJECT:
				ps.setObject(idx++, objectValue, sqlType);
				break;				
			case TYPE_SHORT:
				ps.setShort(idx++, shortValue);
				break;				
			default:
				throw new SQLException("Unrecognized value type: "+type);
		} 
		return idx;
	}

	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + (booleanValue ? 1231 : 1237);
		result = prime * result + charValue;
		long temp;
		temp = Double.doubleToLongBits(doubleValue);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		result = prime * result + Float.floatToIntBits(floatValue);
		result = prime * result + intValue;
		result = prime * result + (int) (longValue ^ (longValue >>> 32));
		result = prime * result
				+ ((objectValue == null) ? 0 : objectValue.hashCode());
		result = prime * result + shortValue;
		result = prime * result + sqlType;
		result = prime * result
				+ ((stringValue == null) ? 0 : stringValue.hashCode());
		result = prime * result + type;
		return result;
	}

	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		final Variant other = (Variant) obj;
		if (booleanValue != other.booleanValue)
			return false;
		if (byteValue != other.byteValue)
			return false;
		if (charValue != other.charValue)
			return false;
		if (Double.doubleToLongBits(doubleValue) != Double
				.doubleToLongBits(other.doubleValue))
			return false;
		if (Float.floatToIntBits(floatValue) != Float
				.floatToIntBits(other.floatValue))
			return false;
		if (intValue != other.intValue)
			return false;
		if (longValue != other.longValue)
			return false;
		if (objectValue == null) {
			if (other.objectValue != null)
				return false;
		} else if (!objectValue.equals(other.objectValue))
			return false;
		if (shortValue != other.shortValue)
			return false;
		if (sqlType != other.sqlType)
			return false;
		if (stringValue == null) {
			if (other.stringValue != null)
				return false;
		} else if (!stringValue.equals(other.stringValue))
			return false;
		if (type != other.type)
			return false;
		return true;
	}

}