KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > alfresco > service > cmr > repository > datatype > DefaultTypeConverter


1 /*
2  * Copyright (C) 2005 Alfresco, Inc.
3  *
4  * Licensed under the Mozilla Public License version 1.1
5  * with a permitted attribution clause. You may obtain a
6  * copy of the License at
7  *
8  * http://www.alfresco.org/legal/license.txt
9  *
10  * Unless required by applicable law or agreed to in writing,
11  * software distributed under the License is distributed on an
12  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
13  * either express or implied. See the License for the specific
14  * language governing permissions and limitations under the
15  * License.
16  */

17 package org.alfresco.service.cmr.repository.datatype;
18
19 import java.io.ByteArrayInputStream JavaDoc;
20 import java.io.ByteArrayOutputStream JavaDoc;
21 import java.io.IOException JavaDoc;
22 import java.io.InputStream JavaDoc;
23 import java.io.UnsupportedEncodingException JavaDoc;
24 import java.math.BigDecimal JavaDoc;
25 import java.math.BigInteger JavaDoc;
26 import java.sql.Timestamp JavaDoc;
27 import java.text.DecimalFormat JavaDoc;
28 import java.text.ParseException JavaDoc;
29 import java.util.Calendar JavaDoc;
30 import java.util.Date JavaDoc;
31
32 import org.alfresco.service.cmr.repository.ContentData;
33 import org.alfresco.service.cmr.repository.ContentReader;
34 import org.alfresco.service.cmr.repository.NodeRef;
35 import org.alfresco.service.cmr.repository.Path;
36 import org.alfresco.service.namespace.QName;
37 import org.alfresco.util.ISO8601DateFormat;
38
39 /**
40  * Support for generic conversion between types.
41  *
42  * Additional conversions may be added. Basic interoperabikitynos supported.
43  *
44  * Direct conversion and two stage conversions via Number are supported. We do
45  * not support conversion by any route at the moment
46  *
47  * TODO: Add support for Path
48  *
49  * TODO: Add support for lucene
50  *
51  * TODO: Add suport to check of a type is convertable
52  *
53  * TODO: Support for dynamically managing conversions
54  *
55  * @author andyh
56  *
57  */

58 public class DefaultTypeConverter
59 {
60
61     /**
62      * Default Type Converter
63      */

64     public static TypeConverter INSTANCE = new TypeConverter();
65
66     /**
67      * Initialise default set of Converters
68      */

69     static
70     {
71         
72         //
73
// From string
74
//
75

76         INSTANCE.addConverter(String JavaDoc.class, Boolean JavaDoc.class, new TypeConverter.Converter<String JavaDoc, Boolean JavaDoc>()
77         {
78             public Boolean JavaDoc convert(String JavaDoc source)
79             {
80                 return Boolean.valueOf(source);
81             }
82         });
83
84         INSTANCE.addConverter(String JavaDoc.class, Character JavaDoc.class, new TypeConverter.Converter<String JavaDoc, Character JavaDoc>()
85         {
86             public Character JavaDoc convert(String JavaDoc source)
87             {
88                 if ((source == null) || (source.length() == 0))
89                 {
90                     return null;
91                 }
92                 return Character.valueOf(source.charAt(0));
93             }
94         });
95
96         INSTANCE.addConverter(String JavaDoc.class, Number JavaDoc.class, new TypeConverter.Converter<String JavaDoc, Number JavaDoc>()
97         {
98             public Number JavaDoc convert(String JavaDoc source)
99             {
100                 try
101                 {
102                     return DecimalFormat.getNumberInstance().parse(source);
103                 }
104                 catch (ParseException JavaDoc e)
105                 {
106                     throw new TypeConversionException("Failed to parse number " + source, e);
107                 }
108             }
109         });
110
111         INSTANCE.addConverter(String JavaDoc.class, Byte JavaDoc.class, new TypeConverter.Converter<String JavaDoc, Byte JavaDoc>()
112         {
113             public Byte JavaDoc convert(String JavaDoc source)
114             {
115                 return Byte.valueOf(source);
116             }
117         });
118
119         INSTANCE.addConverter(String JavaDoc.class, Short JavaDoc.class, new TypeConverter.Converter<String JavaDoc, Short JavaDoc>()
120         {
121             public Short JavaDoc convert(String JavaDoc source)
122             {
123                 return Short.valueOf(source);
124             }
125         });
126
127         INSTANCE.addConverter(String JavaDoc.class, Integer JavaDoc.class, new TypeConverter.Converter<String JavaDoc, Integer JavaDoc>()
128         {
129             public Integer JavaDoc convert(String JavaDoc source)
130             {
131                 return Integer.valueOf(source);
132             }
133         });
134
135         INSTANCE.addConverter(String JavaDoc.class, Long JavaDoc.class, new TypeConverter.Converter<String JavaDoc, Long JavaDoc>()
136         {
137             public Long JavaDoc convert(String JavaDoc source)
138             {
139                 return Long.valueOf(source);
140             }
141         });
142
143         INSTANCE.addConverter(String JavaDoc.class, Float JavaDoc.class, new TypeConverter.Converter<String JavaDoc, Float JavaDoc>()
144         {
145             public Float JavaDoc convert(String JavaDoc source)
146             {
147                 return Float.valueOf(source);
148             }
149         });
150
151         INSTANCE.addConverter(String JavaDoc.class, Double JavaDoc.class, new TypeConverter.Converter<String JavaDoc, Double JavaDoc>()
152         {
153             public Double JavaDoc convert(String JavaDoc source)
154             {
155                 return Double.valueOf(source);
156             }
157         });
158
159         INSTANCE.addConverter(String JavaDoc.class, BigInteger JavaDoc.class, new TypeConverter.Converter<String JavaDoc, BigInteger JavaDoc>()
160         {
161             public BigInteger JavaDoc convert(String JavaDoc source)
162             {
163                 return new BigInteger JavaDoc(source);
164             }
165         });
166
167         INSTANCE.addConverter(String JavaDoc.class, BigDecimal JavaDoc.class, new TypeConverter.Converter<String JavaDoc, BigDecimal JavaDoc>()
168         {
169             public BigDecimal JavaDoc convert(String JavaDoc source)
170             {
171                 return new BigDecimal JavaDoc(source);
172             }
173         });
174
175         INSTANCE.addConverter(String JavaDoc.class, Date JavaDoc.class, new TypeConverter.Converter<String JavaDoc, Date JavaDoc>()
176         {
177             public Date JavaDoc convert(String JavaDoc source)
178             {
179                 Date JavaDoc date = ISO8601DateFormat.parse(source);
180                 if (date == null)
181                 {
182                     throw new TypeConversionException("Failed to parse date " + source);
183                 }
184                 return date;
185             }
186         });
187
188         INSTANCE.addConverter(String JavaDoc.class, Duration.class, new TypeConverter.Converter<String JavaDoc, Duration>()
189         {
190             public Duration convert(String JavaDoc source)
191             {
192                 return new Duration(source);
193             }
194         });
195         
196         INSTANCE.addConverter(String JavaDoc.class, QName.class, new TypeConverter.Converter<String JavaDoc, QName>()
197         {
198             public QName convert(String JavaDoc source)
199             {
200                 return QName.createQName(source);
201             }
202         });
203         
204         INSTANCE.addConverter(String JavaDoc.class, ContentData.class, new TypeConverter.Converter<String JavaDoc, ContentData>()
205         {
206             public ContentData convert(String JavaDoc source)
207             {
208                 return ContentData.createContentProperty(source);
209             }
210     
211         });
212
213         INSTANCE.addConverter(String JavaDoc.class, NodeRef.class, new TypeConverter.Converter<String JavaDoc, NodeRef>()
214                 {
215                     public NodeRef convert(String JavaDoc source)
216                     {
217                         return new NodeRef(source);
218                     }
219             
220                 });
221
222         INSTANCE.addConverter(String JavaDoc.class, InputStream JavaDoc.class, new TypeConverter.Converter<String JavaDoc, InputStream JavaDoc>()
223         {
224             public InputStream JavaDoc convert(String JavaDoc source)
225             {
226                 try
227                 {
228                     return new ByteArrayInputStream JavaDoc(source.getBytes("UTF-8"));
229                 }
230                 catch (UnsupportedEncodingException JavaDoc e)
231                 {
232                     throw new TypeConversionException("Encoding not supported", e);
233                 }
234             }
235         });
236
237         
238         //
239
// From enum
240
//
241

242         INSTANCE.addConverter(Enum JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<Enum JavaDoc, String JavaDoc>()
243         {
244             public String JavaDoc convert(Enum JavaDoc source)
245             {
246                 return source.toString();
247             }
248         });
249
250         
251         //
252
// Number to Subtypes and Date
253
//
254

255         INSTANCE.addConverter(Number JavaDoc.class, Byte JavaDoc.class, new TypeConverter.Converter<Number JavaDoc, Byte JavaDoc>()
256         {
257             public Byte JavaDoc convert(Number JavaDoc source)
258             {
259                 return Byte.valueOf(source.byteValue());
260             }
261         });
262
263         INSTANCE.addConverter(Number JavaDoc.class, Short JavaDoc.class, new TypeConverter.Converter<Number JavaDoc, Short JavaDoc>()
264         {
265             public Short JavaDoc convert(Number JavaDoc source)
266             {
267                 return Short.valueOf(source.shortValue());
268             }
269         });
270
271         INSTANCE.addConverter(Number JavaDoc.class, Integer JavaDoc.class, new TypeConverter.Converter<Number JavaDoc, Integer JavaDoc>()
272         {
273             public Integer JavaDoc convert(Number JavaDoc source)
274             {
275                 return Integer.valueOf(source.intValue());
276             }
277         });
278
279         INSTANCE.addConverter(Number JavaDoc.class, Long JavaDoc.class, new TypeConverter.Converter<Number JavaDoc, Long JavaDoc>()
280         {
281             public Long JavaDoc convert(Number JavaDoc source)
282             {
283                 return Long.valueOf(source.longValue());
284             }
285         });
286
287         INSTANCE.addConverter(Number JavaDoc.class, Float JavaDoc.class, new TypeConverter.Converter<Number JavaDoc, Float JavaDoc>()
288         {
289             public Float JavaDoc convert(Number JavaDoc source)
290             {
291                 return Float.valueOf(source.floatValue());
292             }
293         });
294
295         INSTANCE.addConverter(Number JavaDoc.class, Double JavaDoc.class, new TypeConverter.Converter<Number JavaDoc, Double JavaDoc>()
296         {
297             public Double JavaDoc convert(Number JavaDoc source)
298             {
299                 return Double.valueOf(source.doubleValue());
300             }
301         });
302
303         INSTANCE.addConverter(Number JavaDoc.class, Date JavaDoc.class, new TypeConverter.Converter<Number JavaDoc, Date JavaDoc>()
304         {
305             public Date JavaDoc convert(Number JavaDoc source)
306             {
307                 return new Date JavaDoc(source.longValue());
308             }
309         });
310
311         INSTANCE.addConverter(Number JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<Number JavaDoc, String JavaDoc>()
312         {
313             public String JavaDoc convert(Number JavaDoc source)
314             {
315                 return source.toString();
316             }
317         });
318
319         INSTANCE.addConverter(Number JavaDoc.class, BigInteger JavaDoc.class, new TypeConverter.Converter<Number JavaDoc, BigInteger JavaDoc>()
320         {
321             public BigInteger JavaDoc convert(Number JavaDoc source)
322             {
323                 if (source instanceof BigDecimal JavaDoc)
324                 {
325                     return ((BigDecimal JavaDoc) source).toBigInteger();
326                 }
327                 else
328                 {
329                     return BigInteger.valueOf(source.longValue());
330                 }
331             }
332         });
333
334         INSTANCE.addConverter(Number JavaDoc.class, BigDecimal JavaDoc.class, new TypeConverter.Converter<Number JavaDoc, BigDecimal JavaDoc>()
335         {
336             public BigDecimal JavaDoc convert(Number JavaDoc source)
337             {
338                 if (source instanceof BigInteger JavaDoc)
339                 {
340                     return new BigDecimal JavaDoc((BigInteger JavaDoc) source);
341                 }
342                 else
343                 {
344                     return BigDecimal.valueOf(source.longValue());
345                 }
346             }
347         });
348         
349         INSTANCE.addDynamicTwoStageConverter(Number JavaDoc.class, String JavaDoc.class, InputStream JavaDoc.class);
350         
351         //
352
// Date, Timestamp ->
353
//
354

355         INSTANCE.addConverter(Timestamp JavaDoc.class, Date JavaDoc.class, new TypeConverter.Converter<Timestamp JavaDoc, Date JavaDoc>()
356         {
357             public Date JavaDoc convert(Timestamp JavaDoc source)
358             {
359                 return new Date JavaDoc(source.getTime());
360             }
361         });
362         
363         INSTANCE.addConverter(Date JavaDoc.class, Number JavaDoc.class, new TypeConverter.Converter<Date JavaDoc, Number JavaDoc>()
364         {
365             public Number JavaDoc convert(Date JavaDoc source)
366             {
367                 return Long.valueOf(source.getTime());
368             }
369         });
370
371         INSTANCE.addConverter(Date JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<Date JavaDoc, String JavaDoc>()
372         {
373             public String JavaDoc convert(Date JavaDoc source)
374             {
375                 return ISO8601DateFormat.format(source);
376             }
377         });
378         
379         INSTANCE.addConverter(Date JavaDoc.class, Calendar JavaDoc.class, new TypeConverter.Converter<Date JavaDoc, Calendar JavaDoc>()
380         {
381             public Calendar JavaDoc convert(Date JavaDoc source)
382             {
383                 Calendar JavaDoc calendar = Calendar.getInstance();
384                 calendar.setTime(source);
385                 return calendar;
386             }
387         });
388
389         INSTANCE.addDynamicTwoStageConverter(Date JavaDoc.class, String JavaDoc.class, InputStream JavaDoc.class);
390
391         //
392
// Boolean ->
393
//
394

395         INSTANCE.addConverter(Boolean JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<Boolean JavaDoc, String JavaDoc>()
396         {
397             public String JavaDoc convert(Boolean JavaDoc source)
398             {
399                 return source.toString();
400             }
401         });
402
403         INSTANCE.addDynamicTwoStageConverter(Boolean JavaDoc.class, String JavaDoc.class, InputStream JavaDoc.class);
404
405         //
406
// Character ->
407
//
408

409         INSTANCE.addConverter(Character JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<Character JavaDoc, String JavaDoc>()
410         {
411             public String JavaDoc convert(Character JavaDoc source)
412             {
413                 return source.toString();
414             }
415         });
416
417         INSTANCE.addDynamicTwoStageConverter(Character JavaDoc.class, String JavaDoc.class, InputStream JavaDoc.class);
418
419         //
420
// Duration ->
421
//
422

423         INSTANCE.addConverter(Duration.class, String JavaDoc.class, new TypeConverter.Converter<Duration, String JavaDoc>()
424         {
425             public String JavaDoc convert(Duration source)
426             {
427                 return source.toString();
428             }
429
430         });
431
432         INSTANCE.addDynamicTwoStageConverter(Duration.class, String JavaDoc.class, InputStream JavaDoc.class);
433
434         //
435
// Byte
436
//
437

438         INSTANCE.addConverter(Byte JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<Byte JavaDoc, String JavaDoc>()
439         {
440             public String JavaDoc convert(Byte JavaDoc source)
441             {
442                 return source.toString();
443             }
444         });
445
446         INSTANCE.addDynamicTwoStageConverter(Byte JavaDoc.class, String JavaDoc.class, InputStream JavaDoc.class);
447         
448         //
449
// Short
450
//
451

452         INSTANCE.addConverter(Short JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<Short JavaDoc, String JavaDoc>()
453         {
454             public String JavaDoc convert(Short JavaDoc source)
455             {
456                 return source.toString();
457             }
458         });
459
460         INSTANCE.addDynamicTwoStageConverter(Short JavaDoc.class, String JavaDoc.class, InputStream JavaDoc.class);
461
462         //
463
// Integer
464
//
465

466         INSTANCE.addConverter(Integer JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<Integer JavaDoc, String JavaDoc>()
467         {
468             public String JavaDoc convert(Integer JavaDoc source)
469             {
470                 return source.toString();
471             }
472         });
473
474         INSTANCE.addDynamicTwoStageConverter(Integer JavaDoc.class, String JavaDoc.class, InputStream JavaDoc.class);
475         
476         //
477
// Long
478
//
479

480         INSTANCE.addConverter(Long JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<Long JavaDoc, String JavaDoc>()
481         {
482             public String JavaDoc convert(Long JavaDoc source)
483             {
484                 return source.toString();
485             }
486         });
487
488         INSTANCE.addDynamicTwoStageConverter(Long JavaDoc.class, String JavaDoc.class, InputStream JavaDoc.class);
489
490         //
491
// Float
492
//
493

494         INSTANCE.addConverter(Float JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<Float JavaDoc, String JavaDoc>()
495         {
496             public String JavaDoc convert(Float JavaDoc source)
497             {
498                 return source.toString();
499             }
500         });
501
502         INSTANCE.addDynamicTwoStageConverter(Float JavaDoc.class, String JavaDoc.class, InputStream JavaDoc.class);
503
504         //
505
// Double
506
//
507

508         INSTANCE.addConverter(Double JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<Double JavaDoc, String JavaDoc>()
509         {
510             public String JavaDoc convert(Double JavaDoc source)
511             {
512                 return source.toString();
513             }
514         });
515
516         INSTANCE.addDynamicTwoStageConverter(Double JavaDoc.class, String JavaDoc.class, InputStream JavaDoc.class);
517
518         //
519
// BigInteger
520
//
521

522         INSTANCE.addConverter(BigInteger JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<BigInteger JavaDoc, String JavaDoc>()
523         {
524             public String JavaDoc convert(BigInteger JavaDoc source)
525             {
526                 return source.toString();
527             }
528         });
529
530         INSTANCE.addDynamicTwoStageConverter(BigInteger JavaDoc.class, String JavaDoc.class, InputStream JavaDoc.class);
531
532         //
533
// Calendar
534
//
535

536         INSTANCE.addConverter(Calendar JavaDoc.class, Date JavaDoc.class, new TypeConverter.Converter<Calendar JavaDoc, Date JavaDoc>()
537         {
538             public Date JavaDoc convert(Calendar JavaDoc source)
539             {
540                 return source.getTime();
541             }
542         });
543         
544         INSTANCE.addConverter(Calendar JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<Calendar JavaDoc, String JavaDoc>()
545         {
546             public String JavaDoc convert(Calendar JavaDoc source)
547             {
548                 return ISO8601DateFormat.format(source.getTime());
549             }
550         });
551         
552         //
553
// BigDecimal
554
//
555

556         INSTANCE.addConverter(BigDecimal JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<BigDecimal JavaDoc, String JavaDoc>()
557         {
558             public String JavaDoc convert(BigDecimal JavaDoc source)
559             {
560                 return source.toString();
561             }
562         });
563         
564         INSTANCE.addDynamicTwoStageConverter(BigDecimal JavaDoc.class, String JavaDoc.class, InputStream JavaDoc.class);
565
566         //
567
// QName
568
//
569

570         INSTANCE.addConverter(QName.class, String JavaDoc.class, new TypeConverter.Converter<QName, String JavaDoc>()
571         {
572             public String JavaDoc convert(QName source)
573             {
574                 return source.toString();
575             }
576         });
577
578         INSTANCE.addDynamicTwoStageConverter(QName.class, String JavaDoc.class, InputStream JavaDoc.class);
579
580         //
581
// NodeRef
582
//
583

584         INSTANCE.addConverter(NodeRef.class, String JavaDoc.class, new TypeConverter.Converter<NodeRef, String JavaDoc>()
585         {
586             public String JavaDoc convert(NodeRef source)
587             {
588                 return source.toString();
589             }
590         });
591         
592         INSTANCE.addDynamicTwoStageConverter(NodeRef.class, String JavaDoc.class, InputStream JavaDoc.class);
593         
594         //
595
// ContentData
596
//
597

598         INSTANCE.addConverter(ContentData.class, String JavaDoc.class, new TypeConverter.Converter<ContentData, String JavaDoc>()
599         {
600             public String JavaDoc convert(ContentData source)
601             {
602                 return source.toString();
603             }
604         });
605                 
606         INSTANCE.addDynamicTwoStageConverter(ContentData.class, String JavaDoc.class, InputStream JavaDoc.class);
607         
608         //
609
// Path
610
//
611

612         INSTANCE.addConverter(Path.class, String JavaDoc.class, new TypeConverter.Converter<Path, String JavaDoc>()
613         {
614             public String JavaDoc convert(Path source)
615             {
616                 return source.toString();
617             }
618         });
619
620         INSTANCE.addDynamicTwoStageConverter(Path.class, String JavaDoc.class, InputStream JavaDoc.class);
621         
622         //
623
// Content Reader
624
//
625

626         INSTANCE.addConverter(ContentReader.class, InputStream JavaDoc.class, new TypeConverter.Converter<ContentReader, InputStream JavaDoc>()
627         {
628             public InputStream JavaDoc convert(ContentReader source)
629             {
630                 return source.getContentInputStream();
631             }
632         });
633         
634         INSTANCE.addConverter(ContentReader.class, String JavaDoc.class, new TypeConverter.Converter<ContentReader, String JavaDoc>()
635         {
636             public String JavaDoc convert(ContentReader source)
637             {
638                 String JavaDoc encoding = source.getEncoding();
639                 if (encoding == null || !encoding.equals("UTF-8"))
640                 {
641                     throw new TypeConversionException("Cannot convert non UTF-8 streams to String.");
642                 }
643                 
644                 // TODO: Throw error on size limit
645

646                 return source.getContentString();
647             }
648         });
649
650         INSTANCE.addDynamicTwoStageConverter(ContentReader.class, String JavaDoc.class, Date JavaDoc.class);
651         
652         INSTANCE.addDynamicTwoStageConverter(ContentReader.class, String JavaDoc.class, Double JavaDoc.class);
653         
654         INSTANCE.addDynamicTwoStageConverter(ContentReader.class, String JavaDoc.class, Long JavaDoc.class);
655
656         INSTANCE.addDynamicTwoStageConverter(ContentReader.class, String JavaDoc.class, Boolean JavaDoc.class);
657
658         INSTANCE.addDynamicTwoStageConverter(ContentReader.class, String JavaDoc.class, QName.class);
659
660         INSTANCE.addDynamicTwoStageConverter(ContentReader.class, String JavaDoc.class, Path.class);
661
662         INSTANCE.addDynamicTwoStageConverter(ContentReader.class, String JavaDoc.class, NodeRef.class);
663
664         //
665
// Input Stream
666
//
667

668         INSTANCE.addConverter(InputStream JavaDoc.class, String JavaDoc.class, new TypeConverter.Converter<InputStream JavaDoc, String JavaDoc>()
669         {
670             public String JavaDoc convert(InputStream JavaDoc source)
671             {
672                 try
673                 {
674                     ByteArrayOutputStream JavaDoc out = new ByteArrayOutputStream JavaDoc();
675                     byte[] buffer = new byte[8192];
676                     int read;
677                     while ((read = source.read(buffer)) > 0)
678                     {
679                         out.write(buffer, 0, read);
680                     }
681                     byte[] data = out.toByteArray();
682                     return new String JavaDoc(data, "UTF-8");
683                 }
684                 catch (UnsupportedEncodingException JavaDoc e)
685                 {
686                     throw new TypeConversionException("Cannot convert input stream to String.", e);
687                 }
688                 catch (IOException JavaDoc e)
689                 {
690                     throw new TypeConversionException("Conversion from stream to string failed", e);
691                 }
692                 finally
693                 {
694                     if (source != null)
695                     {
696                         try { source.close(); } catch(IOException JavaDoc e) {};
697                     }
698                 }
699             }
700         });
701
702         INSTANCE.addDynamicTwoStageConverter(InputStream JavaDoc.class, String JavaDoc.class, Date JavaDoc.class);
703         
704         INSTANCE.addDynamicTwoStageConverter(InputStream JavaDoc.class, String JavaDoc.class, Double JavaDoc.class);
705         
706         INSTANCE.addDynamicTwoStageConverter(InputStream JavaDoc.class, String JavaDoc.class, Long JavaDoc.class);
707
708         INSTANCE.addDynamicTwoStageConverter(InputStream JavaDoc.class, String JavaDoc.class, Boolean JavaDoc.class);
709
710         INSTANCE.addDynamicTwoStageConverter(InputStream JavaDoc.class, String JavaDoc.class, QName.class);
711
712         INSTANCE.addDynamicTwoStageConverter(InputStream JavaDoc.class, String JavaDoc.class, Path.class);
713
714         INSTANCE.addDynamicTwoStageConverter(InputStream JavaDoc.class, String JavaDoc.class, NodeRef.class);
715         
716     }
717
718 }
719
Popular Tags