In Files

  • io/wait/wait.c

Class/Module Index [+]

Quicksearch

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 = NULL;
    ioctl_arg n;

    GetOpenFile(io, fptr);
    rb_io_check_readable(fptr);
    int 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 or false click to toggle source

Returns true if input available without blocking, or false.

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

    GetOpenFile(io, fptr);
    rb_io_check_readable(fptr);
    if (rb_io_read_pending(fptr)) return Qtrue;

    return io_wait_event(io, RUBY_IO_READABLE, RB_INT2NUM(0));
}
wait(events, timeout) → event mask or false. click to toggle source
wait(timeout = nil, mode = :read) → event mask or false (deprecated)

Waits until the IO becomes ready for the specified events and returns the subset of events that become ready, or false when times out.

The events can be a bit mask of IO::READABLE, IO::WRITABLE or IO::PRIORITY.

Returns true immediately when buffered data is available.

Optional parameter mode is one of :read, :write, or :read_write (deprecated).

 
               static VALUE
io_wait(int argc, VALUE *argv, VALUE io)
{
    VALUE timeout = Qnil;
    rb_io_event_t events = 0;

    if (argc < 2 || (argc >= 2 && RB_SYMBOL_P(argv[1]))) {
        if (argc > 0) {
            timeout = argv[0];
        }

        for (int i = 1; i < argc; i += 1) {
            events |= wait_mode_sym(argv[i]);
        }
    }
    else if (argc == 2) {
        events = RB_NUM2UINT(argv[0]);

        if (argv[1] != Qnil) {
            timeout = argv[1];
        }
    }
    else {
        // TODO error
        return Qnil;
    }

    if (events == 0) {
        events = RUBY_IO_READABLE;
    }

    if (events & RUBY_IO_READABLE) {
        rb_io_t *fptr = NULL;
        RB_IO_POINTER(io, fptr);

        if (rb_io_read_pending(fptr)) {
            return Qtrue;
        }
    }

    return io_wait_event(io, events, timeout);
}
wait_priority → true or false click to toggle source
wait_priority(timeout) → true or false

Waits until IO is priority and returns true or false when times out.

 
               static VALUE
io_wait_priority(int argc, VALUE *argv, VALUE io)
{
    rb_io_t *fptr = NULL;

    RB_IO_POINTER(io, fptr);
    rb_io_check_readable(fptr);

    if (rb_io_read_pending(fptr)) return Qtrue;

    rb_check_arity(argc, 0, 1);
    VALUE timeout = argc == 1 ? argv[0] : Qnil;

    return io_wait_event(io, RUBY_IO_PRIORITY, timeout);
}
wait_readable → true or false click to toggle source
wait_readable(timeout) → true or false

Waits until IO is readable and returns true, or false 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 = NULL;

    RB_IO_POINTER(io, fptr);
    rb_io_check_readable(fptr);

    if (rb_io_read_pending(fptr)) return Qtrue;

    rb_check_arity(argc, 0, 1);
    VALUE timeout = (argc == 1 ? argv[0] : Qnil);

    return io_wait_event(io, RUBY_IO_READABLE, timeout);
}
wait_writable → true or false click to toggle source
wait_writable(timeout) → true or false

Waits until IO is writable and returns true or false when times out.

 
               static VALUE
io_wait_writable(int argc, VALUE *argv, VALUE io)
{
    rb_io_t *fptr = NULL;

    RB_IO_POINTER(io, fptr);
    rb_io_check_writable(fptr);

    rb_check_arity(argc, 0, 1);
    VALUE timeout = (argc == 1 ? argv[0] : Qnil);

    return io_wait_event(io, RUBY_IO_WRITABLE, timeout);
}