001    /**
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    package org.apache.camel.converter;
018    
019    import java.io.BufferedInputStream;
020    import java.io.BufferedOutputStream;
021    import java.io.BufferedReader;
022    import java.io.BufferedWriter;
023    import java.io.ByteArrayInputStream;
024    import java.io.ByteArrayOutputStream;
025    import java.io.File;
026    import java.io.FileInputStream;
027    import java.io.FileNotFoundException;
028    import java.io.FileOutputStream;
029    import java.io.FileReader;
030    import java.io.FileWriter;
031    import java.io.IOException;
032    import java.io.InputStream;
033    import java.io.InputStreamReader;
034    import java.io.ObjectInput;
035    import java.io.ObjectInputStream;
036    import java.io.ObjectOutput;
037    import java.io.ObjectOutputStream;
038    import java.io.OutputStream;
039    import java.io.OutputStreamWriter;
040    import java.io.Reader;
041    import java.io.StringReader;
042    import java.io.UnsupportedEncodingException;
043    import java.io.Writer;
044    import java.net.URL;
045    
046    import javax.xml.transform.TransformerException;
047    import javax.xml.transform.dom.DOMSource;
048    
049    import org.apache.camel.Converter;
050    import org.apache.camel.Exchange;
051    import org.apache.camel.converter.jaxp.XmlConverter;
052    import org.apache.camel.util.CollectionStringBuffer;
053    import org.apache.commons.logging.Log;
054    import org.apache.commons.logging.LogFactory;
055    
056    /**
057     * Some core java.io based <a
058     * href="http://activemq.apache.org/camel/type-converter.html">Type Converters</a>
059     *
060     * @version $Revision: 65759 $
061     */
062    @Converter
063    public final class IOConverter {
064        private static final transient Log LOG = LogFactory.getLog(IOConverter.class);
065        private static XmlConverter xmlConverter;
066    
067        /**
068         * Utility classes should not have a public constructor.
069         */
070        private IOConverter() {
071        }
072    
073        @Converter
074        public static InputStream toInputStream(URL url) throws IOException {
075            return url.openStream();
076        }
077    
078        @Converter
079        public static InputStream toInputStream(File file) throws FileNotFoundException {
080            return new BufferedInputStream(new FileInputStream(file));
081        }
082    
083        @Converter
084        public static BufferedReader toReader(File file) throws FileNotFoundException {
085            return new BufferedReader(new FileReader(file));
086        }
087    
088        @Converter
089        public static File toFile(String name) throws FileNotFoundException {
090            return new File(name);
091        }
092    
093        @Converter
094        public static OutputStream toOutputStream(File file) throws FileNotFoundException {
095            return new BufferedOutputStream(new FileOutputStream(file));
096        }
097    
098        @Converter
099        public static BufferedWriter toWriter(File file) throws IOException {
100            return new BufferedWriter(new FileWriter(file));
101        }
102    
103        @Converter
104        public static Reader toReader(InputStream in) throws FileNotFoundException {
105            return new InputStreamReader(in);
106        }
107    
108        @Converter
109        public static Writer toWriter(OutputStream out) throws FileNotFoundException {
110            return new OutputStreamWriter(out);
111        }
112    
113        @Converter
114        public static StringReader toReader(String text) {
115            return new StringReader(text);
116        }
117    
118        @Converter
119        public static InputStream toInputStream(String text) {
120            return toInputStream(text, null);
121        }
122        
123        @Converter
124        public static InputStream toInputStream(String text, Exchange exchange) {
125            if (exchange != null) {
126                String charsetName = exchange.getProperty(Exchange.CHARSET_NAME, String.class);
127                if (charsetName != null) {
128                    try {
129                        return toInputStream(text.getBytes(charsetName));
130                    } catch (UnsupportedEncodingException e) {
131                        LOG.warn("Can't convert the String into the bytes with the charset " + charsetName, e);
132                    }
133                }
134            }
135            return toInputStream(text.getBytes());
136        }
137        
138        @Converter
139        public static InputStream toInputStream(BufferedReader buffer) throws IOException {
140            return toInputStream(toString(buffer), null);
141        }
142    
143        @Converter
144        public static InputStream toInputStream(BufferedReader buffer, Exchange exchange) throws IOException {
145            return toInputStream(toString(buffer), exchange);
146        }
147    
148        @Converter
149        public static InputStream toInputStrean(DOMSource source) throws TransformerException, IOException {
150            XmlConverter xmlConverter = createXmlConverter();
151            ByteArrayInputStream bais = new ByteArrayInputStream(xmlConverter.toString(source).getBytes());
152            return bais;
153        }
154    
155        private static XmlConverter createXmlConverter() {
156            if (xmlConverter == null) {
157                xmlConverter = new XmlConverter();
158            }
159            return xmlConverter;
160        }
161    
162        @Converter
163        public static String toString(byte[] data, Exchange exchange) {
164            if (exchange != null) {
165                String charsetName = exchange.getProperty(Exchange.CHARSET_NAME, String.class);
166                if (charsetName != null) {
167                    try {
168                        return new String(data, charsetName);
169                    } catch (UnsupportedEncodingException e) {
170                        LOG.warn("Can't convert the byte to String with the charset " + charsetName, e);
171                    }
172                }
173            }
174            return new String(data);
175        }
176    
177    
178        @Converter
179        public static String toString(File file) throws IOException {
180            return toString(toReader(file));
181        }
182    
183        @Converter
184        public static byte[] toByteArray(File file) throws IOException {
185            return toBytes(toInputStream(file));
186        }
187    
188        @Converter
189        public static byte[] toByteArray(Reader reader) throws IOException {
190            if (reader instanceof BufferedReader) {
191                return toByteArray((BufferedReader)reader);
192            } else {
193                return toByteArray(new BufferedReader(reader));
194            }
195        }
196    
197        @Converter
198        public static String toString(URL url) throws IOException {
199            return toString(toInputStream(url));
200        }
201    
202        @Converter
203        public static String toString(Reader reader) throws IOException {
204            if (reader instanceof BufferedReader) {
205                return toString((BufferedReader)reader);
206            } else {
207                return toString(new BufferedReader(reader));
208            }
209        }
210    
211        @Converter
212        public static String toString(BufferedReader reader) throws IOException {
213            if (reader == null) {
214                return null;
215            }
216            try {
217                CollectionStringBuffer builder = new CollectionStringBuffer("\n");
218                while (true) {
219                    String line = reader.readLine();
220                    if (line == null) {
221                        return builder.toString();
222                    }
223                    builder.append(line);
224                }
225            } finally {
226                try {
227                    reader.close();
228                } catch (IOException e) {
229                    LOG.warn("Failed to close stream: " + e, e);
230                }
231            }
232        }
233    
234        @Converter
235        public static byte[] toByteArray(BufferedReader reader) throws IOException {
236            if (reader == null) {
237                return null;
238            }
239    
240            StringBuilder sb = new StringBuilder(1024);
241            char[] buf = new char[1024];
242            try {
243                int len = reader.read(buf);
244                if (len != -1) {
245                    sb.append(buf, 0, len);
246                }
247            } finally {
248                try {
249                    reader.close();
250                } catch (IOException e) {
251                    LOG.warn("Failed to close stream: " + e, e);
252                }
253            }
254            return sb.toString().getBytes();
255        }
256    
257        @Converter
258        public static String toString(InputStream in) throws IOException {
259            return toString(toReader(in));
260        }
261    
262        @Converter
263        public static InputStream toInputStream(byte[] data) {
264            return new ByteArrayInputStream(data);
265        }
266    
267        @Converter
268        public static ObjectOutput toObjectOutput(OutputStream stream) throws IOException {
269            if (stream instanceof ObjectOutput) {
270                return (ObjectOutput) stream;
271            } else {
272                return new ObjectOutputStream(stream);
273            }
274        }
275    
276        @Converter
277        public static ObjectInput toObjectInput(InputStream stream) throws IOException {
278            if (stream instanceof ObjectInput) {
279                return (ObjectInput) stream;
280            } else {
281                return new ObjectInputStream(stream);
282            }
283        }
284    
285        @Converter
286        public static byte[] toBytes(InputStream stream) throws IOException {
287            ByteArrayOutputStream bos = new ByteArrayOutputStream();
288            copy(stream, bos);
289            return bos.toByteArray();
290        }
291    
292        public static void copy(InputStream stream, OutputStream os) throws IOException {
293            byte[] data = new byte[4096];
294            int read = stream.read(data);        
295            while (read != -1) {            
296                os.write(data, 0, read);
297                read = stream.read(data);
298            }
299            os.flush();
300        }
301    }