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

Support for the Ruby 2.4 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;
        struct timeval tv = {0, 0};

        GetOpenFile(io, fptr);
        rb_io_check_readable(fptr);
        if (rb_io_read_pending(fptr)) return Qtrue;
        if (wait_for_single_fd(fptr, RB_WAITFD_IN, &tv))
            return Qtrue;
        return Qfalse;
    }

wait(timeout = nil, mode = :read) → IO, true or nil click to toggle source

Waits until `IO` is readable or writable without blocking and returns `self`, or `nil` when times out. Returns `true` immediately when buffered data is available. Optional parameter `mode` is one of `:read`, `:write`, or `:read_write`.

                   static VALUE
    io_wait_readwrite(int argc, VALUE *argv, VALUE io)
    {
        rb_io_t *fptr;
        struct timeval timerec;
        struct timeval *tv = NULL;
        int event = 0;
        int i;

        GetOpenFile(io, fptr);
        for (i = 0; i < argc; ++i) {
            if (SYMBOL_P(argv[i])) {
                event |= wait_mode_sym(argv[i]);
            }
            else {
                *(tv = &timerec) = rb_time_interval(argv[i]);
            }
        }
        /* rb_time_interval() and might_mode() might convert the argument */
        rb_io_check_closed(fptr);
        if (!event) event = RB_WAITFD_IN;
        if ((event & RB_WAITFD_IN) && rb_io_read_pending(fptr))
            return Qtrue;
        if (wait_for_single_fd(fptr, event, tv))
            return io;
        return Qnil;
    }

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

Waits until `IO` is readable without blocking and returns `self`, or `nil` when times out. Returns `true` immediately when buffered data is available.

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

        GetOpenFile(io, fptr);
        rb_io_check_readable(fptr);
        tv = get_timeout(argc, argv, &timerec);
        if (rb_io_read_pending(fptr)) return Qtrue;
        if (wait_for_single_fd(fptr, RB_WAITFD_IN, tv)) {
            return io;
        }
        return Qnil;
    }

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

Waits until `IO` is writable without blocking and returns `self` or `nil` when times out.

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

        GetOpenFile(io, fptr);
        rb_io_check_writable(fptr);
        tv = get_timeout(argc, argv, &timerec);
        if (wait_for_single_fd(fptr, RB_WAITFD_OUT, tv)) {
            return io;
        }
        return Qnil;
    }