org.jruby.util.io

Class ChannelStream

java.lang.Object

org.jruby.util.io.ChannelStream

All Implemented Interfaces:

Finalizable, Stream

public class ChannelStream
extends Object
implements Stream, Finalizable

This file implements a seekable IO file.

Field Summary

Fields

Modifier and Type	Field and Description
protected ByteBuffer	buffer
static int	BUFSIZE The size of the read/write buffer allocated for this stream.
protected ModeFlags	modes
protected boolean	reading
protected boolean	sync

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

PARAGRAPH_DELIMETER, PARAGRAPH_SEPARATOR, SEEK_CUR, SEEK_END, SEEK_SET

Method Summary

Methods

Modifier and Type	Method and Description
void	checkPermissionsSubsetOf(ModeFlags subsetModes)
void	checkReadable()
void	checkWritable()
void	clearerr()
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.
static Stream	fopen(Ruby runtime, String path, ModeFlags modes)
void	fputc(int c)
org.jruby.util.ByteList	fread(int number)
void	freopen(Ruby runtime, String path, ModeFlags modes)
void	ftruncate(long newLength)
int	fwrite(org.jruby.util.ByteList string)
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()
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).
InputStream	newInputStream()
OutputStream	newOutputStream()
static Stream	open(Ruby runtime, ChannelDescriptor descriptor)
static Stream	open(Ruby runtime, ChannelDescriptor descriptor, boolean autoclose)
int	read()
int	read(ByteBuffer dst)
int	read(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.
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(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

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

modes

protected ModeFlags modes

sync

protected boolean sync

buffer

protected volatile ByteBuffer buffer

reading

protected boolean reading

Method Detail

getRuntime

public Ruby getRuntime()

checkReadable

public void checkReadable()
                   throws IOException

Throws:

IOException

checkWritable

public void checkWritable()
                   throws IOException

Throws:

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 IOException,
                           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:

IOException

InterruptedException

readDataBuffered

public boolean readDataBuffered()

Specified by:

readDataBuffered in interface Stream

writeDataBuffered

public boolean writeDataBuffered()

Specified by:

writeDataBuffered in interface Stream

fgets

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

Specified by:

fgets in interface Stream

Throws:

IOException

BadDescriptorException

getline

public int getline(org.jruby.util.ByteList dst,
          byte terminator)
            throws 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:

IOException

BadDescriptorException

getline

public int getline(org.jruby.util.ByteList dst,
          byte terminator,
          long limit)
            throws 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:

IOException

BadDescriptorException

readall

@Deprecated
public org.jruby.util.ByteList readall()
                                throws 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:

IOException

BadDescriptorException

fclose

public void fclose()
            throws IOException,
                   BadDescriptorException

Closes IO handler resources.

Specified by:

fclose in interface Stream

Throws:

IOException

BadDescriptorException

fflush

public int fflush()
           throws IOException,
                  BadDescriptorException

Specified by:

fflush in interface Stream

Throws:

IOException

BadDescriptorException

newInputStream

public InputStream newInputStream()

Specified by:

newInputStream in interface Stream

newOutputStream

public OutputStream newOutputStream()

Specified by:

newOutputStream in interface Stream

clearerr

public void clearerr()

Specified by:

clearerr in interface Stream

feof

public boolean feof()
             throws 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:

IOException

BadDescriptorException

fgetpos

public long fgetpos()
             throws 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:

IOException

PipeException - ESPIPE (illegal seek) when not a file

InvalidValueException

BadDescriptorException

lseek

public void lseek(long offset,
         int type)
           throws 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:

IOException

InvalidValueException

PipeException

BadDescriptorException

sync

public void sync()
          throws IOException,
                 BadDescriptorException

Description copied from interface: Stream

Flush and sync all writes to the filesystem.

Specified by:

sync in interface Stream

Throws:

IOException - if the sync does not work

BadDescriptorException

read

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

Specified by:

read in interface Stream

Throws:

IOException

BadDescriptorException

ftruncate

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

Specified by:

ftruncate in interface Stream

Throws:

IOException

BadDescriptorException

InvalidValueException

finalize

public void finalize()
              throws Throwable

Ensure close (especially flush) when we're finished with.

Specified by:

finalize in interface Finalizable

Overrides:

finalize in class Object

Throws:

Throwable

ready

public int ready()
          throws 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:

IOException

fputc

public void fputc(int c)
           throws IOException,
                  BadDescriptorException

Specified by:

fputc in interface Stream

Throws:

IOException

BadDescriptorException

ungetc

public int ungetc(int c)

Specified by:

ungetc in interface Stream

fgetc

public int fgetc()
          throws IOException,
                 BadDescriptorException

Specified by:

fgetc in interface Stream

Throws:

IOException

BadDescriptorException

fwrite

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

Specified by:

fwrite in interface Stream

Throws:

IOException

BadDescriptorException

write

public int write(ByteBuffer buf)
          throws IOException,
                 BadDescriptorException

Throws:

IOException

BadDescriptorException

writenonblock

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

Throws:

IOException

BadDescriptorException

fread

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

Specified by:

fread in interface Stream

Throws:

IOException

BadDescriptorException

readnonblock

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

Throws:

IOException

BadDescriptorException

EOFException

readpartial

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

Throws:

IOException

BadDescriptorException

EOFException

read

public int read(ByteBuffer dst)
         throws IOException,
                BadDescriptorException,
                EOFException

Throws:

IOException

BadDescriptorException

EOFException

read

public int read(ByteBuffer dst,
       boolean partial)
         throws IOException,
                BadDescriptorException,
                EOFException

Throws:

IOException

BadDescriptorException

EOFException

read

public int read()
         throws IOException,
                BadDescriptorException

Throws:

IOException

BadDescriptorException

getDescriptor

public ChannelDescriptor getDescriptor()

Specified by:

getDescriptor in interface Stream

setBlocking

public void setBlocking(boolean block)
                 throws IOException

Specified by:

setBlocking in interface Stream

Throws:

IOException

isBlocking

public boolean isBlocking()

Specified by:

isBlocking in interface Stream

freopen

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

Specified by:

freopen in interface Stream

Throws:

DirectoryAsFileException

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

fopen

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

Throws:

FileNotFoundException

DirectoryAsFileException

FileExistsException

IOException

InvalidValueException

PipeException

BadDescriptorException

getChannel

public Channel getChannel()

Specified by:

getChannel in interface Stream