123456789_123456789_123456789_123456789_123456789_

Class: IO

Relationships & Source Files
Inherits: Object
Defined in: ext/io/wait/wait.c

Instance Attribute Summary

Instance Method Summary

Instance Attribute Details

#ready?Boolean (readonly)

Returns true if input available without blocking, or false.

[ GitHub ]

  
# File 'ext/io/wait/wait.c', line 93

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));
}

Instance Method Details

#nreadInteger

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

[ GitHub ]

  
# File 'ext/io/wait/wait.c', line 51

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);
}

#wait(events, timeout) ⇒ event mask, false. #wait(timeout = nil, mode = :read) ⇒ event mask, 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).

[ GitHub ]

  
# File 'ext/io/wait/wait.c', line 228

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_priorityBoolean #wait_priority(timeout) ⇒ Boolean

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

[ GitHub ]

  
# File 'ext/io/wait/wait.c', line 161

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_readableBoolean #wait_readable(timeout) ⇒ Boolean

Waits until IO is readable and returns true, or false when times out. Returns true immediately when buffered data is available.

[ GitHub ]

  
# File 'ext/io/wait/wait.c', line 115

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_writableBoolean #wait_writable(timeout) ⇒ Boolean

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

[ GitHub ]

  
# File 'ext/io/wait/wait.c', line 139

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);
}