/*
$Source: v:/cvsroot/open/projects/WebARTS/ca/bc/webarts/widgets/StreamPump.java,v $
$Name:  $

$Revision: 567 $
$Date: 2012-11-03 20:36:02 -0700 (Sat, 03 Nov 2012) $
$Locker:  $
*/

/* StreamPump -- Pipes An InputStream Into an OutputStream and pumps
 *               the data through it.
 *
 * Written by Tom Gutwin - WebARTS Design.
 * Copyright (C) 2001 WebARTS Design, North Vancouver Canada
 * http://www.webarts.bc.ca
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

package ca.bc.webarts.widgets;

import java.io.*;

/**
 * A class to pipe the data from the specified InputStream <code>in</code> to
 * the specified OutputStream <code>out</code>.
 * <P>
 * It can be called in a blocking (default) or non-blocking fashion, and can
 * optionally automatically close the output stream when it is done (default).
 * Transfer block size is also configurable.
 * <P>
 * <B><U>Example Usage</U></B><BR>
 * <PRE>
 * InputStream myInput = new InputStream();
 *
 *
 *
 * </pre>
 * @author    Tom Gutwin P.Eng
 * @created   October 4, 2001
 **/

public class StreamPump implements Runnable
{
  /**
   * A class copy of the InputStream to get data from.
   */
  private InputStream in;
  /**
   * The class copy of the OutputStream to pipe in's data to.
   */
  private OutputStream out;
  /**
   * A configurable field that flags the closing of the outputStream when done.
   * default = true  which means out will be closed.
   */
  private boolean autoShutOff = true;
  /**
   * The block size of the chunk to dump. Compromise between
   * BufferedInputStream's 2048 and BufferedOutputStream's 512?
   */
  private int blockSize = 1024;
  /**
   * A class holder for any exceptions that are thrown.
   */
  private Exception exception;


  /**
   * Constructor for the StreamPump object
   */
  public StreamPump() { }


  /**
   * Constructor for the StreamPump object
   *
   * @param input   Description of Parameter
   * @param output  Description of Parameter
   */
  public StreamPump(InputStream input, OutputStream output)
  {
    in = input;
    out = output;
  }


  /**
   * Constructor for the StreamPump object
   *
   * @param input    Description of Parameter
   * @param output   Description of Parameter
   * @param shutoff  Description of Parameter
   */
  public StreamPump(InputStream input, OutputStream output, boolean shutoff)
  {
    in = input;
    out = output;
    autoShutOff = shutoff;
  }


  /**
   * Sets the InputStream attribute of the StreamPump object
   *
   * @param i  The new Input value
   */
  public void setInputStream(InputStream i)
  {
    in = i;
  }


  /**
   * Sets the OutputStream attribute of the StreamPump object
   *
   * @param o  The new Output value
   */
  public void setOutputStream(OutputStream o)
  {
    out = o;
  }


  /**
   * Sets the BlockSize attribute of the StreamPump object
   *
   * @param i  The new BlockSize value
   */
  public void setBlockSize(int i)
  {
    blockSize = i;
  }


  /**
   * Gets the InputStream attribute of the StreamPump object
   *
   * @return   The Input value
   */
  public InputStream getInputStream()
  {
    return in;
  }


  /**
   * Gets the OutputStream attribute of the StreamPump object
   *
   * @return   The Output value
   */
  public OutputStream getOutputStream()
  {
    return out;
  }


  /**
   * Gets the BlockSize attribute of the StreamPump object
   *
   * @return   The BlockSize value
   */
  public int getBlockSize()
  {
    return blockSize;
  }


  /**
   * Gets the Exception attribute of the StreamPump object
   *
   * @return   The Exception value
   */
  public Exception getException()
  {
    return exception;
  }


  /**
   * Starts pumping the data through the Pipe.
   *
   * @return   The newly created Thread that is running the StreamPump
   */
  public synchronized Thread start()
  {
    Thread t = new Thread(this);
    t.start();
    return t;
  }


  /**
   * Main processing method for the StreamPump object. It reads from in and then
   * writes it to out. Toooo Easy
   */
  public void run()
  {
    final BufferedInputStream bis;
    final BufferedOutputStream bos;
    final boolean shutoff;
    final int blksz;
    try
    {
      synchronized (this)
      {
        bis = new BufferedInputStream(in);
        bos = new BufferedOutputStream(out);
        shutoff = autoShutOff;
        blksz = blockSize;
      }

      byte[] buf = new byte[blksz];
      int bytesread = bis.read(buf);
      while (bytesread != -1)
      {
        bos.write(buf, 0, bytesread);
        bytesread = bis.read(buf);
      }
      bis.close();
      bos.flush();
      if (shutoff)
      {
        bos.close();
      }
    }
    catch (IOException ioe)
    {
      synchronized (this)
      {
        exception = ioe;
      }
    }
  }
}