OpenFile (JRuby Core 9.2.1.0 API)

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

All Implemented Interfaces:: Finalizable

public class OpenFile
extends java.lang.Object
implements Finalizable

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`OpenFile.Buffer`
`static interface`	`OpenFile.Finalizer`
`static class`	`OpenFile.InternalReadStruct`
`static class`	`OpenFile.InternalWriteStruct`

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`APPEND`
`static int`	`BINMODE`
`protected java.util.Set<RubyThread>`	`blockingThreads`
`static int`	`BUFSIZ`
`OpenFile.Buffer`	`cbuf`
`static int`	`CREATE`
`java.nio.channels.FileLock`	`currentLock`
`static int`	`DUPLEX`
`IOEncodable.ConvConfig`	`encs`
`static int`	`EOF`
`static int`	`IO_CBUF_CAPA_MIN`
`static int`	`IO_RBUF_CAPA_MIN`
`static int`	`IO_WBUF_CAPA_MIN`
`static int`	`MORE_CHAR_FINISHED`
`static int`	`MORE_CHAR_SUSPENDED`
`static int`	`PIPE_BUF`
`static OpenFile.Finalizer`	`PIPE_FINALIZE` Deprecated.
`PosixShim`	`posix`
`static int`	`PREP`
`OpenFile.Buffer`	`rbuf`
`static int`	`READABLE`
`org.jcodings.transcode.EConv`	`readconv`
`static int`	`READWRITE`
`static int`	`SETENC_BY_BOM`
`java.io.Closeable`	`stdio_file`
`static int`	`SYNC`
`static int`	`SYNCWRITE`
`static int`	`TEXTMODE`
`RubyIO`	`tiedIOForWriting`
`static int`	`TMPFILE`
`static int`	`TRUNC`
`static int`	`TTY`
`OpenFile.Buffer`	`wbuf`
`static int`	`WRITABLE`
`java.util.concurrent.locks.ReentrantReadWriteLock`	`write_lock`
`org.jcodings.transcode.EConv`	`writeconv`
`IRubyObject`	`writeconvAsciicompat`
`boolean`	`writeconvInitialized`
`int`	`writeconvPreEcflags`
`IRubyObject`	`writeconvPreEcopts`
`static int`	`WSPLIT`
`static int`	`WSPLIT_INITIALIZED`

Constructor Summary

Constructors
Constructor and Description

OpenFile(IRubyObject nil)

Constructors
Constructor and Description
`OpenFile(IRubyObject nil)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addBlockingThread(RubyThread thread)` Add a thread to the list of blocking threads for this IO.
`int`	`appendline(ThreadContext context, int delim, ByteList[] strp, int[] lp)`
`void`	`ascii8bitBinmode(Ruby runtime)`
`long`	`binwrite(ThreadContext context, IRubyObject str, byte[] ptrBytes, int ptr, int len, boolean nosync)`
`java.nio.channels.Channel`	`channel()`
`void`	`checkByteReadable(ThreadContext context)`
`void`	`checkCharReadable(ThreadContext context)`
`void`	`checkClosed()`
`void`	`checkReadable(ThreadContext context)`
`void`	`checkReopenSeek(ThreadContext context, Ruby runtime, long pos)`
`void`	`checkTTY()`
`void`	`checkWritable(ThreadContext context)`
`void`	`cleanup(Ruby runtime, boolean noraise)`
`void`	`clearCodeConversion()`
`void`	`clearReadConversion()`
`void`	`clearStdio()`
`void`	`clearTextMode()`
`static int`	`cloexecDup2(PosixShim posix, ChannelFD oldfd, ChannelFD newfd)`
`IRubyObject`	`doWriteconv(ThreadContext context, IRubyObject str)`
`jnr.constants.platform.Errno`	`errno()`
`void`	`errno(jnr.constants.platform.Errno newErrno)`
`ChannelFD`	`fd()`
`static void`	`fdFixCloexec(PosixShim posix, int fd)`
`java.nio.channels.FileChannel`	`fileChannel()`
`int`	`fillbuf(ThreadContext context)`
`void`	`finalize()`
`void`	`finalize(ThreadContext context, boolean noraise)`
`void`	`finalizeFlush(ThreadContext context, boolean noraise)`
`int`	`flushBuffer()`
`int`	`flushBufferAsync2()`
`int`	`fread(ThreadContext context, IRubyObject str, int offset, int size)`
`long`	`fwrite(ThreadContext context, IRubyObject str, boolean nosync)`
`IRubyObject`	`getc(ThreadContext context, org.jcodings.Encoding enc)`
`int`	`getFileno()`
`OpenFile.Finalizer`	`getFinalizer()`
`static int`	`getFModeFromString(java.lang.String modesString)` Deprecated.
`IRubyObject`	`getlineFast(ThreadContext context, org.jcodings.Encoding enc, RubyIO io, boolean chomp)`
`int`	`getLineNumber()`
`int`	`getMode()`
`java.lang.String`	`getModeAsString(Ruby runtime)`
`static int`	`getModeFlagsAsIntFrom(int fmode)`
`java.lang.String`	`getPath()`
`long`	`getPid()`
`java.lang.Process`	`getProcess()`
`static java.lang.String`	`getStringFromMode(int mode)`
`void`	`incrementLineno(Ruby runtime)` Deprecated.
`void`	`incrementLineno(Ruby runtime, RubyIO io)`
`org.jcodings.Encoding`	`inputEncoding(Ruby runtime)`
`void`	`interruptBlockingThreads(ThreadContext context)` Fire an IOError in all threads blocking on this IO object
`int`	`io_fflush(ThreadContext context)`
`int`	`IO_RBUF_CAPA_FOR()`
`static int`	`ioFmodeOflags(int fmode)`
`static int`	`ioModestrFmode(Ruby runtime, java.lang.String modestr)`
`static int`	`ioModestrOflags(Ruby runtime, java.lang.String modestr)`
`static java.lang.String`	`ioOflagsModestr(Ruby runtime, int oflags)`
`boolean`	`IS_PREP_STDIO()`
`boolean`	`isAutoclose()`
`boolean`	`isBinmode()`
`boolean`	`isBlocking()`
`boolean`	`isBOM()`
`boolean`	`isDuplex()`
`boolean`	`isOpen()`
`boolean`	`isReadable()`
`boolean`	`isReadBuffered()`
`boolean`	`isStdio()`
`boolean`	`isSync()`
`boolean`	`isTextMode()`
`boolean`	`isWritable()`
`boolean`	`isWriteBuffered()`
`boolean`	`lock()`
`boolean`	`lockedByMe()`
`void`	`makeReadConversion(ThreadContext context)`
`void`	`makeReadConversion(ThreadContext context, int size)`
`void`	`makeWriteConversion(ThreadContext context)`
`int`	`moreChar(ThreadContext context)`
`void`	`NEED_NEWLINE_DECORATOR_ON_READ_CHECK()`
`boolean`	`NEED_NEWLINE_DECORATOR_ON_READ()`
`boolean`	`NEED_NEWLINE_DECORATOR_ON_WRITE()`
`boolean`	`needsReadConversion()`
`boolean`	`needsWriteConversion(ThreadContext context)`
`java.lang.String`	`PREP_STDIO_NAME()`
`static long`	`rbW32WriteConsole(RubyString buffer)`
`int`	`READ_CHAR_PENDING_COUNT()`
`int`	`READ_CHAR_PENDING_OFF()`
`byte[]`	`READ_CHAR_PENDING_PTR()`
`int`	`READ_CHAR_PENDING_START()`
`boolean`	`READ_CHAR_PENDING()`
`void`	`READ_CHECK(ThreadContext context)`
`boolean`	`READ_DATA_BUFFERED()`
`int`	`READ_DATA_PENDING_COUNT()`
`int`	`READ_DATA_PENDING_OFF()`
`byte[]`	`READ_DATA_PENDING_PTR()`
`int`	`READ_DATA_PENDING_START()`
`boolean`	`READ_DATA_PENDING()`
`IRubyObject`	`readAll(ThreadContext context, int siz, IRubyObject str)`
`int`	`readBufferedData(byte[] ptrBytes, int ptr, int len)`
`java.nio.channels.ReadableByteChannel`	`readChannel()`
`org.jcodings.Encoding`	`readEncoding(Ruby runtime)`
`static int`	`readInternal(ThreadContext context, OpenFile fptr, ChannelFD fd, byte[] bufBytes, int buf, int count)`
`int`	`readPending()`
`boolean`	`ready(Ruby runtime, RubyThread thread, int ops, long timeout)` Wait until the channel is available for the given operations or the timeout expires.
`boolean`	`readyNow(ThreadContext context)` Like `ready(org.jruby.Ruby, org.jruby.RubyThread, int, long)` but returns a result immediately.
`int`	`remainSize()`
`void`	`removeBlockingThread(RubyThread thread)` Remove a thread from the list of blocking threads for this IO.
`long`	`seek(ThreadContext context, long offset, int whence)`
`java.nio.channels.SeekableByteChannel`	`seekChannel()`
`java.nio.channels.SelectableChannel`	`selectChannel()`
`void`	`SET_BINARY_MODE()`
`void`	`setAutoclose(boolean autoclose)`
`void`	`setBinmode()`
`void`	`setBlock(Ruby runtime)`
`void`	`setBlocking(Ruby runtime, boolean blocking)`
`void`	`setBOM(boolean bom)`
`void`	`setChannel(java.nio.channels.Channel fd)`
`void`	`setFD(ChannelFD fd)`
`void`	`setFinalizer(OpenFile.Finalizer finalizer)`
`void`	`setLineNumber(int lineNumber)`
`void`	`setMode(int modes)`
`void`	`setNonblock(Ruby runtime)`
`void`	`setPath(java.lang.String path)`
`void`	`setPid(long pid)`
`void`	`setProcess(java.lang.Process process)`
`void`	`setSync(boolean sync)`
`void`	`setTextMode()`
`IRubyObject`	`shiftCbuf(ThreadContext context, int len, IRubyObject strp)`
`java.nio.channels.SocketChannel`	`socketChannel()`
`boolean`	`swallow(ThreadContext context, int term)`
`long`	`tell(ThreadContext context)`
`int`	`threadFlock(ThreadContext context, int lockMode)`
`void`	`ungetbyte(ThreadContext context, IRubyObject str)`
`void`	`unlock()`
`void`	`unread(ThreadContext context)`
`void`	`waitForBlockingThreads(ThreadContext context)` Wait until all blocking threads have exited their blocking area.
`boolean`	`waitReadable(ThreadContext context)`
`boolean`	`waitReadable(ThreadContext context, long timeout)`
`boolean`	`waitWritable(ThreadContext context)`
`boolean`	`waitWritable(ThreadContext context, long timeout)`
`java.nio.channels.WritableByteChannel`	`writeChannel()`
`static int`	`writeInternal(ThreadContext context, OpenFile fptr, ChannelFD fd, byte[] bufBytes, int buf, int count)`

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

Field Detail

READABLE
```
public static final int READABLE
```
See Also:

Constant Field Values

WRITABLE
```
public static final int WRITABLE
```
See Also:

Constant Field Values

READWRITE
```
public static final int READWRITE
```
See Also:

Constant Field Values

BINMODE
```
public static final int BINMODE
```
See Also:

Constant Field Values

SYNC
```
public static final int SYNC
```
See Also:

Constant Field Values

TTY
```
public static final int TTY
```
See Also:

Constant Field Values

DUPLEX
```
public static final int DUPLEX
```
See Also:

Constant Field Values

APPEND
```
public static final int APPEND
```
See Also:

Constant Field Values

CREATE
```
public static final int CREATE
```
See Also:

Constant Field Values

WSPLIT
```
public static final int WSPLIT
```
See Also:

Constant Field Values

WSPLIT_INITIALIZED
```
public static final int WSPLIT_INITIALIZED
```
See Also:

Constant Field Values

TRUNC
```
public static final int TRUNC
```
See Also:

Constant Field Values

TEXTMODE
```
public static final int TEXTMODE
```
See Also:

Constant Field Values

SETENC_BY_BOM
```
public static final int SETENC_BY_BOM
```
See Also:

Constant Field Values

TMPFILE
```
public static final int TMPFILE
```
See Also:

Constant Field Values

PREP
```
public static final int PREP
```
See Also:

Constant Field Values

SYNCWRITE
```
public static final int SYNCWRITE
```
See Also:

Constant Field Values

PIPE_BUF
```
public static final int PIPE_BUF
```
See Also:

Constant Field Values

BUFSIZ
```
public static final int BUFSIZ
```
See Also:

Constant Field Values

stdio_file
```
public java.io.Closeable stdio_file
```

currentLock

public volatile java.nio.channels.FileLock currentLock

encs
```
public IOEncodable.ConvConfig encs
```

readconv

public org.jcodings.transcode.EConv readconv

writeconv

public org.jcodings.transcode.EConv writeconv

writeconvAsciicompat

public IRubyObject writeconvAsciicompat

writeconvPreEcflags
```
public int writeconvPreEcflags
```

writeconvPreEcopts
```
public IRubyObject writeconvPreEcopts
```

writeconvInitialized
```
public boolean writeconvInitialized
```

write_lock

public volatile java.util.concurrent.locks.ReentrantReadWriteLock write_lock

wbuf
```
public final OpenFile.Buffer wbuf
```

rbuf
```
public final OpenFile.Buffer rbuf
```

cbuf
```
public final OpenFile.Buffer cbuf
```

tiedIOForWriting
```
public RubyIO tiedIOForWriting
```

posix
```
public final PosixShim posix
```

blockingThreads

protected volatile java.util.Set<RubyThread> blockingThreads

PIPE_FINALIZE

@Deprecated
public static final OpenFile.Finalizer PIPE_FINALIZE

Deprecated.

MORE_CHAR_SUSPENDED
```
public static final int MORE_CHAR_SUSPENDED
```
See Also:

Constant Field Values

MORE_CHAR_FINISHED
```
public static final int MORE_CHAR_FINISHED
```
See Also:

Constant Field Values

EOF
```
public static final int EOF
```
See Also:

Constant Field Values

IO_RBUF_CAPA_MIN
```
public static final int IO_RBUF_CAPA_MIN
```
See Also:

Constant Field Values

IO_CBUF_CAPA_MIN
```
public static final int IO_CBUF_CAPA_MIN
```
See Also:

Constant Field Values

IO_WBUF_CAPA_MIN
```
public static final int IO_WBUF_CAPA_MIN
```
See Also:

Constant Field Values

Constructor Detail
- OpenFile
```
public OpenFile(IRubyObject nil)
```

Method Detail

ascii8bitBinmode

public void ascii8bitBinmode(Ruby runtime)

checkReopenSeek

public void checkReopenSeek(ThreadContext context,
                            Ruby runtime,
                            long pos)

clearStdio
```
public void clearStdio()
```

PREP_STDIO_NAME

public java.lang.String PREP_STDIO_NAME()

READ_DATA_PENDING
```
public boolean READ_DATA_PENDING()
```

READ_DATA_PENDING_COUNT
```
public int READ_DATA_PENDING_COUNT()
```

READ_DATA_PENDING_PTR
```
public byte[] READ_DATA_PENDING_PTR()
```

READ_DATA_PENDING_OFF
```
public int READ_DATA_PENDING_OFF()
```

READ_DATA_PENDING_START
```
public int READ_DATA_PENDING_START()
```

READ_DATA_BUFFERED
```
public boolean READ_DATA_BUFFERED()
```

READ_CHAR_PENDING
```
public boolean READ_CHAR_PENDING()
```

READ_CHAR_PENDING_COUNT
```
public int READ_CHAR_PENDING_COUNT()
```

READ_CHAR_PENDING_PTR
```
public byte[] READ_CHAR_PENDING_PTR()
```

READ_CHAR_PENDING_OFF
```
public int READ_CHAR_PENDING_OFF()
```

READ_CHAR_PENDING_START
```
public int READ_CHAR_PENDING_START()
```

READ_CHECK

public void READ_CHECK(ThreadContext context)

IS_PREP_STDIO
```
public boolean IS_PREP_STDIO()
```

setFD
```
public void setFD(ChannelFD fd)
```

setChannel

public void setChannel(java.nio.channels.Channel fd)

getMode
```
public int getMode()
```

getModeAsString

public java.lang.String getModeAsString(Ruby runtime)

getModeFlagsAsIntFrom

public static int getModeFlagsAsIntFrom(int fmode)

ioOflagsModestr

public static java.lang.String ioOflagsModestr(Ruby runtime,
                                               int oflags)

ioModestrOflags

public static int ioModestrOflags(Ruby runtime,
                                  java.lang.String modestr)

ioFmodeOflags

public static int ioFmodeOflags(int fmode)

ioModestrFmode

public static int ioModestrFmode(Ruby runtime,
                                 java.lang.String modestr)

getStringFromMode

public static java.lang.String getStringFromMode(int mode)

checkCharReadable

public void checkCharReadable(ThreadContext context)

checkByteReadable

public void checkByteReadable(ThreadContext context)

checkReadable

public void checkReadable(ThreadContext context)

io_fflush

public int io_fflush(ThreadContext context)

waitWritable

public boolean waitWritable(ThreadContext context,
                            long timeout)

waitWritable

public boolean waitWritable(ThreadContext context)

waitReadable

public boolean waitReadable(ThreadContext context,
                            long timeout)

waitReadable

public boolean waitReadable(ThreadContext context)

ready
```
public boolean ready(Ruby runtime,
                     RubyThread thread,
                     int ops,
                     long timeout)
```
Wait until the channel is available for the given operations or the timeout expires.

Parameters:

runtime -

ops -

timeout -

Returns:

See Also:

RubyThread.select(java.nio.channels.Channel, OpenFile, int, long)

readyNow
```
public boolean readyNow(ThreadContext context)
```
Like ready(org.jruby.Ruby, org.jruby.RubyThread, int, long) but returns a result immediately.

Parameters:

context -

Returns:

flushBuffer
```
public int flushBuffer()
```

flushBufferAsync2
```
public int flushBufferAsync2()
```

seek

public long seek(ThreadContext context,
                 long offset,
                 int whence)

checkWritable

public void checkWritable(ThreadContext context)

checkClosed
```
public void checkClosed()
```

isBinmode
```
public boolean isBinmode()
```

isTextMode
```
public boolean isTextMode()
```

setTextMode
```
public void setTextMode()
```

clearTextMode
```
public void clearTextMode()
```

setBinmode
```
public void setBinmode()
```

isOpen
```
public boolean isOpen()
```

isReadable
```
public boolean isReadable()
```

isWritable
```
public boolean isWritable()
```

isDuplex
```
public boolean isDuplex()
```

isReadBuffered
```
public boolean isReadBuffered()
```

isWriteBuffered
```
public boolean isWriteBuffered()
```

setSync
```
public void setSync(boolean sync)
```

isSync
```
public boolean isSync()
```

setMode
```
public void setMode(int modes)
```

getProcess
```
public java.lang.Process getProcess()
```

setProcess

public void setProcess(java.lang.Process process)

getPid
```
public long getPid()
```

setPid
```
public void setPid(long pid)
```

getLineNumber
```
public int getLineNumber()
```

setLineNumber

public void setLineNumber(int lineNumber)

getPath
```
public java.lang.String getPath()
```

setPath

public void setPath(java.lang.String path)

isAutoclose
```
public boolean isAutoclose()
```

setAutoclose

public void setAutoclose(boolean autoclose)

getFinalizer

public OpenFile.Finalizer getFinalizer()

setFinalizer

public void setFinalizer(OpenFile.Finalizer finalizer)

cleanup

public void cleanup(Ruby runtime,
                    boolean noraise)

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

finalize in interface Finalizable

Overrides:

finalize in class java.lang.Object

finalize

public void finalize(ThreadContext context,
                     boolean noraise)

finalizeFlush

public void finalizeFlush(ThreadContext context,
                          boolean noraise)

needsReadConversion
```
public boolean needsReadConversion()
```

needsWriteConversion

public boolean needsWriteConversion(ThreadContext context)

makeReadConversion

public void makeReadConversion(ThreadContext context,
                               int size)

makeReadConversion

public void makeReadConversion(ThreadContext context)

makeWriteConversion

public void makeWriteConversion(ThreadContext context)

clearReadConversion
```
public void clearReadConversion()
```

clearCodeConversion
```
public void clearCodeConversion()
```

IO_RBUF_CAPA_FOR
```
public int IO_RBUF_CAPA_FOR()
```

appendline

public int appendline(ThreadContext context,
                      int delim,
                      ByteList[] strp,
                      int[] lp)

NEED_NEWLINE_DECORATOR_ON_READ_CHECK

public void NEED_NEWLINE_DECORATOR_ON_READ_CHECK()

NEED_NEWLINE_DECORATOR_ON_READ

public boolean NEED_NEWLINE_DECORATOR_ON_READ()

NEED_NEWLINE_DECORATOR_ON_WRITE

public boolean NEED_NEWLINE_DECORATOR_ON_WRITE()

moreChar

public int moreChar(ThreadContext context)

readBufferedData

public int readBufferedData(byte[] ptrBytes,
                            int ptr,
                            int len)

fillbuf

public int fillbuf(ThreadContext context)

readInternal

public static int readInternal(ThreadContext context,
                               OpenFile fptr,
                               ChannelFD fd,
                               byte[] bufBytes,
                               int buf,
                               int count)

readEncoding

public org.jcodings.Encoding readEncoding(Ruby runtime)

inputEncoding

public org.jcodings.Encoding inputEncoding(Ruby runtime)

swallow

public boolean swallow(ThreadContext context,
                       int term)

shiftCbuf

public IRubyObject shiftCbuf(ThreadContext context,
                             int len,
                             IRubyObject strp)

getlineFast

public IRubyObject getlineFast(ThreadContext context,
                               org.jcodings.Encoding enc,
                               RubyIO io,
                               boolean chomp)

incrementLineno

public void incrementLineno(Ruby runtime,
                            RubyIO io)

incrementLineno

@Deprecated
public void incrementLineno(Ruby runtime)

Deprecated.

readAll

public IRubyObject readAll(ThreadContext context,
                           int siz,
                           IRubyObject str)

fread

public int fread(ThreadContext context,
                 IRubyObject str,
                 int offset,
                 int size)

ungetbyte

public void ungetbyte(ThreadContext context,
                      IRubyObject str)

getc

public IRubyObject getc(ThreadContext context,
                        org.jcodings.Encoding enc)

tell

public long tell(ThreadContext context)

unread

public void unread(ThreadContext context)

fwrite

public long fwrite(ThreadContext context,
                   IRubyObject str,
                   boolean nosync)

rbW32WriteConsole

public static long rbW32WriteConsole(RubyString buffer)

doWriteconv

public IRubyObject doWriteconv(ThreadContext context,
                               IRubyObject str)

binwrite

public long binwrite(ThreadContext context,
                     IRubyObject str,
                     byte[] ptrBytes,
                     int ptr,
                     int len,
                     boolean nosync)

writeInternal

public static int writeInternal(ThreadContext context,
                                OpenFile fptr,
                                ChannelFD fd,
                                byte[] bufBytes,
                                int buf,
                                int count)

fd
```
public ChannelFD fd()
```

channel

public java.nio.channels.Channel channel()

readChannel

public java.nio.channels.ReadableByteChannel readChannel()

writeChannel

public java.nio.channels.WritableByteChannel writeChannel()

seekChannel

public java.nio.channels.SeekableByteChannel seekChannel()

selectChannel

public java.nio.channels.SelectableChannel selectChannel()

fileChannel

public java.nio.channels.FileChannel fileChannel()

socketChannel

public java.nio.channels.SocketChannel socketChannel()

setNonblock

public void setNonblock(Ruby runtime)

setBlock
```
public void setBlock(Ruby runtime)
```

setBlocking

public void setBlocking(Ruby runtime,
                        boolean blocking)

isBlocking
```
public boolean isBlocking()
```

checkTTY
```
public void checkTTY()
```

isBOM
```
public boolean isBOM()
```

setBOM
```
public void setBOM(boolean bom)
```

isStdio
```
public boolean isStdio()
```

readPending
```
public int readPending()
```

getFModeFromString

@Deprecated
public static int getFModeFromString(java.lang.String modesString)
                                          throws InvalidValueException

Deprecated.

Throws:: InvalidValueException

getFileno
```
public int getFileno()
```

threadFlock

public int threadFlock(ThreadContext context,
                       int lockMode)

errno

public jnr.constants.platform.Errno errno()

errno

public void errno(jnr.constants.platform.Errno newErrno)

cloexecDup2

public static int cloexecDup2(PosixShim posix,
                              ChannelFD oldfd,
                              ChannelFD newfd)

fdFixCloexec

public static void fdFixCloexec(PosixShim posix,
                                int fd)

addBlockingThread
```
public void addBlockingThread(RubyThread thread)
```
Add a thread to the list of blocking threads for this IO.

Parameters:

thread - A thread blocking on this IO

removeBlockingThread
```
public void removeBlockingThread(RubyThread thread)
```
Remove a thread from the list of blocking threads for this IO.

Parameters:

thread - A thread blocking on this IO

interruptBlockingThreads
```
public void interruptBlockingThreads(ThreadContext context)
```
Fire an IOError in all threads blocking on this IO object

waitForBlockingThreads
```
public void waitForBlockingThreads(ThreadContext context)
```
Wait until all blocking threads have exited their blocking area. Use in combination with interruptBlockingThreads to ensure every blocking thread has moved on before proceding to manipulate the IO.

SET_BINARY_MODE
```
public void SET_BINARY_MODE()
```

remainSize
```
public int remainSize()
```

lock
```
public boolean lock()
```

unlock
```
public void unlock()
```

lockedByMe
```
public boolean lockedByMe()
```

Class OpenFile

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

READABLE

WRITABLE

READWRITE

BINMODE

SYNC

TTY

DUPLEX

APPEND

CREATE

WSPLIT

WSPLIT_INITIALIZED

TRUNC

TEXTMODE

SETENC_BY_BOM

TMPFILE

PREP

SYNCWRITE

PIPE_BUF

BUFSIZ

stdio_file

currentLock

encs

readconv

writeconv

writeconvAsciicompat

writeconvPreEcflags

writeconvPreEcopts

writeconvInitialized

write_lock

wbuf

rbuf

cbuf

tiedIOForWriting

posix

blockingThreads

PIPE_FINALIZE

MORE_CHAR_SUSPENDED

MORE_CHAR_FINISHED

EOF

IO_RBUF_CAPA_MIN

IO_CBUF_CAPA_MIN

IO_WBUF_CAPA_MIN

Constructor Detail

OpenFile

Method Detail

ascii8bitBinmode

checkReopenSeek

clearStdio

PREP_STDIO_NAME

READ_DATA_PENDING

READ_DATA_PENDING_COUNT

READ_DATA_PENDING_PTR

READ_DATA_PENDING_OFF

READ_DATA_PENDING_START

READ_DATA_BUFFERED

READ_CHAR_PENDING

READ_CHAR_PENDING_COUNT

READ_CHAR_PENDING_PTR

READ_CHAR_PENDING_OFF

READ_CHAR_PENDING_START

READ_CHECK

IS_PREP_STDIO

setFD

setChannel

getMode

getModeAsString

getModeFlagsAsIntFrom

ioOflagsModestr

ioModestrOflags

ioFmodeOflags

ioModestrFmode

getStringFromMode

checkCharReadable