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



  

    #nread  ⇒ Integer   



  

    

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. 
    

  



  

    

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.


  





  


  [ GitHub ]


  

  


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



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

    if (argc != 2 || (RB_SYMBOL_P(argv[0]) || RB_SYMBOL_P(argv[1]))) {
	for (int i = 0; i < argc; i += 1) {
	    if (RB_SYMBOL_P(argv[i])) {
		events |= wait_mode_sym(argv[i]);
	    }
	    else if (timeout == Qundef) {
		rb_time_interval(timeout = argv[i]);
	    }
	    else {
		rb_raise(rb_eArgError, "timeout given more than once");
	    }
	}
	if (timeout == Qundef) timeout = Qnil;
    }
    else /* argc == 2 */ {
	events = RB_NUM2UINT(argv[0]);
	timeout = argv[1];
    }

    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  ⇒ Boolean 
      #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_readable  ⇒ Boolean 
      #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_writable  ⇒ Boolean 
      #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);
}