KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > bsf > util > type > TypeConvertorRegistry


1 /*
2  * The Apache Software License, Version 1.1
3  *
4  * Copyright (c) 2002 The Apache Software Foundation. All rights
5  * reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  * notice, this list of conditions and the following disclaimer.
13  *
14  * 2. Redistributions in binary form must reproduce the above copyright
15  * notice, this list of conditions and the following disclaimer in
16  * the documentation and/or other materials provided with the
17  * distribution.
18  *
19  * 3. The end-user documentation included with the redistribution, if
20  * any, must include the following acknowlegement:
21  * "This product includes software developed by the
22  * Apache Software Foundation (http://www.apache.org/)."
23  * Alternately, this acknowlegement may appear in the software itself,
24  * if and wherever such third-party acknowlegements normally appear.
25  *
26  * 4. The names "Apache BSF", "Apache", and "Apache Software Foundation"
27  * must not be used to endorse or promote products derived from
28  * this software without prior written permission. For written
29  * permission, please contact apache@apache.org.
30  *
31  * 5. Products derived from this software may not be called "Apache"
32  * nor may "Apache" appear in their names without prior written
33  * permission of the Apache Group.
34  *
35  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
36  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
37  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
38  * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
39  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
41  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
42  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
43  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
44  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
45  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
46  * SUCH DAMAGE.
47  * ====================================================================
48  *
49  * This software consists of voluntary contributions made by many individuals
50  * on behalf of the Apache Software Foundation and was originally created by
51  * Sanjiva Weerawarana and others at International Business Machines
52  * Corporation. For more information on the Apache Software Foundation,
53  * please see <http://www.apache.org/>.
54  */

55
56 package org.apache.bsf.util.type;
57
58 import java.awt.Color JavaDoc;
59 import java.awt.Font JavaDoc;
60 import java.util.*;
61
62 /**
63  * The <em>TypeConvertorRegistry</em> is the registry of type convertors.
64  * It has lookup and register capabilities based on the types to be
65  * converted as well as by some object key.
66  *
67  * @author Sanjiva Weerawarana
68  * @author Matthew J. Duftler
69  * @see TypeConvertorRegistry
70  */

71 public class TypeConvertorRegistry {
72   Hashtable reg = new Hashtable ();
73   Hashtable keyedReg = new Hashtable ();
74
75   // register some standard convertors at construction time
76
public TypeConvertorRegistry () {
77     // no-op convertors: cvt from primitive wrappers to the object wrapper
78
TypeConvertor tc = new TypeConvertor () {
79       public Object JavaDoc convert (Class JavaDoc from, Class JavaDoc to, Object JavaDoc obj) {
80           return obj;
81       }
82         
83       public String JavaDoc getCodeGenString() {
84         return "(Class from, Class to, Object obj) {\n" +
85                "return obj;\n" +
86                "}";
87       }
88     };
89     register (Boolean JavaDoc.class, boolean.class, tc);
90     register (boolean.class, Boolean JavaDoc.class, tc);
91     register (Byte JavaDoc.class, byte.class, tc);
92     register (byte.class, Byte JavaDoc.class, tc);
93     register (Character JavaDoc.class, char.class, tc);
94     register (char.class, Character JavaDoc.class, tc);
95     register (Short JavaDoc.class, short.class, tc);
96     register (short.class, Short JavaDoc.class, tc);
97     register (Integer JavaDoc.class, int.class, tc);
98     register (int.class, Integer JavaDoc.class, tc);
99     register (Long JavaDoc.class, long.class, tc);
100     register (long.class, Long JavaDoc.class, tc);
101     register (Float JavaDoc.class, float.class, tc);
102     register (float.class, Float JavaDoc.class, tc);
103     register (Double JavaDoc.class, double.class, tc);
104     register (double.class, Double JavaDoc.class, tc);
105
106     // object to string: the registry special cases this one as the backup
107
// if the target is string and there is no special convertor available
108
// otherwise
109
tc = new TypeConvertor () {
110       public Object JavaDoc convert (Class JavaDoc from, Class JavaDoc to, Object JavaDoc obj) {
111           return (obj == null) ? "(null)" : obj.toString ();
112       }
113         
114         public String JavaDoc getCodeGenString() {
115         return "(Class from, Class to, Object obj) {\n" +
116                "return (obj == null) ? \"(null)\" : obj.toString ();\n" +
117                "}";
118         }
119     };
120     register (Object JavaDoc.class, String JavaDoc.class, tc);
121     
122     // convert strings to various primitives (both their object versions
123
// and wrappers for primitive versions)
124
tc = new TypeConvertor () {
125       public Object JavaDoc convert (Class JavaDoc from, Class JavaDoc to, Object JavaDoc obj) {
126         String JavaDoc str = (String JavaDoc) obj;
127         if (to == Boolean JavaDoc.class || to == boolean.class) {
128           return Boolean.valueOf (str);
129         } else if (to == Byte JavaDoc.class || to == byte.class) {
130           return Byte.valueOf (str);
131         } else if (to == Character JavaDoc.class || to == char.class) {
132           return new Character JavaDoc (str.charAt (0));
133         } else if (to == Short JavaDoc.class || to == short.class) {
134           return Short.valueOf (str);
135         } else if (to == Integer JavaDoc.class || to == int.class) {
136           return Integer.valueOf (str);
137         } else if (to == Long JavaDoc.class || to == long.class) {
138           return Long.valueOf (str);
139         } else if (to == Float JavaDoc.class || to == float.class) {
140           return Float.valueOf (str);
141         } else if (to == Double JavaDoc.class || to == double.class) {
142           return Double.valueOf (str);
143         } else {
144           return null;
145         }
146       }
147         
148         public String JavaDoc getCodeGenString() {
149         return "(Class from, Class to, Object obj) {\n" +
150                "String str = (String) obj;\n" +
151                "if (to == Boolean.class || to == boolean.class) {\n" +
152                "return Boolean.valueOf (str);\n" +
153                "} else if (to == Byte.class || to == byte.class) {\n" +
154                "return Byte.valueOf (str);\n" +
155                "} else if (to == Character.class || to == char.class) {\n" +
156                "return new Character (str.charAt (0));\n" +
157                "} else if (to == Short.class || to == short.class) {\n" +
158                "return Short.valueOf (str);\n" +
159                "} else if (to == Integer.class || to == int.class) {\n" +
160                "return Integer.valueOf (str);\n" +
161                "} else if (to == Long.class || to == long.class) {\n" +
162                "return Long.valueOf (str);\n" +
163                "} else if (to == Float.class || to == float.class) {\n" +
164                "return Float.valueOf (str);\n" +
165                "} else if (to == Double.class || to == double.class) {\n" +
166                "return Double.valueOf (str);\n" +
167                "} else {\n" +
168                "return null;\n" +
169                "}\n" +
170                "}";
171       }
172     };
173     register (String JavaDoc.class, boolean.class, tc);
174     register (String JavaDoc.class, Boolean JavaDoc.class, tc);
175     register (String JavaDoc.class, byte.class, tc);
176     register (String JavaDoc.class, Byte JavaDoc.class, tc);
177     register (String JavaDoc.class, char.class, tc);
178     register (String JavaDoc.class, Character JavaDoc.class, tc);
179     register (String JavaDoc.class, short.class, tc);
180     register (String JavaDoc.class, Short JavaDoc.class, tc);
181     register (String JavaDoc.class, int.class, tc);
182     register (String JavaDoc.class, Integer JavaDoc.class, tc);
183     register (String JavaDoc.class, long.class, tc);
184     register (String JavaDoc.class, Long JavaDoc.class, tc);
185     register (String JavaDoc.class, float.class, tc);
186     register (String JavaDoc.class, Float JavaDoc.class, tc);
187     register (String JavaDoc.class, double.class, tc);
188     register (String JavaDoc.class, Double JavaDoc.class, tc);
189
190     // strings to fonts
191
tc = new TypeConvertor () {
192       public Object JavaDoc convert (Class JavaDoc from, Class JavaDoc to, Object JavaDoc obj) {
193           return Font.decode ((String JavaDoc) obj);
194       }
195         
196       public String JavaDoc getCodeGenString() {
197         return "(Class from, Class to, Object obj) {\n" +
198                "return Font.decode ((String) obj);\n" +
199                "}";
200       }
201     };
202     register (String JavaDoc.class, Font JavaDoc.class, tc);
203
204     // strings to colors
205
tc = new TypeConvertor () {
206       public Object JavaDoc convert (Class JavaDoc from, Class JavaDoc to, Object JavaDoc obj) {
207           return Color.decode ((String JavaDoc) obj);
208       }
209         
210         public String JavaDoc getCodeGenString() {
211         return "(Class from, Class to, Object obj) {\n" +
212                "return Color.decode ((String) obj);\n" +
213                "}";
214         }
215     };
216     register (String JavaDoc.class, Color JavaDoc.class, tc);
217   }
218   // lookup a convertor
219
public TypeConvertor lookup (Class JavaDoc from, Class JavaDoc to) {
220     String JavaDoc key = from.getName () + " -> " + to.getName ();
221     TypeConvertor tc = (TypeConvertor) reg.get (key);
222     if (tc == null) {
223       Class JavaDoc objectClass = Object JavaDoc.class;
224       if (from != void.class
225           && from != Void JavaDoc.class
226           && to == String JavaDoc.class) {
227         // find the object -> string convertor
228
return lookup (Object JavaDoc.class, String JavaDoc.class);
229       }
230     }
231     return tc;
232   }
233   // lookup a convertor by key
234
public TypeConvertor lookupByKey (Object JavaDoc key) {
235     return (TypeConvertor) keyedReg.get (key);
236   }
237   // register a convertor
238
public void register (Class JavaDoc from, Class JavaDoc to, TypeConvertor convertor) {
239     String JavaDoc key = from.getName () + " -> " + to.getName ();
240     reg.put (key, convertor);
241   }
242   // register a convertor by key
243
public void registerByKey (Object JavaDoc key, TypeConvertor convertor) {
244     keyedReg.put (key, convertor);
245   }
246 }
247
Popular Tags