BufferUtil.java

package org.docx4j.utils;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class BufferUtil {

	private static Logger log = LoggerFactory.getLogger(BufferUtil.class);		
	
	
    private static final int BUFFER_SIZE = 1024;

    /**
     * Fully reads the given InputStream, returning its contents as a ByteBuffer
     *
     * @param in an <code>InputStream</code> value
     * @return a <code>ByteBuffer</code> value
     * @exception IOException if an error occurs
     */
    public static ByteBuffer readInputStream(InputStream in) throws IOException {
    	/**
    	 * Some useful methods for reading URLs or streams and returning the data as Direct Buffers
    	 *
    	 * @author Ivan Z. Ganza
    	 * @author Robert Schuster
    	 * @author Bart LEBOEUF
    	 * 
    	 * Originally from com.lilly.chorus.eSignatures.utils.BufferUtil
    	 */
    	
    	/*
		 * Converts the InputStream into a channels which allows us to read into
		 * a ByteBuffer.
		 */
		ReadableByteChannel ch = Channels.newChannel(in);

		// Creates a list that stores the intermediate buffers.
		List list = new LinkedList();

		// A variable storing the accumulated size of the data.
		int sum = 0, read = 0;

		/*
		 * Reads all the bytes from the channel and stores them in various
		 * buffer objects.
		 */
		do {
			ByteBuffer b = createByteBuffer(BUFFER_SIZE);
			read = ch.read(b);

			if (read > 0) {
				b.flip(); // make ready for reading later
				list.add(b);
				sum += read;
			}
		} while (read != -1);

		/*
		 * If there is only one buffer used we do not need to merge the data.
		 */
		if (list.size() == 1) {
			return (ByteBuffer) list.get(0);
		}

		ByteBuffer bb = createByteBuffer(sum);

		/* Merges all buffers into the Buffer bb */
		Iterator ite = list.iterator();
		while (ite.hasNext()) {
			bb.put((ByteBuffer) ite.next());
		}

		list.clear();

		return bb;
	}
    
    
    public static ByteBuffer createByteBuffer(int capacity) {
    	return ByteBuffer.allocateDirect(capacity).order(ByteOrder.nativeOrder());
    }
    
    /**
     * Returns an input stream for a ByteBuffer.
     * The read() methods use the relative ByteBuffer get() methods.
     */
    public static InputStream newInputStream(final ByteBuffer buf)
    {
    	
    // From http://docs.jboss.org/jbossas/javadoc/4.0.2/org/jboss/media/util/ByteBufferUtils.java.html
    	
    	// Not working properly?  Make sure any method being called is implemented
    	
       return new InputStream()
       {
          public synchronized int read() throws IOException
          {
             if (!buf.hasRemaining())
             {
            	 log.debug("done");
                return -1;
             }
             log.debug("#");
             return buf.get();
          }

          public synchronized int read(byte[] bytes) throws IOException
          {
             if (!buf.hasRemaining())
             {
            	 log.debug("done");
                return -1;
             }
             log.debug("#");
                                       
             int len = Math.min(bytes.length, buf.remaining());
             buf.get(bytes, 0, len );
             return len;
          }          
          
          public synchronized int read(byte[] bytes, int off, int len)
             throws IOException
          {
             // Read only what's left
             len = Math.min(len, buf.remaining());
             buf.get(bytes, off, len);
             return len;
          }
       };
    }
    
	public static byte[] getBytesFromInputStream(InputStream is)
			throws IOException {

		BufferedInputStream bufIn = new BufferedInputStream(is);
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		BufferedOutputStream bos = new BufferedOutputStream(baos);
		int c = bufIn.read();
		while (c != -1) {
			bos.write(c);
			c = bufIn.read();
		}
		bos.flush();
		baos.flush();
		bufIn.close();
		bos.close();
		return baos.toByteArray();
	} 		
    
    
}