Source code

001package org.apache.camel.impl.converter;
002
003import org.apache.camel.Exchange;
004import org.apache.camel.TypeConversionException;
005import org.apache.camel.TypeConverterLoaderException;
006import org.apache.camel.spi.TypeConverterLoader;
007import org.apache.camel.spi.TypeConverterRegistry;
008import org.apache.camel.support.TypeConverterSupport;
009
010@SuppressWarnings("unchecked")
011public class CoreStaticTypeConverterLoader implements TypeConverterLoader {
012
013    static abstract class SimpleTypeConverter extends TypeConverterSupport {
014        private final boolean allowNull;
015
016        public SimpleTypeConverter(boolean allowNull) {
017            this.allowNull = allowNull;
018        }
019
020        @Override
021        public boolean allowNull() {
022            return allowNull;
023        }
024
025        @Override
026        public <T> T convertTo(Class<T> type, Exchange exchange, Object value) throws TypeConversionException {
027            try {
028                return (T) doConvert(exchange, value);
029            } catch (TypeConversionException e) {
030                throw e;
031            } catch (Exception e) {
032                throw new TypeConversionException(value, type, e);
033            }
034        }
035        protected abstract Object doConvert(Exchange exchange, Object value) throws Exception;
036    };
037
038    @Override
039    public void load(TypeConverterRegistry registry) throws TypeConverterLoaderException {
040        registry.addTypeConverter(boolean.class, java.lang.Object.class, new SimpleTypeConverter(false) {
041            @Override
042            public Object doConvert(Exchange exchange, Object value) throws Exception {
043                return org.apache.camel.converter.ObjectConverter.toBool(value);
044            }
045        });
046        registry.addTypeConverter(byte[].class, java.io.BufferedReader.class, new SimpleTypeConverter(false) {
047            @Override
048            public Object doConvert(Exchange exchange, Object value) throws Exception {
049                return org.apache.camel.converter.IOConverter.toByteArray((java.io.BufferedReader) value, exchange);
050            }
051        });
052        registry.addTypeConverter(byte[].class, java.io.ByteArrayOutputStream.class, new SimpleTypeConverter(false) {
053            @Override
054            public Object doConvert(Exchange exchange, Object value) throws Exception {
055                return org.apache.camel.converter.IOConverter.toByteArray((java.io.ByteArrayOutputStream) value);
056            }
057        });
058        registry.addTypeConverter(byte[].class, java.io.File.class, new SimpleTypeConverter(false) {
059            @Override
060            public Object doConvert(Exchange exchange, Object value) throws Exception {
061                return org.apache.camel.converter.IOConverter.toByteArray((java.io.File) value);
062            }
063        });
064        registry.addTypeConverter(byte[].class, java.io.InputStream.class, new SimpleTypeConverter(false) {
065            @Override
066            public Object doConvert(Exchange exchange, Object value) throws Exception {
067                return org.apache.camel.converter.IOConverter.toBytes((java.io.InputStream) value);
068            }
069        });
070        registry.addTypeConverter(byte[].class, java.io.Reader.class, new SimpleTypeConverter(false) {
071            @Override
072            public Object doConvert(Exchange exchange, Object value) throws Exception {
073                return org.apache.camel.converter.IOConverter.toByteArray((java.io.Reader) value, exchange);
074            }
075        });
076        registry.addTypeConverter(byte[].class, java.lang.String.class, new SimpleTypeConverter(false) {
077            @Override
078            public Object doConvert(Exchange exchange, Object value) throws Exception {
079                return org.apache.camel.converter.IOConverter.toByteArray((java.lang.String) value, exchange);
080            }
081        });
082        registry.addTypeConverter(byte[].class, java.nio.ByteBuffer.class, new SimpleTypeConverter(false) {
083            @Override
084            public Object doConvert(Exchange exchange, Object value) throws Exception {
085                return org.apache.camel.converter.NIOConverter.toByteArray((java.nio.ByteBuffer) value);
086            }
087        });
088        registry.addTypeConverter(byte[].class, javax.xml.transform.Source.class, new SimpleTypeConverter(false) {
089            @Override
090            public Object doConvert(Exchange exchange, Object value) throws Exception {
091                return getXmlConverter().toByteArray((javax.xml.transform.Source) value, exchange);
092            }
093        });
094        registry.addTypeConverter(byte[].class, org.apache.camel.StreamCache.class, new SimpleTypeConverter(false) {
095            @Override
096            public Object doConvert(Exchange exchange, Object value) throws Exception {
097                return org.apache.camel.converter.stream.StreamCacheConverter.convertToByteArray((org.apache.camel.StreamCache) value, exchange);
098            }
099        });
100        registry.addTypeConverter(byte[].class, org.w3c.dom.NodeList.class, new SimpleTypeConverter(false) {
101            @Override
102            public Object doConvert(Exchange exchange, Object value) throws Exception {
103                return getDomConverter().toByteArray((org.w3c.dom.NodeList) value, exchange);
104            }
105        });
106        registry.addTypeConverter(char.class, java.lang.String.class, new SimpleTypeConverter(false) {
107            @Override
108            public Object doConvert(Exchange exchange, Object value) throws Exception {
109                return org.apache.camel.converter.ObjectConverter.toChar((java.lang.String) value);
110            }
111        });
112        registry.addTypeConverter(char[].class, java.lang.String.class, new SimpleTypeConverter(false) {
113            @Override
114            public Object doConvert(Exchange exchange, Object value) throws Exception {
115                return org.apache.camel.converter.ObjectConverter.toCharArray((java.lang.String) value);
116            }
117        });
118        registry.addTypeConverter(java.io.BufferedReader.class, java.io.File.class, new SimpleTypeConverter(false) {
119            @Override
120            public Object doConvert(Exchange exchange, Object value) throws Exception {
121                return org.apache.camel.converter.IOConverter.toReader((java.io.File) value, exchange);
122            }
123        });
124        registry.addTypeConverter(java.io.BufferedWriter.class, java.io.File.class, new SimpleTypeConverter(false) {
125            @Override
126            public Object doConvert(Exchange exchange, Object value) throws Exception {
127                return org.apache.camel.converter.IOConverter.toWriter((java.io.File) value, exchange);
128            }
129        });
130        registry.addTypeConverter(java.io.File.class, java.lang.String.class, new SimpleTypeConverter(false) {
131            @Override
132            public Object doConvert(Exchange exchange, Object value) throws Exception {
133                return org.apache.camel.converter.IOConverter.toFile((java.lang.String) value);
134            }
135        });
136        registry.addTypeConverter(java.io.InputStream.class, byte[].class, new SimpleTypeConverter(false) {
137            @Override
138            public Object doConvert(Exchange exchange, Object value) throws Exception {
139                return org.apache.camel.converter.IOConverter.toInputStream((byte[]) value);
140            }
141        });
142        registry.addTypeConverter(java.io.InputStream.class, java.io.BufferedReader.class, new SimpleTypeConverter(false) {
143            @Override
144            public Object doConvert(Exchange exchange, Object value) throws Exception {
145                return org.apache.camel.converter.IOConverter.toInputStream((java.io.BufferedReader) value, exchange);
146            }
147        });
148        registry.addTypeConverter(java.io.InputStream.class, java.io.ByteArrayOutputStream.class, new SimpleTypeConverter(false) {
149            @Override
150            public Object doConvert(Exchange exchange, Object value) throws Exception {
151                return org.apache.camel.converter.IOConverter.toInputStream((java.io.ByteArrayOutputStream) value);
152            }
153        });
154        registry.addTypeConverter(java.io.InputStream.class, java.io.File.class, new SimpleTypeConverter(false) {
155            @Override
156            public Object doConvert(Exchange exchange, Object value) throws Exception {
157                return org.apache.camel.converter.IOConverter.toInputStream((java.io.File) value);
158            }
159        });
160        registry.addTypeConverter(java.io.InputStream.class, java.lang.String.class, new SimpleTypeConverter(false) {
161            @Override
162            public Object doConvert(Exchange exchange, Object value) throws Exception {
163                return org.apache.camel.converter.IOConverter.toInputStream((java.lang.String) value, exchange);
164            }
165        });
166        registry.addTypeConverter(java.io.InputStream.class, java.lang.StringBuffer.class, new SimpleTypeConverter(false) {
167            @Override
168            public Object doConvert(Exchange exchange, Object value) throws Exception {
169                return org.apache.camel.converter.IOConverter.toInputStream((java.lang.StringBuffer) value, exchange);
170            }
171        });
172        registry.addTypeConverter(java.io.InputStream.class, java.lang.StringBuilder.class, new SimpleTypeConverter(false) {
173            @Override
174            public Object doConvert(Exchange exchange, Object value) throws Exception {
175                return org.apache.camel.converter.IOConverter.toInputStream((java.lang.StringBuilder) value, exchange);
176            }
177        });
178        registry.addTypeConverter(java.io.InputStream.class, java.net.URL.class, new SimpleTypeConverter(false) {
179            @Override
180            public Object doConvert(Exchange exchange, Object value) throws Exception {
181                return org.apache.camel.converter.IOConverter.toInputStream((java.net.URL) value);
182            }
183        });
184        registry.addTypeConverter(java.io.InputStream.class, java.nio.ByteBuffer.class, new SimpleTypeConverter(false) {
185            @Override
186            public Object doConvert(Exchange exchange, Object value) throws Exception {
187                return org.apache.camel.converter.NIOConverter.toInputStream((java.nio.ByteBuffer) value);
188            }
189        });
190        registry.addTypeConverter(java.io.InputStream.class, javax.xml.stream.XMLStreamReader.class, new SimpleTypeConverter(false) {
191            @Override
192            public Object doConvert(Exchange exchange, Object value) throws Exception {
193                return getStaxConverter().createInputStream((javax.xml.stream.XMLStreamReader) value, exchange);
194            }
195        });
196        registry.addTypeConverter(java.io.InputStream.class, javax.xml.transform.dom.DOMSource.class, new SimpleTypeConverter(false) {
197            @Override
198            public Object doConvert(Exchange exchange, Object value) throws Exception {
199                return getXmlConverter().toInputStream((javax.xml.transform.dom.DOMSource) value, exchange);
200            }
201        });
202        registry.addTypeConverter(java.io.InputStream.class, javax.xml.transform.stream.StreamSource.class, new SimpleTypeConverter(false) {
203            @Override
204            public Object doConvert(Exchange exchange, Object value) throws Exception {
205                return org.apache.camel.converter.jaxp.StreamSourceConverter.toInputStream((javax.xml.transform.stream.StreamSource) value);
206            }
207        });
208        registry.addTypeConverter(java.io.InputStream.class, org.apache.camel.component.file.GenericFile.class, new SimpleTypeConverter(false) {
209            @Override
210            public Object doConvert(Exchange exchange, Object value) throws Exception {
211                return org.apache.camel.component.file.GenericFileConverter.genericFileToInputStream((org.apache.camel.component.file.GenericFile) value, exchange);
212            }
213        });
214        registry.addTypeConverter(java.io.InputStream.class, org.w3c.dom.Document.class, new SimpleTypeConverter(false) {
215            @Override
216            public Object doConvert(Exchange exchange, Object value) throws Exception {
217                return getXmlConverter().toInputStream((org.w3c.dom.Document) value, exchange);
218            }
219        });
220        registry.addTypeConverter(java.io.InputStream.class, org.w3c.dom.NodeList.class, new SimpleTypeConverter(false) {
221            @Override
222            public Object doConvert(Exchange exchange, Object value) throws Exception {
223                return getDomConverter().toInputStream((org.w3c.dom.NodeList) value, exchange);
224            }
225        });
226        registry.addTypeConverter(java.io.ObjectInput.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
227            @Override
228            public Object doConvert(Exchange exchange, Object value) throws Exception {
229                return org.apache.camel.converter.IOConverter.toObjectInput((java.io.InputStream) value, exchange);
230            }
231        });
232        registry.addTypeConverter(java.io.ObjectOutput.class, java.io.OutputStream.class, new SimpleTypeConverter(false) {
233            @Override
234            public Object doConvert(Exchange exchange, Object value) throws Exception {
235                return org.apache.camel.converter.IOConverter.toObjectOutput((java.io.OutputStream) value);
236            }
237        });
238        registry.addTypeConverter(java.io.OutputStream.class, java.io.File.class, new SimpleTypeConverter(false) {
239            @Override
240            public Object doConvert(Exchange exchange, Object value) throws Exception {
241                return org.apache.camel.converter.IOConverter.toOutputStream((java.io.File) value);
242            }
243        });
244        registry.addTypeConverter(java.io.Reader.class, byte[].class, new SimpleTypeConverter(false) {
245            @Override
246            public Object doConvert(Exchange exchange, Object value) throws Exception {
247                return org.apache.camel.converter.IOConverter.toReader((byte[]) value, exchange);
248            }
249        });
250        registry.addTypeConverter(java.io.Reader.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
251            @Override
252            public Object doConvert(Exchange exchange, Object value) throws Exception {
253                return org.apache.camel.converter.IOConverter.toReader((java.io.InputStream) value, exchange);
254            }
255        });
256        registry.addTypeConverter(java.io.Reader.class, javax.xml.stream.XMLStreamReader.class, new SimpleTypeConverter(false) {
257            @Override
258            public Object doConvert(Exchange exchange, Object value) throws Exception {
259                return getStaxConverter().createReader((javax.xml.stream.XMLStreamReader) value, exchange);
260            }
261        });
262        registry.addTypeConverter(java.io.Reader.class, javax.xml.transform.stream.StreamSource.class, new SimpleTypeConverter(false) {
263            @Override
264            public Object doConvert(Exchange exchange, Object value) throws Exception {
265                return org.apache.camel.converter.jaxp.StreamSourceConverter.toReader((javax.xml.transform.stream.StreamSource) value);
266            }
267        });
268        registry.addTypeConverter(java.io.Reader.class, javax.xml.transform.Source.class, new SimpleTypeConverter(false) {
269            @Override
270            public Object doConvert(Exchange exchange, Object value) throws Exception {
271                return getXmlConverter().toReaderFromSource((javax.xml.transform.Source) value, exchange);
272            }
273        });
274        registry.addTypeConverter(java.io.Serializable.class, org.apache.camel.StreamCache.class, new SimpleTypeConverter(false) {
275            @Override
276            public Object doConvert(Exchange exchange, Object value) throws Exception {
277                return org.apache.camel.converter.stream.StreamCacheConverter.convertToSerializable((org.apache.camel.StreamCache) value, exchange);
278            }
279        });
280        registry.addTypeConverter(java.io.Serializable.class, org.apache.camel.component.file.GenericFile.class, new SimpleTypeConverter(false) {
281            @Override
282            public Object doConvert(Exchange exchange, Object value) throws Exception {
283                return org.apache.camel.component.file.GenericFileConverter.genericFileToSerializable((org.apache.camel.component.file.GenericFile) value, exchange);
284            }
285        });
286        registry.addTypeConverter(java.io.StringReader.class, java.lang.String.class, new SimpleTypeConverter(false) {
287            @Override
288            public Object doConvert(Exchange exchange, Object value) throws Exception {
289                return org.apache.camel.converter.IOConverter.toReader((java.lang.String) value);
290            }
291        });
292        registry.addTypeConverter(java.io.Writer.class, java.io.OutputStream.class, new SimpleTypeConverter(false) {
293            @Override
294            public Object doConvert(Exchange exchange, Object value) throws Exception {
295                return org.apache.camel.converter.IOConverter.toWriter((java.io.OutputStream) value, exchange);
296            }
297        });
298        registry.addTypeConverter(java.lang.Boolean.class, java.lang.String.class, new SimpleTypeConverter(false) {
299            @Override
300            public Object doConvert(Exchange exchange, Object value) throws Exception {
301                return org.apache.camel.converter.ObjectConverter.toBoolean((java.lang.String) value);
302            }
303        });
304        registry.addTypeConverter(java.lang.Boolean.class, org.w3c.dom.NodeList.class, new SimpleTypeConverter(false) {
305            @Override
306            public Object doConvert(Exchange exchange, Object value) throws Exception {
307                return getXmlConverter().toBoolean((org.w3c.dom.NodeList) value);
308            }
309        });
310        registry.addTypeConverter(java.lang.Boolean.class, java.lang.Object.class, new SimpleTypeConverter(false) {
311            @Override
312            public Object doConvert(Exchange exchange, Object value) throws Exception {
313                return org.apache.camel.converter.ObjectConverter.toBoolean(value);
314            }
315        });
316        registry.addTypeConverter(java.lang.Byte.class, java.lang.Object.class, new SimpleTypeConverter(false) {
317            @Override
318            public Object doConvert(Exchange exchange, Object value) throws Exception {
319                return org.apache.camel.converter.ObjectConverter.toByte(value);
320            }
321        });
322        registry.addTypeConverter(java.lang.CharSequence.class, java.net.URI.class, new SimpleTypeConverter(false) {
323            @Override
324            public Object doConvert(Exchange exchange, Object value) throws Exception {
325                return org.apache.camel.impl.converter.UriTypeConverter.toCharSequence((java.net.URI) value);
326            }
327        });
328        registry.addTypeConverter(java.lang.Character.class, java.lang.String.class, new SimpleTypeConverter(false) {
329            @Override
330            public Object doConvert(Exchange exchange, Object value) throws Exception {
331                return org.apache.camel.converter.ObjectConverter.toCharacter((java.lang.String) value);
332            }
333        });
334        registry.addTypeConverter(java.lang.Class.class, java.lang.Object.class, new SimpleTypeConverter(false) {
335            @Override
336            public Object doConvert(Exchange exchange, Object value) throws Exception {
337                return org.apache.camel.converter.ObjectConverter.toClass(value, exchange);
338            }
339        });
340        registry.addTypeConverter(java.lang.Double.class, java.lang.String.class, new SimpleTypeConverter(false) {
341            @Override
342            public Object doConvert(Exchange exchange, Object value) throws Exception {
343                return org.apache.camel.converter.ObjectConverter.toDouble((java.lang.String) value);
344            }
345        });
346        registry.addTypeConverter(java.lang.Double.class, java.lang.Object.class, new SimpleTypeConverter(false) {
347            @Override
348            public Object doConvert(Exchange exchange, Object value) throws Exception {
349                return org.apache.camel.converter.ObjectConverter.toDouble(value);
350            }
351        });
352        registry.addTypeConverter(java.lang.Float.class, java.lang.String.class, new SimpleTypeConverter(false) {
353            @Override
354            public Object doConvert(Exchange exchange, Object value) throws Exception {
355                return org.apache.camel.converter.ObjectConverter.toFloat((java.lang.String) value);
356            }
357        });
358        registry.addTypeConverter(java.lang.Float.class, java.lang.Object.class, new SimpleTypeConverter(false) {
359            @Override
360            public Object doConvert(Exchange exchange, Object value) throws Exception {
361                return org.apache.camel.converter.ObjectConverter.toFloat(value);
362            }
363        });
364        registry.addTypeConverter(java.lang.Integer.class, java.lang.String.class, new SimpleTypeConverter(false) {
365            @Override
366            public Object doConvert(Exchange exchange, Object value) throws Exception {
367                return org.apache.camel.converter.ObjectConverter.toInteger((java.lang.String) value);
368            }
369        });
370        registry.addTypeConverter(java.lang.Integer.class, org.w3c.dom.NodeList.class, new SimpleTypeConverter(false) {
371            @Override
372            public Object doConvert(Exchange exchange, Object value) throws Exception {
373                return org.apache.camel.converter.jaxp.DomConverter.toInteger((org.w3c.dom.NodeList) value);
374            }
375        });
376        registry.addTypeConverter(java.lang.Integer.class, java.lang.Object.class, new SimpleTypeConverter(false) {
377            @Override
378            public Object doConvert(Exchange exchange, Object value) throws Exception {
379                return org.apache.camel.converter.ObjectConverter.toInteger(value);
380            }
381        });
382        registry.addTypeConverter(java.lang.Iterable.class, java.lang.Object.class, new SimpleTypeConverter(false) {
383            @Override
384            public Object doConvert(Exchange exchange, Object value) throws Exception {
385                return org.apache.camel.converter.ObjectConverter.iterable(value);
386            }
387        });
388        registry.addTypeConverter(java.lang.Long.class, java.lang.String.class, new SimpleTypeConverter(false) {
389            @Override
390            public Object doConvert(Exchange exchange, Object value) throws Exception {
391                return org.apache.camel.converter.ObjectConverter.toLong((java.lang.String) value);
392            }
393        });
394        registry.addTypeConverter(java.lang.Long.class, java.sql.Timestamp.class, new SimpleTypeConverter(false) {
395            @Override
396            public Object doConvert(Exchange exchange, Object value) throws Exception {
397                return org.apache.camel.converter.SQLConverter.toLong((java.sql.Timestamp) value);
398            }
399        });
400        registry.addTypeConverter(java.lang.Long.class, java.util.Date.class, new SimpleTypeConverter(false) {
401            @Override
402            public Object doConvert(Exchange exchange, Object value) throws Exception {
403                return org.apache.camel.converter.DateTimeConverter.toLong((java.util.Date) value);
404            }
405        });
406        registry.addTypeConverter(java.lang.Long.class, org.w3c.dom.NodeList.class, new SimpleTypeConverter(false) {
407            @Override
408            public Object doConvert(Exchange exchange, Object value) throws Exception {
409                return org.apache.camel.converter.jaxp.DomConverter.toLong((org.w3c.dom.NodeList) value);
410            }
411        });
412        registry.addTypeConverter(java.lang.Long.class, java.lang.Object.class, new SimpleTypeConverter(false) {
413            @Override
414            public Object doConvert(Exchange exchange, Object value) throws Exception {
415                return org.apache.camel.converter.ObjectConverter.toLong(value);
416            }
417        });
418        registry.addTypeConverter(java.lang.Object[].class, java.util.Collection.class, new SimpleTypeConverter(false) {
419            @Override
420            public Object doConvert(Exchange exchange, Object value) throws Exception {
421                return org.apache.camel.converter.CollectionConverter.toArray((java.util.Collection) value);
422            }
423        });
424        registry.addTypeConverter(java.lang.Short.class, java.lang.Object.class, new SimpleTypeConverter(false) {
425            @Override
426            public Object doConvert(Exchange exchange, Object value) throws Exception {
427                return org.apache.camel.converter.ObjectConverter.toShort(value);
428            }
429        });
430        registry.addTypeConverter(java.lang.String.class, byte[].class, new SimpleTypeConverter(false) {
431            @Override
432            public Object doConvert(Exchange exchange, Object value) throws Exception {
433                return org.apache.camel.converter.IOConverter.toString((byte[]) value, exchange);
434            }
435        });
436        registry.addTypeConverter(java.lang.String.class, char[].class, new SimpleTypeConverter(false) {
437            @Override
438            public Object doConvert(Exchange exchange, Object value) throws Exception {
439                return org.apache.camel.converter.ObjectConverter.fromCharArray((char[]) value);
440            }
441        });
442        registry.addTypeConverter(java.lang.String.class, java.io.BufferedReader.class, new SimpleTypeConverter(false) {
443            @Override
444            public Object doConvert(Exchange exchange, Object value) throws Exception {
445                return org.apache.camel.converter.IOConverter.toString((java.io.BufferedReader) value);
446            }
447        });
448        registry.addTypeConverter(java.lang.String.class, java.io.ByteArrayOutputStream.class, new SimpleTypeConverter(false) {
449            @Override
450            public Object doConvert(Exchange exchange, Object value) throws Exception {
451                return org.apache.camel.converter.IOConverter.toString((java.io.ByteArrayOutputStream) value, exchange);
452            }
453        });
454        registry.addTypeConverter(java.lang.String.class, java.io.File.class, new SimpleTypeConverter(false) {
455            @Override
456            public Object doConvert(Exchange exchange, Object value) throws Exception {
457                return org.apache.camel.converter.IOConverter.toString((java.io.File) value, exchange);
458            }
459        });
460        registry.addTypeConverter(java.lang.String.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
461            @Override
462            public Object doConvert(Exchange exchange, Object value) throws Exception {
463                return org.apache.camel.converter.IOConverter.toString((java.io.InputStream) value, exchange);
464            }
465        });
466        registry.addTypeConverter(java.lang.String.class, java.io.Reader.class, new SimpleTypeConverter(false) {
467            @Override
468            public Object doConvert(Exchange exchange, Object value) throws Exception {
469                return org.apache.camel.converter.IOConverter.toString((java.io.Reader) value);
470            }
471        });
472        registry.addTypeConverter(java.lang.String.class, java.lang.Boolean.class, new SimpleTypeConverter(false) {
473            @Override
474            public Object doConvert(Exchange exchange, Object value) throws Exception {
475                return org.apache.camel.converter.ObjectConverter.toString((java.lang.Boolean) value);
476            }
477        });
478        registry.addTypeConverter(java.lang.String.class, java.lang.Integer.class, new SimpleTypeConverter(false) {
479            @Override
480            public Object doConvert(Exchange exchange, Object value) throws Exception {
481                return org.apache.camel.converter.ObjectConverter.toString((java.lang.Integer) value);
482            }
483        });
484        registry.addTypeConverter(java.lang.String.class, java.lang.Long.class, new SimpleTypeConverter(false) {
485            @Override
486            public Object doConvert(Exchange exchange, Object value) throws Exception {
487                return org.apache.camel.converter.ObjectConverter.toString((java.lang.Long) value);
488            }
489        });
490        registry.addTypeConverter(java.lang.String.class, java.lang.StringBuffer.class, new SimpleTypeConverter(false) {
491            @Override
492            public Object doConvert(Exchange exchange, Object value) throws Exception {
493                return org.apache.camel.converter.ObjectConverter.toString((java.lang.StringBuffer) value);
494            }
495        });
496        registry.addTypeConverter(java.lang.String.class, java.lang.StringBuilder.class, new SimpleTypeConverter(false) {
497            @Override
498            public Object doConvert(Exchange exchange, Object value) throws Exception {
499                return org.apache.camel.converter.ObjectConverter.toString((java.lang.StringBuilder) value);
500            }
501        });
502        registry.addTypeConverter(java.lang.String.class, java.net.URL.class, new SimpleTypeConverter(false) {
503            @Override
504            public Object doConvert(Exchange exchange, Object value) throws Exception {
505                return org.apache.camel.converter.IOConverter.toString((java.net.URL) value, exchange);
506            }
507        });
508        registry.addTypeConverter(java.lang.String.class, java.nio.ByteBuffer.class, new SimpleTypeConverter(false) {
509            @Override
510            public Object doConvert(Exchange exchange, Object value) throws Exception {
511                return org.apache.camel.converter.NIOConverter.toString((java.nio.ByteBuffer) value, exchange);
512            }
513        });
514        registry.addTypeConverter(java.lang.String.class, java.time.Duration.class, new SimpleTypeConverter(false) {
515            @Override
516            public Object doConvert(Exchange exchange, Object value) throws Exception {
517                return org.apache.camel.converter.DurationConverter.toString((java.time.Duration) value);
518            }
519        });
520        registry.addTypeConverter(java.lang.String.class, javax.xml.transform.Source.class, new SimpleTypeConverter(false) {
521            @Override
522            public Object doConvert(Exchange exchange, Object value) throws Exception {
523                return getXmlConverter().toString((javax.xml.transform.Source) value, exchange);
524            }
525        });
526        registry.addTypeConverter(java.lang.String.class, org.apache.camel.component.file.GenericFile.class, new SimpleTypeConverter(false) {
527            @Override
528            public Object doConvert(Exchange exchange, Object value) throws Exception {
529                return org.apache.camel.component.file.GenericFileConverter.genericFileToString((org.apache.camel.component.file.GenericFile) value, exchange);
530            }
531        });
532        registry.addTypeConverter(java.lang.String.class, org.w3c.dom.Node.class, new SimpleTypeConverter(false) {
533            @Override
534            public Object doConvert(Exchange exchange, Object value) throws Exception {
535                return getXmlConverter().toString((org.w3c.dom.Node) value, exchange);
536            }
537        });
538        registry.addTypeConverter(java.lang.String.class, org.w3c.dom.NodeList.class, new SimpleTypeConverter(false) {
539            @Override
540            public Object doConvert(Exchange exchange, Object value) throws Exception {
541                return getDomConverter().toString((org.w3c.dom.NodeList) value, exchange);
542            }
543        });
544        registry.addTypeConverter(java.math.BigInteger.class, java.lang.Object.class, new SimpleTypeConverter(false) {
545            @Override
546            public Object doConvert(Exchange exchange, Object value) throws Exception {
547                return org.apache.camel.converter.ObjectConverter.toBigInteger(value);
548            }
549        });
550        registry.addTypeConverter(java.net.URI.class, java.lang.CharSequence.class, new SimpleTypeConverter(false) {
551            @Override
552            public Object doConvert(Exchange exchange, Object value) throws Exception {
553                return org.apache.camel.impl.converter.UriTypeConverter.toUri((java.lang.CharSequence) value);
554            }
555        });
556        registry.addTypeConverter(java.nio.ByteBuffer.class, byte[].class, new SimpleTypeConverter(false) {
557            @Override
558            public Object doConvert(Exchange exchange, Object value) throws Exception {
559                return org.apache.camel.converter.NIOConverter.toByteBuffer((byte[]) value);
560            }
561        });
562        registry.addTypeConverter(java.nio.ByteBuffer.class, java.io.File.class, new SimpleTypeConverter(false) {
563            @Override
564            public Object doConvert(Exchange exchange, Object value) throws Exception {
565                return org.apache.camel.converter.NIOConverter.toByteBuffer((java.io.File) value);
566            }
567        });
568        registry.addTypeConverter(java.nio.ByteBuffer.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
569            @Override
570            public Object doConvert(Exchange exchange, Object value) throws Exception {
571                return org.apache.camel.converter.IOConverter.covertToByteBuffer((java.io.InputStream) value);
572            }
573        });
574        registry.addTypeConverter(java.nio.ByteBuffer.class, java.lang.Double.class, new SimpleTypeConverter(false) {
575            @Override
576            public Object doConvert(Exchange exchange, Object value) throws Exception {
577                return org.apache.camel.converter.NIOConverter.toByteBuffer((java.lang.Double) value);
578            }
579        });
580        registry.addTypeConverter(java.nio.ByteBuffer.class, java.lang.Float.class, new SimpleTypeConverter(false) {
581            @Override
582            public Object doConvert(Exchange exchange, Object value) throws Exception {
583                return org.apache.camel.converter.NIOConverter.toByteBuffer((java.lang.Float) value);
584            }
585        });
586        registry.addTypeConverter(java.nio.ByteBuffer.class, java.lang.Integer.class, new SimpleTypeConverter(false) {
587            @Override
588            public Object doConvert(Exchange exchange, Object value) throws Exception {
589                return org.apache.camel.converter.NIOConverter.toByteBuffer((java.lang.Integer) value);
590            }
591        });
592        registry.addTypeConverter(java.nio.ByteBuffer.class, java.lang.Long.class, new SimpleTypeConverter(false) {
593            @Override
594            public Object doConvert(Exchange exchange, Object value) throws Exception {
595                return org.apache.camel.converter.NIOConverter.toByteBuffer((java.lang.Long) value);
596            }
597        });
598        registry.addTypeConverter(java.nio.ByteBuffer.class, java.lang.Short.class, new SimpleTypeConverter(false) {
599            @Override
600            public Object doConvert(Exchange exchange, Object value) throws Exception {
601                return org.apache.camel.converter.NIOConverter.toByteBuffer((java.lang.Short) value);
602            }
603        });
604        registry.addTypeConverter(java.nio.ByteBuffer.class, java.lang.String.class, new SimpleTypeConverter(false) {
605            @Override
606            public Object doConvert(Exchange exchange, Object value) throws Exception {
607                return org.apache.camel.converter.NIOConverter.toByteBuffer((java.lang.String) value, exchange);
608            }
609        });
610        registry.addTypeConverter(java.nio.ByteBuffer.class, org.apache.camel.StreamCache.class, new SimpleTypeConverter(false) {
611            @Override
612            public Object doConvert(Exchange exchange, Object value) throws Exception {
613                return org.apache.camel.converter.stream.StreamCacheConverter.convertToByteBuffer((org.apache.camel.StreamCache) value, exchange);
614            }
615        });
616        registry.addTypeConverter(java.sql.Timestamp.class, java.lang.Long.class, new SimpleTypeConverter(false) {
617            @Override
618            public Object doConvert(Exchange exchange, Object value) throws Exception {
619                return org.apache.camel.converter.SQLConverter.toTimestamp((java.lang.Long) value);
620            }
621        });
622        registry.addTypeConverter(java.time.Duration.class, java.lang.String.class, new SimpleTypeConverter(false) {
623            @Override
624            public Object doConvert(Exchange exchange, Object value) throws Exception {
625                return org.apache.camel.converter.DurationConverter.toDuration((java.lang.String) value);
626            }
627        });
628        registry.addTypeConverter(java.util.ArrayList.class, java.util.Iterator.class, new SimpleTypeConverter(false) {
629            @Override
630            public Object doConvert(Exchange exchange, Object value) throws Exception {
631                return org.apache.camel.converter.CollectionConverter.toArrayList((java.util.Iterator) value);
632            }
633        });
634        registry.addTypeConverter(java.util.Date.class, java.lang.Long.class, new SimpleTypeConverter(false) {
635            @Override
636            public Object doConvert(Exchange exchange, Object value) throws Exception {
637                return org.apache.camel.converter.DateTimeConverter.toDate((java.lang.Long) value);
638            }
639        });
640        registry.addTypeConverter(java.util.HashMap.class, java.util.Map.class, new SimpleTypeConverter(false) {
641            @Override
642            public Object doConvert(Exchange exchange, Object value) throws Exception {
643                return org.apache.camel.converter.CollectionConverter.toHashMap((java.util.Map) value);
644            }
645        });
646        registry.addTypeConverter(java.util.Hashtable.class, java.util.Map.class, new SimpleTypeConverter(false) {
647            @Override
648            public Object doConvert(Exchange exchange, Object value) throws Exception {
649                return org.apache.camel.converter.CollectionConverter.toHashtable((java.util.Map) value);
650            }
651        });
652        registry.addTypeConverter(java.util.Iterator.class, java.lang.Object.class, new SimpleTypeConverter(false) {
653            @Override
654            public Object doConvert(Exchange exchange, Object value) throws Exception {
655                return org.apache.camel.converter.ObjectConverter.iterator(value);
656            }
657        });
658        registry.addTypeConverter(java.util.List.class, java.lang.Iterable.class, new SimpleTypeConverter(false) {
659            @Override
660            public Object doConvert(Exchange exchange, Object value) throws Exception {
661                return org.apache.camel.converter.CollectionConverter.toList((java.lang.Iterable) value);
662            }
663        });
664        registry.addTypeConverter(java.util.List.class, java.lang.Object[].class, new SimpleTypeConverter(false) {
665            @Override
666            public Object doConvert(Exchange exchange, Object value) throws Exception {
667                return org.apache.camel.converter.CollectionConverter.toList((java.lang.Object[]) value);
668            }
669        });
670        registry.addTypeConverter(java.util.List.class, java.util.Collection.class, new SimpleTypeConverter(false) {
671            @Override
672            public Object doConvert(Exchange exchange, Object value) throws Exception {
673                return org.apache.camel.converter.CollectionConverter.toList((java.util.Collection) value);
674            }
675        });
676        registry.addTypeConverter(java.util.List.class, org.w3c.dom.NodeList.class, new SimpleTypeConverter(false) {
677            @Override
678            public Object doConvert(Exchange exchange, Object value) throws Exception {
679                return org.apache.camel.converter.jaxp.DomConverter.toList((org.w3c.dom.NodeList) value);
680            }
681        });
682        registry.addTypeConverter(java.util.Properties.class, java.io.File.class, new SimpleTypeConverter(false) {
683            @Override
684            public Object doConvert(Exchange exchange, Object value) throws Exception {
685                return org.apache.camel.converter.IOConverter.toProperties((java.io.File) value);
686            }
687        });
688        registry.addTypeConverter(java.util.Properties.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
689            @Override
690            public Object doConvert(Exchange exchange, Object value) throws Exception {
691                return org.apache.camel.converter.IOConverter.toProperties((java.io.InputStream) value);
692            }
693        });
694        registry.addTypeConverter(java.util.Properties.class, java.io.Reader.class, new SimpleTypeConverter(false) {
695            @Override
696            public Object doConvert(Exchange exchange, Object value) throws Exception {
697                return org.apache.camel.converter.IOConverter.toProperties((java.io.Reader) value);
698            }
699        });
700        registry.addTypeConverter(java.util.Properties.class, java.util.Map.class, new SimpleTypeConverter(false) {
701            @Override
702            public Object doConvert(Exchange exchange, Object value) throws Exception {
703                return org.apache.camel.converter.CollectionConverter.toProperties((java.util.Map) value);
704            }
705        });
706        registry.addTypeConverter(java.util.Set.class, java.lang.Object[].class, new SimpleTypeConverter(false) {
707            @Override
708            public Object doConvert(Exchange exchange, Object value) throws Exception {
709                return org.apache.camel.converter.CollectionConverter.toSet((java.lang.Object[]) value);
710            }
711        });
712        registry.addTypeConverter(java.util.Set.class, java.util.Collection.class, new SimpleTypeConverter(false) {
713            @Override
714            public Object doConvert(Exchange exchange, Object value) throws Exception {
715                return org.apache.camel.converter.CollectionConverter.toSet((java.util.Collection) value);
716            }
717        });
718        registry.addTypeConverter(java.util.Set.class, java.util.Map.class, new SimpleTypeConverter(false) {
719            @Override
720            public Object doConvert(Exchange exchange, Object value) throws Exception {
721                return org.apache.camel.converter.CollectionConverter.toSet((java.util.Map) value);
722            }
723        });
724        registry.addTypeConverter(java.util.TimeZone.class, java.lang.String.class, new SimpleTypeConverter(false) {
725            @Override
726            public Object doConvert(Exchange exchange, Object value) throws Exception {
727                return org.apache.camel.converter.DateTimeConverter.toTimeZone((java.lang.String) value);
728            }
729        });
730        registry.addTypeConverter(javax.activation.DataHandler.class, org.apache.camel.Attachment.class, new SimpleTypeConverter(false) {
731            @Override
732            public Object doConvert(Exchange exchange, Object value) throws Exception {
733                return org.apache.camel.converter.AttachmentConverter.toDataHandler((org.apache.camel.Attachment) value);
734            }
735        });
736        registry.addTypeConverter(javax.xml.stream.XMLEventReader.class, java.io.File.class, new SimpleTypeConverter(false) {
737            @Override
738            public Object doConvert(Exchange exchange, Object value) throws Exception {
739                return getStaxConverter().createXMLEventReader((java.io.File) value, exchange);
740            }
741        });
742        registry.addTypeConverter(javax.xml.stream.XMLEventReader.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
743            @Override
744            public Object doConvert(Exchange exchange, Object value) throws Exception {
745                return getStaxConverter().createXMLEventReader((java.io.InputStream) value, exchange);
746            }
747        });
748        registry.addTypeConverter(javax.xml.stream.XMLEventReader.class, java.io.Reader.class, new SimpleTypeConverter(false) {
749            @Override
750            public Object doConvert(Exchange exchange, Object value) throws Exception {
751                return getStaxConverter().createXMLEventReader((java.io.Reader) value);
752            }
753        });
754        registry.addTypeConverter(javax.xml.stream.XMLEventReader.class, javax.xml.stream.XMLStreamReader.class, new SimpleTypeConverter(false) {
755            @Override
756            public Object doConvert(Exchange exchange, Object value) throws Exception {
757                return getStaxConverter().createXMLEventReader((javax.xml.stream.XMLStreamReader) value);
758            }
759        });
760        registry.addTypeConverter(javax.xml.stream.XMLEventReader.class, javax.xml.transform.Source.class, new SimpleTypeConverter(false) {
761            @Override
762            public Object doConvert(Exchange exchange, Object value) throws Exception {
763                return getStaxConverter().createXMLEventReader((javax.xml.transform.Source) value);
764            }
765        });
766        registry.addTypeConverter(javax.xml.stream.XMLEventWriter.class, java.io.OutputStream.class, new SimpleTypeConverter(false) {
767            @Override
768            public Object doConvert(Exchange exchange, Object value) throws Exception {
769                return getStaxConverter().createXMLEventWriter((java.io.OutputStream) value, exchange);
770            }
771        });
772        registry.addTypeConverter(javax.xml.stream.XMLEventWriter.class, java.io.Writer.class, new SimpleTypeConverter(false) {
773            @Override
774            public Object doConvert(Exchange exchange, Object value) throws Exception {
775                return getStaxConverter().createXMLEventWriter((java.io.Writer) value);
776            }
777        });
778        registry.addTypeConverter(javax.xml.stream.XMLEventWriter.class, javax.xml.transform.Result.class, new SimpleTypeConverter(false) {
779            @Override
780            public Object doConvert(Exchange exchange, Object value) throws Exception {
781                return getStaxConverter().createXMLEventWriter((javax.xml.transform.Result) value);
782            }
783        });
784        registry.addTypeConverter(javax.xml.stream.XMLStreamReader.class, java.io.File.class, new SimpleTypeConverter(false) {
785            @Override
786            public Object doConvert(Exchange exchange, Object value) throws Exception {
787                return getStaxConverter().createXMLStreamReader((java.io.File) value, exchange);
788            }
789        });
790        registry.addTypeConverter(javax.xml.stream.XMLStreamReader.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
791            @Override
792            public Object doConvert(Exchange exchange, Object value) throws Exception {
793                return getStaxConverter().createXMLStreamReader((java.io.InputStream) value, exchange);
794            }
795        });
796        registry.addTypeConverter(javax.xml.stream.XMLStreamReader.class, java.io.Reader.class, new SimpleTypeConverter(false) {
797            @Override
798            public Object doConvert(Exchange exchange, Object value) throws Exception {
799                return getStaxConverter().createXMLStreamReader((java.io.Reader) value);
800            }
801        });
802        registry.addTypeConverter(javax.xml.stream.XMLStreamReader.class, java.lang.String.class, new SimpleTypeConverter(false) {
803            @Override
804            public Object doConvert(Exchange exchange, Object value) throws Exception {
805                return getStaxConverter().createXMLStreamReader((java.lang.String) value);
806            }
807        });
808        registry.addTypeConverter(javax.xml.stream.XMLStreamReader.class, javax.xml.transform.Source.class, new SimpleTypeConverter(false) {
809            @Override
810            public Object doConvert(Exchange exchange, Object value) throws Exception {
811                return getStaxConverter().createXMLStreamReader((javax.xml.transform.Source) value);
812            }
813        });
814        registry.addTypeConverter(javax.xml.stream.XMLStreamWriter.class, java.io.OutputStream.class, new SimpleTypeConverter(false) {
815            @Override
816            public Object doConvert(Exchange exchange, Object value) throws Exception {
817                return getStaxConverter().createXMLStreamWriter((java.io.OutputStream) value, exchange);
818            }
819        });
820        registry.addTypeConverter(javax.xml.stream.XMLStreamWriter.class, java.io.Writer.class, new SimpleTypeConverter(false) {
821            @Override
822            public Object doConvert(Exchange exchange, Object value) throws Exception {
823                return getStaxConverter().createXMLStreamWriter((java.io.Writer) value);
824            }
825        });
826        registry.addTypeConverter(javax.xml.stream.XMLStreamWriter.class, javax.xml.transform.Result.class, new SimpleTypeConverter(false) {
827            @Override
828            public Object doConvert(Exchange exchange, Object value) throws Exception {
829                return getStaxConverter().createXMLStreamWriter((javax.xml.transform.Result) value);
830            }
831        });
832        registry.addTypeConverter(javax.xml.transform.Source.class, java.lang.String.class, new SimpleTypeConverter(false) {
833            @Override
834            public Object doConvert(Exchange exchange, Object value) throws Exception {
835                return getXmlConverter().toSource((java.lang.String) value);
836            }
837        });
838        registry.addTypeConverter(javax.xml.transform.dom.DOMSource.class, byte[].class, new SimpleTypeConverter(false) {
839            @Override
840            public Object doConvert(Exchange exchange, Object value) throws Exception {
841                return getXmlConverter().toDOMSource((byte[]) value);
842            }
843        });
844        registry.addTypeConverter(javax.xml.transform.dom.DOMSource.class, java.io.File.class, new SimpleTypeConverter(false) {
845            @Override
846            public Object doConvert(Exchange exchange, Object value) throws Exception {
847                return getXmlConverter().toDOMSource((java.io.File) value, exchange);
848            }
849        });
850        registry.addTypeConverter(javax.xml.transform.dom.DOMSource.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
851            @Override
852            public Object doConvert(Exchange exchange, Object value) throws Exception {
853                return getXmlConverter().toDOMSource((java.io.InputStream) value, exchange);
854            }
855        });
856        registry.addTypeConverter(javax.xml.transform.dom.DOMSource.class, java.lang.String.class, new SimpleTypeConverter(false) {
857            @Override
858            public Object doConvert(Exchange exchange, Object value) throws Exception {
859                return getXmlConverter().toDOMSource((java.lang.String) value);
860            }
861        });
862        registry.addTypeConverter(javax.xml.transform.dom.DOMSource.class, javax.xml.transform.sax.SAXSource.class, new SimpleTypeConverter(false) {
863            @Override
864            public Object doConvert(Exchange exchange, Object value) throws Exception {
865                return getXmlConverter().toDOMSourceFromSAX((javax.xml.transform.sax.SAXSource) value);
866            }
867        });
868        registry.addTypeConverter(javax.xml.transform.dom.DOMSource.class, javax.xml.transform.stax.StAXSource.class, new SimpleTypeConverter(false) {
869            @Override
870            public Object doConvert(Exchange exchange, Object value) throws Exception {
871                return getXmlConverter().toDOMSourceFromStAX((javax.xml.transform.stax.StAXSource) value);
872            }
873        });
874        registry.addTypeConverter(javax.xml.transform.dom.DOMSource.class, javax.xml.transform.stream.StreamSource.class, new SimpleTypeConverter(false) {
875            @Override
876            public Object doConvert(Exchange exchange, Object value) throws Exception {
877                return getXmlConverter().toDOMSourceFromStream((javax.xml.transform.stream.StreamSource) value, exchange);
878            }
879        });
880        registry.addTypeConverter(javax.xml.transform.dom.DOMSource.class, javax.xml.transform.Source.class, new SimpleTypeConverter(false) {
881            @Override
882            public Object doConvert(Exchange exchange, Object value) throws Exception {
883                return getXmlConverter().toDOMSource((javax.xml.transform.Source) value, exchange);
884            }
885        });
886        registry.addTypeConverter(javax.xml.transform.dom.DOMSource.class, org.w3c.dom.Document.class, new SimpleTypeConverter(false) {
887            @Override
888            public Object doConvert(Exchange exchange, Object value) throws Exception {
889                return getXmlConverter().toDOMSource((org.w3c.dom.Document) value);
890            }
891        });
892        registry.addTypeConverter(javax.xml.transform.dom.DOMSource.class, org.w3c.dom.Node.class, new SimpleTypeConverter(false) {
893            @Override
894            public Object doConvert(Exchange exchange, Object value) throws Exception {
895                return getXmlConverter().toDOMSource((org.w3c.dom.Node) value);
896            }
897        });
898        registry.addTypeConverter(javax.xml.transform.sax.SAXSource.class, byte[].class, new SimpleTypeConverter(false) {
899            @Override
900            public Object doConvert(Exchange exchange, Object value) throws Exception {
901                return getXmlConverter().toSAXSource((byte[]) value, exchange);
902            }
903        });
904        registry.addTypeConverter(javax.xml.transform.sax.SAXSource.class, java.io.File.class, new SimpleTypeConverter(false) {
905            @Override
906            public Object doConvert(Exchange exchange, Object value) throws Exception {
907                return getXmlConverter().toSAXSource((java.io.File) value, exchange);
908            }
909        });
910        registry.addTypeConverter(javax.xml.transform.sax.SAXSource.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
911            @Override
912            public Object doConvert(Exchange exchange, Object value) throws Exception {
913                return getXmlConverter().toSAXSource((java.io.InputStream) value, exchange);
914            }
915        });
916        registry.addTypeConverter(javax.xml.transform.sax.SAXSource.class, java.lang.String.class, new SimpleTypeConverter(false) {
917            @Override
918            public Object doConvert(Exchange exchange, Object value) throws Exception {
919                return getXmlConverter().toSAXSource((java.lang.String) value, exchange);
920            }
921        });
922        registry.addTypeConverter(javax.xml.transform.sax.SAXSource.class, javax.xml.transform.dom.DOMSource.class, new SimpleTypeConverter(false) {
923            @Override
924            public Object doConvert(Exchange exchange, Object value) throws Exception {
925                return getXmlConverter().toSAXSourceFromDOM((javax.xml.transform.dom.DOMSource) value, exchange);
926            }
927        });
928        registry.addTypeConverter(javax.xml.transform.sax.SAXSource.class, javax.xml.transform.stax.StAXSource.class, new SimpleTypeConverter(false) {
929            @Override
930            public Object doConvert(Exchange exchange, Object value) throws Exception {
931                return getXmlConverter().toSAXSourceFromStAX((javax.xml.transform.stax.StAXSource) value, exchange);
932            }
933        });
934        registry.addTypeConverter(javax.xml.transform.sax.SAXSource.class, javax.xml.transform.stream.StreamSource.class, new SimpleTypeConverter(false) {
935            @Override
936            public Object doConvert(Exchange exchange, Object value) throws Exception {
937                return getXmlConverter().toSAXSourceFromStream((javax.xml.transform.stream.StreamSource) value, exchange);
938            }
939        });
940        registry.addTypeConverter(javax.xml.transform.sax.SAXSource.class, javax.xml.transform.Source.class, new SimpleTypeConverter(false) {
941            @Override
942            public Object doConvert(Exchange exchange, Object value) throws Exception {
943                return getXmlConverter().toSAXSource((javax.xml.transform.Source) value, exchange);
944            }
945        });
946        registry.addTypeConverter(javax.xml.transform.stax.StAXSource.class, byte[].class, new SimpleTypeConverter(false) {
947            @Override
948            public Object doConvert(Exchange exchange, Object value) throws Exception {
949                return getXmlConverter().toStAXSource((byte[]) value, exchange);
950            }
951        });
952        registry.addTypeConverter(javax.xml.transform.stax.StAXSource.class, java.io.File.class, new SimpleTypeConverter(false) {
953            @Override
954            public Object doConvert(Exchange exchange, Object value) throws Exception {
955                return getXmlConverter().toStAXSource((java.io.File) value, exchange);
956            }
957        });
958        registry.addTypeConverter(javax.xml.transform.stax.StAXSource.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
959            @Override
960            public Object doConvert(Exchange exchange, Object value) throws Exception {
961                return getXmlConverter().toStAXSource((java.io.InputStream) value, exchange);
962            }
963        });
964        registry.addTypeConverter(javax.xml.transform.stax.StAXSource.class, java.lang.String.class, new SimpleTypeConverter(false) {
965            @Override
966            public Object doConvert(Exchange exchange, Object value) throws Exception {
967                return getXmlConverter().toStAXSource((java.lang.String) value, exchange);
968            }
969        });
970        registry.addTypeConverter(javax.xml.transform.stream.StreamSource.class, byte[].class, new SimpleTypeConverter(false) {
971            @Override
972            public Object doConvert(Exchange exchange, Object value) throws Exception {
973                return getXmlConverter().toStreamSource((byte[]) value, exchange);
974            }
975        });
976        registry.addTypeConverter(javax.xml.transform.stream.StreamSource.class, java.io.File.class, new SimpleTypeConverter(false) {
977            @Override
978            public Object doConvert(Exchange exchange, Object value) throws Exception {
979                return getXmlConverter().toStreamSource((java.io.File) value);
980            }
981        });
982        registry.addTypeConverter(javax.xml.transform.stream.StreamSource.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
983            @Override
984            public Object doConvert(Exchange exchange, Object value) throws Exception {
985                return getXmlConverter().toStreamSource((java.io.InputStream) value);
986            }
987        });
988        registry.addTypeConverter(javax.xml.transform.stream.StreamSource.class, java.io.Reader.class, new SimpleTypeConverter(false) {
989            @Override
990            public Object doConvert(Exchange exchange, Object value) throws Exception {
991                return getXmlConverter().toStreamSource((java.io.Reader) value);
992            }
993        });
994        registry.addTypeConverter(javax.xml.transform.stream.StreamSource.class, java.nio.ByteBuffer.class, new SimpleTypeConverter(false) {
995            @Override
996            public Object doConvert(Exchange exchange, Object value) throws Exception {
997                return getXmlConverter().toStreamSource((java.nio.ByteBuffer) value, exchange);
998            }
999        });
1000        registry.addTypeConverter(javax.xml.transform.stream.StreamSource.class, javax.xml.transform.dom.DOMSource.class, new SimpleTypeConverter(false) {
1001            @Override
1002            public Object doConvert(Exchange exchange, Object value) throws Exception {
1003                return getXmlConverter().toStreamSourceFromDOM((javax.xml.transform.dom.DOMSource) value, exchange);
1004            }
1005        });
1006        registry.addTypeConverter(javax.xml.transform.stream.StreamSource.class, javax.xml.transform.sax.SAXSource.class, new SimpleTypeConverter(false) {
1007            @Override
1008            public Object doConvert(Exchange exchange, Object value) throws Exception {
1009                return getXmlConverter().toStreamSourceFromSAX((javax.xml.transform.sax.SAXSource) value, exchange);
1010            }
1011        });
1012        registry.addTypeConverter(javax.xml.transform.stream.StreamSource.class, javax.xml.transform.stax.StAXSource.class, new SimpleTypeConverter(false) {
1013            @Override
1014            public Object doConvert(Exchange exchange, Object value) throws Exception {
1015                return getXmlConverter().toStreamSourceFromStAX((javax.xml.transform.stax.StAXSource) value, exchange);
1016            }
1017        });
1018        registry.addTypeConverter(javax.xml.transform.stream.StreamSource.class, javax.xml.transform.Source.class, new SimpleTypeConverter(false) {
1019            @Override
1020            public Object doConvert(Exchange exchange, Object value) throws Exception {
1021                return getXmlConverter().toStreamSource((javax.xml.transform.Source) value, exchange);
1022            }
1023        });
1024        registry.addTypeConverter(long.class, java.lang.String.class, new SimpleTypeConverter(false) {
1025            @Override
1026            public Object doConvert(Exchange exchange, Object value) throws Exception {
1027                return org.apache.camel.converter.TimePatternConverter.toMilliSeconds((java.lang.String) value);
1028            }
1029        });
1030        registry.addTypeConverter(long.class, java.time.Duration.class, new SimpleTypeConverter(false) {
1031            @Override
1032            public Object doConvert(Exchange exchange, Object value) throws Exception {
1033                return org.apache.camel.converter.DurationConverter.toMilliSeconds((java.time.Duration) value);
1034            }
1035        });
1036        registry.addTypeConverter(org.apache.camel.BytesSource.class, byte[].class, new SimpleTypeConverter(false) {
1037            @Override
1038            public Object doConvert(Exchange exchange, Object value) throws Exception {
1039                return getXmlConverter().toBytesSource((byte[]) value);
1040            }
1041        });
1042        registry.addTypeConverter(org.apache.camel.Processor.class, org.apache.camel.Expression.class, new SimpleTypeConverter(false) {
1043            @Override
1044            public Object doConvert(Exchange exchange, Object value) throws Exception {
1045                return org.apache.camel.converter.CamelConverter.toProcessor((org.apache.camel.Expression) value);
1046            }
1047        });
1048        registry.addTypeConverter(org.apache.camel.Processor.class, org.apache.camel.Predicate.class, new SimpleTypeConverter(false) {
1049            @Override
1050            public Object doConvert(Exchange exchange, Object value) throws Exception {
1051                return org.apache.camel.converter.CamelConverter.toProcessor((org.apache.camel.Predicate) value);
1052            }
1053        });
1054        registry.addTypeConverter(org.apache.camel.StreamCache.class, java.io.ByteArrayInputStream.class, new SimpleTypeConverter(false) {
1055            @Override
1056            public Object doConvert(Exchange exchange, Object value) throws Exception {
1057                return org.apache.camel.converter.stream.StreamCacheConverter.convertToStreamCache((java.io.ByteArrayInputStream) value, exchange);
1058            }
1059        });
1060        registry.addTypeConverter(org.apache.camel.StreamCache.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
1061            @Override
1062            public Object doConvert(Exchange exchange, Object value) throws Exception {
1063                return org.apache.camel.converter.stream.StreamCacheConverter.convertToStreamCache((java.io.InputStream) value, exchange);
1064            }
1065        });
1066        registry.addTypeConverter(org.apache.camel.StreamCache.class, java.io.Reader.class, new SimpleTypeConverter(false) {
1067            @Override
1068            public Object doConvert(Exchange exchange, Object value) throws Exception {
1069                return org.apache.camel.converter.stream.StreamCacheConverter.convertToStreamCache((java.io.Reader) value, exchange);
1070            }
1071        });
1072        registry.addTypeConverter(org.apache.camel.StreamCache.class, javax.xml.transform.sax.SAXSource.class, new SimpleTypeConverter(false) {
1073            @Override
1074            public Object doConvert(Exchange exchange, Object value) throws Exception {
1075                return org.apache.camel.converter.stream.StreamCacheConverter.convertToStreamCache((javax.xml.transform.sax.SAXSource) value, exchange);
1076            }
1077        });
1078        registry.addTypeConverter(org.apache.camel.StreamCache.class, org.apache.camel.BytesSource.class, new SimpleTypeConverter(false) {
1079            @Override
1080            public Object doConvert(Exchange exchange, Object value) throws Exception {
1081                return org.apache.camel.converter.stream.StreamCacheConverter.convertToStreamCache((org.apache.camel.BytesSource) value);
1082            }
1083        });
1084        registry.addTypeConverter(org.apache.camel.StreamCache.class, org.apache.camel.StringSource.class, new SimpleTypeConverter(false) {
1085            @Override
1086            public Object doConvert(Exchange exchange, Object value) throws Exception {
1087                return org.apache.camel.converter.stream.StreamCacheConverter.convertToStreamCache((org.apache.camel.StringSource) value);
1088            }
1089        });
1090        registry.addTypeConverter(org.apache.camel.StreamCache.class, javax.xml.transform.stream.StreamSource.class, new SimpleTypeConverter(false) {
1091            @Override
1092            public Object doConvert(Exchange exchange, Object value) throws Exception {
1093                return org.apache.camel.converter.stream.StreamCacheConverter.convertToStreamCache((javax.xml.transform.stream.StreamSource) value, exchange);
1094            }
1095        });
1096        registry.addTypeConverter(org.apache.camel.StreamCache.class, org.apache.camel.converter.stream.CachedOutputStream.class, new SimpleTypeConverter(false) {
1097            @Override
1098            public Object doConvert(Exchange exchange, Object value) throws Exception {
1099                return org.apache.camel.converter.stream.StreamCacheConverter.convertToStreamCache((org.apache.camel.converter.stream.CachedOutputStream) value, exchange);
1100            }
1101        });
1102        registry.addTypeConverter(org.apache.camel.StringSource.class, java.lang.String.class, new SimpleTypeConverter(false) {
1103            @Override
1104            public Object doConvert(Exchange exchange, Object value) throws Exception {
1105                return getXmlConverter().toStringSource((java.lang.String) value);
1106            }
1107        });
1108        registry.addTypeConverter(org.w3c.dom.Document.class, byte[].class, new SimpleTypeConverter(false) {
1109            @Override
1110            public Object doConvert(Exchange exchange, Object value) throws Exception {
1111                return getXmlConverter().toDOMDocument((byte[]) value, exchange);
1112            }
1113        });
1114        registry.addTypeConverter(org.w3c.dom.Document.class, java.io.File.class, new SimpleTypeConverter(false) {
1115            @Override
1116            public Object doConvert(Exchange exchange, Object value) throws Exception {
1117                return getXmlConverter().toDOMDocument((java.io.File) value, exchange);
1118            }
1119        });
1120        registry.addTypeConverter(org.w3c.dom.Document.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
1121            @Override
1122            public Object doConvert(Exchange exchange, Object value) throws Exception {
1123                return getXmlConverter().toDOMDocument((java.io.InputStream) value, exchange);
1124            }
1125        });
1126        registry.addTypeConverter(org.w3c.dom.Document.class, java.io.Reader.class, new SimpleTypeConverter(false) {
1127            @Override
1128            public Object doConvert(Exchange exchange, Object value) throws Exception {
1129                return getXmlConverter().toDOMDocument((java.io.Reader) value, exchange);
1130            }
1131        });
1132        registry.addTypeConverter(org.w3c.dom.Document.class, java.lang.String.class, new SimpleTypeConverter(false) {
1133            @Override
1134            public Object doConvert(Exchange exchange, Object value) throws Exception {
1135                return getXmlConverter().toDOMDocument((java.lang.String) value, exchange);
1136            }
1137        });
1138        registry.addTypeConverter(org.w3c.dom.Document.class, javax.xml.transform.Source.class, new SimpleTypeConverter(false) {
1139            @Override
1140            public Object doConvert(Exchange exchange, Object value) throws Exception {
1141                return getXmlConverter().toDOMDocument((javax.xml.transform.Source) value);
1142            }
1143        });
1144        registry.addTypeConverter(org.w3c.dom.Document.class, org.w3c.dom.Node.class, new SimpleTypeConverter(false) {
1145            @Override
1146            public Object doConvert(Exchange exchange, Object value) throws Exception {
1147                return getXmlConverter().toDOMDocument((org.w3c.dom.Node) value);
1148            }
1149        });
1150        registry.addTypeConverter(org.w3c.dom.Document.class, org.w3c.dom.NodeList.class, new SimpleTypeConverter(true) {
1151            @Override
1152            public Object doConvert(Exchange exchange, Object value) throws Exception {
1153                return getXmlConverter().toDOMDocumentFromSingleNodeList((org.w3c.dom.NodeList) value);
1154            }
1155        });
1156        registry.addTypeConverter(org.w3c.dom.Document.class, org.xml.sax.InputSource.class, new SimpleTypeConverter(false) {
1157            @Override
1158            public Object doConvert(Exchange exchange, Object value) throws Exception {
1159                return getXmlConverter().toDOMDocument((org.xml.sax.InputSource) value, exchange);
1160            }
1161        });
1162        registry.addTypeConverter(org.w3c.dom.Element.class, javax.xml.transform.Source.class, new SimpleTypeConverter(false) {
1163            @Override
1164            public Object doConvert(Exchange exchange, Object value) throws Exception {
1165                return getXmlConverter().toDOMElement((javax.xml.transform.Source) value);
1166            }
1167        });
1168        registry.addTypeConverter(org.w3c.dom.Element.class, org.w3c.dom.Node.class, new SimpleTypeConverter(false) {
1169            @Override
1170            public Object doConvert(Exchange exchange, Object value) throws Exception {
1171                return getXmlConverter().toDOMElement((org.w3c.dom.Node) value);
1172            }
1173        });
1174        registry.addTypeConverter(org.w3c.dom.Node.class, javax.xml.transform.sax.SAXSource.class, new SimpleTypeConverter(false) {
1175            @Override
1176            public Object doConvert(Exchange exchange, Object value) throws Exception {
1177                return getXmlConverter().toDOMNodeFromSAX((javax.xml.transform.sax.SAXSource) value);
1178            }
1179        });
1180        registry.addTypeConverter(org.w3c.dom.Node.class, javax.xml.transform.stax.StAXSource.class, new SimpleTypeConverter(false) {
1181            @Override
1182            public Object doConvert(Exchange exchange, Object value) throws Exception {
1183                return getXmlConverter().toDOMNodeFromStAX((javax.xml.transform.stax.StAXSource) value);
1184            }
1185        });
1186        registry.addTypeConverter(org.w3c.dom.Node.class, javax.xml.transform.Source.class, new SimpleTypeConverter(true) {
1187            @Override
1188            public Object doConvert(Exchange exchange, Object value) throws Exception {
1189                return getXmlConverter().toDOMNode((javax.xml.transform.Source) value);
1190            }
1191        });
1192        registry.addTypeConverter(org.w3c.dom.Node.class, org.w3c.dom.NodeList.class, new SimpleTypeConverter(true) {
1193            @Override
1194            public Object doConvert(Exchange exchange, Object value) throws Exception {
1195                return getXmlConverter().toDOMNodeFromSingleNodeList((org.w3c.dom.NodeList) value);
1196            }
1197        });
1198        registry.addTypeConverter(org.xml.sax.InputSource.class, java.io.File.class, new SimpleTypeConverter(false) {
1199            @Override
1200            public Object doConvert(Exchange exchange, Object value) throws Exception {
1201                return getXmlConverter().toInputSource((java.io.File) value, exchange);
1202            }
1203        });
1204        registry.addTypeConverter(org.xml.sax.InputSource.class, java.io.InputStream.class, new SimpleTypeConverter(false) {
1205            @Override
1206            public Object doConvert(Exchange exchange, Object value) throws Exception {
1207                return getXmlConverter().toInputSource((java.io.InputStream) value, exchange);
1208            }
1209        });
1210        registry.addFallbackTypeConverter(new TypeConverterSupport() {
1211            @Override
1212            public boolean allowNull() {
1213                return false;
1214            }
1215            @Override
1216            public <T> T convertTo(Class<T> type, Exchange exchange, Object value) throws TypeConversionException {
1217                try {
1218                    return (T) org.apache.camel.component.bean.BeanConverter.convertTo(type, exchange, value, registry);
1219                } catch (TypeConversionException e) {
1220                    throw e;
1221                } catch (Exception e) {
1222                    throw new TypeConversionException(value, type, e);
1223                }
1224            }
1225        }, false);
1226        registry.addFallbackTypeConverter(new TypeConverterSupport() {
1227            @Override
1228            public boolean allowNull() {
1229                return false;
1230            }
1231            @Override
1232            public <T> T convertTo(Class<T> type, Exchange exchange, Object value) throws TypeConversionException {
1233                try {
1234                    return (T) org.apache.camel.component.file.GenericFileConverter.convertTo(type, exchange, value, registry);
1235                } catch (TypeConversionException e) {
1236                    throw e;
1237                } catch (Exception e) {
1238                    throw new TypeConversionException(value, type, e);
1239                }
1240            }
1241        }, false);
1242
1243    }
1244
1245    private volatile org.apache.camel.converter.jaxp.XmlConverter xmlConverter;
1246    private org.apache.camel.converter.jaxp.XmlConverter getXmlConverter() {
1247        if (xmlConverter == null) {
1248            synchronized (this) {
1249                if (xmlConverter == null) {
1250                    xmlConverter = new org.apache.camel.converter.jaxp.XmlConverter();
1251                }
1252            }
1253        }
1254        return xmlConverter;
1255    }
1256    private volatile org.apache.camel.converter.jaxp.DomConverter domConverter;
1257    private org.apache.camel.converter.jaxp.DomConverter getDomConverter() {
1258        if (domConverter == null) {
1259            synchronized (this) {
1260                if (domConverter == null) {
1261                    domConverter = new org.apache.camel.converter.jaxp.DomConverter();
1262                }
1263            }
1264        }
1265        return domConverter;
1266    }
1267    private volatile org.apache.camel.converter.jaxp.StaxConverter staxConverter;
1268    private org.apache.camel.converter.jaxp.StaxConverter getStaxConverter() {
1269        if (staxConverter == null) {
1270            synchronized (this) {
1271                if (staxConverter == null) {
1272                    staxConverter = new org.apache.camel.converter.jaxp.StaxConverter();
1273                }
1274            }
1275        }
1276        return staxConverter;
1277    }
1278}