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.Writer;
043 import java.net.URL;
044 import java.util.Properties;
045
046 import javax.xml.transform.OutputKeys;
047 import javax.xml.transform.Source;
048 import javax.xml.transform.Transformer;
049 import javax.xml.transform.TransformerException;
050 import javax.xml.transform.TransformerFactory;
051 import javax.xml.transform.dom.DOMSource;
052 import javax.xml.transform.stream.StreamResult;
053
054 import org.apache.camel.Converter;
055 import org.apache.camel.util.CollectionStringBuffer;
056 import org.apache.commons.logging.Log;
057 import org.apache.commons.logging.LogFactory;
058
059 /**
060 * Some core java.io based <a
061 * href="http://activemq.apache.org/camel/type-converter.html">Type Converters</a>
062 *
063 * @version $Revision: 642102 $
064 */
065 @Converter
066 public final class IOConverter {
067 private static final transient Log LOG = LogFactory.getLog(IOConverter.class);
068
069 /**
070 * Utility classes should not have a public constructor.
071 */
072 private IOConverter() {
073 }
074
075 @Converter
076 public static InputStream toInputStream(URL url) throws IOException {
077 return url.openStream();
078 }
079
080 @Converter
081 public static InputStream toInputStream(File file) throws FileNotFoundException {
082 return new BufferedInputStream(new FileInputStream(file));
083 }
084
085 @Converter
086 public static BufferedReader toReader(File file) throws FileNotFoundException {
087 return new BufferedReader(new FileReader(file));
088 }
089
090 @Converter
091 public static File toFile(String name) throws FileNotFoundException {
092 return new File(name);
093 }
094
095 @Converter
096 public static OutputStream toOutputStream(File file) throws FileNotFoundException {
097 return new BufferedOutputStream(new FileOutputStream(file));
098 }
099
100 @Converter
101 public static BufferedWriter toWriter(File file) throws IOException {
102 return new BufferedWriter(new FileWriter(file));
103 }
104
105 @Converter
106 public static Reader toReader(InputStream in) throws FileNotFoundException {
107 return new InputStreamReader(in);
108 }
109
110 @Converter
111 public static Writer toWriter(OutputStream out) throws FileNotFoundException {
112 return new OutputStreamWriter(out);
113 }
114
115 @Converter
116 public static StringReader toReader(String text) {
117 // TODO could we automatically find this?
118 return new StringReader(text);
119 }
120
121 @Converter
122 public static InputStream toInputStream(String text) {
123 return toInputStream(text.getBytes());
124 }
125
126 @Converter
127 public static InputStream toInputStream(BufferedReader buffer) throws IOException {
128 return toInputStream(toString(buffer));
129 }
130
131 @Converter
132 public static InputStream toInputStrean(DOMSource source) throws TransformerException, IOException {
133 ByteArrayInputStream bais = new ByteArrayInputStream(toString(source).getBytes());
134 return bais;
135 }
136
137 @Converter
138 public static String toString(byte[] data) {
139 return new String(data);
140 }
141
142 @Converter
143 public static String toString(File file) throws IOException {
144 return toString(toReader(file));
145 }
146
147 @Converter
148 public static String toString(URL url) throws IOException {
149 return toString(toInputStream(url));
150 }
151
152 @Converter
153 public static String toString(Reader reader) throws IOException {
154 if (reader instanceof BufferedReader) {
155 return toString((BufferedReader)reader);
156 } else {
157 return toString(new BufferedReader(reader));
158 }
159 }
160
161 @Converter
162 public static String toString(BufferedReader reader) throws IOException {
163 if (reader == null) {
164 return null;
165 }
166 try {
167 CollectionStringBuffer builder = new CollectionStringBuffer("\n");
168 while (true) {
169 String line = reader.readLine();
170 if (line == null) {
171 return builder.toString();
172 }
173 builder.append(line);
174 }
175 } finally {
176 try {
177 reader.close();
178 } catch (IOException e) {
179 LOG.warn("Failed to close stream: " + e, e);
180 }
181 }
182 }
183
184 @Converter
185 public static String toString(InputStream in) throws IOException {
186 return toString(toReader(in));
187 }
188
189 public static String toString(Source source) throws TransformerException, IOException {
190 return toString(source, null);
191 }
192
193 public static String toString(Source source, Properties props) throws TransformerException, IOException {
194 ByteArrayOutputStream bos = new ByteArrayOutputStream();
195 StreamResult sr = new StreamResult(bos);
196 Transformer trans = TransformerFactory.newInstance().newTransformer();
197 if (props == null) {
198 props = new Properties();
199 props.put(OutputKeys.OMIT_XML_DECLARATION, "yes");
200 }
201 trans.setOutputProperties(props);
202 trans.transform(source, sr);
203 bos.close();
204 return bos.toString();
205 }
206
207 @Converter
208 public static InputStream toInputStream(byte[] data) {
209 return new ByteArrayInputStream(data);
210 }
211
212 @Converter
213 public static ObjectOutput toObjectOutput(OutputStream stream) throws IOException {
214 if (stream instanceof ObjectOutput) {
215 return (ObjectOutput) stream;
216 } else {
217 return new ObjectOutputStream(stream);
218 }
219 }
220
221 @Converter
222 public static ObjectInput toObjectInput(InputStream stream) throws IOException {
223 if (stream instanceof ObjectInput) {
224 return (ObjectInput) stream;
225 } else {
226 return new ObjectInputStream(stream);
227 }
228 }
229
230 @Converter
231 public static byte[] toBytes(InputStream stream) throws IOException {
232 ByteArrayOutputStream bos = new ByteArrayOutputStream();
233 copy(stream, bos);
234 return bos.toByteArray();
235 }
236
237 protected static void copy(InputStream stream, ByteArrayOutputStream bos) throws IOException {
238 byte[] data = new byte[4096];
239 int read = stream.read(data);
240 while (read != -1) {
241 bos.write(data, 0, read);
242 read = stream.read(data);
243 }
244 bos.flush();
245 }
246 }