ChannelStream

java.lang.Object
- org.jruby.util.io.ChannelStream

All Implemented Interfaces:: Finalizable, Stream

public class ChannelStream
extends java.lang.Object
implements Stream, Finalizable

This file implements a seekable IO file.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private static class ChannelStream.InputStreamAdapter

private static class ChannelStream.OutputStreamAdapter

Nested Classes
Modifier and Type	Class and Description
`private static class`	`ChannelStream.InputStreamAdapter`
`private static class`	`ChannelStream.OutputStreamAdapter`

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`autoclose`
`private boolean`	`blocking`
`protected java.nio.ByteBuffer`	`buffer`
`static int`	`BUFSIZE` The size of the read/write buffer allocated for this stream.
`private static int`	`BULK_READ_SIZE` The size at which a single read should turn into a chunkier bulk read.
`private boolean`	`closedExplicitly`
`private static boolean`	`DEBUG`
`private ChannelDescriptor`	`descriptor`
`private static java.nio.ByteBuffer`	`EMPTY_BUFFER`
`private boolean`	`eof`
`private static java.io.EOFException`	`eofException` A cached EOFException.
`private static Logger`	`LOG`
`protected ModeFlags`	`modes`
`protected boolean`	`reading`
`private Ruby`	`runtime`
`protected boolean`	`sync`
`private org.jruby.util.ByteList`	`ungotChars`

Fields inherited from interface org.jruby.util.io.Stream
PARAGRAPH_DELIMETER, PARAGRAPH_SEPARATOR, SEEK_CUR, SEEK_END, SEEK_SET

Constructor Summary

Constructors
Modifier	Constructor and Description
`private`	`ChannelStream(Ruby runtime, ChannelDescriptor descriptor, boolean autoclose)`
`private`	`ChannelStream(Ruby runtime, ChannelDescriptor descriptor, ModeFlags modes, boolean autoclose)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`private int`	`bufferedInputBytesRemaining()` Returns a count of how many bytes are available in the read buffer
`private int`	`bufferedOutputSpaceRemaining()` Returns a count of how many bytes of space is available in the write buffer.
`private int`	`bufferedRead()`
`private int`	`bufferedRead(java.nio.ByteBuffer dst, boolean partial)`
`private int`	`bufferedRead(org.jruby.util.ByteList dst, int number)`
`private org.jruby.util.ByteList`	`bufferedRead(int number)`
`private int`	`bufferedWrite(java.nio.ByteBuffer buf)`
`private int`	`bufferedWrite(org.jruby.util.ByteList buf)`
`private int`	`bufferedWrite(int c)`
`void`	`checkPermissionsSubsetOf(ModeFlags subsetModes)`
`void`	`checkReadable()`
`void`	`checkWritable()`
`void`	`clearerr()`
`private void`	`clearUngotChars()`
`private void`	`close()` Internal close.
`private int`	`copyBufferedBytes(byte[] dst, int off, int len)` Copies bytes from the channel buffer into a destination `ByteBuffer`
`private int`	`copyBufferedBytes(java.nio.ByteBuffer dst)` Copies bytes from the channel buffer into a destination `ByteBuffer`
`private int`	`copyBufferedBytes(org.jruby.util.ByteList dst, int len)` Copies bytes from the channel buffer into a destination `ByteBuffer`
`private void`	`ensureRead()` Ensure buffer is ready for reading, flushing remaining writes if required
`private void`	`ensureReadNonBuffered()` Ensure buffer is ready for reading, flushing remaining writes if required
`private void`	`ensureWrite()` Ensure buffer is ready for writing.
`void`	`fclose()` Closes IO handler resources.
`static Stream`	`fdopen(Ruby runtime, ChannelDescriptor descriptor, ModeFlags modes)`
`static Stream`	`fdopen(Ruby runtime, ChannelDescriptor descriptor, ModeFlags modes, boolean autoclose)`
`boolean`	`feof()` Return true when at end of file (EOF).
`int`	`fflush()`
`int`	`fgetc()`
`long`	`fgetpos()` Get the current position within the file associated with this handler.
`org.jruby.util.ByteList`	`fgets(org.jruby.util.ByteList separatorString)`
`void`	`finalize()` Ensure close (especially flush) when we're finished with.
`private void`	`finish(boolean close)`
`private void`	`flushWrite()` Flush the write buffer to the channel (if needed)
`private boolean`	`flushWrite(boolean block)` Flush the write buffer to the channel (if needed)
`static Stream`	`fopen(Ruby runtime, java.lang.String path, ModeFlags modes)`
`void`	`fputc(int c)`
`org.jruby.util.ByteList`	`fread(int number)`
`void`	`freopen(Ruby runtime, java.lang.String path, ModeFlags modes)`
`void`	`ftruncate(long newLength)`
`int`	`fwrite(org.jruby.util.ByteList string)`
`java.nio.channels.Channel`	`getChannel()`
`ChannelDescriptor`	`getDescriptor()`
`int`	`getline(org.jruby.util.ByteList dst, byte terminator)` Read all bytes up to and including a terminator byte.
`int`	`getline(org.jruby.util.ByteList dst, byte terminator, long limit)` Reads all bytes up to and including a terminator byte or until limit is reached.
`ModeFlags`	`getModes()`
`Ruby`	`getRuntime()`
`private boolean`	`hasBufferedInputBytes()` Tests if there are bytes remaining in the read buffer.
`private boolean`	`hasBufferedOutputSpace()` Tests if there is space available in the write buffer.
`private boolean`	`hasUngotChars()`
`private void`	`invalidateBuffer()` Invalidate buffer before a position change has occurred (e.g.
`boolean`	`isAutoclose()`
`boolean`	`isBinmode()`
`boolean`	`isBlocking()`
`boolean`	`isSync()`
`void`	`lseek(long offset, int type)` Implementation of libc "lseek", which seeks on seekable streams, raises EPIPE if the fd is assocated with a pipe, socket, or FIFO, and doesn't do anything for other cases (like stdio).
`private static Stream`	`maybeWrapWithLineEndingWrapper(Stream stream, ModeFlags modes)`
`private java.io.EOFException`	`newEOFException()`
`java.io.InputStream`	`newInputStream()`
`java.io.OutputStream`	`newOutputStream()`
`static Stream`	`open(Ruby runtime, ChannelDescriptor descriptor)`
`static Stream`	`open(Ruby runtime, ChannelDescriptor descriptor, boolean autoclose)`
`int`	`read()`
`int`	`read(java.nio.ByteBuffer dst)`
`int`	`read(java.nio.ByteBuffer dst, boolean partial)`
`org.jruby.util.ByteList`	`read(int number)`
`org.jruby.util.ByteList`	`readall()` Deprecated. readall do busy loop for the IO which has NONBLOCK bit. You should implement the logic by yourself with fread().
`boolean`	`readDataBuffered()`
`org.jruby.util.ByteList`	`readnonblock(int number)`
`org.jruby.util.ByteList`	`readpartial(int number)`
`int`	`ready()` Implement IO#ready? as per io/wait in MRI.
`private int`	`refillBuffer()`
`private void`	`resetForWrite()`
`void`	`setAutoclose(boolean autoclose)`
`void`	`setBinmode()`
`void`	`setBlocking(boolean block)`
`void`	`setModes(ModeFlags modes)`
`void`	`setSync(boolean sync)`
`void`	`sync()` Flush and sync all writes to the filesystem.
`int`	`ungetc(int c)`
`void`	`waitUntilReady()` Implement IO#wait as per io/wait in MRI.
`int`	`write(java.nio.ByteBuffer buf)`
`boolean`	`writeDataBuffered()`
`int`	`writenonblock(org.jruby.util.ByteList buf)`

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- LOG
```
private static final Logger LOG
```
- DEBUG
```
private static final boolean DEBUG
```
  See Also:
  
  Constant Field Values
- BUFSIZE
```
public static final int BUFSIZE
```
  The size of the read/write buffer allocated for this stream. This size has been scaled back from its original 16k because although the larger buffer size results in raw File.open times being rather slow (due to the cost of instantiating a relatively large buffer). We should try to find a happy medium, or potentially pool buffers, or perhaps even choose a value based on platform(??), but for now I am reducing it along with changes for the "large read" patch from JRUBY-2657.
  
  See Also:
  
  Constant Field Values
- BULK_READ_SIZE
```
private static final int BULK_READ_SIZE
```
  The size at which a single read should turn into a chunkier bulk read. Currently, this size is about 4x a normal buffer size. This size was not really arrived at experimentally, and could potentially be increased. However, it seems like a "good size" and we should probably only adjust it if it turns out we would perform better with a larger buffer for large bulk reads.
  
  See Also:
  
  Constant Field Values
- EMPTY_BUFFER
```
private static final java.nio.ByteBuffer EMPTY_BUFFER
```
- eofException
```
private static java.io.EOFException eofException
```
  A cached EOFException. Since EOFException is only used by us internally, we create a single instance to avoid stack trace generation. Comment out the initialization of this field to cause a new one each time.
- runtime
```
private volatile Ruby runtime
```
- modes
```
protected ModeFlags modes
```
- sync
```
protected boolean sync
```
- buffer
```
protected volatile java.nio.ByteBuffer buffer
```
- reading
```
protected boolean reading
```
- descriptor
```
private ChannelDescriptor descriptor
```
- blocking
```
private boolean blocking
```
- ungotChars
```
private org.jruby.util.ByteList ungotChars
```
- closedExplicitly
```
private volatile boolean closedExplicitly
```
- eof
```
private volatile boolean eof
```
- autoclose
```
private volatile boolean autoclose
```

Constructor Detail

ChannelStream

private ChannelStream(Ruby runtime,
                      ChannelDescriptor descriptor,
                      boolean autoclose)

ChannelStream

private ChannelStream(Ruby runtime,
                      ChannelDescriptor descriptor,
                      ModeFlags modes,
                      boolean autoclose)

Method Detail

getRuntime
```
public Ruby getRuntime()
```

checkReadable

public void checkReadable()
                   throws java.io.IOException

Throws:: java.io.IOException

checkWritable

public void checkWritable()
                   throws java.io.IOException

Throws:: java.io.IOException

checkPermissionsSubsetOf

public void checkPermissionsSubsetOf(ModeFlags subsetModes)

getModes
```
public ModeFlags getModes()
```
Specified by:

getModes in interface Stream

setModes
```
public void setModes(ModeFlags modes)
```
Specified by:

setModes in interface Stream

isSync
```
public boolean isSync()
```
Specified by:

isSync in interface Stream

setSync
```
public void setSync(boolean sync)
```
Specified by:

setSync in interface Stream

setBinmode
```
public void setBinmode()
```
Specified by:

setBinmode in interface Stream

isBinmode
```
public boolean isBinmode()
```
Specified by:

isBinmode in interface Stream

isAutoclose
```
public boolean isAutoclose()
```
Specified by:

isAutoclose in interface Stream

setAutoclose
```
public void setAutoclose(boolean autoclose)
```
Specified by:

setAutoclose in interface Stream

waitUntilReady
```
public void waitUntilReady()
                    throws java.io.IOException,
                           java.lang.InterruptedException
```
Implement IO#wait as per io/wait in MRI. waits until input available or timed out and returns self, or nil when EOF reached. The default implementation loops while ready returns 0.

Specified by:

waitUntilReady in interface Stream

Throws:

java.io.IOException

java.lang.InterruptedException

readDataBuffered
```
public boolean readDataBuffered()
```
Specified by:

readDataBuffered in interface Stream

hasUngotChars
```
private boolean hasUngotChars()
```

writeDataBuffered
```
public boolean writeDataBuffered()
```
Specified by:

writeDataBuffered in interface Stream

refillBuffer

private final int refillBuffer()
                        throws java.io.IOException

Throws:: java.io.IOException

fgets

public org.jruby.util.ByteList fgets(org.jruby.util.ByteList separatorString)
                              throws java.io.IOException,
                                     BadDescriptorException

Specified by:: fgets in interface Stream
Throws:: java.io.IOException; BadDescriptorException

getline
```
public int getline(org.jruby.util.ByteList dst,
                   byte terminator)
            throws java.io.IOException,
                   BadDescriptorException
```
Description copied from interface: Stream

Read all bytes up to and including a terminator byte.
If the terminator byte is found, it will be the last byte in the output buffer.

Specified by:

getline in interface Stream

Parameters:

dst - The output buffer.

terminator - The byte to terminate reading.

Returns:

The number of bytes read, or -1 if EOF is reached.

Throws:

java.io.IOException

BadDescriptorException

getline
```
public int getline(org.jruby.util.ByteList dst,
                   byte terminator,
                   long limit)
            throws java.io.IOException,
                   BadDescriptorException
```
Description copied from interface: Stream

Reads all bytes up to and including a terminator byte or until limit is reached.
If the terminator byte is found, it will be the last byte in the output buffer.

Specified by:

getline in interface Stream

Parameters:

dst - The output buffer.

terminator - The byte to terminate reading.

limit - the number of bytes to read unless EOF or terminator is found

Returns:

The number of bytes read, or -1 if EOF is reached.

Throws:

java.io.IOException

BadDescriptorException

clearUngotChars
```
private void clearUngotChars()
```

readall

@Deprecated
public org.jruby.util.ByteList readall()
                                            throws java.io.IOException,
                                                   BadDescriptorException

Deprecated. readall do busy loop for the IO which has NONBLOCK bit. You should implement the logic by yourself with fread().

Specified by:: readall in interface Stream
Throws:: java.io.IOException; BadDescriptorException

copyBufferedBytes
```
private final int copyBufferedBytes(java.nio.ByteBuffer dst)
```
Copies bytes from the channel buffer into a destination ByteBuffer

Parameters:

dst - A ByteBuffer to place the data in.

Returns:

The number of bytes copied.

copyBufferedBytes
```
private final int copyBufferedBytes(byte[] dst,
                                    int off,
                                    int len)
```
Copies bytes from the channel buffer into a destination ByteBuffer

Parameters:

dst - A ByteBuffer to place the data in.

Returns:

The number of bytes copied.

copyBufferedBytes
```
private final int copyBufferedBytes(org.jruby.util.ByteList dst,
                                    int len)
```
Copies bytes from the channel buffer into a destination ByteBuffer

Parameters:

dst - A ByteList to place the data in.

len - The maximum number of bytes to copy.

Returns:

The number of bytes copied.

bufferedInputBytesRemaining
```
private final int bufferedInputBytesRemaining()
```
Returns a count of how many bytes are available in the read buffer

Returns:

The number of bytes that can be read without reading the underlying stream.

hasBufferedInputBytes
```
private final boolean hasBufferedInputBytes()
```
Tests if there are bytes remaining in the read buffer.

Returns:

true if there are bytes available in the read buffer.

bufferedOutputSpaceRemaining
```
private final int bufferedOutputSpaceRemaining()
```
Returns a count of how many bytes of space is available in the write buffer.

Returns:

The number of bytes that can be written to the buffer without flushing to the underlying stream.

hasBufferedOutputSpace
```
private final boolean hasBufferedOutputSpace()
```
Tests if there is space available in the write buffer.

Returns:

true if there are bytes available in the write buffer.

fclose

public void fclose()
            throws java.io.IOException,
                   BadDescriptorException

Closes IO handler resources.

Specified by:: fclose in interface Stream
Throws:: java.io.IOException; BadDescriptorException

close

private void close()
            throws java.io.IOException,
                   BadDescriptorException

Internal close.

Throws:: java.io.IOException; BadDescriptorException

finish

private void finish(boolean close)
             throws BadDescriptorException,
                    java.io.IOException

Throws:: BadDescriptorException; java.io.IOException

fflush

public int fflush()
           throws java.io.IOException,
                  BadDescriptorException

Specified by:: fflush in interface Stream
Throws:: java.io.IOException; BadDescriptorException

flushWrite

private void flushWrite()
                 throws java.io.IOException,
                        BadDescriptorException

Flush the write buffer to the channel (if needed)

Throws:: java.io.IOException; BadDescriptorException

flushWrite

private boolean flushWrite(boolean block)
                    throws java.io.IOException,
                           BadDescriptorException

Flush the write buffer to the channel (if needed)

Throws:: java.io.IOException; BadDescriptorException

newInputStream
```
public java.io.InputStream newInputStream()
```
Specified by:

newInputStream in interface Stream

newOutputStream
```
public java.io.OutputStream newOutputStream()
```
Specified by:

newOutputStream in interface Stream

clearerr
```
public void clearerr()
```
Specified by:

clearerr in interface Stream

feof
```
public boolean feof()
             throws java.io.IOException,
                    BadDescriptorException
```
Description copied from interface: Stream

Return true when at end of file (EOF).

Specified by:

feof in interface Stream

Returns:

true if at EOF; false otherwise

Throws:

java.io.IOException

BadDescriptorException

fgetpos
```
public long fgetpos()
             throws java.io.IOException,
                    PipeException,
                    InvalidValueException,
                    BadDescriptorException
```
Description copied from interface: Stream

Get the current position within the file associated with this handler.

Specified by:

fgetpos in interface Stream

Returns:

the current position in the file.

Throws:

java.io.IOException

PipeException - ESPIPE (illegal seek) when not a file

InvalidValueException

BadDescriptorException

lseek
```
public void lseek(long offset,
                  int type)
           throws java.io.IOException,
                  InvalidValueException,
                  PipeException,
                  BadDescriptorException
```
Implementation of libc "lseek", which seeks on seekable streams, raises EPIPE if the fd is assocated with a pipe, socket, or FIFO, and doesn't do anything for other cases (like stdio).

Specified by:

lseek in interface Stream

Throws:

java.io.IOException

InvalidValueException

PipeException

BadDescriptorException

sync
```
public void sync()
          throws java.io.IOException,
                 BadDescriptorException
```
Description copied from interface: Stream

Flush and sync all writes to the filesystem.

Specified by:

sync in interface Stream

Throws:

java.io.IOException - if the sync does not work

BadDescriptorException

ensureRead

private void ensureRead()
                 throws java.io.IOException,
                        BadDescriptorException

Ensure buffer is ready for reading, flushing remaining writes if required

Throws:: java.io.IOException; BadDescriptorException

ensureReadNonBuffered

private void ensureReadNonBuffered()
                            throws java.io.IOException,
                                   BadDescriptorException

Ensure buffer is ready for reading, flushing remaining writes if required

Throws:: java.io.IOException; BadDescriptorException

resetForWrite

private void resetForWrite()
                    throws java.io.IOException

Throws:: java.io.IOException

ensureWrite

private void ensureWrite()
                  throws java.io.IOException

Ensure buffer is ready for writing.

Throws:: java.io.IOException

read

public org.jruby.util.ByteList read(int number)
                             throws java.io.IOException,
                                    BadDescriptorException

Specified by:: read in interface Stream
Throws:: java.io.IOException; BadDescriptorException

bufferedRead

private org.jruby.util.ByteList bufferedRead(int number)
                                      throws java.io.IOException,
                                             BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

bufferedRead

private int bufferedRead(org.jruby.util.ByteList dst,
                         int number)
                  throws java.io.IOException,
                         BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

newEOFException

private java.io.EOFException newEOFException()

bufferedRead

private int bufferedRead(java.nio.ByteBuffer dst,
                         boolean partial)
                  throws java.io.IOException,
                         BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

bufferedRead

private int bufferedRead()
                  throws java.io.IOException,
                         BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

bufferedWrite

private int bufferedWrite(org.jruby.util.ByteList buf)
                   throws java.io.IOException,
                          BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

bufferedWrite

private int bufferedWrite(java.nio.ByteBuffer buf)
                   throws java.io.IOException,
                          BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

bufferedWrite

private int bufferedWrite(int c)
                   throws java.io.IOException,
                          BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

ftruncate

public void ftruncate(long newLength)
               throws java.io.IOException,
                      BadDescriptorException,
                      InvalidValueException

Specified by:: ftruncate in interface Stream
Throws:: java.io.IOException; BadDescriptorException; InvalidValueException

invalidateBuffer
```
private void invalidateBuffer()
                       throws java.io.IOException,
                              BadDescriptorException
```
Invalidate buffer before a position change has occurred (e.g. seek), flushing writes if required, and correcting file position if reading

Throws:

java.io.IOException

BadDescriptorException

finalize
```
public void finalize()
              throws java.lang.Throwable
```
Ensure close (especially flush) when we're finished with.

Specified by:

finalize in interface Finalizable

Overrides:

finalize in class java.lang.Object

Throws:

java.lang.Throwable

ready
```
public int ready()
          throws java.io.IOException
```
Description copied from interface: Stream

Implement IO#ready? as per io/wait in MRI. returns non-nil if input available without blocking, or nil.

Specified by:

ready in interface Stream

Throws:

java.io.IOException

fputc

public void fputc(int c)
           throws java.io.IOException,
                  BadDescriptorException

Specified by:: fputc in interface Stream
Throws:: java.io.IOException; BadDescriptorException

ungetc
```
public int ungetc(int c)
```
Specified by:

ungetc in interface Stream

fgetc

public int fgetc()
          throws java.io.IOException,
                 BadDescriptorException

Specified by:: fgetc in interface Stream
Throws:: java.io.IOException; BadDescriptorException

fwrite

public int fwrite(org.jruby.util.ByteList string)
           throws java.io.IOException,
                  BadDescriptorException

Specified by:: fwrite in interface Stream
Throws:: java.io.IOException; BadDescriptorException

write

public int write(java.nio.ByteBuffer buf)
          throws java.io.IOException,
                 BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

writenonblock

public int writenonblock(org.jruby.util.ByteList buf)
                  throws java.io.IOException,
                         BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

fread

public org.jruby.util.ByteList fread(int number)
                              throws java.io.IOException,
                                     BadDescriptorException

Specified by:: fread in interface Stream
Throws:: java.io.IOException; BadDescriptorException

readnonblock

public org.jruby.util.ByteList readnonblock(int number)
                                     throws java.io.IOException,
                                            BadDescriptorException,
                                            java.io.EOFException

Throws:: java.io.IOException; BadDescriptorException; java.io.EOFException

readpartial

public org.jruby.util.ByteList readpartial(int number)
                                    throws java.io.IOException,
                                           BadDescriptorException,
                                           java.io.EOFException

Throws:: java.io.IOException; BadDescriptorException; java.io.EOFException

read

public int read(java.nio.ByteBuffer dst)
         throws java.io.IOException,
                BadDescriptorException,
                java.io.EOFException

Throws:: java.io.IOException; BadDescriptorException; java.io.EOFException

read

public int read(java.nio.ByteBuffer dst,
                boolean partial)
         throws java.io.IOException,
                BadDescriptorException,
                java.io.EOFException

Throws:: java.io.IOException; BadDescriptorException; java.io.EOFException

read

public int read()
         throws java.io.IOException,
                BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

getDescriptor
```
public ChannelDescriptor getDescriptor()
```
Specified by:

getDescriptor in interface Stream

setBlocking

public void setBlocking(boolean block)
                 throws java.io.IOException

Specified by:: setBlocking in interface Stream
Throws:: java.io.IOException

isBlocking
```
public boolean isBlocking()
```
Specified by:

isBlocking in interface Stream

freopen

public void freopen(Ruby runtime,
                    java.lang.String path,
                    ModeFlags modes)
             throws DirectoryAsFileException,
                    java.io.IOException,
                    InvalidValueException,
                    PipeException,
                    BadDescriptorException

Specified by:: freopen in interface Stream
Throws:: DirectoryAsFileException; java.io.IOException; InvalidValueException; PipeException; BadDescriptorException

open

public static Stream open(Ruby runtime,
                          ChannelDescriptor descriptor)

fdopen

public static Stream fdopen(Ruby runtime,
                            ChannelDescriptor descriptor,
                            ModeFlags modes)
                     throws InvalidValueException

Throws:: InvalidValueException

open

public static Stream open(Ruby runtime,
                          ChannelDescriptor descriptor,
                          boolean autoclose)

fdopen

public static Stream fdopen(Ruby runtime,
                            ChannelDescriptor descriptor,
                            ModeFlags modes,
                            boolean autoclose)
                     throws InvalidValueException

Throws:: InvalidValueException

maybeWrapWithLineEndingWrapper

private static Stream maybeWrapWithLineEndingWrapper(Stream stream,
                                                     ModeFlags modes)

fopen

public static Stream fopen(Ruby runtime,
                           java.lang.String path,
                           ModeFlags modes)
                    throws java.io.FileNotFoundException,
                           DirectoryAsFileException,
                           FileExistsException,
                           java.io.IOException,
                           InvalidValueException,
                           PipeException,
                           BadDescriptorException

Throws:: java.io.FileNotFoundException; DirectoryAsFileException; FileExistsException; java.io.IOException; InvalidValueException; PipeException; BadDescriptorException

getChannel
```
public java.nio.channels.Channel getChannel()
```
Specified by:

getChannel in interface Stream

Class ChannelStream

Nested Class Summary

Field Summary

Fields inherited from interface org.jruby.util.io.Stream

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

DEBUG

BUFSIZE

BULK_READ_SIZE

EMPTY_BUFFER

eofException

runtime

modes

sync

buffer

reading

descriptor

blocking

ungotChars

closedExplicitly

eof

autoclose

Constructor Detail

ChannelStream

ChannelStream

Method Detail

getRuntime

checkReadable

checkWritable

checkPermissionsSubsetOf

getModes

setModes

isSync

setSync

setBinmode

isBinmode

isAutoclose

setAutoclose

waitUntilReady

readDataBuffered

hasUngotChars

writeDataBuffered

refillBuffer

fgets

getline

getline

clearUngotChars

readall

copyBufferedBytes

copyBufferedBytes

copyBufferedBytes

bufferedInputBytesRemaining

hasBufferedInputBytes

bufferedOutputSpaceRemaining

hasBufferedOutputSpace

fclose

close

finish

fflush

flushWrite

flushWrite

newInputStream

newOutputStream

clearerr

feof

fgetpos

lseek

sync

ensureRead

ensureReadNonBuffered

resetForWrite

ensureWrite

read

bufferedRead

bufferedRead

newEOFException

bufferedRead