/**
* Creates a new named {@code Timer} which may be specified to be run as a
* daemon thread.
*
* @param name the name of the {@code Timer}.
* @param isDaemon true if {@code Timer}'s thread should be a daemon thread.
* @throws NullPointerException is {@code name} is {@code null}
*/
public Timer(String name, bool isDaemon) : base()
{
if (name == null)
{
throw new java.lang.NullPointerException("name is null");
}
this.impl = new TimerImpl(name, isDaemon);
this.finalizer = new FinalizerHelper(impl);
java.lang.Thread t = new java.lang.Thread(new IAC_CallTimerCancelMethodRunnable(this.impl));
java.lang.Runtime.getRuntime().addShutdownHook(t);
}
/*
* Receives a char and stores it into the PipedReader. This called by
* PipedWriter.write() when writes occur.
* <p/>
* If the buffer is full and the thread sending #receive is interrupted, the
* InterruptedIOException will be thrown.
*
* @param oneChar
* the char to store into the pipe.
*
* @throws IOException
* If the stream is already closed or another IOException
* occurs.
*/
public void receive(char oneChar)
{//throws IOException {// public modifier, because called from PipedWriter
lock (lockJ)
{
if (data == null)
{
throw new IOException("Pipe is closed"); //$NON-NLS-1$
}
if (lastReader != null && !lastReader.isAlive())
{
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
/*
* Set the last thread to be writing on this PipedWriter. If
* lastWriter dies while someone is waiting to read an IOException
* of "Pipe broken" will be thrown in read()
*/
lastWriter = java.lang.Thread.currentThread();
try
{
while (data != null && outJ == inJ)
{
lockJ.notifyAll();
this.wait(1000);
if (lastReader != null && !lastReader.isAlive())
{
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
}
}
catch (java.lang.InterruptedException e)
{
throw new InterruptedIOException();
}
catch (System.Threading.ThreadInterruptedException e)
{
throw new InterruptedIOException();
}
if (data != null)
{
if (inJ == -1)
{
inJ = 0;
}
data[inJ++] = oneChar;
if (inJ == data.Length)
{
inJ = 0;
}
return;
}
}
}
public void start()
{
java.net.ServerSocket server = new java.net.ServerSocket(this.port);
// Create a receiver main loop...
this.running = true;
while (this.running)
{
// waiting for connect...
java.net.Socket client = server.accept();
// create new thread for work
java.lang.Thread worker = new java.lang.Thread(new SampleSimpleHttpServerWorker(client));
worker.start();
}
}
public void start()
{
java.net.ServerSocket server = new java.net.ServerSocket(this.port);
// Create a receiver main loop...
this.running = true;
while (this.running)
{
// waiting for connect...
java.net.Socket client = server.accept();
// create new thread for work
java.lang.Thread worker = new java.lang.Thread(new SampleSimpleHttpServerWorker(client));
worker.start();
}
}
/// <summary>
/// Return the current thread
/// </summary>
/// <returns></returns>
public static java.lang.Thread currentThread()
{
java.lang.Thread result = new java.lang.Thread();
result.delegateInstance = System.Threading.Thread.CurrentThread;
return(result);
}
/*
* Reads at most {@code count} bytes from this stream and stores them in the
* byte array {@code bytes} starting at {@code offset}. Blocks until at
* least one byte has been read, the end of the stream is detected or an
* exception is thrown.
* <p/>
* Separate threads should be used to read from a {@code PipedInputStream}
* and to write to the connected {@link PipedOutputStream}. If the same
* thread is used, a deadlock may occur.
*
* @param bytes
* the array in which to store the bytes read.
* @param offset
* the initial position in {@code bytes} to store the bytes
* read from this stream.
* @param count
* the maximum number of bytes to store in {@code bytes}.
* @return the number of bytes actually read or -1 if the end of the stream
* has been reached.
* @throws IndexOutOfBoundsException
* if {@code offset < 0} or {@code count < 0}, or if {@code
* offset + count} is greater than the size of {@code bytes}.
* @throws InterruptedIOException
* if the thread reading from this stream is interrupted.
* @throws IOException
* if this stream is closed or not connected to an output
* stream, or if the thread writing to the connected output
* stream is no longer alive.
* @throws NullPointerException
* if {@code bytes} is {@code null}.
*/
public override int read(byte[] bytes, int offset, int count)
{// throws IOException {
lock (this)
{
if (bytes == null)
{
throw new java.lang.NullPointerException();
}
if (offset < 0 || offset > bytes.Length || count < 0 ||
count > bytes.Length - offset)
{
throw new java.lang.IndexOutOfBoundsException();
}
if (count == 0)
{
return(0);
}
if (!isConnected)
{
// luni.CB=Not connected
throw new IOException("Not connected"); //$NON-NLS-1$
}
if (buffer == null)
{
// luni.CC=InputStream is closed
throw new IOException("InputStream is closed"); //$NON-NLS-1$
}
if (lastWriter != null && !lastWriter.isAlive() && (inJ < 0))
{
// luni.CD=Write end dead
throw new IOException("Write end dead"); //$NON-NLS-1$
}
/*
* Set the last thread to be reading on this PipedInputStream. If
* lastReader dies while someone is waiting to write an IOException of
* "Pipe broken" will be thrown in receive()
*/
lastReader = java.lang.Thread.currentThread();
try
{
int attempts = 3;
while (inJ == -1)
{
// Are we at end of stream?
if (isClosed)
{
return(-1);
}
if ((attempts-- <= 0) && lastWriter != null && !lastWriter.isAlive())
{
// luni.CE=Pipe broken
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
// Notify callers of receive()
this.notifyAll();
this.wait(1000);
}
}
catch (java.lang.InterruptedException e)
{
throw new InterruptedIOException();
}
int copyLength = 0;
/* Copy bytes from out to end of buffer first */
if (outJ >= inJ)
{
copyLength = count > (buffer.Length - outJ) ? buffer.Length - outJ
: count;
java.lang.SystemJ.arraycopy(buffer, outJ, bytes, offset, copyLength);
outJ += copyLength;
if (outJ == buffer.Length)
{
outJ = 0;
}
if (outJ == inJ)
{
// empty buffer
inJ = -1;
outJ = 0;
}
}
/*
* Did the read fully succeed in the previous copy or is the buffer
* empty?
*/
if (copyLength == count || inJ == -1)
{
return(copyLength);
}
int bytesCopied = copyLength;
/* Copy bytes from 0 to the number of available bytes */
copyLength = inJ - outJ > (count - bytesCopied) ? count - bytesCopied
: inJ - outJ;
java.lang.SystemJ.arraycopy(buffer, outJ, bytes, offset + bytesCopied, copyLength);
outJ += copyLength;
if (outJ == inJ)
{
// empty buffer
inJ = -1;
outJ = 0;
}
return(bytesCopied + copyLength);
}
}
/*
* Reads a single byte from this stream and returns it as an integer in the
* range from 0 to 255. Returns -1 if the end of this stream has been
* reached. If there is no data in the pipe, this method blocks until data
* is available, the end of the stream is detected or an exception is
* thrown.
* <p/>
* Separate threads should be used to read from a {@code PipedInputStream}
* and to write to the connected {@link PipedOutputStream}. If the same
* thread is used, a deadlock may occur.
*
* @return the byte read or -1 if the end of the source stream has been
* reached.
* @throws IOException
* if this stream is closed or not connected to an output
* stream, or if the thread writing to the connected output
* stream is no longer alive.
*/
public override int read()
{//throws IOException {
lock (this)
{
if (!isConnected)
{
// luni.CB=Not connected
throw new IOException("Not connected"); //$NON-NLS-1$
}
if (buffer == null)
{
// luni.CC=InputStream is closed
throw new IOException("InputStream is closed"); //$NON-NLS-1$
}
if (lastWriter != null && !lastWriter.isAlive() && (inJ < 0))
{
// luni.CD=Write end dead
throw new IOException("Write end dead"); //$NON-NLS-1$
}
/*
* Set the last thread to be reading on this PipedInputStream. If
* lastReader dies while someone is waiting to write an IOException of
* "Pipe broken" will be thrown in receive()
*/
lastReader = java.lang.Thread.currentThread();
try
{
int attempts = 3;
while (inJ == -1)
{
// Are we at end of stream?
if (isClosed)
{
return(-1);
}
if ((attempts-- <= 0) && lastWriter != null && !lastWriter.isAlive())
{
// luni.CE=Pipe broken
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
// Notify callers of receive()
this.notifyAll();
this.wait(1000);
}
}
catch (java.lang.InterruptedException e)
{
throw new InterruptedIOException();
}
byte result = buffer[outJ++];
if (outJ == buffer.Length)
{
outJ = 0;
}
if (outJ == inJ)
{
// empty buffer
inJ = -1;
outJ = 0;
}
return(result & 0xff);
}
}
/**
* Receives a char array and stores it into the PipedReader. This called by
* PipedWriter.write() when writes occur.
* <p/>
* If the buffer is full and the thread sending #receive is interrupted, the
* InterruptedIOException will be thrown.
*
* @param chars
* the char array to store into the pipe.
* @param offset
* offset to start reading from
* @param count
* total characters to read
*
* @throws IOException
* If the stream is already closed or another IOException
* occurs.
*/
public void receive(char[] chars, int offset, int count)
{
//throws IOException { // public modifier, because called from PipedWriter
lock (lockJ){
if (data == null) {
throw new IOException("Pipe is closed"); //$NON-NLS-1$
}
if (lastReader != null && !lastReader.isAlive()) {
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
/*
* Set the last thread to be writing on this PipedWriter. If
* lastWriter dies while someone is waiting to read an IOException
* of "Pipe broken" will be thrown in read()
*/
lastWriter = java.lang.Thread.currentThread();
while (count > 0) {
try {
while (data != null && outJ == inJ) {
lockJ.notifyAll();
this.wait(1000);
if (lastReader != null && !lastReader.isAlive()) {
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
}
} catch (java.lang.InterruptedException e) {
throw new InterruptedIOException();
}
catch (System.Threading.ThreadInterruptedException e) {
throw new InterruptedIOException ();
}
if (data == null) {
break;
}
if (inJ == -1) {
inJ = 0;
}
if (inJ >= outJ) {
int length = data.Length - inJ;
if (count < length) {
length = count;
}
java.lang.SystemJ.arraycopy(chars, offset, data, inJ, length);
offset += length;
count -= length;
inJ += length;
if (inJ == data.Length) {
inJ = 0;
}
}
if (count > 0 && inJ != outJ) {
int length = outJ - inJ;
if (count < length) {
length = count;
}
java.lang.SystemJ.arraycopy(chars, offset, data, inJ, length);
offset += length;
count -= length;
inJ += length;
}
}
if (count == 0) {
return;
}
}
}
/**
* Receives a char and stores it into the PipedReader. This called by
* PipedWriter.write() when writes occur.
* <p/>
* If the buffer is full and the thread sending #receive is interrupted, the
* InterruptedIOException will be thrown.
*
* @param oneChar
* the char to store into the pipe.
*
* @throws IOException
* If the stream is already closed or another IOException
* occurs.
*/
public void receive(char oneChar)
{
//throws IOException {// public modifier, because called from PipedWriter
lock (lockJ){
if (data == null) {
throw new IOException("Pipe is closed"); //$NON-NLS-1$
}
if (lastReader != null && !lastReader.isAlive()) {
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
/*
* Set the last thread to be writing on this PipedWriter. If
* lastWriter dies while someone is waiting to read an IOException
* of "Pipe broken" will be thrown in read()
*/
lastWriter = java.lang.Thread.currentThread();
try {
while (data != null && outJ == inJ) {
lockJ.notifyAll();
this.wait(1000);
if (lastReader != null && !lastReader.isAlive()) {
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
}
} catch (java.lang.InterruptedException e) {
throw new InterruptedIOException();
}
catch (System.Threading.ThreadInterruptedException e) {
throw new InterruptedIOException ();
}
if (data != null) {
if (inJ == -1) {
inJ = 0;
}
data[inJ++] = oneChar;
if (inJ == data.Length) {
inJ = 0;
}
return;
}
}
}
/**
* Reads at most {@code count} characters from this reader and stores them
* in the character array {@code buffer} starting at {@code offset}. If
* there is no data in the pipe, this method blocks until at least one byte
* has been read, the end of the reader is detected or an exception is
* thrown.
* <p>
* Separate threads should be used to read from a {@code PipedReader} and to
* write to the connected {@link PipedWriter}. If the same thread is used, a
* deadlock may occur.
*
* @param buffer
* the character array in which to store the characters read.
* @param offset
* the initial position in {@code bytes} to store the characters
* read from this reader.
* @param count
* the maximum number of characters to store in {@code buffer}.
* @return the number of characters read or -1 if the end of the reader has
* been reached.
* @throws IndexOutOfBoundsException
* if {@code offset < 0} or {@code count < 0}, or if {@code
* offset + count} is greater than the size of {@code buffer}.
* @throws InterruptedIOException
* if the thread reading from this reader is interrupted.
* @throws IOException
* if this reader is closed or not connected to a writer, or if
* the thread writing to the connected writer is no longer
* alive.
*/
public override int read(char[] buffer, int offset, int count)
{
// throws IOException {
lock (lockJ){
if (!isConnected) {
throw new IOException("Pipe Not Connected"); //$NON-NLS-1$
}
if (data == null) {
throw new IOException("Pipe is closed"); //$NON-NLS-1$
}
// avoid int overflow
if (offset < 0 || count > buffer.Length - offset || count < 0) {
throw new java.lang.IndexOutOfBoundsException();
}
if (count == 0) {
return 0;
}
/*
* Set the last thread to be reading on this PipedReader. If
* lastReader dies while someone is waiting to write an IOException
* of "Pipe broken" will be thrown in receive()
*/
lastReader = java.lang.Thread.currentThread();
try {
bool first = true;
while (inJ == -1) {
// Are we at end of stream?
if (isClosed) {
return -1;
}
if (!first && lastWriter != null && !lastWriter.isAlive()) {
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
first = false;
// Notify callers of receive()
lockJ.notifyAll();
lockJ.wait(1000);
}
} catch (java.lang.InterruptedException e) {
throw new InterruptedIOException();
}
catch (System.Threading.ThreadInterruptedException e) {
throw new InterruptedIOException ();
}
int copyLength = 0;
/* Copy chars from out to end of buffer first */
if (outJ >= inJ) {
copyLength = count > data.Length - outJ ? data.Length - outJ
: count;
java.lang.SystemJ.arraycopy(data, outJ, buffer, offset, copyLength);
outJ += copyLength;
if (outJ == data.Length) {
outJ = 0;
}
if (outJ == inJ) {
// empty buffer
inJ = -1;
outJ = 0;
}
}
/*
* Did the read fully succeed in the previous copy or is the buffer
* empty?
*/
if (copyLength == count || inJ == -1) {
return copyLength;
}
int charsCopied = copyLength;
/* Copy bytes from 0 to the number of available bytes */
copyLength = inJ - outJ > count - copyLength ? count - copyLength
: inJ - outJ;
java.lang.SystemJ.arraycopy(data, outJ, buffer, offset + charsCopied,
copyLength);
outJ += copyLength;
if (outJ == inJ) {
// empty buffer
inJ = -1;
outJ = 0;
}
return charsCopied + copyLength;
}
}
/*
* Reads at most {@code count} characters from this reader and stores them
* in the character array {@code buffer} starting at {@code offset}. If
* there is no data in the pipe, this method blocks until at least one byte
* has been read, the end of the reader is detected or an exception is
* thrown.
* <p>
* Separate threads should be used to read from a {@code PipedReader} and to
* write to the connected {@link PipedWriter}. If the same thread is used, a
* deadlock may occur.
*
* @param buffer
* the character array in which to store the characters read.
* @param offset
* the initial position in {@code bytes} to store the characters
* read from this reader.
* @param count
* the maximum number of characters to store in {@code buffer}.
* @return the number of characters read or -1 if the end of the reader has
* been reached.
* @throws IndexOutOfBoundsException
* if {@code offset < 0} or {@code count < 0}, or if {@code
* offset + count} is greater than the size of {@code buffer}.
* @throws InterruptedIOException
* if the thread reading from this reader is interrupted.
* @throws IOException
* if this reader is closed or not connected to a writer, or if
* the thread writing to the connected writer is no longer
* alive.
*/
public override int read(char[] buffer, int offset, int count)
{// throws IOException {
lock (lockJ)
{
if (!isConnected)
{
throw new IOException("Pipe Not Connected"); //$NON-NLS-1$
}
if (data == null)
{
throw new IOException("Pipe is closed"); //$NON-NLS-1$
}
// avoid int overflow
if (offset < 0 || count > buffer.Length - offset || count < 0)
{
throw new java.lang.IndexOutOfBoundsException();
}
if (count == 0)
{
return(0);
}
/*
* Set the last thread to be reading on this PipedReader. If
* lastReader dies while someone is waiting to write an IOException
* of "Pipe broken" will be thrown in receive()
*/
lastReader = java.lang.Thread.currentThread();
try
{
bool first = true;
while (inJ == -1)
{
// Are we at end of stream?
if (isClosed)
{
return(-1);
}
if (!first && lastWriter != null && !lastWriter.isAlive())
{
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
first = false;
// Notify callers of receive()
lockJ.notifyAll();
lockJ.wait(1000);
}
}
catch (java.lang.InterruptedException e)
{
throw new InterruptedIOException();
}
catch (System.Threading.ThreadInterruptedException e)
{
throw new InterruptedIOException();
}
int copyLength = 0;
/* Copy chars from out to end of buffer first */
if (outJ >= inJ)
{
copyLength = count > data.Length - outJ ? data.Length - outJ
: count;
java.lang.SystemJ.arraycopy(data, outJ, buffer, offset, copyLength);
outJ += copyLength;
if (outJ == data.Length)
{
outJ = 0;
}
if (outJ == inJ)
{
// empty buffer
inJ = -1;
outJ = 0;
}
}
/*
* Did the read fully succeed in the previous copy or is the buffer
* empty?
*/
if (copyLength == count || inJ == -1)
{
return(copyLength);
}
int charsCopied = copyLength;
/* Copy bytes from 0 to the number of available bytes */
copyLength = inJ - outJ > count - copyLength ? count - copyLength
: inJ - outJ;
java.lang.SystemJ.arraycopy(data, outJ, buffer, offset + charsCopied,
copyLength);
outJ += copyLength;
if (outJ == inJ)
{
// empty buffer
inJ = -1;
outJ = 0;
}
return(charsCopied + copyLength);
}
}
/// <summary>
/// Return the current thread
/// </summary>
/// <returns></returns>
public static java.lang.Thread currentThread()
{
java.lang.Thread result = new java.lang.Thread();
result.delegateInstance = System.Threading.Thread.CurrentThread;
return result;
}
/*
* Receives a char array and stores it into the PipedReader. This called by
* PipedWriter.write() when writes occur.
* <p/>
* If the buffer is full and the thread sending #receive is interrupted, the
* InterruptedIOException will be thrown.
*
* @param chars
* the char array to store into the pipe.
* @param offset
* offset to start reading from
* @param count
* total characters to read
*
* @throws IOException
* If the stream is already closed or another IOException
* occurs.
*/
public void receive(char[] chars, int offset, int count)
{//throws IOException { // public modifier, because called from PipedWriter
lock (lockJ)
{
if (data == null)
{
throw new IOException("Pipe is closed"); //$NON-NLS-1$
}
if (lastReader != null && !lastReader.isAlive())
{
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
/*
* Set the last thread to be writing on this PipedWriter. If
* lastWriter dies while someone is waiting to read an IOException
* of "Pipe broken" will be thrown in read()
*/
lastWriter = java.lang.Thread.currentThread();
while (count > 0)
{
try
{
while (data != null && outJ == inJ)
{
lockJ.notifyAll();
this.wait(1000);
if (lastReader != null && !lastReader.isAlive())
{
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
}
}
catch (java.lang.InterruptedException e)
{
throw new InterruptedIOException();
}
catch (System.Threading.ThreadInterruptedException e)
{
throw new InterruptedIOException();
}
if (data == null)
{
break;
}
if (inJ == -1)
{
inJ = 0;
}
if (inJ >= outJ)
{
int length = data.Length - inJ;
if (count < length)
{
length = count;
}
java.lang.SystemJ.arraycopy(chars, offset, data, inJ, length);
offset += length;
count -= length;
inJ += length;
if (inJ == data.Length)
{
inJ = 0;
}
}
if (count > 0 && inJ != outJ)
{
int length = outJ - inJ;
if (count < length)
{
length = count;
}
java.lang.SystemJ.arraycopy(chars, offset, data, inJ, length);
offset += length;
count -= length;
inJ += length;
}
}
if (count == 0)
{
return;
}
}
}
/**
* Reads a single byte from this stream and returns it as an integer in the
* range from 0 to 255. Returns -1 if the end of this stream has been
* reached. If there is no data in the pipe, this method blocks until data
* is available, the end of the stream is detected or an exception is
* thrown.
* <p/>
* Separate threads should be used to read from a {@code PipedInputStream}
* and to write to the connected {@link PipedOutputStream}. If the same
* thread is used, a deadlock may occur.
*
* @return the byte read or -1 if the end of the source stream has been
* reached.
* @throws IOException
* if this stream is closed or not connected to an output
* stream, or if the thread writing to the connected output
* stream is no longer alive.
*/
public override int read()
{
//throws IOException {
lock (this)
{
if (!isConnected)
{
// luni.CB=Not connected
throw new IOException("Not connected"); //$NON-NLS-1$
}
if (buffer == null)
{
// luni.CC=InputStream is closed
throw new IOException("InputStream is closed"); //$NON-NLS-1$
}
if (lastWriter != null && !lastWriter.isAlive() && (inJ < 0))
{
// luni.CD=Write end dead
throw new IOException("Write end dead"); //$NON-NLS-1$
}
/*
* Set the last thread to be reading on this PipedInputStream. If
* lastReader dies while someone is waiting to write an IOException of
* "Pipe broken" will be thrown in receive()
*/
lastReader = java.lang.Thread.currentThread();
try
{
int attempts = 3;
while (inJ == -1)
{
// Are we at end of stream?
if (isClosed)
{
return -1;
}
if ((attempts-- <= 0) && lastWriter != null && !lastWriter.isAlive())
{
// luni.CE=Pipe broken
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
// Notify callers of receive()
this.notifyAll();
this.wait(1000);
}
}
catch (java.lang.InterruptedException e)
{
throw new InterruptedIOException();
}
byte result = buffer[outJ++];
if (outJ == buffer.Length)
{
outJ = 0;
}
if (outJ == inJ)
{
// empty buffer
inJ = -1;
outJ = 0;
}
return result & 0xff;
}
}
/**
* Creates a new named {@code Timer} which may be specified to be run as a
* daemon thread.
*
* @param name the name of the {@code Timer}.
* @param isDaemon true if {@code Timer}'s thread should be a daemon thread.
* @throws NullPointerException is {@code name} is {@code null}
*/
public Timer(String name, bool isDaemon)
: base()
{
if (name == null){
throw new java.lang.NullPointerException("name is null");
}
this.impl = new TimerImpl(name, isDaemon);
this.finalizer = new FinalizerHelper(impl);
java.lang.Thread t = new java.lang.Thread (new IAC_CallTimerCancelMethodRunnable(this.impl));
java.lang.Runtime.getRuntime().addShutdownHook(t);
}
/**
* Reads at most {@code count} bytes from this stream and stores them in the
* byte array {@code bytes} starting at {@code offset}. Blocks until at
* least one byte has been read, the end of the stream is detected or an
* exception is thrown.
* <p/>
* Separate threads should be used to read from a {@code PipedInputStream}
* and to write to the connected {@link PipedOutputStream}. If the same
* thread is used, a deadlock may occur.
*
* @param bytes
* the array in which to store the bytes read.
* @param offset
* the initial position in {@code bytes} to store the bytes
* read from this stream.
* @param count
* the maximum number of bytes to store in {@code bytes}.
* @return the number of bytes actually read or -1 if the end of the stream
* has been reached.
* @throws IndexOutOfBoundsException
* if {@code offset < 0} or {@code count < 0}, or if {@code
* offset + count} is greater than the size of {@code bytes}.
* @throws InterruptedIOException
* if the thread reading from this stream is interrupted.
* @throws IOException
* if this stream is closed or not connected to an output
* stream, or if the thread writing to the connected output
* stream is no longer alive.
* @throws NullPointerException
* if {@code bytes} is {@code null}.
*/
public override int read(byte[] bytes, int offset, int count)
{
// throws IOException {
lock (this)
{
if (bytes == null)
{
throw new java.lang.NullPointerException();
}
if (offset < 0 || offset > bytes.Length || count < 0
|| count > bytes.Length - offset)
{
throw new java.lang.IndexOutOfBoundsException();
}
if (count == 0)
{
return 0;
}
if (!isConnected)
{
// luni.CB=Not connected
throw new IOException("Not connected"); //$NON-NLS-1$
}
if (buffer == null)
{
// luni.CC=InputStream is closed
throw new IOException("InputStream is closed"); //$NON-NLS-1$
}
if (lastWriter != null && !lastWriter.isAlive() && (inJ < 0))
{
// luni.CD=Write end dead
throw new IOException("Write end dead"); //$NON-NLS-1$
}
/*
* Set the last thread to be reading on this PipedInputStream. If
* lastReader dies while someone is waiting to write an IOException of
* "Pipe broken" will be thrown in receive()
*/
lastReader = java.lang.Thread.currentThread();
try
{
int attempts = 3;
while (inJ == -1)
{
// Are we at end of stream?
if (isClosed)
{
return -1;
}
if ((attempts-- <= 0) && lastWriter != null && !lastWriter.isAlive())
{
// luni.CE=Pipe broken
throw new IOException("Pipe broken"); //$NON-NLS-1$
}
// Notify callers of receive()
this.notifyAll();
this.wait(1000);
}
}
catch (java.lang.InterruptedException e)
{
throw new InterruptedIOException();
}
int copyLength = 0;
/* Copy bytes from out to end of buffer first */
if (outJ >= inJ)
{
copyLength = count > (buffer.Length - outJ) ? buffer.Length - outJ
: count;
java.lang.SystemJ.arraycopy(buffer, outJ, bytes, offset, copyLength);
outJ += copyLength;
if (outJ == buffer.Length)
{
outJ = 0;
}
if (outJ == inJ)
{
// empty buffer
inJ = -1;
outJ = 0;
}
}
/*
* Did the read fully succeed in the previous copy or is the buffer
* empty?
*/
if (copyLength == count || inJ == -1)
{
return copyLength;
}
int bytesCopied = copyLength;
/* Copy bytes from 0 to the number of available bytes */
copyLength = inJ - outJ > (count - bytesCopied) ? count - bytesCopied
: inJ - outJ;
java.lang.SystemJ.arraycopy(buffer, outJ, bytes, offset + bytesCopied, copyLength);
outJ += copyLength;
if (outJ == inJ)
{
// empty buffer
inJ = -1;
outJ = 0;
}
return bytesCopied + copyLength;
}
}
/**
* Read informations of a rpm file out of an input stream.
*
* @param rpmInputStream The input stream representing the rpm file
* @throws IOException if an error occurs during read of the rpm file
*/
private void readFromStream(java.io.InputStream rpmInputStream)
{//throws IOException {
ByteCountInputStream allCountInputStream = new ByteCountInputStream(
rpmInputStream);
java.io.InputStream inputStream = new java.io.DataInputStream(allCountInputStream);
lead = new RPMLead((java.io.DataInputStream)inputStream);
signature = new RPMSignature((java.io.DataInputStream)inputStream, store);
if (logger.isLoggable(java.util.logging.Level.FINER))
{
logger.finer("Signature Size: " + signature.getSize());
}
header = new RPMHeader((java.io.DataInputStream)inputStream, store);
if (logger.isLoggable(java.util.logging.Level.FINER))
{
logger.finer("Header Size: " + header.getSize());
}
DataTypeIf payloadTag = getTag("PAYLOADFORMAT");
String payloadFormat = payloadTag != null?payloadTag.toString()
: "cpio";
DataTypeIf payloadCompressionTag = getTag("PAYLOADCOMPRESSOR");
String payloadCompressor = payloadCompressionTag != null?payloadCompressionTag
.toString()
: "gzip";
if (payloadFormat.equals("cpio"))
{
if (logger.isLoggable(java.util.logging.Level.FINER))
{
logger.finer("PAYLOADCOMPRESSOR: " + payloadCompressor);
}
if (payloadCompressor.equals("gzip"))
{
inputStream = new GzipCompressorInputStream(allCountInputStream);
}
else if (payloadCompressor.equals("bzip2"))
{
inputStream = new BZip2CompressorInputStream(allCountInputStream);
}
else if (payloadCompressor.equals("lzma"))
{
try
{
java.io.PipedOutputStream pout = new java.io.PipedOutputStream();
inputStream = new java.io.PipedInputStream(pout);
byte[] properties = new byte[5];
if (allCountInputStream.read(properties, 0, 5) != 5)
{
throw (new java.io.IOException("input .lzma is too short"));
}
SevenZip.Compression.LZMA.Decoder decoder = new SevenZip.Compression.LZMA.Decoder();
decoder.SetDecoderProperties(properties);
long outSize = 0;
for (int i = 0; i < 8; i++)
{
int v = allCountInputStream.read();
if (v < 0)
{
throw (new java.io.IOException("lzma error : Can't Read 1"));
}
outSize |= ((long)v) << (8 * i);
}
if (outSize == -1)
{
outSize = java.lang.Long.MAX_VALUE;
}
Decode decoderRunnable = new Decode(decoder,
allCountInputStream, pout, outSize);
java.lang.Thread t = new java.lang.Thread(decoderRunnable, "LZMA Decoder");
t.start();
}
catch (java.lang.NoClassDefFoundError)
{
String message = "No LZMA library found. Attach p7zip library to classpath (http://p7zip.sourceforge.net/)";
logger.severe(message);
throw new java.io.IOException(message);
}
}
else if (payloadCompressor.equals("none"))
{
inputStream = allCountInputStream;
}
else
{
throw new java.io.IOException("Unsupported compressor type "
+ payloadCompressor);
}
ByteCountInputStream countInputStream = new ByteCountInputStream(inputStream);
CpioArchiveInputStream cpioInputStream = new CpioArchiveInputStream(countInputStream);
CpioArchiveEntry readEntry;
java.util.List <String> fileNamesList = new java.util.ArrayList <String>();
String fileEntry;
while ((readEntry = cpioInputStream.getNextCPIOEntry()) != null)
{
if (logger.isLoggable(java.util.logging.Level.FINER))
{
logger.finer("Read CPIO entry: " + readEntry.getName()
+ " ;mode:" + readEntry.getMode());
}
if (readEntry.isRegularFile() || readEntry.isSymbolicLink() ||
readEntry.isDirectory())
{
fileEntry = readEntry.getName();
if (fileEntry.startsWith("./"))
{
fileEntry = fileEntry.substring(1);
}
fileNamesList.add(fileEntry);
}
}
store.setTag("FILENAMES", TypeFactory.createSTRING_ARRAY((String[])fileNamesList.toArray(new String[fileNamesList.size()])));
setHeaderTagFromSignature("ARCHIVESIZE", "PAYLOADSIZE");
// check ARCHIVESIZE with countInputStream.getCount();
Object archiveSizeObject = getTag("ARCHIVESIZE");
if (archiveSizeObject != null)
{
if (archiveSizeObject is INT32)
{
int archiveSize = ((INT32)archiveSizeObject).getData()[0];
if (archiveSize != countInputStream.getCount())
{
new java.io.IOException("ARCHIVESIZE not correct");
}
}
}
store.setTag("J_ARCHIVESIZE", TypeFactory
.createINT64(new long[] { countInputStream.getCount() }));
}
else
{
throw new java.io.IOException("Unsupported Payload type " + payloadFormat);
}
// filling in signatures
// TODO: check signatures!
setHeaderTagFromSignature("SIGSIZE", "SIZE");
setHeaderTagFromSignature("SIGLEMD5_1", "LEMD5_1");
setHeaderTagFromSignature("SIGPGP", "PGP");
setHeaderTagFromSignature("SIGLEMD5_2", "LEMD5_2");
setHeaderTagFromSignature("SIGMD5", "MD5");
setHeaderTagFromSignature("SIGGPG", "GPG");
setHeaderTagFromSignature("SIGPGP5", "PGP5");
setHeaderTagFromSignature("DSAHEADER", "DSA");
setHeaderTagFromSignature("RSAHEADER", "RSA");
setHeaderTagFromSignature("SHA1HEADER", "SHA1");
store.setTag("J_FILESIZE", TypeFactory
.createINT64(new long[] { allCountInputStream.getCount() }));
rpmInputStream.close();
}