/*
The contents of this file are subject to the Common Public Attribution License
Version 1.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.projity.com/license . The License is based on the Mozilla Public
License Version 1.1 but Sections 14 and 15 have been added to cover use of
software over a computer network and provide for limited attribution for the
Original Developer. In addition, Exhibit A has been modified to be consistent
with Exhibit B.
Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the
specific language governing rights and limitations under the License. The
Original Code is OpenProj. The Original Developer is the Initial Developer and
is Projity, Inc. All portions of the code written by Projity are Copyright (c)
2006, 2007. All Rights Reserved. Contributors Projity, Inc.
Alternatively, the contents of this file may be used under the terms of the
Projity End-User License Agreeement (the Projity License), in which case the
provisions of the Projity License are applicable instead of those above. If you
wish to allow use of your version of this file only under the terms of the
Projity License and not to allow others to use your version of this file under
the CPAL, indicate your decision by deleting the provisions above and replace
them with the notice and other provisions required by the Projity License. If
you do not delete the provisions above, a recipient may use your version of this
file under either the CPAL or the Projity License.
[NOTE: The text of this license may differ slightly from the text of the notices
in Exhibits A and B of the license at http://www.projity.com/license. You should
use the latest text at http://www.projity.com/license for your modifications.
You may not remove this license text from the source files.]
Attribution Information: Attribution Copyright Notice: Copyright � 2006, 2007
Projity, Inc. Attribution Phrase (not exceeding 10 words): Powered by OpenProj,
an open source solution from Projity. Attribution URL: http://www.projity.com
Graphic Image as provided in the Covered Code as file: openproj_logo.png with
alternatives listed on http://www.projity.com/logo
Display of Attribution Information is required in Larger Works which are defined
in the CPAL as a work which combines Covered Code or portions thereof with code
not governed by the terms of the CPAL. However, in addition to the other notice
obligations, all copies of the Covered Code in Executable and Source Code form
distributed must, as a form of attribution of the original author, include on
each user interface screen the "OpenProj" logo visible to all users. The
OpenProj logo should be located horizontally aligned with the menu bar and left
justified on the top left of the screen adjacent to the File menu. The logo
must be at least 100 x 25 pixels. When users click on the "OpenProj" logo it
must direct them back to http://www.projity.com.
*/
package com.projity.field;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import org.apache.commons.beanutils.ConversionException;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.Converter;
import com.projity.datatype.Duration;
import com.projity.datatype.DurationFormat;
import com.projity.datatype.Money;
import com.projity.datatype.Work;
import com.projity.options.EditOption;
import com.projity.strings.Messages;
import com.projity.util.DateTime;
/**
* This class decorates ConvertUtils to use Projity specific types and validation
*/
public class FieldConverter {
HashMap<FieldContext,HashMap<Class,Converter>> contextMaps = new HashMap<FieldContext,HashMap<Class,Converter>>();
private StringConverter stringConverter;
private StringConverter compactStringConverter;
public static String toString(Object value, Class clazz, FieldContext context ) {
return getInstance()._toString(value,clazz,context);
}
public static String toString(Object value ) {
return getInstance()._toString(value,value.getClass(),null);
}
public static Object fromString(String value, Class clazz) {
return ConvertUtils.convert(value, clazz);
}
/**
* Convert from an object, usually a string, into another object
* @param value. Convert from this value
* @param clazz. Convert to this clazz type.
* @param context Converter context to use
* @return object of type clazz.
* @throws FieldParseException
*/
public static Object convert(Object value, Class clazz, FieldContext context) throws FieldParseException {
return getInstance()._convert(value,clazz,context);
}
private static FieldConverter instance = null;
public static FieldConverter getInstance() {
if (instance == null)
instance = new FieldConverter();
return instance;
}
public static void reinitialize() {
instance = null;
}
/**
*
* @param value. Convert from this value
* @param clazz. Convert to this clazz type.
* @return object of type clazz.
* @throws FieldParseException
*/
private Object _convert(Object value, Class clazz, FieldContext context) throws FieldParseException {
try {
if (value instanceof String) {
Object result = null;
if (context == null)
result = ConvertUtils.convert((String) value,clazz);
else {
Converter contextConverter = null;
HashMap<Class,Converter> contextMap = contextMaps.get(context);
if (contextMap != null)
contextConverter = contextMap.get(clazz);
if (contextConverter != null) {
contextConverter.convert(clazz,value);
} else {
System.out.println("no context converter found ");
result = ConvertUtils.convert((String) value,clazz);
}
}
// if (result instanceof java.util.Date) { // dates need to be normalized
// result = new Date(DateTime.gmt((Date) result));
// }
if (result == null) {
throw new FieldParseException("Invalid type");
}
return result;
}
// Because of stupidity of beanutils which assumes type string, I implement this by hand
Converter converter = ConvertUtils.lookup(clazz);
if (converter == null) {
System.out.println("converter is null for class " + clazz + " instance " + instance.hashCode() + " resetting") ;
instance = new FieldConverter();
converter = ConvertUtils.lookup(String.class);
}
return converter.convert(clazz, value);
} catch (ConversionException conversionException) {
throw new FieldParseException(conversionException);
}
}
private String _toString(Object value, Class clazz, FieldContext context) {
if (context == COMPACT_CONVERTER_CONTEXT)
return (String) compactStringConverter.convert(clazz, value);
else
return (String) stringConverter.convert(clazz, value);
}
public static final FieldContext COMPACT_CONVERTER_CONTEXT=new FieldContext();
static {
COMPACT_CONVERTER_CONTEXT.setCompact(true);
}
private FieldConverter() {
instance = this;
stringConverter = new StringConverter(false);
compactStringConverter = new StringConverter(true);
ConvertUtils.register(stringConverter, String.class); // Wrapper class
ConvertUtils.register(new DateConverter(), Date.class); // Wrapper class
ConvertUtils.register(new CalendarConverter(), GregorianCalendar.class); // Wrapper class
ConvertUtils.register(new DurationConverter(), Duration.class); // Wrapper class
ConvertUtils.register(new WorkConverter(), Work.class); // Wrapper class
ConvertUtils.register(new MoneyConverter(), Money.class); // Wrapper class
Converter longConverter = new LongConverter();
ConvertUtils.register(longConverter, Long.TYPE); // Native type
ConvertUtils.register(longConverter, Long.class); // Wrapper class
Converter doubleConverter = new DoubleConverter();
ConvertUtils.register(doubleConverter, Double.TYPE); // Native type
ConvertUtils.register(doubleConverter, Double.class); // Wrapper class
// short context converters
HashMap<Class,Converter> compactMap = new HashMap<Class,Converter>();
contextMaps.put(COMPACT_CONVERTER_CONTEXT, compactMap);
compactMap.put(String.class,compactStringConverter);
// no need for duration or money as parsing is done in long form
}
private static class StringConverter implements Converter {
private boolean compact = false;
StringConverter(boolean compact) {
this.compact = compact;
}
public Object convert(Class clazz, Object value) {
if (value instanceof Work) {
if (compact)
return ((DurationFormat)DurationFormat.getWorkInstance()).formatCompact(value);
else
return ((DurationFormat)DurationFormat.getWorkInstance()).format(value);
} else if (value instanceof Duration) {
if (compact)
return ((DurationFormat)DurationFormat.getInstance()).formatCompact(value);
else
return ((DurationFormat)DurationFormat.getInstance()).format(value);
} else if (value instanceof Money) {
return Money.formatCurrency(((Money)value).doubleValue(),compact);
} else if (value instanceof Date) {
if (value.equals(DateTime.getZeroDate()))
return null;
return EditOption.getInstance().getDateFormat().format(value);
} else {
if (value == null)
return null;
else
return value.toString();
}
}
}
// make a converter for long that can process dates and durations
private static class LongConverter implements Converter {
Converter baseConverter = new org.apache.commons.beanutils.converters.LongConverter();
public Object convert(Class type, Object value) throws ConversionException {
if (value == null)
return null;
if (value != null) {
if (value instanceof Date) {
return new Long(((Date)value).getTime());
} else if (value instanceof GregorianCalendar) {
return new Long(((GregorianCalendar)value).getTimeInMillis());
} else if (value instanceof Duration || value instanceof Work) {
return new Long(((Duration)value).getEncodedMillis());
}
}
return baseConverter.convert(type,value);
}
};
private static class DateConverter implements Converter {
public Object convert(Class type, Object value) throws ConversionException {
if (value == null)
return null;
if (value instanceof Long) {
long longValue = ((Long)value).longValue();
if (longValue == 0)
return null;
return new Date(longValue);
} else if (value instanceof Date) {
return value;
} else if (value instanceof Calendar) {
return ((Calendar)value).getTime();
} else if (value instanceof String) {
try {
return EditOption.getInstance().getDateFormat().parse((String)value);
} catch (ParseException e) {
try {
return DateTime.utcShortDateFormatInstance().parse((String)value); // try without time
} catch (ParseException e1) {
throw new ConversionException(Messages.getString("Message.invalidDate"));
}
}
}
throw new ConversionException("Error: no conversion from " + value.getClass().getName() + " to " + type.getName() + " for value" + value);
}
};
// GregorianCalendar converter
private static class CalendarConverter implements Converter {
private static DateConverter dateConverter = new DateConverter();
public Object convert(Class type, Object value) throws ConversionException {
GregorianCalendar cal = DateTime.calendarInstance();
if (value == null) {
return null;
} else if (value instanceof Long) {
long longValue = ((Long)value).longValue();
if (longValue == 0)
return null;
cal.setTimeInMillis(longValue);
return cal;
} else if (value instanceof Date) {
cal.setTime((Date)value);
return cal;
} else if (value instanceof String) {
Date d = (Date) dateConverter.convert(Date.class,value);
cal.setTime(d);
return cal;
}
throw new ConversionException("Error: no conversion from " + value.getClass().getName() + " to " + type.getName() + " for value" + value);
}
};
private static class DurationConverter implements Converter {
public Object convert(Class type, Object value) throws ConversionException {
if (value == null)
return Duration.getInstanceFromDouble(null);
if (value instanceof Number) {
return new Duration(((Number)value).longValue());
} else if (value instanceof Work) {
return new Duration(((Work)value).longValue());
} else if (value instanceof Duration) {
return value;
} else if (value instanceof String) {
try {
return DurationFormat.getInstance().parseObject((String) value);
} catch (ParseException e) {
throw new ConversionException(Messages.getString("Message.invalidDuration"));
}
}
throw new ConversionException("Error: no conversion from " + value.getClass().getName() + " to " + type.getName() + " for value" + value);
}
};
private static class WorkConverter implements Converter {
public Object convert(Class type, Object value) throws ConversionException {
if (value == null)
return Duration.getInstanceFromDouble(null);
if (value instanceof Number) {
return new Work(((Number)value).longValue());
} else if (value instanceof Work) {
return new Work(((Work)value).longValue());
} else if (value instanceof Duration) {
return value;
} else if (value instanceof String) {
try {
return DurationFormat.getWorkInstance().parseObject((String) value);
} catch (ParseException e) {
throw new ConversionException(Messages.getString("Message.invalidDuration"));
}
}
throw new ConversionException("Error: no conversion from " + value.getClass().getName() + " to " + type.getName() + " for value" + value);
}
};
private static class DoubleConverter implements Converter {
Converter baseConverter = new org.apache.commons.beanutils.converters.DoubleConverter();
public Object convert(Class type, Object value) throws ConversionException {
if (value != null) {
if (value instanceof Double) {
return value;
} else if (value instanceof Money) {
double num = ((Number)value).doubleValue();
if (Double.isInfinite(num) || Double.isNaN(num)) {
System.out.println("Error: number is invalid double in MoneyConverter " +value );
num = 0.0;
}
return new Double(num);
}
}
return baseConverter.convert(type,value);
}
};
/* TODO I have also experimented with the JADE library's Money class. It is probably more useful
* for performing currency conversions than as a datatype. A possible source for currency exchange rates is the
* web service here:
* http://www.bindingpoint.com/service.aspx?skey=377e6659-061f-4956-8edb-19b5023bc33b
*
*/
private static class MoneyConverter implements Converter {
public Object convert(Class type, Object value) throws ConversionException {
if (value == null)
return Money.getInstance(0);
if (value instanceof Money) {
return value;
} else if (value instanceof Number) {
double num = ((Number)value).doubleValue();
if (Double.isInfinite(num) || Double.isNaN(num)) {
System.out.println("Error: number is invalid double in MoneyConverter " +value );
num = 0.0;
}
return Money.getInstance(num);
} else if (value instanceof String) {
try {
return Money.getFormat(false).parseObject((String) value);
} catch (ParseException e) {
throw new ConversionException(Messages.getString("Message.invalidDuration"));
}
}
throw new ConversionException("Error: no conversion from " + value.getClass().getName() + " to " + type.getName() + " for value" + value);
}
}
}