Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Conditions Of Use
   *
   * This software was developed by employees of the National Institute of
   * Standards and Technology (NIST), an agency of the Federal Government.
   * Pursuant to title 15 Untied States Code Section 105, works of NIST
   * employees are not subject to copyright protection in the United States
   * and are considered to be in the public domain.  As a result, a formal
   * license is not needed to use the software.
  *
  * This software is provided by NIST as a service and is expressly
  * provided "AS IS."  NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
  * OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
  * AND DATA ACCURACY.  NIST does not warrant or make any representations
  * regarding the use of the software or the results thereof, including but
  * not limited to the correctness, accuracy, reliability or usefulness of
  * the software.
  *
  * Permission to use this software is contingent upon your acceptance
  * of the terms of this agreement
  *
  * .
  *
  */
 package gov.nist.javax.sip.parser;
 
 
 import java.io.*;
 import java.util.*;

Input class for the pipelined parser. Buffer all bytes read from the socket and make them available to the message parser.

Author(s):
M. Ranganathan (Contains a bug fix contributed by Rob Daugherty ( Lucent Technologies) )
 
 
 public class Pipeline extends InputStream {
     private LinkedList buffList;
 
     private Buffer currentBuffer;
 
     private boolean isClosed;
 
     private Timer timer;
 
     private InputStream pipe;
 
     private int readTimeout;
 
     private TimerTask myTimerTask;
 
     class MyTimer extends SIPStackTimerTask {
         Pipeline pipeline;
 
         private boolean isCancelled;
 
         protected MyTimer(Pipeline pipeline) {
             this. = pipeline;
         }
 
         protected void runTask() {
             if (this.)
                 return;
 
             try {
                 .close();
             } catch (IOException ex) {
                 InternalErrorHandler.handleException(ex);
             }
         }
 
         public boolean cancel() {
             boolean retval = super.cancel();
             this. = true;
             return retval;
         }
 
     }
 
     class Buffer {
         byte[] bytes;
 
         int length;
 
         int ptr;
 
         public Buffer(byte[] bytesint length) {
              = 0;
             this. = length;
             this. = bytes;
         }
 
         public int getNextByte() {
            return (int[++] & 0xFF;
        }
    }
    public void startTimer() {
        if (this. == -1)
            return;
        // TODO make this a tunable number. For now 4 seconds
        // between reads seems reasonable upper limit.
        this. = new MyTimer(this);
        this..schedule(this.this.);
    }
    public void stopTimer() {
        if (this. == -1)
            return;
        if (this. != null)
            this..cancel();
    }
    public Pipeline(InputStream pipeint readTimeoutTimer timer) {
        // pipe is the Socket stream
        // this is recorded here to implement a timeout.
        this. = timer;
        this. = pipe;
         = new LinkedList();
        this. = readTimeout;
    }
    public void write(byte[] bytesint startint lengththrows IOException {
        if (this.)
            throw new IOException("Closed!!");
        Buffer buff = new Buffer(byteslength);
        buff.ptr = start;
        synchronized (this.) {
            .add(buff);
            .notifyAll();
        }
    }
    public void write(byte[] bytesthrows IOException {
        if (this.)
            throw new IOException("Closed!!");
        Buffer buff = new Buffer(bytesbytes.length);
        synchronized (this.) {
            .add(buff);
            .notifyAll();
        }
    }
    public void close() throws IOException {
        this. = true;
        synchronized (this.) {
            this..notifyAll();
        }
        // JvB: added
        this..close();
    }
    public int read() throws IOException {
        // if (this.isClosed) return -1;
        synchronized (this.) {
            if ( != null
                    && . < .) {
                int retval = .getNextByte();
                if (. == .)
                    this. = null;
                return retval;
            }
            // Bug fix contributed by Rob Daugherty.
            if (this. && this..isEmpty())
                return -1;
            try {
                // wait till something is posted.
                while (this..isEmpty()) {
                    this..wait();
                    // jeand : Issue 314 : return -1 only if the buffer is empty 
                    if (this..isEmpty() && this.)
                        return -1;
                }
                 = (Bufferthis..removeFirst();
                int retval = .getNextByte();
                if (. == .)
                    this. = null;
                return retval;
            } catch (InterruptedException ex) {
                throw new IOException(ex.getMessage());
            } catch (NoSuchElementException ex) {
                ex.printStackTrace();
                throw new IOException(ex.getMessage());
            }
        }
    }

Returns:
the isClosed
	public boolean isClosed() {
		return ;
	}
New to GrepCode? Check out our FAQ X