nio4r 1.2.1 → 2.5.3

data/ext/libev/ev_poll.c

@@ -1,7 +1,7 @@
 /*
  * libev poll fd activity backend
  *
- * Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009,2010,2011,2016,2019 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -39,11 +39,14 @@
 
 #include <poll.h>
 
-void inline_size
-pollidx_init (int *base, int count)
+inline_size
+void
+array_needsize_pollidx (int *base, int offset, int count)
 {
-  /* consider using memset (.., -1, ...), which is practically guaranteed
-   * to work on all systems implementing poll */
+  /* using memset (.., -1, ...) is tempting, we we try
+   * to be ultraportable
+   */
+  base += offset;
   while (count--)
     *base++ = -1;
 }
@@ -56,14 +59,14 @@ poll_modify (EV_P_ int fd, int oev, int nev)
   if (oev == nev)
     return;
 
-  array_needsize (int, pollidxs, pollidxmax, fd + 1, pollidx_init);
+  array_needsize (int, pollidxs, pollidxmax, fd + 1, array_needsize_pollidx);
 
   idx = pollidxs [fd];
 
   if (idx < 0) /* need to allocate a new pollfd */
     {
       pollidxs [fd] = idx = pollcnt++;
-      array_needsize (struct pollfd, polls, pollmax, pollcnt, EMPTY2);
+      array_needsize (struct pollfd, polls, pollmax, pollcnt, array_needsize_noinit);
       polls [idx].fd = fd;
     }
 
@@ -107,14 +110,17 @@ poll_poll (EV_P_ ev_tstamp timeout)
   else
     for (p = polls; res; ++p)
       {
-        assert (("libev: poll() returned illegal result, broken BSD kernel?", p < polls + pollcnt));
+        assert (("libev: poll returned illegal result, broken BSD kernel?", p < polls + pollcnt));
 
         if (expect_false (p->revents)) /* this expect is debatable */
           {
             --res;
 
             if (expect_false (p->revents & POLLNVAL))
-              fd_kill (EV_A_ p->fd);
+              {
+                assert (("libev: poll found invalid fd in poll set", 0));
+                fd_kill (EV_A_ p->fd);
+              }
             else
               fd_event (
                 EV_A_
@@ -126,7 +132,8 @@ poll_poll (EV_P_ ev_tstamp timeout)
       }
 }
 
-int inline_size
+inline_size
+int
 poll_init (EV_P_ int flags)
 {
   backend_mintime = 1e-3;
@@ -139,7 +146,8 @@ poll_init (EV_P_ int flags)
   return EVBACKEND_POLL;
 }
 
-void inline_size
+inline_size
+void
 poll_destroy (EV_P)
 {
   ev_free (pollidxs);

data/ext/libev/ev_port.c

@@ -1,7 +1,7 @@
 /*
  * libev solaris event port backend
  *
- * Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009,2010,2011,2019 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -55,7 +55,8 @@
 #include <string.h>
 #include <errno.h>
 
-void inline_speed
+inline_speed
+void
 port_associate_and_check (EV_P_ int fd, int ev)
 {
   if (0 >
@@ -68,7 +69,10 @@ port_associate_and_check (EV_P_ int fd, int ev)
   )
     {
       if (errno == EBADFD)
-        fd_kill (EV_A_ fd);
+        {
+          assert (("libev: port_associate found invalid fd", errno != EBADFD));
+          fd_kill (EV_A_ fd);
+        }
       else
         ev_syserr ("(libev) port_associate");
     }
@@ -136,7 +140,8 @@ port_poll (EV_P_ ev_tstamp timeout)
     }
 }
 
-int inline_size
+inline_size
+int
 port_init (EV_P_ int flags)
 {
   /* Initialize the kernel queue */
@@ -163,13 +168,15 @@ port_init (EV_P_ int flags)
   return EVBACKEND_PORT;
 }
 
-void inline_size
+inline_size
+void
 port_destroy (EV_P)
 {
   ev_free (port_events);
 }
 
-void inline_size
+inline_size
+void
 port_fork (EV_P)
 {
   close (backend_fd);

data/ext/libev/ev_select.c

@@ -271,7 +271,8 @@ select_poll (EV_P_ ev_tstamp timeout)
 #endif
 }
 
-int inline_size
+inline_size
+int
 select_init (EV_P_ int flags)
 {
   backend_mintime = 1e-6;
@@ -300,7 +301,8 @@ select_init (EV_P_ int flags)
   return EVBACKEND_SELECT;
 }
 
-void inline_size
+inline_size
+void
 select_destroy (EV_P)
 {
   ev_free (vec_ri);

data/ext/libev/ev_vars.h

@@ -1,7 +1,7 @@
 /*
  * loop member variable declarations
  *
- * Copyright (c) 2007,2008,2009,2010,2011,2012,2013 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009,2010,2011,2012,2013,2019 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -107,6 +107,17 @@ VARx(int, epoll_epermcnt)
 VARx(int, epoll_epermmax)
 #endif
 
+#if EV_USE_LINUXAIO || EV_GENWRAP
+VARx(aio_context_t, linuxaio_ctx)
+VARx(int, linuxaio_iteration)
+VARx(struct aniocb **, linuxaio_iocbps)
+VARx(int, linuxaio_iocbpmax)
+VARx(struct iocb **, linuxaio_submits)
+VARx(int, linuxaio_submitcnt)
+VARx(int, linuxaio_submitmax)
+VARx(ev_io, linuxaio_epoll_w)
+#endif
+
 #if EV_USE_KQUEUE || EV_GENWRAP
 VARx(pid_t, kqueue_fd_pid)
 VARx(struct kevent *, kqueue_changes)
@@ -195,8 +206,8 @@ VARx(unsigned int, loop_depth) /* #ev_run enters - #ev_run leaves */
 
 VARx(void *, userdata)
 /* C++ doesn't support the ev_loop_callback typedef here. stinks. */
-VAR (release_cb, void (*release_cb)(EV_P) EV_THROW)
-VAR (acquire_cb, void (*acquire_cb)(EV_P) EV_THROW)
+VAR (release_cb, void (*release_cb)(EV_P) EV_NOEXCEPT)
+VAR (acquire_cb, void (*acquire_cb)(EV_P) EV_NOEXCEPT)
 VAR (invoke_cb , ev_loop_callback invoke_cb)
 #endif
 

data/ext/libev/ev_wrap.h

@@ -50,6 +50,14 @@
 #define kqueue_eventmax ((loop)->kqueue_eventmax)
 #define kqueue_events ((loop)->kqueue_events)
 #define kqueue_fd_pid ((loop)->kqueue_fd_pid)
+#define linuxaio_ctx ((loop)->linuxaio_ctx)
+#define linuxaio_epoll_w ((loop)->linuxaio_epoll_w)
+#define linuxaio_iocbpmax ((loop)->linuxaio_iocbpmax)
+#define linuxaio_iocbps ((loop)->linuxaio_iocbps)
+#define linuxaio_iteration ((loop)->linuxaio_iteration)
+#define linuxaio_submitcnt ((loop)->linuxaio_submitcnt)
+#define linuxaio_submitmax ((loop)->linuxaio_submitmax)
+#define linuxaio_submits ((loop)->linuxaio_submits)
 #define loop_count ((loop)->loop_count)
 #define loop_depth ((loop)->loop_depth)
 #define loop_done ((loop)->loop_done)
@@ -149,6 +157,14 @@
 #undef kqueue_eventmax
 #undef kqueue_events
 #undef kqueue_fd_pid
+#undef linuxaio_ctx
+#undef linuxaio_epoll_w
+#undef linuxaio_iocbpmax
+#undef linuxaio_iocbps
+#undef linuxaio_iteration
+#undef linuxaio_submitcnt
+#undef linuxaio_submitmax
+#undef linuxaio_submits
 #undef loop_count
 #undef loop_depth
 #undef loop_done

data/ext/nio4r/bytebuffer.c

@@ -0,0 +1,429 @@
+#include "nio4r.h"
+
+static VALUE mNIO = Qnil;
+static VALUE cNIO_ByteBuffer = Qnil;
+static VALUE cNIO_ByteBuffer_OverflowError = Qnil;
+static VALUE cNIO_ByteBuffer_UnderflowError = Qnil;
+static VALUE cNIO_ByteBuffer_MarkUnsetError = Qnil;
+
+/* Allocator/deallocator */
+static VALUE NIO_ByteBuffer_allocate(VALUE klass);
+static void NIO_ByteBuffer_gc_mark(struct NIO_ByteBuffer *byteBuffer);
+static void NIO_ByteBuffer_free(struct NIO_ByteBuffer *byteBuffer);
+
+/* Methods */
+static VALUE NIO_ByteBuffer_initialize(VALUE self, VALUE capacity);
+static VALUE NIO_ByteBuffer_clear(VALUE self);
+static VALUE NIO_ByteBuffer_get_position(VALUE self);
+static VALUE NIO_ByteBuffer_set_position(VALUE self, VALUE new_position);
+static VALUE NIO_ByteBuffer_get_limit(VALUE self);
+static VALUE NIO_ByteBuffer_set_limit(VALUE self, VALUE new_limit);
+static VALUE NIO_ByteBuffer_capacity(VALUE self);
+static VALUE NIO_ByteBuffer_remaining(VALUE self);
+static VALUE NIO_ByteBuffer_full(VALUE self);
+static VALUE NIO_ByteBuffer_get(int argc, VALUE *argv, VALUE self);
+static VALUE NIO_ByteBuffer_fetch(VALUE self, VALUE index);
+static VALUE NIO_ByteBuffer_put(VALUE self, VALUE string);
+static VALUE NIO_ByteBuffer_write_to(VALUE self, VALUE file);
+static VALUE NIO_ByteBuffer_read_from(VALUE self, VALUE file);
+static VALUE NIO_ByteBuffer_flip(VALUE self);
+static VALUE NIO_ByteBuffer_rewind(VALUE self);
+static VALUE NIO_ByteBuffer_mark(VALUE self);
+static VALUE NIO_ByteBuffer_reset(VALUE self);
+static VALUE NIO_ByteBuffer_compact(VALUE self);
+static VALUE NIO_ByteBuffer_each(VALUE self);
+static VALUE NIO_ByteBuffer_inspect(VALUE self);
+
+#define MARK_UNSET -1
+
+void Init_NIO_ByteBuffer()
+{
+    mNIO = rb_define_module("NIO");
+    cNIO_ByteBuffer = rb_define_class_under(mNIO, "ByteBuffer", rb_cObject);
+    rb_define_alloc_func(cNIO_ByteBuffer, NIO_ByteBuffer_allocate);
+
+    cNIO_ByteBuffer_OverflowError  = rb_define_class_under(cNIO_ByteBuffer, "OverflowError", rb_eIOError);
+    cNIO_ByteBuffer_UnderflowError = rb_define_class_under(cNIO_ByteBuffer, "UnderflowError", rb_eIOError);
+    cNIO_ByteBuffer_MarkUnsetError = rb_define_class_under(cNIO_ByteBuffer, "MarkUnsetError", rb_eIOError);
+
+    rb_include_module(cNIO_ByteBuffer, rb_mEnumerable);
+
+    rb_define_method(cNIO_ByteBuffer, "initialize", NIO_ByteBuffer_initialize, 1);
+    rb_define_method(cNIO_ByteBuffer, "clear", NIO_ByteBuffer_clear, 0);
+    rb_define_method(cNIO_ByteBuffer, "position", NIO_ByteBuffer_get_position, 0);
+    rb_define_method(cNIO_ByteBuffer, "position=", NIO_ByteBuffer_set_position, 1);
+    rb_define_method(cNIO_ByteBuffer, "limit", NIO_ByteBuffer_get_limit, 0);
+    rb_define_method(cNIO_ByteBuffer, "limit=", NIO_ByteBuffer_set_limit, 1);
+    rb_define_method(cNIO_ByteBuffer, "capacity", NIO_ByteBuffer_capacity, 0);
+    rb_define_method(cNIO_ByteBuffer, "size", NIO_ByteBuffer_capacity, 0);
+    rb_define_method(cNIO_ByteBuffer, "remaining", NIO_ByteBuffer_remaining, 0);
+    rb_define_method(cNIO_ByteBuffer, "full?", NIO_ByteBuffer_full, 0);
+    rb_define_method(cNIO_ByteBuffer, "get", NIO_ByteBuffer_get, -1);
+    rb_define_method(cNIO_ByteBuffer, "[]", NIO_ByteBuffer_fetch, 1);
+    rb_define_method(cNIO_ByteBuffer, "<<", NIO_ByteBuffer_put, 1);
+    rb_define_method(cNIO_ByteBuffer, "read_from", NIO_ByteBuffer_read_from, 1);
+    rb_define_method(cNIO_ByteBuffer, "write_to", NIO_ByteBuffer_write_to, 1);
+    rb_define_method(cNIO_ByteBuffer, "flip", NIO_ByteBuffer_flip, 0);
+    rb_define_method(cNIO_ByteBuffer, "rewind", NIO_ByteBuffer_rewind, 0);
+    rb_define_method(cNIO_ByteBuffer, "mark", NIO_ByteBuffer_mark, 0);
+    rb_define_method(cNIO_ByteBuffer, "reset", NIO_ByteBuffer_reset, 0);
+    rb_define_method(cNIO_ByteBuffer, "compact", NIO_ByteBuffer_compact, 0);
+    rb_define_method(cNIO_ByteBuffer, "each", NIO_ByteBuffer_each, 0);
+    rb_define_method(cNIO_ByteBuffer, "inspect", NIO_ByteBuffer_inspect, 0);
+}
+
+static VALUE NIO_ByteBuffer_allocate(VALUE klass)
+{
+    struct NIO_ByteBuffer *bytebuffer = (struct NIO_ByteBuffer *)xmalloc(sizeof(struct NIO_ByteBuffer));
+    bytebuffer->buffer = NULL;
+    return Data_Wrap_Struct(klass, NIO_ByteBuffer_gc_mark, NIO_ByteBuffer_free, bytebuffer);
+}
+
+static void NIO_ByteBuffer_gc_mark(struct NIO_ByteBuffer *buffer)
+{
+}
+
+static void NIO_ByteBuffer_free(struct NIO_ByteBuffer *buffer)
+{
+    if(buffer->buffer)
+      xfree(buffer->buffer);
+    xfree(buffer);
+}
+
+static VALUE NIO_ByteBuffer_initialize(VALUE self, VALUE capacity)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    buffer->capacity = NUM2INT(capacity);
+    buffer->buffer = xmalloc(buffer->capacity);
+
+    NIO_ByteBuffer_clear(self);
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_clear(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    memset(buffer->buffer, 0, buffer->capacity);
+
+    buffer->position = 0;
+    buffer->limit = buffer->capacity;
+    buffer->mark = MARK_UNSET;
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_get_position(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    return INT2NUM(buffer->position);
+}
+
+static VALUE NIO_ByteBuffer_set_position(VALUE self, VALUE new_position)
+{
+    int pos;
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    pos = NUM2INT(new_position);
+
+    if(pos < 0) {
+        rb_raise(rb_eArgError, "negative position given");
+    }
+
+    if(pos > buffer->limit) {
+        rb_raise(rb_eArgError, "specified position exceeds limit");
+    }
+
+    buffer->position = pos;
+
+    if(buffer->mark > buffer->position) {
+        buffer->mark = MARK_UNSET;
+    }
+
+    return new_position;
+}
+
+static VALUE NIO_ByteBuffer_get_limit(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    return INT2NUM(buffer->limit);
+}
+
+static VALUE NIO_ByteBuffer_set_limit(VALUE self, VALUE new_limit)
+{
+    int lim;
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    lim = NUM2INT(new_limit);
+
+    if(lim < 0) {
+        rb_raise(rb_eArgError, "negative limit given");
+    }
+
+    if(lim > buffer->capacity) {
+        rb_raise(rb_eArgError, "specified limit exceeds capacity");
+    }
+
+    buffer->limit = lim;
+
+    if(buffer->position > lim) {
+        buffer->position = lim;
+    }
+
+    if(buffer->mark > lim) {
+        buffer->mark = MARK_UNSET;
+    }
+
+    return new_limit;
+}
+
+static VALUE NIO_ByteBuffer_capacity(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    return INT2NUM(buffer->capacity);
+}
+
+static VALUE NIO_ByteBuffer_remaining(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    return INT2NUM(buffer->limit - buffer->position);
+}
+
+static VALUE NIO_ByteBuffer_full(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    return buffer->position == buffer->limit ? Qtrue : Qfalse;
+}
+
+static VALUE NIO_ByteBuffer_get(int argc, VALUE *argv, VALUE self)
+{
+    int len;
+    VALUE length, result;
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    rb_scan_args(argc, argv, "01", &length);
+
+    if(length == Qnil) {
+        len = buffer->limit - buffer->position;
+    } else {
+        len = NUM2INT(length);
+    }
+
+    if(len < 0) {
+        rb_raise(rb_eArgError, "negative length given");
+    }
+
+    if(len > buffer->limit - buffer->position) {
+        rb_raise(cNIO_ByteBuffer_UnderflowError, "not enough data in buffer");
+    }
+
+    result = rb_str_new(buffer->buffer + buffer->position, len);
+    buffer->position += len;
+
+    return result;
+}
+
+static VALUE NIO_ByteBuffer_fetch(VALUE self, VALUE index)
+{
+    int i;
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    i = NUM2INT(index);
+
+    if(i < 0) {
+        rb_raise(rb_eArgError, "negative index given");
+    }
+
+    if(i >= buffer->limit) {
+        rb_raise(rb_eArgError, "specified index exceeds limit");
+    }
+
+    return INT2NUM(buffer->buffer[i]);
+}
+
+static VALUE NIO_ByteBuffer_put(VALUE self, VALUE string)
+{
+    long length;
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    StringValue(string);
+    length = RSTRING_LEN(string);
+
+    if(length > buffer->limit - buffer->position) {
+        rb_raise(cNIO_ByteBuffer_OverflowError, "buffer is full");
+    }
+
+    memcpy(buffer->buffer + buffer->position, StringValuePtr(string), length);
+    buffer->position += length;
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_read_from(VALUE self, VALUE io)
+{
+    struct NIO_ByteBuffer *buffer;
+    rb_io_t *fptr;
+    ssize_t nbytes, bytes_read;
+
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+    GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
+    rb_io_set_nonblock(fptr);
+
+    nbytes = buffer->limit - buffer->position;
+    if(nbytes == 0) {
+        rb_raise(cNIO_ByteBuffer_OverflowError, "buffer is full");
+    }
+
+    bytes_read = read(FPTR_TO_FD(fptr), buffer->buffer + buffer->position, nbytes);
+
+    if(bytes_read < 0) {
+        if(errno == EAGAIN) {
+            return INT2NUM(0);
+        } else {
+            rb_sys_fail("write");
+        }
+    }
+
+    buffer->position += bytes_read;
+
+    return INT2NUM(bytes_read);
+}
+
+static VALUE NIO_ByteBuffer_write_to(VALUE self, VALUE io)
+{
+    struct NIO_ByteBuffer *buffer;
+    rb_io_t *fptr;
+    ssize_t nbytes, bytes_written;
+
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+    GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
+    rb_io_set_nonblock(fptr);
+
+    nbytes = buffer->limit - buffer->position;
+    if(nbytes == 0) {
+        rb_raise(cNIO_ByteBuffer_UnderflowError, "no data remaining in buffer");
+    }
+
+    bytes_written = write(FPTR_TO_FD(fptr), buffer->buffer + buffer->position, nbytes);
+
+    if(bytes_written < 0) {
+        if(errno == EAGAIN) {
+            return INT2NUM(0);
+        } else {
+            rb_sys_fail("write");
+        }
+    }
+
+    buffer->position += bytes_written;
+
+    return INT2NUM(bytes_written);
+}
+
+static VALUE NIO_ByteBuffer_flip(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    buffer->limit = buffer->position;
+    buffer->position = 0;
+    buffer->mark = MARK_UNSET;
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_rewind(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    buffer->position = 0;
+    buffer->mark = MARK_UNSET;
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_mark(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    buffer->mark = buffer->position;
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_reset(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    if(buffer->mark < 0) {
+        rb_raise(cNIO_ByteBuffer_MarkUnsetError, "mark has not been set");
+    } else {
+        buffer->position = buffer->mark;
+    }
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_compact(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    memmove(buffer->buffer, buffer->buffer + buffer->position, buffer->limit - buffer->position);
+    buffer->position = buffer->limit - buffer->position;
+    buffer->limit = buffer->capacity;
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_each(VALUE self)
+{
+    int i;
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    if(rb_block_given_p()) {
+        for(i = 0; i < buffer->limit; i++) {
+            rb_yield(INT2NUM(buffer->buffer[i]));
+        }
+    } else {
+        rb_raise(rb_eArgError, "no block given");
+    }
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_inspect(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    return rb_sprintf(
+        "#<%s:%p @position=%d @limit=%d @capacity=%d>",
+        rb_class2name(CLASS_OF(self)),
+        (void*)self,
+        buffer->position,
+        buffer->limit,
+        buffer->capacity
+    );
+}