plugins/org.eclipse.bpel.validator/src/org/eclipse/bpel/validator/tools/ParserTool.java - bpel/org.eclipse.bpel - Git at Google

 /*******************************************************************************
  * Copyright (c) 2006 Oracle Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Oracle Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.bpel.validator.tools;

 import java.text.SimpleDateFormat;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.GregorianCalendar;
 import java.util.Locale;
 import java.util.TimeZone;

 import javax.xml.namespace.QName;

 /**
  * @author Michal Chmielewski (michal.chmielewski@oracle.com)
  * @author Glenn Mi (glenn.me@oracle.com)
  *
  * @date Sep 29, 2006
  *
  */
 public class ParserTool {

 	private static final Locale INTERNAL_PARSE_LOCALE = Locale.US;

 	private static final Locale INTERNAL_CAL_LOCALE = Locale.US;

 	private static SimpleDateFormat zulu = new SimpleDateFormat(
 			"yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", INTERNAL_PARSE_LOCALE); //$NON-NLS-1$

 	static {
 		zulu.setTimeZone(TimeZone.getDefault());
 	}

 	/**
 	 * Format date time string into the format:
 	 *  2005-04-04T14:59:11.302-08:00
 	 *
 	 * @param time
 	 * @return the formatted date time string.
 	 */

 	public static String getDateTimeString(long time) {
 		// 2005-04-04T14:59:11.302-08:00
 		SimpleDateFormat xmlDateFormat = new SimpleDateFormat(
 				"yyyy-MM-dd'T'HH:mm:ss.SSSZ", INTERNAL_PARSE_LOCALE); //$NON-NLS-1$
 		Calendar cal = Calendar.getInstance(INTERNAL_CAL_LOCALE);
 		cal.setTime(new Date(time));
 		String javaFmt = xmlDateFormat.format(cal.getTime());

 		int length = javaFmt.length();
 		String dt = javaFmt.substring(0, length - 2);

 		StringBuilder retVal = new StringBuilder(dt);
 		retVal.append(":"); //$NON-NLS-1$
 		retVal.append(javaFmt.substring(length - 2, length));

 		return retVal.toString();
 	}

 	public static String getDateString(long time) {
 		Calendar cal = Calendar.getInstance(INTERNAL_CAL_LOCALE);
 		cal.setTime(new Date(time));
 		SimpleDateFormat xmlDateFormat = new SimpleDateFormat(
 				"yyyy-MM-dd", INTERNAL_PARSE_LOCALE); //$NON-NLS-1$
 		return xmlDateFormat.format(cal.getTime());
 	}

 	/**
 	 * parse XML duration in the format of P1Y2M3DT10H30M12.3S
 	 *
 	 * @param src
 	 * @return ?
 	 * @throws IllegalArgumentException
 	 */

 	public static long parseDuration(String src)
 			throws IllegalArgumentException {
 		int years = 0;
 		int months = 0;
 		int days = 0;
 		int hours = 0;
 		int minutes = 0;
 		double seconds = 0.;

 		int idx = 0;
 		int idx2 = 0;
 		if (src.charAt(idx) != 'P')
 			throw new IllegalArgumentException(
 					"Duration has to start with 'P'."); //$NON-NLS-1$
 		idx++;

 		String dayPart = null;
 		String timePart = null;

 		idx2 = src.indexOf('T');
 		if (idx2 > 0) {
 			dayPart = src.substring(idx, idx2);
 			timePart = src.substring(idx2 + 1);
 		} else {
 			dayPart = src.substring(idx);
 		}

 		try {
 			String str;
 			if (dayPart != null && dayPart.length() > 0) {
 				// parse day part
 				idx = 0;

 				idx2 = dayPart.indexOf('Y');
 				if (idx2 > 0) {
 					str = dayPart.substring(idx, idx2);
 					years = Integer.parseInt(str);
 					idx = idx2 + 1;
 				}

 				idx2 = dayPart.indexOf('M');
 				if (idx2 > 0) {
 					str = dayPart.substring(idx, idx2);
 					months = Integer.parseInt(str);
 					idx = idx2 + 1;
 				}

 				idx2 = dayPart.indexOf('D');
 				if (idx2 > 0) {
 					str = dayPart.substring(idx, idx2);
 					days = Integer.parseInt(str);
 					idx = idx2 + 1;
 				}

 				if (dayPart.indexOf('H') >= 0 || dayPart.indexOf('S') >= 0)
 					throw new NumberFormatException();
 			}

 			if (timePart != null) {
 				// parse time part
 				idx = 0;

 				idx2 = timePart.indexOf('H');
 				if (idx2 > 0) {
 					str = timePart.substring(idx, idx2);
 					hours = Integer.parseInt(str);
 					idx = idx2 + 1;
 				}

 				idx2 = timePart.indexOf('M');
 				if (idx2 > 0) {
 					str = timePart.substring(idx, idx2);
 					minutes = Integer.parseInt(str);
 					idx = idx2 + 1;
 				}

 				idx2 = timePart.indexOf('S');
 				if (idx2 > 0) {
 					str = timePart.substring(idx, idx2);
 					seconds = Double.parseDouble(str);
 				}

 				if (timePart.indexOf('Y') >= 0 || timePart.indexOf('D') >= 0)
 					throw new NumberFormatException();
 			}
 		} catch (NumberFormatException e) {
 			throw new IllegalArgumentException(
 					"duration should be in the format of 'P1Y2M3DT10H30M12.3S'"); //$NON-NLS-1$
 		}

 		long duration = (long) (((((((years * 365 + months * 30) + days) * 24 + hours) * 60) + minutes) * 60 + seconds) * 1000);
 		return duration;
 	}

 	/**
 	 * Parse date string into a Date.
 	 *
 	 * @param dateStr
 	 * @return the date
 	 */

 	public static Date parseDate(String dateStr) {
 		try {
 			if( dateStr == null || dateStr.length() < 10 )
 				throw new NumberFormatException("badDateTime"); //$NON-NLS-1$

 			SimpleDateFormat df = new SimpleDateFormat(
 					"yyyy-MM-dd", INTERNAL_PARSE_LOCALE); //$NON-NLS-1$
 			return df.parse( dateStr );

 		} catch (Exception e) {
 			throw new NumberFormatException(e.toString());
 		}
 	}

 	public static Date parseDateFromLong(String longString) {
 		if (longString != null) {
 			return new Date(Long.parseLong(longString));
 		}
 		return null;
 	}

 	public static Calendar parseDateTimeFromLong(String longString) {
 		if (longString != null) {
 			Calendar calendar = Calendar.getInstance(INTERNAL_CAL_LOCALE);
 			calendar.setTime(new Date(Long.parseLong(longString)));
 			return calendar;
 		}
 		return null;
 	}

 	public static Calendar parseDateTime(String source) {
 		return parseDateAndTime(source);
 	}

 	/**
 	 * The simple deserializer provides most of the stuff. We just need to
 	 * override makeValue().
 	 *
 	 * @param source
 	 *            the source string to parse
 	 * @return the Calandar instance that the string was parsed into
 	 *
 	 */

 	public static Calendar parseDateAndTime(String source) {
 		if (source == null || isEmpty(source))
 			return null;

 		Calendar calendar = Calendar.getInstance(INTERNAL_CAL_LOCALE);
 		Date date;
 		boolean bc = false;

 		// validate fixed portion of format
 		if (source.charAt(0) == '+')
 			source = source.substring(1);

 		if (source.charAt(0) == '-') {
 			source = source.substring(1);
 			bc = true;
 		}
 		if (source.length() < 19) {
 			throw new NumberFormatException("badDateTime"); //$NON-NLS-1$
 		}

 		if (source.charAt(4) != '-' || source.charAt(7) != '-'
 				|| source.charAt(10) != 'T') {
 			throw new NumberFormatException("badDate"); //$NON-NLS-1$
 		}

 		if (source.charAt(13) != ':' || source.charAt(16) != ':') {
 			throw new NumberFormatException("badTime"); //$NON-NLS-1$
 		}

 		// convert what we have validated so far
 		try {
 			synchronized (zulu) {
 				date = zulu.parse((source.substring(0, 19) + ".000Z")); //$NON-NLS-1$
 			}
 		} catch (Exception e) {
 			throw new NumberFormatException(e.toString());
 		}

 		int pos = 19;

 		// parse optional milliseconds
 		if (pos < source.length() && source.charAt(pos) == '.') {
 			int milliseconds = 0;
 			int start = ++pos;
 			while (pos < source.length()
 					&& Character.isDigit(source.charAt(pos)))
 				pos++;

 			String decimal = source.substring(start, pos);
 			if (decimal.length() == 3)
 				milliseconds = Integer.parseInt(decimal);
 			else if (decimal.length() < 3)
 				milliseconds = Integer.parseInt((decimal + "000") //$NON-NLS-1$
 						.substring(0, 3));
 			else {
 				milliseconds = Integer.parseInt(decimal.substring(0, 3));
 				if (decimal.charAt(3) >= '5')
 					++milliseconds;
 			}

 			// add milliseconds to the current date
 			date.setTime(date.getTime() + milliseconds);
 		}

 		// parse optional timezone
 		if (pos + 5 < source.length()
 				&& (source.charAt(pos) == '+' || (source.charAt(pos) == '-'))) {
 			if (!Character.isDigit(source.charAt(pos + 1))
 					|| !Character.isDigit(source.charAt(pos + 2))
 					|| source.charAt(pos + 3) != ':'
 					|| !Character.isDigit(source.charAt(pos + 4))
 					|| !Character.isDigit(source.charAt(pos + 5))) {
 				throw new NumberFormatException("badTimezone"); //$NON-NLS-1$
 			}

 			// subtract milliseconds from current date to obtain GMT
 			// if (source.charAt(pos)=='+') milliseconds=-milliseconds;
 			// date.setTime(date.getTime()+milliseconds);
 			pos += 6;
 		}

 		if (pos < source.length() && source.charAt(pos) == 'Z') {
 			pos++;
 			// calendar.setTimeZone(TimeZone.getTimeZone("GMT"));
 		}

 		if (pos < source.length())
 			throw new NumberFormatException("badChars");

 		calendar.setTime(date);

 		// support dates before the Christian era
 		if (bc) {
 			calendar.set(Calendar.ERA, GregorianCalendar.BC);
 		}

 		return calendar;
 	}

 	public static float parseFloat(String floatStr) {
 		if (!isEmpty(floatStr)) {
 			return Float.parseFloat(floatStr);
 		}
 		return 0f;
 	}

 	public static double parseDouble(String value) {
 		String v = String.valueOf(value);
 		if (!isEmpty(v)) {
 			return Double.parseDouble(v);
 		}
 		return 0d;
 	}

 	public static int parseInt(String value) {
 		try {
 			if (!isEmpty(value)) {
 				value = String.valueOf(adjustResult(value));
 				return Integer.parseInt(value);
 			}
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		return 0;

 	}

 	public static boolean parseBoolean(String value) {
 		if (!isEmpty(value)) {
 			return Boolean.valueOf( value );
 		}
 		return false;
 	}

 	public static short parseShort(String value) {
 		if (!isEmpty(value)) {
 			value = String.valueOf(adjustResult(value));
 			return Short.parseShort(value);
 		}
 		return 0;
 	}

 	public static byte parseByte(String value) {
 		if (!isEmpty(value)) {
 			return Byte.parseByte(value);
 		}
 		return 0;
 	}

 	public static long parseLong(String value) {
 		if (!isEmpty(value)) {
 			return Long.parseLong(value);
 		}
 		return 0l;
 	}

 	public static char parseChar(String value) {
 		if (!isEmpty(value)) {
 			char arr[] = value.toCharArray();
 			return arr[0];
 		}
 		return 0;
 	}

 	public static Object convertToObject(double d) {
 		return Double.valueOf( d );
 	}

 	public static Object convertToObject(int d) {
 		return Integer.valueOf( d );
 	}

 	public static Object convertToObject(char d) {
 		return Character.valueOf( d );
 	}

 	public static Object convertToObject(byte d) {
 		return Byte.valueOf( d );
 	}

 	public static Object convertToObject(short d) {
 		return Short.valueOf( d );
 	}

 	public static Object convertToObject(long d) {
 		return Long.valueOf( d );
 	}

 	public static Object convertToObject(float d) {
 		return Float.valueOf( d );
 	}

 	public static Object convertToObject(Object d) {
 		return d;
 	}

 	public static String convertToXMLString(Object value) {
 		String xmlString = null;
 		if (value != null) {
 			// Conversion process:
 			// Object -> Object
 			// primitve -> String
 			//
 			Class type = value.getClass();
 			if (type.isPrimitive()) {
 				xmlString = primitiveToXMLString(value, type);
 			} else if (value instanceof QName) {
 				// calender
 				QName qname = (QName) value;
 				if (qname.getPrefix() != null && qname.getPrefix().length() > 0)
 					xmlString = qname.getPrefix() + ":" + qname.getLocalPart();
 				else
 					xmlString = qname.getLocalPart();
 			} else if (value instanceof Calendar) {
 				// calender
 				xmlString = calendarToXMLString((Calendar) value);
 			} else if (value instanceof Date) {
 				xmlString = dateToXMLString((Date) value);
 			}
 			// else if (value instanceof DateTimeBase)
 			// {
 			// xmlString = dateTimeToXMLString( (DateTimeBase) value );
 			// }
 			// else if (value instanceof Duration)
 			// {
 			// xmlString = durationToXMLString( (Duration) value );
 			// }
 			else {
 				xmlString = String.valueOf(value);
 			}

 		}
 		return xmlString;
 	}

 	// public static String durationToXMLString( Duration value )
 	// {
 	// return value != null ? value.toString() : "";
 	// }
 	//
 	// public static String dateTimeToXMLString( DateTimeBase value )
 	// {
 	// return value != null ? calendarToXMLString( value.toCalendar() ) : "";
 	// }
 	//
 	public static String dateToXMLString(Date value) {
 		return value != null ? getDateString(value.getTime()) : "";
 	}

 	public static String calendarToXMLString(Calendar value) {
 		return value != null ? getDateTimeString(value.getTime().getTime())
 				: "";
 	}

 	public static String primitiveToXMLString(Object primitiveObject, Class type) {
 		String xmlString = null;
 		if (type == Double.class) {
 			xmlString = ((Double) primitiveObject).toString();
 		} else if (type == Integer.class) {
 			xmlString = ((Integer) primitiveObject).toString();
 		} else if (type == Boolean.class) {
 			xmlString = ((Boolean) primitiveObject).toString();
 		} else if (type == Float.class) {
 			xmlString = ((Float) primitiveObject).toString();
 		} else if (type == Byte.class) {
 			xmlString = ((Byte) primitiveObject).toString();
 		} else if (type == Short.class) {
 			xmlString = ((Short) primitiveObject).toString();
 		} else if (type == Long.class) {
 			xmlString = ((Long) primitiveObject).toString();
 		} else if (type == Character.class) {
 			xmlString = ((Character) primitiveObject).toString();
 		}
 		return xmlString;
 	}

 	public static void main(String[] args) throws Exception {
 		// System.out.println(parseDuration(args[0]));

 		Date d = new Date();
 		String dtStr = getDateTimeString(d.getTime());
 		System.out.println("dateTime=" + dtStr);
 		Calendar cal = parseDateTime(dtStr);
 		System.out.println("cal is: " + cal);
 		System.out.println("date is: " + cal.getTime());
 		System.out.println("XML Datetime "
 				+ getDateTimeString(cal.getTime().getTime()));
 		System.out
 				.println("XML Date " + getDateString(cal.getTime().getTime()));

 	}

 	private static Object adjustResult(String result) {
 		if (result != null && result.indexOf(".") > 0) {
 			String dS = result;

 			int fracIndex = dS.indexOf(".");
 			String fr = dS.substring(fracIndex + 1, dS.length());
 			String in = dS.substring(0, fracIndex);
 			// fraction = (n - abs(n))
 			// if the fraction is 0 then assume that the result is an integer
 			// and construct an integer object and return it.
 			//
 			// TODO: FIXME Once we have schema types then we should do proper
 			// typed return value
 			// System.out.println("___________ fraction : " + fr );
 			// System.out.println("___________ before decimal : " + in );
 			Double d1 = new Double(fr);
 			if (d1.doubleValue() == 0) {
 				return new Integer(in);
 			}
 		}
 		return result;
 	}

 	/**
 	 * Returns true if the string is either null or contains just whitespace.
 	 */

 	static boolean isEmpty(String value) {
 		if (value == null || value.length() == 0) {
 			return true;
 		}
 		for (int i = 0, j = value.length(); i < j; i++) {
 			if (!Character.isWhitespace(value.charAt(i))) {
 				return false;
 			}
 		}
 		return true;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2006 Oracle Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* Oracle Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.bpel.validator.tools;

	import java.text.SimpleDateFormat;
	import java.util.Calendar;
	import java.util.Date;
	import java.util.GregorianCalendar;
	import java.util.Locale;
	import java.util.TimeZone;

	import javax.xml.namespace.QName;

	/**
	* @author Michal Chmielewski (michal.chmielewski@oracle.com)
	* @author Glenn Mi (glenn.me@oracle.com)
	*
	* @date Sep 29, 2006
	*
	*/
	public class ParserTool {

	private static final Locale INTERNAL_PARSE_LOCALE = Locale.US;

	private static final Locale INTERNAL_CAL_LOCALE = Locale.US;

	private static SimpleDateFormat zulu = new SimpleDateFormat(
	"yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", INTERNAL_PARSE_LOCALE); //$NON-NLS-1$

	static {
	zulu.setTimeZone(TimeZone.getDefault());
	}

	/**
	* Format date time string into the format:
	* 2005-04-04T14:59:11.302-08:00
	*
	* @param time
	* @return the formatted date time string.
	*/

	public static String getDateTimeString(long time) {
	// 2005-04-04T14:59:11.302-08:00
	SimpleDateFormat xmlDateFormat = new SimpleDateFormat(
	"yyyy-MM-dd'T'HH:mm:ss.SSSZ", INTERNAL_PARSE_LOCALE); //$NON-NLS-1$
	Calendar cal = Calendar.getInstance(INTERNAL_CAL_LOCALE);
	cal.setTime(new Date(time));
	String javaFmt = xmlDateFormat.format(cal.getTime());

	int length = javaFmt.length();
	String dt = javaFmt.substring(0, length - 2);

	StringBuilder retVal = new StringBuilder(dt);
	retVal.append(":"); //$NON-NLS-1$
	retVal.append(javaFmt.substring(length - 2, length));

	return retVal.toString();
	}

	public static String getDateString(long time) {
	Calendar cal = Calendar.getInstance(INTERNAL_CAL_LOCALE);
	cal.setTime(new Date(time));
	SimpleDateFormat xmlDateFormat = new SimpleDateFormat(
	"yyyy-MM-dd", INTERNAL_PARSE_LOCALE); //$NON-NLS-1$
	return xmlDateFormat.format(cal.getTime());
	}

	/**
	* parse XML duration in the format of P1Y2M3DT10H30M12.3S
	*
	* @param src
	* @return ?
	* @throws IllegalArgumentException
	*/

	public static long parseDuration(String src)
	throws IllegalArgumentException {
	int years = 0;
	int months = 0;
	int days = 0;
	int hours = 0;
	int minutes = 0;
	double seconds = 0.;

	int idx = 0;
	int idx2 = 0;
	if (src.charAt(idx) != 'P')
	throw new IllegalArgumentException(
	"Duration has to start with 'P'."); //$NON-NLS-1$
	idx++;

	String dayPart = null;
	String timePart = null;

	idx2 = src.indexOf('T');
	if (idx2 > 0) {
	dayPart = src.substring(idx, idx2);
	timePart = src.substring(idx2 + 1);
	} else {
	dayPart = src.substring(idx);
	}

	try {
	String str;
	if (dayPart != null && dayPart.length() > 0) {
	// parse day part
	idx = 0;

	idx2 = dayPart.indexOf('Y');
	if (idx2 > 0) {
	str = dayPart.substring(idx, idx2);
	years = Integer.parseInt(str);
	idx = idx2 + 1;
	}

	idx2 = dayPart.indexOf('M');
	if (idx2 > 0) {
	str = dayPart.substring(idx, idx2);
	months = Integer.parseInt(str);
	idx = idx2 + 1;
	}

	idx2 = dayPart.indexOf('D');
	if (idx2 > 0) {
	str = dayPart.substring(idx, idx2);
	days = Integer.parseInt(str);
	idx = idx2 + 1;
	}

	if (dayPart.indexOf('H') >= 0 \|\| dayPart.indexOf('S') >= 0)
	throw new NumberFormatException();
	}

	if (timePart != null) {
	// parse time part
	idx = 0;

	idx2 = timePart.indexOf('H');
	if (idx2 > 0) {
	str = timePart.substring(idx, idx2);
	hours = Integer.parseInt(str);
	idx = idx2 + 1;
	}

	idx2 = timePart.indexOf('M');
	if (idx2 > 0) {
	str = timePart.substring(idx, idx2);
	minutes = Integer.parseInt(str);
	idx = idx2 + 1;
	}

	idx2 = timePart.indexOf('S');
	if (idx2 > 0) {
	str = timePart.substring(idx, idx2);
	seconds = Double.parseDouble(str);
	}

	if (timePart.indexOf('Y') >= 0 \|\| timePart.indexOf('D') >= 0)
	throw new NumberFormatException();
	}
	} catch (NumberFormatException e) {
	throw new IllegalArgumentException(
	"duration should be in the format of 'P1Y2M3DT10H30M12.3S'"); //$NON-NLS-1$
	}

	long duration = (long) (((((((years * 365 + months * 30) + days) * 24 + hours) * 60) + minutes) * 60 + seconds) * 1000);
	return duration;
	}

	/**
	* Parse date string into a Date.
	*
	* @param dateStr
	* @return the date
	*/

	public static Date parseDate(String dateStr) {
	try {
	if( dateStr == null \|\| dateStr.length() < 10 )
	throw new NumberFormatException("badDateTime"); //$NON-NLS-1$

	SimpleDateFormat df = new SimpleDateFormat(
	"yyyy-MM-dd", INTERNAL_PARSE_LOCALE); //$NON-NLS-1$
	return df.parse( dateStr );

	} catch (Exception e) {
	throw new NumberFormatException(e.toString());
	}
	}

	public static Date parseDateFromLong(String longString) {
	if (longString != null) {
	return new Date(Long.parseLong(longString));
	}
	return null;
	}

	public static Calendar parseDateTimeFromLong(String longString) {
	if (longString != null) {
	Calendar calendar = Calendar.getInstance(INTERNAL_CAL_LOCALE);
	calendar.setTime(new Date(Long.parseLong(longString)));
	return calendar;
	}
	return null;
	}

	public static Calendar parseDateTime(String source) {
	return parseDateAndTime(source);
	}

	/**
	* The simple deserializer provides most of the stuff. We just need to
	* override makeValue().
	*
	* @param source
	* the source string to parse
	* @return the Calandar instance that the string was parsed into
	*
	*/

	public static Calendar parseDateAndTime(String source) {
	if (source == null \|\| isEmpty(source))
	return null;

	Calendar calendar = Calendar.getInstance(INTERNAL_CAL_LOCALE);
	Date date;
	boolean bc = false;

	// validate fixed portion of format
	if (source.charAt(0) == '+')
	source = source.substring(1);

	if (source.charAt(0) == '-') {
	source = source.substring(1);
	bc = true;
	}
	if (source.length() < 19) {
	throw new NumberFormatException("badDateTime"); //$NON-NLS-1$
	}

	if (source.charAt(4) != '-' \|\| source.charAt(7) != '-'
	\|\| source.charAt(10) != 'T') {
	throw new NumberFormatException("badDate"); //$NON-NLS-1$
	}

	if (source.charAt(13) != ':' \|\| source.charAt(16) != ':') {
	throw new NumberFormatException("badTime"); //$NON-NLS-1$
	}

	// convert what we have validated so far
	try {
	synchronized (zulu) {
	date = zulu.parse((source.substring(0, 19) + ".000Z")); //$NON-NLS-1$
	}
	} catch (Exception e) {
	throw new NumberFormatException(e.toString());
	}

	int pos = 19;

	// parse optional milliseconds
	if (pos < source.length() && source.charAt(pos) == '.') {
	int milliseconds = 0;
	int start = ++pos;
	while (pos < source.length()
	&& Character.isDigit(source.charAt(pos)))
	pos++;

	String decimal = source.substring(start, pos);
	if (decimal.length() == 3)
	milliseconds = Integer.parseInt(decimal);
	else if (decimal.length() < 3)
	milliseconds = Integer.parseInt((decimal + "000") //$NON-NLS-1$
	.substring(0, 3));
	else {
	milliseconds = Integer.parseInt(decimal.substring(0, 3));
	if (decimal.charAt(3) >= '5')
	++milliseconds;
	}

	// add milliseconds to the current date
	date.setTime(date.getTime() + milliseconds);
	}

	// parse optional timezone
	if (pos + 5 < source.length()
	&& (source.charAt(pos) == '+' \|\| (source.charAt(pos) == '-'))) {
	if (!Character.isDigit(source.charAt(pos + 1))
	\|\| !Character.isDigit(source.charAt(pos + 2))
	\|\| source.charAt(pos + 3) != ':'
	\|\| !Character.isDigit(source.charAt(pos + 4))
	\|\| !Character.isDigit(source.charAt(pos + 5))) {
	throw new NumberFormatException("badTimezone"); //$NON-NLS-1$
	}

	// subtract milliseconds from current date to obtain GMT
	// if (source.charAt(pos)=='+') milliseconds=-milliseconds;
	// date.setTime(date.getTime()+milliseconds);
	pos += 6;
	}

	if (pos < source.length() && source.charAt(pos) == 'Z') {
	pos++;
	// calendar.setTimeZone(TimeZone.getTimeZone("GMT"));
	}

	if (pos < source.length())
	throw new NumberFormatException("badChars");

	calendar.setTime(date);

	// support dates before the Christian era
	if (bc) {
	calendar.set(Calendar.ERA, GregorianCalendar.BC);
	}

	return calendar;
	}

	public static float parseFloat(String floatStr) {
	if (!isEmpty(floatStr)) {
	return Float.parseFloat(floatStr);
	}
	return 0f;
	}

	public static double parseDouble(String value) {
	String v = String.valueOf(value);
	if (!isEmpty(v)) {
	return Double.parseDouble(v);
	}
	return 0d;
	}

	public static int parseInt(String value) {
	try {
	if (!isEmpty(value)) {
	value = String.valueOf(adjustResult(value));
	return Integer.parseInt(value);
	}
	} catch (Exception e) {
	e.printStackTrace();
	}
	return 0;

	}

	public static boolean parseBoolean(String value) {
	if (!isEmpty(value)) {
	return Boolean.valueOf( value );
	}
	return false;
	}

	public static short parseShort(String value) {
	if (!isEmpty(value)) {
	value = String.valueOf(adjustResult(value));
	return Short.parseShort(value);
	}
	return 0;
	}

	public static byte parseByte(String value) {
	if (!isEmpty(value)) {
	return Byte.parseByte(value);
	}
	return 0;
	}

	public static long parseLong(String value) {
	if (!isEmpty(value)) {
	return Long.parseLong(value);
	}
	return 0l;
	}

	public static char parseChar(String value) {
	if (!isEmpty(value)) {
	char arr[] = value.toCharArray();
	return arr[0];
	}
	return 0;
	}

	public static Object convertToObject(double d) {
	return Double.valueOf( d );
	}

	public static Object convertToObject(int d) {
	return Integer.valueOf( d );
	}

	public static Object convertToObject(char d) {
	return Character.valueOf( d );
	}

	public static Object convertToObject(byte d) {
	return Byte.valueOf( d );
	}

	public static Object convertToObject(short d) {
	return Short.valueOf( d );
	}

	public static Object convertToObject(long d) {
	return Long.valueOf( d );
	}

	public static Object convertToObject(float d) {
	return Float.valueOf( d );
	}

	public static Object convertToObject(Object d) {
	return d;
	}

	public static String convertToXMLString(Object value) {
	String xmlString = null;
	if (value != null) {
	// Conversion process:
	// Object -> Object
	// primitve -> String
	//
	Class type = value.getClass();
	if (type.isPrimitive()) {
	xmlString = primitiveToXMLString(value, type);
	} else if (value instanceof QName) {
	// calender
	QName qname = (QName) value;
	if (qname.getPrefix() != null && qname.getPrefix().length() > 0)
	xmlString = qname.getPrefix() + ":" + qname.getLocalPart();
	else
	xmlString = qname.getLocalPart();
	} else if (value instanceof Calendar) {
	// calender
	xmlString = calendarToXMLString((Calendar) value);
	} else if (value instanceof Date) {
	xmlString = dateToXMLString((Date) value);
	}
	// else if (value instanceof DateTimeBase)
	// {
	// xmlString = dateTimeToXMLString( (DateTimeBase) value );
	// }
	// else if (value instanceof Duration)
	// {
	// xmlString = durationToXMLString( (Duration) value );
	// }
	else {
	xmlString = String.valueOf(value);
	}

	}
	return xmlString;
	}

	// public static String durationToXMLString( Duration value )
	// {
	// return value != null ? value.toString() : "";
	// }
	//
	// public static String dateTimeToXMLString( DateTimeBase value )
	// {
	// return value != null ? calendarToXMLString( value.toCalendar() ) : "";
	// }
	//
	public static String dateToXMLString(Date value) {
	return value != null ? getDateString(value.getTime()) : "";
	}

	public static String calendarToXMLString(Calendar value) {
	return value != null ? getDateTimeString(value.getTime().getTime())
	: "";
	}

	public static String primitiveToXMLString(Object primitiveObject, Class type) {
	String xmlString = null;
	if (type == Double.class) {
	xmlString = ((Double) primitiveObject).toString();
	} else if (type == Integer.class) {
	xmlString = ((Integer) primitiveObject).toString();
	} else if (type == Boolean.class) {
	xmlString = ((Boolean) primitiveObject).toString();
	} else if (type == Float.class) {
	xmlString = ((Float) primitiveObject).toString();
	} else if (type == Byte.class) {
	xmlString = ((Byte) primitiveObject).toString();
	} else if (type == Short.class) {
	xmlString = ((Short) primitiveObject).toString();
	} else if (type == Long.class) {
	xmlString = ((Long) primitiveObject).toString();
	} else if (type == Character.class) {
	xmlString = ((Character) primitiveObject).toString();
	}
	return xmlString;
	}

	public static void main(String[] args) throws Exception {
	// System.out.println(parseDuration(args[0]));

	Date d = new Date();
	String dtStr = getDateTimeString(d.getTime());
	System.out.println("dateTime=" + dtStr);
	Calendar cal = parseDateTime(dtStr);
	System.out.println("cal is: " + cal);
	System.out.println("date is: " + cal.getTime());
	System.out.println("XML Datetime "
	+ getDateTimeString(cal.getTime().getTime()));
	System.out
	.println("XML Date " + getDateString(cal.getTime().getTime()));

	}

	private static Object adjustResult(String result) {
	if (result != null && result.indexOf(".") > 0) {
	String dS = result;

	int fracIndex = dS.indexOf(".");
	String fr = dS.substring(fracIndex + 1, dS.length());
	String in = dS.substring(0, fracIndex);
	// fraction = (n - abs(n))
	// if the fraction is 0 then assume that the result is an integer
	// and construct an integer object and return it.
	//
	// TODO: FIXME Once we have schema types then we should do proper
	// typed return value
	// System.out.println("___________ fraction : " + fr );
	// System.out.println("___________ before decimal : " + in );
	Double d1 = new Double(fr);
	if (d1.doubleValue() == 0) {
	return new Integer(in);
	}
	}
	return result;
	}

	/**
	* Returns true if the string is either null or contains just whitespace.
	*/

	static boolean isEmpty(String value) {
	if (value == null \|\| value.length() == 0) {
	return true;
	}
	for (int i = 0, j = value.length(); i < j; i++) {
	if (!Character.isWhitespace(value.charAt(i))) {
	return false;
	}
	}
	return true;
	}
	}