@Override public int available() throws IOException { if (eof || closed.get()) { checkThrowable(); return 0; } int available = 0; if (current != null && current.hasRemaining()) { available = current.remaining(); } for (final ByteBuffer buffer : buffers) { if (buffer == EOF) { break; } available += buffer.remaining(); } checkThrowable(); return closed.get() ? 0 : available; }
@Override public void close() throws IOException { if (closed.compareAndSet(false, true)) { closeQueue(); // we can now safely clear the queue - any blocking read waiting for a buffer // has been resumed by the EOF buffer buffers.clear(); } checkThrowable(); }
@Override public int available() throws IOException { if (eof || closed.get()) { checkThrowable(); return 0; } int available = 0; if (current != null && current.hasRemaining()) { available = current.remaining(); } for (final ByteBuffer buffer : buffers) { if (buffer == EOF) { break; } available += buffer.remaining(); } checkThrowable(); return closed.get() ? 0 : available; }
@Override public void close() throws IOException { if (closed.compareAndSet(false, true)) { closeQueue(); // we can now safely clear the queue - any blocking read waiting for a buffer // has been resumed by the EOF buffer buffers.clear(); } checkThrowable(); }
private int tryRead(boolean block) throws IOException { checkThrowable(); checkNotClosed(); if (eof) { return -1; } if (current != null && current.hasRemaining()) { return current.get() & 0xFF; } try { // try to fetch, but don't block && check if something has been fetched if (fetchChunk(block) && current != null) { return current.get() & 0xFF; } else if (block) { return -1; } } catch (final InterruptedException e) { Thread.currentThread().interrupt(); if (block) { throw new IOException(e); } } return (eof) ? -1 : NOTHING; } }
private int tryRead(boolean block) throws IOException { checkThrowable(); checkNotClosed(); if (eof) { return -1; } if (current != null && current.hasRemaining()) { return current.get() & 0xFF; } try { // try to fetch, but don't block && check if something has been fetched if (fetchChunk(block) && current != null) { return current.get() & 0xFF; } else if (block) { return -1; } } catch (final InterruptedException e) { Thread.currentThread().interrupt(); if (block) { throw new IOException(e); } } return (eof) ? -1 : NOTHING; } }
private int tryRead(final byte[] b, final int off, final int len, boolean block) throws IOException { checkThrowable(); checkNotClosed();
private int tryRead(final byte[] b, final int off, final int len, boolean block) throws IOException { checkThrowable(); checkNotClosed();
@Override public int available() throws IOException { if (eof || closed.get()) { checkThrowable(); return 0; } int available = 0; if (current != null && current.hasRemaining()) { available = current.remaining(); } for (final ByteBuffer buffer : buffers) { if (buffer == EOF) { break; } available += buffer.remaining(); } checkThrowable(); return closed.get() ? 0 : available; }
@Override public void close() throws IOException { if (closed.compareAndSet(false, true)) { closeQueue(); // we can now safely clear the queue - any blocking read waiting for a buffer // has been resumed by the EOF buffer buffers.clear(); } checkThrowable(); }
@Override public int available() throws IOException { if (eof || closed.get()) { checkThrowable(); return 0; } int available = 0; if (current != null && current.hasRemaining()) { available = current.remaining(); } for (final ByteBuffer buffer : buffers) { if (buffer == EOF) { break; } available += buffer.remaining(); } checkThrowable(); return closed.get() ? 0 : available; }
@Override public int available() throws IOException { if (eof || closed.get()) { checkThrowable(); return 0; } int available = 0; if (current != null && current.hasRemaining()) { available = current.remaining(); } for (final ByteBuffer buffer : buffers) { if (buffer == EOF) { break; } available += buffer.remaining(); } checkThrowable(); return closed.get() ? 0 : available; }
@Override public int available() throws IOException { if (eof || closed.get()) { checkThrowable(); return 0; } int available = 0; if (current != null && current.hasRemaining()) { available = current.remaining(); } for (final ByteBuffer buffer : buffers) { if (buffer == EOF) { break; } available += buffer.remaining(); } checkThrowable(); return closed.get() ? 0 : available; }
@Override public void close() throws IOException { if (closed.compareAndSet(false, true)) { closeQueue(); // we can now safely clear the queue - any blocking read waiting for a buffer // has been resumed by the EOF buffer buffers.clear(); } checkThrowable(); }
@Override public void close() throws IOException { if (closed.compareAndSet(false, true)) { closeQueue(); // we can now safely clear the queue - any blocking read waiting for a buffer // has been resumed by the EOF buffer buffers.clear(); } checkThrowable(); }
@Override public int available() throws IOException { if (eof || closed.get()) { checkThrowable(); return 0; } int available = 0; if (current != null && current.hasRemaining()) { available = current.remaining(); } for (final ByteBuffer buffer : buffers) { if (buffer == EOF) { break; } available += buffer.remaining(); } checkThrowable(); return closed.get() ? 0 : available; }
@Override public void close() throws IOException { if (closed.compareAndSet(false, true)) { closeQueue(); // we can now safely clear the queue - any blocking read waiting for a buffer // has been resumed by the EOF buffer buffers.clear(); } checkThrowable(); }
@Override public void close() throws IOException { if (closed.compareAndSet(false, true)) { closeQueue(); // we can now safely clear the queue - any blocking read waiting for a buffer // has been resumed by the EOF buffer buffers.clear(); } checkThrowable(); }
private int tryRead(boolean block) throws IOException { checkThrowable(); checkNotClosed(); if (eof) { return -1; } if (current != null && current.hasRemaining()) { return current.get() & 0xFF; } try { // try to fetch, but don't block && check if something has been fetched if (fetchChunk(block) && current != null) { return current.get() & 0xFF; } else if (block) { return -1; } } catch (final InterruptedException e) { Thread.currentThread().interrupt(); if (block) { throw new IOException(e); } } return (eof) ? -1 : NOTHING; } }
private int tryRead(boolean block) throws IOException { checkThrowable(); checkNotClosed(); if (eof) { return -1; } if (current != null && current.hasRemaining()) { return current.get() & 0xFF; } try { // try to fetch, but don't block && check if something has been fetched if (fetchChunk(block) && current != null) { return current.get() & 0xFF; } else if (block) { return -1; } } catch (final InterruptedException e) { Thread.currentThread().interrupt(); if (block) { throw new IOException(e); } } return (eof) ? -1 : NOTHING; } }