Logo
Distributed Genetic Programming Framework
print print

File org.sfc.io.block.BlockOutputStream.java

Here you can find all the information about the file org.sfc.io.block.BlockOutputStream.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2006 Thomas Weise
 * 
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2006-06-27 17:33:52
 * Original Filename: org.sfc.io.BlockOutputStream.java
 * Version          : 1.0.0
 * Last modification: 2006-06-27
 *                by: Thomas Weise
 * 
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *                    
 * Warranty         : This software is provided "as is" without any
 *                    warranty; without even the implied warranty of
 *                    merchantability or fitness for a particular purpose.
 *                    See the Gnu Lesser General Public License for more
 *                    details.
 */

 
package org.sfc.io.block;

import java.io.IOException;
import java.io.OutputStream;

import org.sfc.io.ReferenceCountedOutputStream;

/**
 * A block output stream groups written data into blocks of equal size
 * before storing it.
 *
 * @author Thomas Weise
 */

public class BlockOutputStream  extends ReferenceCountedOutputStream
  {
/**
 * The destination output stream.
 */

  private final OutputStream  m_out     ;
/**
 * The output buffer.
 */

  private final byte[]        m_buffer  ;
/**
 * The current size of the output data.
 */

  private       int           m_size    ;
/**
 * The block handler interface to delegate to.
 */

  private final IBlockHandler m_handler ;
  
/**
 * The end mark for data.
 */

  static  final byte          END_MARK  = 67;
  
/**
 * Create a new block data output stream.
 * @param p_out         The output stream to write to.
 * @param p_block_size  The block size to use for writing.
 * @param p_handler     The block handler interface to delegate to.
 */

  public  BlockOutputStream (final OutputStream  p_out,
                             final int           p_block_size,
                             final IBlockHandler p_handler)
    {
    super();
    this.m_out    = p_out;
    this.m_buffer  = new byte[(p_block_size > 0) ? p_block_size : 1];
    this.m_handler = p_handler;
    }
  
  
/**
 * Writes the specified byte to this output stream. The general 
 * contract for <code>write</code> is that one byte is written 
 * to the output stream. The byte to be written is the eight 
 * low-order bits of the argument <code>b</code>. The 24 
 * high-order bits of <code>b</code> are ignored.
 * <p>
 * Subclasses of <code>OutputStream</code> must provide an 
 * implementation for this method. 
 *
 * @param      p_b   the <code>byte</code>.
 * @exception  IOException  if an I/O error occurs. In particular, 
 *             an <code>IOException</code> may be thrown if the 
 *             output stream has been closed.
 */

  @Override
  public final void write(final int p_b) throws IOException
    {
    byte[]  l_b;
    int     l_s;
    
    l_s = this.m_size;
    l_b = this.m_buffer;
    
    if(l_s >= l_b.length)
      {
      this.m_handler.on_block(l_b);
      this.m_out.write(l_b);
      l_s = 0;
      }
    
    l_b[l_s]    = ((byte)(p_b));
    this.m_size = (l_s+1);
    }
  
  
/**
 * Writes <code>len</code> bytes from the specified byte array 
 * starting at offset <code>off</code> to this output stream. 
 * The general contract for <code>write(b, off, len)</code> is that 
 * some of the bytes in the array <code>b</code> are written to the 
 * output stream in order; element <code>b[off]</code> is the first 
 * byte written and <code>b[off+len-1]</code> is the last byte written 
 * by this operation.
 * <p>
 * The <code>write</code> method of <code>OutputStream</code> calls 
 * the write method of one argument on each of the bytes to be 
 * written out. Subclasses are encouraged to override this method and 
 * provide a more efficient implementation. 
 * <p>
 * If <code>b</code> is <code>null</code>, a 
 * <code>NullPointerException</code> is thrown.
 * <p>
 * If <code>off</code> is negative, or <code>len</code> is negative, or 
 * <code>off+len</code> is greater than the length of the array 
 * <code>b</code>, then an <tt>IndexOutOfBoundsException</tt> is thrown.
 *
 * @param      p_b     the data.
 * @param      p_off   the start offset in the data.
 * @param      p_len   the number of bytes to write.
 * @exception  IOException  if an I/O error occurs. In particular, 
 *             an <code>IOException</code> is thrown if the output 
 *             stream is closed.
 */

  @Override
  public final  void write(final byte[] p_b,
                                 int    p_off,
                                 int    p_len) throws IOException
    {   
    byte[]        l_b;
    int           l_s, l_bl, l_w;
    OutputStream  l_os;
    
    l_s  = this.m_size;
    l_b  = this.m_buffer;
    l_bl = l_b.length;
    l_os = this.m_out;
    
    while(p_len > 0)
      {
      l_w = (l_bl - l_s);
      if(l_w > p_len) l_w = p_len;
      System.arraycopy(p_b, p_off, l_b, l_s, l_w);
      l_s += l_w;
      if(l_s >= l_bl)
        {
        this.m_handler.on_block(l_b);
        l_os.write(l_b, 0, l_bl);
        l_s = 0;
        p_off += l_w;
        p_len -= l_w;
        }
      else break;
      }
    
    this.m_size = l_s;
    }
  
/**
 * The internal dispose method.
 * @throws  IOException If the underlying was closed and caused an
 *                      IOException.
 */

  @Override
  protected final void  dispose () throws IOException
    {
    byte[]  l_b;
    int     l_s, l_bl, l_v;
    byte    l_x;
    
    try
      {
      l_b = this.m_buffer;
      l_s = this.m_size;
      
      l_b[l_s] = END_MARK;
      l_bl     = l_b.length;
      l_v      = (int)(System.currentTimeMillis() >>> 3);
      for(++l_s; l_s < l_bl; l_s++)
        {
        do
          {
          l_x  = ((byte)l_v);
          l_v ^= (-((l_v*3) + l_s));
          } while (l_x == END_MARK);
        
        l_b[l_s] = l_x;        
        }
      
      this.m_handler.on_block(l_b);
      this.m_out.write(l_b, 0, l_bl);
      }
    finally
      {
      try
        {
        this.m_out.close();
        }
      finally
        {
        super.dispose();
        }
      }
    }
  

/**
 * Flushes this output stream and forces any buffered output bytes 
 * to be written out. The general contract of <code>flush</code> is 
 * that calling it is an indication that, if any bytes previously 
 * written have been buffered by the implementation of the output 
 * stream, such bytes should immediately be written to their 
 * intended destination.
 * <p>
 * If the intended destination of this stream is an abstraction provided by
 * the underlying operating system, for example a file, then flushing the
 * stream guarantees only that bytes previously written to the stream are
 * passed to the operating system for writing; it does not guarantee that
 * they are actually written to a physical device such as a disk drive.
 * <p>
 * The <code>flush</code> method of <code>OutputStream</code> does nothing.
 *
 * @exception  IOException  if an I/O error occurs.
 */

  @Override
  public void flush() throws IOException
    {
    try
      {
      this.m_out.flush();
      }
    finally
      {
      super.flush();
      }
    }
  }

File Information:

file name:BlockOutputStream.java
package:org.sfc.io.block
qualified name:org.sfc.io.block.BlockOutputStream.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/io/block/BlockOutputStream.java
size:7.576 KB (7758 B)
uploaded: 2018-01-07 12:03:36 GMT+0000
last update: 2006-07-11 06:49:27 GMT+0000
last access: 2018-04-26 03:56:59 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2018-01-07 12:03:34 GMT+0000 served at 2018-04-26 03:56:59 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo