1 /* -------------------------------------------------------------------
2 * Java source file for the class PrimitiveToWrapperConverter
3 *
4 * Copyright (c), 2002, Masahiro Takatsuka.
5 * All Rights Researved.
6 *
7 * Original Author: Masahiro Takatsuka (masa@jbeans.net)
8 * $Author: takatsukam $
9 *
10 * $Date: 2003/07/25 04:51:45 $
11 *
12 * $Id: PrimitiveToWrapperConverter.java,v 1.1.1.1 2003/07/25 04:51:45 takatsukam Exp $
13 *
14 * Reference: Document no:
15 * ___ ___
16 *
17 * To Do:
18 * ___
19 *
20 ------------------------------------------------------------------- */
21
22 /* --------------------------- Package ---------------------------- */
23 package net.jbeans.data.converter;
24
25 /* ------------------ Import classes (packages) ------------------- *//package-summary/html">color="#329900"> ------------------ Import classes (packages) ------------------- *//package-summary.html">color="#329900">/* ------------------ Import classes (packages) ------------------- *//package-summary.html">color="#329900"> ------------------ Import classes (packages) ------------------- */
26 import net.jbeans.data.*;
27
28 /*====================================================================
29 Implementation of class PrimitiveToWrapperConverter
30 ====================================================================*/
31 /***
32 * generally describe PrimitiveToWrapperConverter in here
33 *
34 * @version $Revision: 1.1.1.1 $
35 * @author Masahiro Takatsuka (masa@jbeans.net)
36 * @see DataConverter
37 */
38
39 public final class PrimitiveToWrapperConverter extends DataConverter {
40 private static final int PRIMITIVE_TO_WRAPPER_COUNT = 7;
41
42 private static final int BYTE = 0;
43 private static final int DOUBLE = 1;
44 private static final int FLOAT = 2;
45 private static final int INTEGER = 3;
46 private static final int LONG = 4;
47 private static final int SHORT = 5;
48 private static final int BOOLEAN = 6;
49
50 /***
51 * Initializes acceptable soruce and target types.
52 */
53 protected void setDataTypes() {
54 this.sourceTypes = new Class[PRIMITIVE_TO_WRAPPER_COUNT];
55 this.sourceTypes[BYTE] = Byte.TYPE;
56 this.sourceTypes[DOUBLE] = Double.TYPE;
57 this.sourceTypes[FLOAT] = Float.TYPE;
58 this.sourceTypes[INTEGER] = Integer.TYPE;
59 this.sourceTypes[LONG] = Long.TYPE;
60 this.sourceTypes[SHORT] = Short.TYPE;
61 this.sourceTypes[BOOLEAN] = Boolean.TYPE;
62 this.targetTypes = new Class[PRIMITIVE_TO_WRAPPER_COUNT + 1];
63 this.targetTypes[BYTE] = java.lang.Byte.class;
64 this.targetTypes[DOUBLE] = java.lang.Double.class;
65 this.targetTypes[FLOAT] = java.lang.Float.class;
66 this.targetTypes[INTEGER] = java.lang.Integer.class;
67 this.targetTypes[LONG] = java.lang.Long.class;
68 this.targetTypes[SHORT] = java.lang.Short.class;
69 this.targetTypes[BOOLEAN] = java.lang.Boolean.class;
70 this.targetTypes[BOOLEAN + 1] = java.lang.Object.class;
71 }
72
73 /***
74 * Converts the specified object "obj" into an object of a class "class1".
75 */
76 protected Object convert(Object obj, Class class1) throws InvalidDataTypeException, UnsupportedTypeException {
77 System.out.println("PrimitiveToStringConverter: emtpy method");
78 return null;
79 }
80
81 public final Object convert(byte obj, String className) throws InvalidDataTypeException, UnsupportedTypeException {
82 try {
83 Class class1 = Class.forName(className);
84 if (! isTargetDataTypeSupported(class1)) {
85 throw new UnsupportedTypeException("PrimitiveToWrapper: Unsupported output type");
86 }
87 PrimitiveToStringConverter ps = new PrimitiveToStringConverter();
88 String str = ps.convert(obj, "java.lang.String");
89 BasicTypeConverter bt = new BasicTypeConverter();
90 if (class1 == java.lang.Object.class) {
91 return bt.convert(str, "java.lang.Byte");
92 } else {
93 return bt.convert(str, className);
94 }
95 } catch (ClassNotFoundException ex) {
96 ex.printStackTrace();
97 }
98
99 return null;
100 }
101
102 public final Object convert(double obj, String className) throws InvalidDataTypeException, UnsupportedTypeException {
103 try {
104 Class class1 = Class.forName(className);
105 if (! isTargetDataTypeSupported(class1)) {
106 throw new UnsupportedTypeException("PrimitiveToWrapper: Unsupported output type");
107 }
108 PrimitiveToStringConverter ps = new PrimitiveToStringConverter();
109 String str = ps.convert(obj, "java.lang.String");
110 BasicTypeConverter bt = new BasicTypeConverter();
111 if (class1 == java.lang.Object.class) {
112 return bt.convert(str, "java.lang.Double");
113 } else {
114 return bt.convert(str, className);
115 }
116 } catch (ClassNotFoundException ex) {
117 ex.printStackTrace();
118 }
119
120 return null;
121 }
122
123 public final Object convert(float obj, String className) throws InvalidDataTypeException, UnsupportedTypeException {
124 try {
125 Class class1 = Class.forName(className);
126 if (! isTargetDataTypeSupported(class1)) {
127 throw new UnsupportedTypeException("PrimitiveToWrapper: Unsupported output type");
128 }
129 PrimitiveToStringConverter ps = new PrimitiveToStringConverter();
130 String str = ps.convert(obj, "java.lang.String");
131 BasicTypeConverter bt = new BasicTypeConverter();
132 if (class1 == java.lang.Object.class) {
133 return bt.convert(str, "java.lang.Float");
134 } else {
135 return bt.convert(str, className);
136 }
137 } catch (ClassNotFoundException ex) {
138 ex.printStackTrace();
139 }
140 return null;
141 }
142
143 public final Object convert(int obj, String className) throws InvalidDataTypeException, UnsupportedTypeException {
144 try {
145 Class class1 = Class.forName(className);
146 if (! isTargetDataTypeSupported(class1)) {
147 throw new UnsupportedTypeException("PrimitiveToWrapper: Unsupported output type");
148 }
149 PrimitiveToStringConverter ps = new PrimitiveToStringConverter();
150 String str = ps.convert(obj, "java.lang.String");
151 BasicTypeConverter bt = new BasicTypeConverter();
152 if (class1 == java.lang.Object.class) {
153 return bt.convert(str, "java.lang.Integer");
154 } else {
155 return bt.convert(str, className);
156 }
157 } catch (ClassNotFoundException ex) {
158 ex.printStackTrace();
159 }
160 return null;
161 }
162
163 public final Object convert(long obj, String className) throws InvalidDataTypeException, UnsupportedTypeException {
164 try {
165 Class class1 = Class.forName(className);
166 if (! isTargetDataTypeSupported(class1)) {
167 throw new UnsupportedTypeException("PrimitiveToWrapper: Unsupported output type");
168 }
169 PrimitiveToStringConverter ps = new PrimitiveToStringConverter();
170 String str = ps.convert(obj, "java.lang.String");
171 BasicTypeConverter bt = new BasicTypeConverter();
172 if (class1 == java.lang.Object.class) {
173 return bt.convert(str, "java.lang.Long");
174 } else {
175 return bt.convert(str, className);
176 }
177 } catch (ClassNotFoundException ex) {
178 ex.printStackTrace();
179 }
180 return null;
181 }
182
183 public final Object convert(short obj, String className) throws InvalidDataTypeException, UnsupportedTypeException {
184 try {
185 Class class1 = Class.forName(className);
186 if (! isTargetDataTypeSupported(class1)) {
187 throw new UnsupportedTypeException("PrimitiveToWrapper: Unsupported output type");
188 }
189 PrimitiveToStringConverter ps = new PrimitiveToStringConverter();
190 String str = ps.convert(obj, "java.lang.String");
191 BasicTypeConverter bt = new BasicTypeConverter();
192 if (class1 == java.lang.Object.class) {
193 return bt.convert(str, "java.lang.Short");
194 } else {
195 return bt.convert(str, className);
196 }
197 } catch (ClassNotFoundException ex) {
198 ex.printStackTrace();
199 }
200 return null;
201 }
202
203 public final Object convert(boolean obj, String className) throws InvalidDataTypeException, UnsupportedTypeException {
204 try {
205 Class class1 = Class.forName(className);
206 if (! isTargetDataTypeSupported(class1)) {
207 throw new UnsupportedTypeException("PrimitiveToWrapper: Unsupported output type");
208 }
209 PrimitiveToStringConverter ps = new PrimitiveToStringConverter();
210 String str = ps.convert(obj, "java.lang.String");
211 BasicTypeConverter bt = new BasicTypeConverter();
212 if (class1 == java.lang.Object.class) {
213 return bt.convert(str, "java.lang.Boolean");
214 } else {
215 return bt.convert(str, className);
216 }
217 } catch (ClassNotFoundException ex) {
218 ex.printStackTrace();
219 }
220 return null;
221 }
222 }
This page was automatically generated by Maven