Logo
Distributed Genetic Programming Framework
print print

File org.sfc.io.DefaultInputStream.java

Here you can find all the information about the file org.sfc.io.DefaultInputStream.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2005 Thomas Weise
 * 
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2005-06-25 16:25:35
 * Original Filename: org.sfc.io.DefaultInputStream.java
 * Version          : 1.0.2
 * Last modification: 2006-03-07
 *                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;

import java.io.IOException;
import java.io.InputStream;

/**
 * This class is a wrapper for <code>InputStream</code>s that makes them
 * reference counted.
 * @author Thomas Weise 
 */

final class DefaultInputStream extends  ReferenceCountedInputStream
  { 
/**
 * The internal input stream.
 */

  private final InputStream m_is;  
    
/**
 * Create a reference counted <code>InputStream</code>.
 * 
 * @param p_original  The underlying object.
 */

  DefaultInputStream  (final InputStream p_original)
    {
    super();
    this.m_is = p_original;
    }
  
/**
 * Dispose the reference counted input stream.
 * @throws  IOException If the underlying was closed and caused an
 *                      IOException.
 */

  @Override
  protected final void  dispose ()  throws IOException
    {
    try
      {
      this.m_is.close();
      }
    finally
      {
      super.dispose();
      }
    }
  
  
/**
 * Reads the next byte of data from this input stream. The value 
 * byte is returned as an <code>int</code> in the range 
 * <code>0</code> to <code>255</code>. If no byte is available 
 * because the end of the stream has been reached, the value 
 * <code>-1</code> is returned. This method blocks until input data 
 * is available, the end of the stream is detected, or an exception 
 * is thrown. 
 * <p>
 * This method
 * simply performs <code>in.read()</code> and returns the result.
 *
 * @return     the next byte of data, or <code>-1</code> if the end of the
 *             stream is reached.
 * @exception  IOException  if an I/O error occurs.
 */

  @Override
  public final  int read() throws IOException
    {
    return this.m_is.read();
    }

/**
 * Reads up to <code>byte.length</code> bytes of data from this 
 * input stream into an array of bytes. This method blocks until some 
 * input is available. 
 * <p>
 * This method simply performs the call
 * <code>read(b, 0, b.length)</code> and returns
 * the  result. It is important that it does
 * <i>not</i> do <code>in.read(b)</code> instead;
 * certain subclasses of  <code>DefaultInputStream</code>
 * depend on the implementation strategy actually
 * used.
 *
 * @param      p_b   the buffer into which the data is read.
 * @return     the total number of bytes read into the buffer, or
 *             <code>-1</code> if there is no more data because the end of
 *             the stream has been reached.
 * @exception  IOException  if an I/O error occurs.
 * @see        DefaultInputStream#read(byte[], int, int)
 */

  @Override
  public final  int read(final  byte p_b[]) throws IOException
    {
    return this.m_is.read(p_b);
    }

/**
 * Reads up to <code>len</code> bytes of data from this input stream 
 * into an array of bytes. This method blocks until some input is 
 * available. 
 * <p>
 * This method simply performs <code>in.read(b, off, len)</code> 
 * and returns the result.
 *
 * @param      p_b     the buffer into which the data is read.
 * @param      p_off   the start offset of the data.
 * @param      p_len   the maximum number of bytes read.
 * @return     the total number of bytes read into the buffer, or
 *             <code>-1</code> if there is no more data because the end of
 *             the stream has been reached.
 * @exception  IOException  if an I/O error occurs.
 */

  @Override
  public int read(final byte  p_b[],
                  final int   p_off,
                  final int   p_len) throws IOException
    {
    return this.m_is.read(p_b, p_off, p_len);
    }

/**
 * Skips over and discards <code>n</code> bytes of data from the 
 * input stream. The <code>skip</code> method may, for a variety of 
 * reasons, end up skipping over some smaller number of bytes, 
 * possibly <code>0</code>. The actual number of bytes skipped is 
 * returned. 
 * <p>
 * This method
 * simply performs <code>in.skip(n)</code>.
 *
 * @param      p_n   the number of bytes to be skipped.
 * @return     the actual number of bytes skipped.
 * @exception  IOException  if an I/O error occurs.
 */

  @Override
  public final  long skip(final  long p_n) throws IOException
    {
    return this.m_is.skip(p_n);
    }

/**
 * Returns the number of bytes that can be read from this input 
 * stream without blocking. 
 * <p>
 * This method
 * simply performs <code>in.available()</code> and
 * returns the result.
 *
 * @return     the number of bytes that can be read from the input stream
 *             without blocking.
 * @exception  IOException  if an I/O error occurs.
 */

  @Override
  public final  int available() throws IOException
    {
    return this.m_is.available();
    }


/**
 * Marks the current position in this input stream. A subsequent 
 * call to the <code>reset</code> method repositions this stream at 
 * the last marked position so that subsequent reads re-read the same bytes.
 * <p>
 * The <code>readlimit</code> argument tells this input stream to 
 * allow that many bytes to be read before the mark position gets 
 * invalidated. 
 * <p>
 * This method simply performs <code>in.mark(readlimit)</code>.
 *
 * @param   p_readlimit   the maximum limit of bytes that can be read before
 *                      the mark position becomes invalid.
 * @see     DefaultInputStream#reset()
 */

  @Override  
  public final  void mark(final int p_readlimit)
    {
    this.m_is.mark(p_readlimit);
    }

/**
 * Repositions this stream to the position at the time the 
 * <code>mark</code> method was last called on this input stream. 
 * <p>
 * This method
 * simply performs <code>in.reset()</code>.
 * <p>
 * Stream marks are intended to be used in
 * situations where you need to read ahead a little to see what's in
 * the stream. Often this is most easily done by invoking some
 * general parser. If the stream is of the type handled by the
 * parse, it just chugs along happily. If the stream is not of
 * that type, the parser should toss an exception when it fails.
 * If this happens within readlimit bytes, it allows the outer
 * code to reset the stream and try another parser.
 *
 * @exception  IOException  if the stream has not been marked or if the
 *               mark has been invalidated.
 * @see        DefaultInputStream#mark(int)
 */

  @Override
  public final  void reset() throws IOException
    {
    this.m_is.reset();
    }

/**
 * Tests if this input stream supports the <code>mark</code> 
 * and <code>reset</code> methods. 
 * This method
 * simply performs <code>in.markSupported()</code>.
 *
 * @return  <code>true</code> if this stream type supports the
 *          <code>mark</code> and <code>reset</code> method;
 *          <code>false</code> otherwise.
 * @see     java.io.InputStream#mark(int)
 * @see     java.io.InputStream#reset()
 */

  @Override
  public final  boolean markSupported()
    {
    return this.m_is.markSupported();
    }
  }

File Information:

file name:DefaultInputStream.java
package:org.sfc.io
qualified name:org.sfc.io.DefaultInputStream.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/io/DefaultInputStream.java
size:7.979 KB (8171 B)
uploaded: 2018-01-07 12:03:36 GMT+0000
last update: 2006-03-07 04:20:28 GMT+0000
last access: 2018-04-24 03:05:01 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-24 03:05:01 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo