ConcurrentBufferOutputStream.java

// ConcurrentBufferOutputStream.java -- write bytes to blocking queue
// Copyright (c)2007 Christopher League <league@contrapunctus.net>

// This is free software, but it comes with ABSOLUTELY NO WARRANTY.
// GNU Lesser General Public License 2.1 or Common Public License 1.0

package net.contrapunctus.lzma;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.concurrent.ArrayBlockingQueue;

class ConcurrentBufferOutputStream extends OutputStream
{
    protected ArrayBlockingQueue<byte[]> q;
    static final int                     BUFSIZE   = 16384;
    static final int                     QUEUESIZE = 4096;
    private static final PrintStream     dbg       = System.err;
    private static final boolean         DEBUG;
    
    static
    {
        String ds = null;
        try
        {
            ds = System.getProperty("DEBUG_ConcurrentBuffer");
        }
        catch (final SecurityException e)
        {
        }
        DEBUG = ds != null;
    }
    
    private ConcurrentBufferOutputStream(ArrayBlockingQueue<byte[]> q)
    {
        if (DEBUG)
        {
            dbg.printf("%s >> %s%n", this, q);
        }
        this.q = q;
    }
    
    static OutputStream create(ArrayBlockingQueue<byte[]> q)
    {
        OutputStream out = new ConcurrentBufferOutputStream(q);
        out = new BufferedOutputStream(out, BUFSIZE);
        return out;
    }
    
    static ArrayBlockingQueue<byte[]> newQueue()
    {
        return new ArrayBlockingQueue<byte[]>(QUEUESIZE);
    }
    
    protected void guarded_put(byte[] a) throws IOException
    {
        try
        {
            q.put(a);
        }
        catch (final InterruptedException exn)
        {
            throw new InterruptedIOException(exn.getMessage());
        }
    }
    
    
    public void write(int i) throws IOException
    {
        final byte b[] = new byte[1];
        b[0] = (byte) (i & 0xff);
        guarded_put(b);
    }
    
    
    public void write(byte[] b, int off, int len) throws IOException
    {
        final byte[] a = new byte[len];
        System.arraycopy(b, off, a, 0, len);
        guarded_put(a);
    }
    
    
    public void close() throws IOException
    {
        if (DEBUG)
        {
            dbg.printf("%s closed%n", this);
        }
        final byte b[] = new byte[0]; // sentinel
        guarded_put(b);
    }
}