001    /*
002    @license.text@
003     */
004    package biz.hammurapi.convert;
005    
006    import java.io.File;
007    import java.io.FileInputStream;
008    import java.io.FileReader;
009    import java.io.InputStream;
010    import java.io.InputStreamReader;
011    import java.io.Reader;
012    import java.lang.reflect.Constructor;
013    import java.math.BigDecimal;
014    import java.util.ArrayList;
015    import java.util.Collection;
016    import java.util.Collections;
017    import java.util.List;
018    
019    import biz.hammurapi.config.Context;
020    
021    
022    /**
023     * @author Pavel Vlasov
024     * @version $Revision: 1.7 $
025     */
026    public class FoundationAtomicConvertersBundle implements AtomicConvertersBundle {
027    
028            private List converters=new ArrayList();
029            
030            public Collection getConverters() {
031                    return Collections.unmodifiableCollection(converters);
032            }
033    
034        /**
035         * Creates new composite converter populated by default with some generic converters.
036         */
037        public FoundationAtomicConvertersBundle() {
038                    addConverter(Number.class, byte.class, "byteValue", null);
039                    addConverter(Number.class, double.class, "doubleValue", null);
040                    addConverter(Number.class, float.class, "floatValue", null);
041                    addConverter(Number.class, int.class, "intValue", null);
042                    addConverter(Number.class, long.class, "longValue", null);
043                    addConverter(Number.class, short.class, "shortValue", null);
044                    
045                    addConverter(Number.class, Byte.class, "byteValue", null);
046                    addConverter(Number.class, Double.class, "doubleValue", null);
047                    addConverter(Number.class, Float.class, "floatValue", null);
048                    addConverter(Number.class, Integer.class, "intValue", null);
049                    addConverter(Number.class, Long.class, "longValue", null);
050                    addConverter(Number.class, Short.class, "shortValue", null);
051                    
052                    converters.addAll(ReflectionConverter.discoverConstructorConverters(String.class));
053                    converters.addAll(ReflectionConverter.discoverConstructorConverters(Integer.class));
054                    converters.addAll(ReflectionConverter.discoverConstructorConverters(Long.class));
055                    converters.addAll(ReflectionConverter.discoverConstructorConverters(Double.class));
056                    converters.addAll(ReflectionConverter.discoverConstructorConverters(Float.class));
057                    converters.addAll(ReflectionConverter.discoverConstructorConverters(Byte.class));
058                    converters.addAll(ReflectionConverter.discoverConstructorConverters(Short.class));
059                    converters.addAll(ReflectionConverter.discoverConstructorConverters(BigDecimal.class));
060                    
061                    try {
062                            addConverter(File.class, Reader.class, null, FileReader.class.getConstructor(new Class[] {File.class}));
063                            addConverter(File.class, InputStream.class, null, FileInputStream.class.getConstructor(new Class[] {File.class}));
064                            addConverter(InputStream.class, Reader.class, null, InputStreamReader.class.getConstructor(new Class[] {InputStream.class}));
065                    } catch (SecurityException e) {
066                            throw new ConversionException(e);
067                    } catch (NoSuchMethodException e) {
068                            throw new ConversionException(e);
069                    }
070                    
071                    converters.add(new AtomicConverterBase(String.class, boolean.class) {
072    
073                            public Object convert(Object source, Converter master, Context context) {
074                                    if (source==null) {
075                                            return Boolean.FALSE;
076                                    }
077                                    
078                                    String str = ((String) source).trim();
079                                    if (str.length()==0 || "no".equalsIgnoreCase(str) || "false".equalsIgnoreCase(str) || "0".equals(source) || "".equals(source)) {
080                                            return Boolean.FALSE;
081                                    } else if ("yes".equalsIgnoreCase(str) || "true".equalsIgnoreCase(str) || "1".equals(source) || "on".equals(source)) {
082                                            return Boolean.TRUE;
083                                    } 
084                                    
085                                    return null;
086                            }
087                            
088                    });
089                    
090                    converters.add(new AtomicConverterBase(String.class, byte.class) {
091    
092                            public Object convert(Object source, Converter master, Context context) {
093                                    return new Byte((String) source);
094                            }
095                            
096                    });
097                    
098                    converters.add(new AtomicConverterBase(String.class, double.class) {
099    
100                            public Object convert(Object source, Converter master, Context context) {
101                                    return new Double((String) source);
102                            }
103                            
104                    });
105                    
106                    converters.add(new AtomicConverterBase(String.class, float.class) {
107    
108                            public Object convert(Object source, Converter master, Context context) {
109                                    return new Float((String) source);
110                            }
111                            
112                    });
113                    
114    
115                    converters.add(new AtomicConverterBase(String.class, int.class) {
116    
117                            public Object convert(Object source, Converter master, Context context) {
118                                    return new Integer((String) source);
119                            }
120                            
121                    });
122                    
123    
124                    converters.add(new AtomicConverterBase(String.class, long.class) {
125    
126                            public Object convert(Object source, Converter master, Context context) {
127                                    return new Long((String) source);
128                            }
129                            
130                    });
131                    
132    
133                    converters.add(new AtomicConverterBase(String.class, short.class) {
134    
135                            public Object convert(Object source, Converter master, Context context) {
136                                    return new Short((String) source);
137                            }
138                            
139                    });
140                                    
141                    converters.add(new AtomicConverterBase(String.class, Class.class) {
142    
143                            public Object convert(Object source, Converter master, Context context) {
144                                    try {
145                                            return Class.forName((String) source);
146                                    } catch (ClassNotFoundException e) {
147                                            throw new ConversionException(e);
148                                    }
149                            }
150                            
151                    });             
152                    
153        }
154                    
155            private void addConverter(Class source, Class target, String accessor, Constructor constructor) {
156                    try {
157                            converters.add(new ReflectionConverter(accessor==null ? null : source.getMethod(accessor, null), constructor));
158                    } catch (Exception e) {
159                            throw new ConversionException(e);
160                    }
161            }
162                    
163    }