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 import javax.xml.transform.TransformerException;
046 import javax.xml.transform.dom.DOMSource;
047
048 import org.apache.camel.Converter;
049 import org.apache.camel.Exchange;
050 import org.apache.camel.converter.jaxp.XmlConverter;
051 import org.apache.camel.util.CollectionStringBuffer;
052 import org.apache.camel.util.IOHelper;
053 import org.apache.camel.util.ObjectHelper;
054 import org.apache.commons.logging.Log;
055 import org.apache.commons.logging.LogFactory;
056
057 /**
058 * Some core java.io based <a
059 * href="http://camel.apache.org/type-converter.html">Type Converters</a>
060 *
061 * @version $Revision: 749236 $
062 */
063 @Converter
064 public final class IOConverter {
065 private static final transient Log LOG = LogFactory.getLog(IOConverter.class);
066 private static XmlConverter xmlConverter;
067
068 /**
069 * Utility classes should not have a public constructor.
070 */
071 private IOConverter() {
072 }
073
074 @Converter
075 public static InputStream toInputStream(URL url) throws IOException {
076 return url.openStream();
077 }
078
079 @Converter
080 public static InputStream toInputStream(File file) throws FileNotFoundException {
081 return new BufferedInputStream(new FileInputStream(file));
082 }
083
084 @Converter
085 public static BufferedReader toReader(File file) throws FileNotFoundException {
086 return new BufferedReader(new FileReader(file));
087 }
088
089 @Converter
090 public static File toFile(String name) throws FileNotFoundException {
091 return new File(name);
092 }
093
094 @Converter
095 public static OutputStream toOutputStream(File file) throws FileNotFoundException {
096 return new BufferedOutputStream(new FileOutputStream(file));
097 }
098
099 @Converter
100 public static BufferedWriter toWriter(File file) throws IOException {
101 return new BufferedWriter(new FileWriter(file));
102 }
103
104 @Converter
105 public static Reader toReader(InputStream in) {
106 return new InputStreamReader(in);
107 }
108
109 @Converter
110 public static Writer toWriter(OutputStream out) {
111 return new OutputStreamWriter(out);
112 }
113
114 @Converter
115 public static StringReader toReader(String text) {
116 return new StringReader(text);
117 }
118
119 @Converter
120 public static InputStream toInputStream(String text, Exchange exchange) {
121 if (exchange != null) {
122 String charsetName = exchange.getProperty(Exchange.CHARSET_NAME, String.class);
123 if (charsetName != null) {
124 try {
125 return toInputStream(text.getBytes(charsetName));
126 } catch (UnsupportedEncodingException e) {
127 LOG.warn("Cannot convert the String into byte[] with the charset: " + charsetName, e);
128 }
129 }
130 }
131 return toInputStream(text.getBytes());
132 }
133
134 @Converter
135 public static InputStream toInputStream(BufferedReader buffer, Exchange exchange) throws IOException {
136 return toInputStream(toString(buffer), exchange);
137 }
138
139 @Converter
140 public static InputStream toInputStrean(DOMSource source) throws TransformerException, IOException {
141 XmlConverter xmlConverter = createXmlConverter();
142 ByteArrayInputStream bais = new ByteArrayInputStream(xmlConverter.toString(source).getBytes());
143 return bais;
144 }
145
146 private static XmlConverter createXmlConverter() {
147 if (xmlConverter == null) {
148 xmlConverter = new XmlConverter();
149 }
150 return xmlConverter;
151 }
152
153 @Converter
154 public static String toString(byte[] data, Exchange exchange) {
155 if (exchange != null) {
156 String charsetName = exchange.getProperty(Exchange.CHARSET_NAME, String.class);
157 if (charsetName != null) {
158 try {
159 return new String(data, charsetName);
160 } catch (UnsupportedEncodingException e) {
161 LOG.warn("Cannot convert the byte[] to String with the charset: " + charsetName, e);
162 }
163 }
164 }
165 return new String(data);
166 }
167
168
169 @Converter
170 public static String toString(File file) throws IOException {
171 return toString(toReader(file));
172 }
173
174 @Converter
175 public static byte[] toByteArray(File file) throws IOException {
176 return toBytes(toInputStream(file));
177 }
178
179 @Converter
180 public static byte[] toByteArray(Reader reader) throws IOException {
181 if (reader instanceof BufferedReader) {
182 return toByteArray((BufferedReader)reader);
183 } else {
184 return toByteArray(new BufferedReader(reader));
185 }
186 }
187
188 @Converter
189 public static String toString(URL url) throws IOException {
190 return toString(toInputStream(url));
191 }
192
193 @Converter
194 public static String toString(Reader reader) throws IOException {
195 if (reader instanceof BufferedReader) {
196 return toString((BufferedReader)reader);
197 } else {
198 return toString(new BufferedReader(reader));
199 }
200 }
201
202 @Converter
203 public static String toString(BufferedReader reader) throws IOException {
204 if (reader == null) {
205 return null;
206 }
207 try {
208 CollectionStringBuffer builder = new CollectionStringBuffer("\n");
209 while (true) {
210 String line = reader.readLine();
211 if (line == null) {
212 return builder.toString();
213 }
214 builder.append(line);
215 }
216 } finally {
217 ObjectHelper.close(reader, "reader", LOG);
218 }
219 }
220
221 @Converter
222 public static byte[] toByteArray(BufferedReader reader) throws IOException {
223 if (reader == null) {
224 return null;
225 }
226
227 StringBuilder sb = new StringBuilder(1024);
228 char[] buf = new char[1024];
229 try {
230 int len = reader.read(buf);
231 if (len != -1) {
232 sb.append(buf, 0, len);
233 }
234 } finally {
235 ObjectHelper.close(reader, "reader", LOG);
236 }
237
238 return sb.toString().getBytes();
239 }
240
241 @Converter
242 public static String toString(InputStream in) throws IOException {
243 return toString(toReader(in));
244 }
245
246 @Converter
247 public static InputStream toInputStream(byte[] data) {
248 return new ByteArrayInputStream(data);
249 }
250
251 @Converter
252 public static ObjectOutput toObjectOutput(OutputStream stream) throws IOException {
253 if (stream instanceof ObjectOutput) {
254 return (ObjectOutput) stream;
255 } else {
256 return new ObjectOutputStream(stream);
257 }
258 }
259
260 @Converter
261 public static ObjectInput toObjectInput(InputStream stream) throws IOException {
262 if (stream instanceof ObjectInput) {
263 return (ObjectInput) stream;
264 } else {
265 return new ObjectInputStream(stream);
266 }
267 }
268
269 @Converter
270 public static byte[] toBytes(InputStream stream) throws IOException {
271 ByteArrayOutputStream bos = new ByteArrayOutputStream();
272 try {
273 IOHelper.copy(stream, bos);
274 return bos.toByteArray();
275 } finally {
276 ObjectHelper.close(bos, "stream", LOG);
277 }
278 }
279
280 @Converter
281 public static byte[] toByteArray(ByteArrayOutputStream os) {
282 return os.toByteArray();
283 }
284
285 @Converter
286 public static String toString(ByteArrayOutputStream os) {
287 return os.toString();
288 }
289
290 @Converter
291 public static InputStream toInputStream(ByteArrayOutputStream os) {
292 return new ByteArrayInputStream(os.toByteArray());
293 }
294
295 }