| package org.apache.fulcrum.jce.crypto; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| |
| /** |
| * Helper class to provde generic stream functions. |
| * |
| * @author <a href="mailto:siegfried.goeschl@it20one.at">Siegfried Goeschl </a> |
| */ |
| |
| public final class StreamUtil |
| { |
| /** the size of the internal buffer to copy streams */ |
| private static final int BUFFER_SIZE = 1024; |
| |
| /** |
| * Create an input stream supporting the following types |
| * |
| * <ul> |
| * <li>String (using the UTF-8 encoded content)</li> |
| * <li>File</li> |
| * <li>byte[]</li> |
| * <li>char[]</li> |
| * <li>ByteArrayOutputStream</li> |
| * <li>InputStream</li> |
| * </ul> |
| * |
| * @param source the source object |
| * @return the created input stream |
| * @throws java.io.IOException creating the input stream failed |
| */ |
| public static InputStream createInputStream( Object source ) |
| throws IOException |
| { |
| InputStream is; |
| |
| // create an InputStream |
| |
| if( source instanceof String ) |
| { |
| byte[] content = ((String) source).getBytes("utf-8"); |
| is = new ByteArrayInputStream( content ); |
| } |
| else if( source instanceof File ) |
| { |
| is = new FileInputStream( (File) source ); |
| } |
| else if( source instanceof byte[] ) |
| { |
| is = new ByteArrayInputStream( (byte[]) source ); |
| } |
| else if( source instanceof char[] ) |
| { |
| byte[] content = new String((char[])source).getBytes("utf-8"); |
| is = new ByteArrayInputStream( content ); |
| } |
| else if( source instanceof ByteArrayOutputStream ) |
| { |
| byte[] content = ((ByteArrayOutputStream) source).toByteArray(); |
| is = new ByteArrayInputStream( content ); |
| } |
| else if( source instanceof InputStream ) |
| { |
| is = (InputStream) source; |
| } |
| else |
| { |
| throw new IllegalArgumentException("Don't know hot to handle " + source.getClass().getName()); |
| } |
| |
| return is; |
| } |
| |
| /** |
| * Create an output stream supporting the following types |
| * |
| * <ul> |
| * <li>File</li> |
| * <li>String</li> |
| * <li>OutputStream</li> |
| * </ul> |
| * |
| * @param target the target object |
| * @return the output stream |
| * @throws java.io.IOException creating the output stream failed |
| */ |
| public static OutputStream createOutputStream( Object target ) |
| throws IOException |
| { |
| OutputStream os; |
| |
| if( target instanceof File ) |
| { |
| File currFile = (File) target; |
| createParentFile(currFile); |
| os = new FileOutputStream(currFile); |
| } |
| else if( target instanceof String ) |
| { |
| File currFile = new File((String) target); |
| createParentFile(currFile); |
| os = new FileOutputStream(currFile); |
| } |
| else if( target instanceof OutputStream ) |
| { |
| os = (OutputStream) target; |
| } |
| else |
| { |
| throw new IllegalArgumentException("Don't know hot to handle " + target.getClass().getName()); |
| } |
| |
| return os; |
| } |
| |
| /** |
| * Pumps the input stream to the output stream. |
| * |
| * @param is the source input stream |
| * @param os the target output stream |
| * @return the number of bytes copied |
| * @throws java.io.IOException the copying failed |
| */ |
| public static long copy( InputStream is, OutputStream os ) |
| throws IOException |
| { |
| byte[] buf = new byte[BUFFER_SIZE]; |
| int n = 0; |
| long total = 0; |
| |
| while ((n = is.read(buf)) > 0) |
| { |
| os.write(buf, 0, n); |
| total += n; |
| } |
| |
| is.close(); |
| |
| os.flush(); |
| os.close(); |
| |
| return total; |
| } |
| |
| /** |
| * Ensure that the parent directories exists before writing to |
| * the file. |
| * |
| * @param currFile the file to write to |
| */ |
| private static void createParentFile(File currFile) |
| { |
| File parentFile = currFile.getParentFile(); |
| |
| if((parentFile != null) && !parentFile.exists()) |
| { |
| boolean success = parentFile.mkdirs(); |
| if ( !success ) |
| { |
| System.err.println("Error, could not create directory to write parent file"); |
| } |
| } |
| } |
| } |