DBUtil.java

package me.xhh.hector07;

import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import me.prettyprint.cassandra.serializers.BooleanSerializer;
import me.prettyprint.cassandra.serializers.ByteBufferSerializer;
import me.prettyprint.cassandra.serializers.DateSerializer;
import me.prettyprint.cassandra.serializers.IntegerSerializer;
import me.prettyprint.cassandra.serializers.LongSerializer;
import me.prettyprint.cassandra.serializers.StringSerializer;
import me.prettyprint.cassandra.serializers.UUIDSerializer;
import me.prettyprint.hector.api.beans.HColumn;
import me.prettyprint.hector.api.beans.HSuperColumn;

import org.apache.cassandra.thrift.Column;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Utility for database operations
 * 
 * @author xhh
 */
public class DBUtil {

	public static StringSerializer STRING_SERIALIZER = StringSerializer.get();
	public static LongSerializer LONG_SERIALIZER = LongSerializer.get();
	public static UUIDSerializer UUID__SERIALIZER = UUIDSerializer.get();
	public static IntegerSerializer INT_SERIALIZER = IntegerSerializer.get();
	public static BooleanSerializer BOOL_SERIALIZER = BooleanSerializer.get();
	public static DateSerializer DATE_SERIALIZER = DateSerializer.get();
	public static ByteBufferSerializer BYTE_BUFFER_SERIALIZER = ByteBufferSerializer.get();

	private static final Logger log = LoggerFactory.getLogger(DBUtil.class);

	public static <SN, N, V> HColumn<N, V> getColumn(HSuperColumn<SN, N, V> superCol, N colName) {
		if (colName == null) {
			throw new RuntimeException("Column Name can not be null!");
		}
		if (superCol == null) {
			return null;
		}
		List<HColumn<N, V>> columns = superCol.getColumns();
		if (columns == null || columns.isEmpty()) {
			return null;
		}

		for (HColumn<N, V> c : columns) {
			if (colName.equals(c.getName())) {
				return c;
			}
		}

		return null;
	}

	public static <N, V> Map<N, V> columnsToMap(List<HColumn<N, V>> cols) {
		if (cols == null) {
			return new LinkedHashMap<N, V>(0);
		}
		LinkedHashMap<N, V> map = new LinkedHashMap<N, V>(cols.size());
		for (HColumn<N, V> c : cols) {
			if (c == null) {
				continue;
			}
			map.put(c.getName(), c.getValue());
		}
		return map;
	}

	/**
	 * @param colNames
	 *            column names to include
	 */
	public static <N, V> Map<N, V> columnsToMap(List<HColumn<N, V>> cols, List<N> colNames) {
		if (colNames == null) {
			return columnsToMap(cols);
		}
		if (cols == null) {
			return new LinkedHashMap<N, V>(0);
		}
		LinkedHashMap<N, V> map = new LinkedHashMap<N, V>(cols.size());
		for (HColumn<N, V> c : cols) {
			if (c == null) {
				continue;
			}
			N colName = c.getName();
			for (N each : colNames) {
				if (colName.equals(each.toString())) {
					map.put(colName, c.getValue());
					break;
				}
			}
		}
		return columnsToMap(cols);
	}

	public static boolean isTrue(String str) {
		return "1".equals(str) || "true".equalsIgnoreCase(str) || "yes".equalsIgnoreCase(str) || "on".equalsIgnoreCase(str);
	}

	public static boolean isFalse(String str) {
		return "0".equals(str) || "false".equalsIgnoreCase(str) || "no".equalsIgnoreCase(str) || "off".equalsIgnoreCase(str);
	}

	public static Boolean toBoolean(String str) {
		if (isTrue(str))
			return true;
		if (isFalse(str))
			return false;
		return null;
	}

	/**
	 * Convert boolean to string.
	 * 
	 * @return "0" for false, "1" for "true"
	 */
	public static String toString(Boolean b) {
		if (b == null)
			return null;
		else
			return b.booleanValue() ? "1" : "0";
	}

	public static String nullIfEmpty(String value) {
		return isValueEmpty(value) ? null : value;
	}

	/**
	 * @param date
	 * @return date.getTime(), or null if date is null
	 */
	public static Long date2Long(Date date) {
		return date == null ? null : date.getTime();
	}

	/**
	 * @param date
	 * @return string format of date.getTime() (the milliseconds since January 1, 1970, 00:00:00 GMT).<br/>
	 *         Null is returned if date is null.
	 */
	public static String date2Str(Date date) {
		return date == null ? null : String.valueOf(date.getTime());
	}

	/**
	 * @param time
	 *            the milliseconds since January 1, 1970, 00:00:00 GMT
	 * @return new Date(time), or null if "time" is null
	 */
	public static Date long2Date(Long time) {
		return time == null ? null : new Date(time);
	}

	public static <T extends Enum<T>> T str2Enum(Class<T> enumCls, String item) {
		if (enumCls == null || item == null)
			return null;

		try {
			return Enum.valueOf(enumCls, item);
		} catch (IllegalArgumentException e) {
			log.warn("str2Enum failed! Enum class: {}, item: {}", enumCls.getName(), item);
			return null;
		}
	}

	/**
	 * @param time
	 *            the milliseconds since January 1, 1970, 00:00:00 GMT, in String format
	 * @return null will be returned if "time" is null or an empty string
	 */
	public static Date str2Date(String time) {
		if (isValueEmpty(time))
			return null;
		try {
			return new Date(Long.parseLong(time));
		} catch (NumberFormatException e) {
			log.error("Bad time string: {} !!", time);
			return null;
		}
	}

	public static Integer str2Int(String intValue) {
		if (isValueEmpty(intValue))
			return null;
		try {
			return Integer.parseInt(intValue);
		} catch (NumberFormatException e) {
			log.error("Bad integer string: {} !!", intValue);
			return null;
		}
	}

	public static Double str2Double(String doubleValue) {
		if (isValueEmpty(doubleValue))
			return null;
		try {
			return Double.parseDouble(doubleValue);
		} catch (NumberFormatException e) {
			log.error("Bad double string: {} !!", doubleValue);
			return null;
		}
	}

	public static boolean isValueEmpty(String value) {
		return value == null || value.length() == 0;
	}

	public static boolean isColumnComplete(Column c) {
		return c.getName() != null && c.getValue() != null;
	}

	public static Long str2Long(String longValue) {
		if (isValueEmpty(longValue))
			return null;
		try {
			return Long.parseLong(longValue);
		} catch (NumberFormatException e) {
			log.error("Bad long string: {} !!", longValue);
			return null;
		}
	}

	/**
	 * @param value
	 * @return value.toString(), or empty string ("") if value if null
	 */
	public static String toStringDefaultEmpty(Object value) {
		return value == null ? "" : value.toString();
	}

}