Class: IO (Ruby 2.2.4)
Description: Class : IO - Ruby 2.2.4

- Home
- Core 2.2.4
- Std-lib 2.2.4
- Downloads

Support for the Ruby 2.2 series has ended. See here for reference.

### Home Classes Methods

### In Files

- io/wait/wait.c

### Parent

Object

### Methods

- #nread
- #ready?
- #wait
- #wait_readable
- #wait_writable

### Class/Module Index

Quicksearch

- IO

No matching classes.

# IO

### Public Instance Methods

nread → int click to toggle source

Returns number of bytes that can be read without blocking. Returns zero if no information available.

                   static VALUE
    io_nread(VALUE io)
    {
        rb_io_t *fptr;
        int len;
        ioctl_arg n;

        GetOpenFile(io, fptr);
        rb_io_check_readable(fptr);
        len = rb_io_read_pending(fptr);
        if (len > 0) return INT2FIX(len);
        if (!FIONREAD_POSSIBLE_P(fptr->fd)) return INT2FIX(0);
        if (ioctl(fptr->fd, FIONREAD, &n)) return INT2FIX(0);
        if (n > 0) return ioctl_arg2num(n);
        return INT2FIX(0);
    }

ready? → true, false or nil click to toggle source

Returns true if input available without blocking, or false. Returns nil if no information available.

                   static VALUE
    io_ready_p(VALUE io)
    {
        rb_io_t *fptr;
        ioctl_arg n;

        GetOpenFile(io, fptr);
        rb_io_check_readable(fptr);
        if (rb_io_read_pending(fptr)) return Qtrue;
        if (!FIONREAD_POSSIBLE_P(fptr->fd)) return Qnil;
        if (ioctl(fptr->fd, FIONREAD, &n)) return Qnil;
        if (n > 0) return Qtrue;
        return Qfalse;
    }

wait → IO, true, false or nil click to toggle source
wait(timeout) → IO, true, false or nil
wait_readable → IO, true, false or nil
wait_readable(timeout) → IO, true, false or nil

Waits until input is available or times out and returns self or nil when EOF is reached.

                   static VALUE
    io_wait_readable(int argc, VALUE *argv, VALUE io)
    {
        rb_io_t *fptr;
        int i;
        ioctl_arg n;
        VALUE timeout;
        struct timeval timerec;
        struct timeval *tv;

        GetOpenFile(io, fptr);
        rb_io_check_readable(fptr);
        rb_scan_args(argc, argv, "01", &timeout);
        if (NIL_P(timeout)) {
            tv = NULL;
        }
        else {
            timerec = rb_time_interval(timeout);
            tv = &timerec;
        }

        if (rb_io_read_pending(fptr)) return Qtrue;
        if (!FIONREAD_POSSIBLE_P(fptr->fd)) return Qfalse;
        i = rb_wait_for_single_fd(fptr->fd, RB_WAITFD_IN, tv);
        if (i < 0)
            rb_sys_fail(0);
        rb_io_check_closed(fptr);
        if (ioctl(fptr->fd, FIONREAD, &n)) rb_sys_fail(0);
        if (n > 0) return io;
        return Qnil;
    }

wait_readable → IO, true, false or nil click to toggle source
wait_readable(timeout) → IO, true, false or nil

Waits until input is available or times out and returns self or nil when EOF is reached.

                   static VALUE
    io_wait_readable(int argc, VALUE *argv, VALUE io)
    {
        rb_io_t *fptr;
        int i;
        ioctl_arg n;
        VALUE timeout;
        struct timeval timerec;
        struct timeval *tv;

        GetOpenFile(io, fptr);
        rb_io_check_readable(fptr);
        rb_scan_args(argc, argv, "01", &timeout);
        if (NIL_P(timeout)) {
            tv = NULL;
        }
        else {
            timerec = rb_time_interval(timeout);
            tv = &timerec;
        }

        if (rb_io_read_pending(fptr)) return Qtrue;
        if (!FIONREAD_POSSIBLE_P(fptr->fd)) return Qfalse;
        i = rb_wait_for_single_fd(fptr->fd, RB_WAITFD_IN, tv);
        if (i < 0)
            rb_sys_fail(0);
        rb_io_check_closed(fptr);
        if (ioctl(fptr->fd, FIONREAD, &n)) rb_sys_fail(0);
        if (n > 0) return io;
        return Qnil;
    }

wait_writable → IO click to toggle source
wait_writable(timeout) → IO or nil

Waits until IO writable is available or times out and returns self or nil when EOF is reached.

                   static VALUE
    io_wait_writable(int argc, VALUE *argv, VALUE io)
    {
        rb_io_t *fptr;
        int i;
        VALUE timeout;
        struct timeval timerec;
        struct timeval *tv;

        GetOpenFile(io, fptr);
        rb_io_check_writable(fptr);
        rb_scan_args(argc, argv, "01", &timeout);
        if (NIL_P(timeout)) {
            tv = NULL;
        }
        else {
            timerec = rb_time_interval(timeout);
            tv = &timerec;
        }

        i = rb_wait_for_single_fd(fptr->fd, RB_WAITFD_OUT, tv);
        if (i < 0)
            rb_sys_fail(0);
        rb_io_check_closed(fptr);
        if (i & RB_WAITFD_OUT)
            return io;
        return Qnil;
    }