nio4r 1.2.1 → 2.0.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 40a72f524510c03062dc6c3dbf8a6a20236b1f25
-  data.tar.gz: 0378f2eeeb4ab372da04f9a2f1010d4847c85587
+  metadata.gz: f6641deb5a7b32db8287d8856510a07dd33ec737
+  data.tar.gz: e414ccbb0aef8b0d8cf9ab63e09154753652766b
 SHA512:
-  metadata.gz: 02c255084b29eccedf83860ece30471660af81abcf294cc332cd86816c963ff53e81d1fa4ed7f84108e33762775b08fbf124877452690dfe4755d23cb5788bf4
-  data.tar.gz: 6b5e34b3863e6cfe1311f4aed6706de099cc09371a2fb8a6439c6a5f164afa2511a18cf0086abded3541770561342c0d6a58ad4e96aaa6b5d7021e66054f1bbe
+  metadata.gz: 37539315f05ec820ec9a5644acb178c49098e6384955ce234c7b5d4f137d8122d98a8486e9ebc419250057b4268d55f72f82ca28145c2ebf713af7823bd9a7fb
+  data.tar.gz: 1c151cb3ac3d8aef61665ebf4827b59712509d2482c1b26ad1af2853711e6888c8043306a312d4d84b89f511085c346ade0915e768307811bddabc2cc39c41ae

data/.travis.yml

@@ -1,26 +1,44 @@
 language: ruby
 sudo: false
+cache: bundler
+
+bundler_args: --without development
+
+branches:
+  only:
+    - master
+
+os:
+  - linux
+  - osx
 
 rvm:
-  - 2.0.0
-  - 2.1.1
-  - 2.2.2
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3.1
   - ruby-head
-  - jruby
+  - jruby-9.1.5.0 # latest stable
   - jruby-head
-  - rbx-2
+  - rbx
 
 env:
-  - NIO4R_PURE=false
-  - NIO4R_PURE=true
+  global:
+    - JRUBY_OPTS="--dev -J-Djruby.launch.inproc=true -J-Xmx1024M"      
+  matrix:
+    - NIO4R_PURE=false
+    - NIO4R_PURE=true
 
 matrix:
   fast_finish: true
   allow_failures:
+    - os:  osx # TODO: make tests pass reliably on OS X
     - rvm: ruby-head
     - rvm: jruby-head
-    - rvm: rbx-2
-    - rvm: jruby
+    - rvm: rbx
+    - rvm: jruby-1.7
+      env: NIO4R_PURE=true
+    - rvm: jruby-9.1
       env: NIO4R_PURE=true
 
 notifications:

data/Gemfile

@@ -4,12 +4,9 @@ gemspec
 
 gem "jruby-openssl" if defined? JRUBY_VERSION
 
-group :development do
+group :development, :test do
   gem "rake-compiler"
-end
-
-group :test do
-  gem "rspec",     "~> 3.0"
-  gem "rubocop",   "0.36.0"
-  gem "coveralls", require: false
+  gem "rspec",   "~> 3",   require: false
+  gem "rubocop", "0.36.0", require: false
+  gem "coveralls",         require: false
 end

data/README.md

@@ -1,47 +1,52 @@
-![nio4r](https://raw.github.com/celluloid/nio4r/master/logo.png)
-===============
+# ![nio4r](https://raw.github.com/celluloid/nio4r/master/logo.png)
+
 [![Gem Version](https://badge.fury.io/rb/nio4r.svg)](http://rubygems.org/gems/nio4r)
 [![Build Status](https://secure.travis-ci.org/celluloid/nio4r.svg?branch=master)](http://travis-ci.org/celluloid/nio4r)
 [![Code Climate](https://codeclimate.com/github/celluloid/nio4r.svg)](https://codeclimate.com/github/celluloid/nio4r)
 [![Coverage Status](https://coveralls.io/repos/celluloid/nio4r/badge.svg?branch=master)](https://coveralls.io/r/celluloid/nio4r)
 [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/celluloid/nio4r/blob/master/LICENSE.txt)
 
-nio4r: New IO for Ruby.
+_NOTE: This is the 2.x **development** branch of nio4r.  For the 1.x **stable**
+branch (used by [Rails 5]), please see:_
+
+https://github.com/celluloid/nio4r/tree/1-x-stable
+
+**New I/O for Ruby (nio4r)**: cross-platform asynchronous I/O primitives for
+scalable network clients and servers. Modeled after the Java NIO API, but
+simplified for ease-of-use.
 
-nio4r provides an abstract, cross-platform stateful I/O selector API for Ruby.
+**nio4r** provides an abstract, cross-platform stateful I/O selector API for Ruby.
 I/O selectors are the heart of "reactor"-based event loops, and monitor
 multiple I/O objects for various types of readiness, e.g. ready for reading or
 writing.
 
-The most similar API provided by Ruby today is Kernel.select, however the
-select API requires you to pass in arrays of all of the I/O objects you're
-interested in every time. nio4r provides a more object-oriented API that lets
-you register I/O objects with a selector then handle them when they're selected
-for various types of events.
+[Rails 5]: https://rubygems.org/gems/actioncable
 
-nio4r is modeled after the Java NIO API, but simplified for ease-of-use.
+## Projects using nio4r
 
-Its goals are:
+* [ActionCable]: Rails 5 WebSocket protocol, uses nio4r for a WebSocket server
+* [Celluloid::IO]: Actor-based concurrency framework, uses nio4r for async I/O
+
+[ActionCable]: https://rubygems.org/gems/actioncable
+[Celluloid::IO]: https://github.com/celluloid/celluloid-io
+
+## Goals
 
 * Expose high-level interfaces for stateful IO selectors
 * Keep the API small to maximize both portability and performance across many
   different OSes and Ruby VMs
 * Provide inherently thread-safe facilities for working with IO objects
 
-[Celluloid::IO](https://github.com/celluloid/celluloid-io) uses nio4r to
-monitor multiple IO objects from a single Celluloid actor.
-
-Supported Platforms
--------------------
+## Supported platforms
 
-nio4r is known to work on the following Ruby implementations:
+* Ruby 2.0
+* Ruby 2.1
+* Ruby 2.2
+* Ruby 2.3
+* JRuby 9000
+* Pure Ruby using Kernel.select
 
-* MRI/YARV 1.9.3, 2.0.0, 2.1.0
-* JRuby 1.7.x
-* Rubinius 2.x
-* A pure Ruby implementation based on Kernel.select is also provided
-
-Platform notes:
+## Platform notes
 
 * MRI/YARV and Rubinius implement nio4r with a C extension based on libev,
   which provides a high performance binding to native IO APIs
@@ -49,8 +54,14 @@ Platform notes:
 * A pure Ruby implementation is also provided for Ruby implementations which
   don't implement the MRI C extension API
 
-Usage
------
+## Usage
+
+If you're interested in using nio4r for a project but just getting started,
+check out this blog post which provides some background and examples:
+
+[A gentle introduction to nio4r: low-level portable asynchronous I/O for Ruby][blogpost]
+
+[blogpost]: https://tonyarcieri.com/a-gentle-introduction-to-nio4r
 
 ### Selectors
 
@@ -152,10 +163,9 @@ For information on how to compose nio4r selectors inside of event loops,
 please read the [Flow Control Guide on the
 Wiki](https://github.com/celluloid/nio4r/wiki/Basic-Flow-Control)
 
-Concurrency
------------
+## Concurrency
 
-nio4r provides internal locking to ensure that it's safe to use from multiple
+**nio4r** provides internal locking to ensure that it's safe to use from multiple
 concurrent threads. Only one thread can select on a NIO::Selector at a given
 time, and while a thread is selecting other threads are blocked from
 registering or deregistering IO objects. Once a pending select has completed,
@@ -166,28 +176,18 @@ middle of an NIO::Selector#select operation. This lets other threads that need
 to communicate immediately with the selector unblock it so it can process
 other events that it's not presently selecting on.
 
-What nio4r is not
------------------
+## Non-goals
 
-nio4r is not a full-featured event framework like EventMachine or Cool.io.
+**nio4r** is not a full-featured event framework like [EventMachine] or [Cool.io].
 Instead, nio4r is the sort of thing you might write a library like that on
 top of. nio4r provides a minimal API such that individual Ruby implementers
 may choose to produce optimized versions for their platform, without having
 to maintain a large codebase.
 
-As of the time of writing, the current implementation is (approximately):
-
-* 200 lines of Ruby code
-* 700 lines of "custom" C code (not counting libev)
-* 400 lines of Java code
-
-nio4r is also not a replacement for Kinder Gentler IO (KGIO), a set of
-advanced Ruby IO APIs. At some point in the future nio4r might provide a
-cross-platform implementation that uses KGIO on CRubies, and Java NIO on JRuby,
-however this is not the case today.
+[EventMachine]: https://github.com/eventmachine/eventmachine
+[Cool.io]: https://coolio.github.io/
 
-License
--------
+## License
 
 Copyright (c) 2011-2016 Tony Arcieri. Distributed under the MIT License.
 See LICENSE.txt for further details.

data/Rakefile

@@ -1,4 +1,3 @@
-#!/usr/bin/env rake
 require "bundler/gem_tasks"
 require "rake/clean"
 

data/ext/libev/ev.c

@@ -39,6 +39,7 @@
 
 /* ########## NIO4R PATCHERY HO! ########## */
 #include "ruby.h"
+#include "ruby/thread.h"
 /* ######################################## */
 
 /* this big block deduces configuration from config.h */

data/ext/nio4r/bytebuffer.c

@@ -0,0 +1,413 @@
+#include "nio4r.h"
+
+static VALUE mNIO = Qnil;
+static VALUE cNIO_ByteBuffer = Qnil;
+
+/* Allocator/deallocator */
+static VALUE NIO_ByteBuffer_allocate(VALUE klass);
+static void NIO_ByteBuffer_mark(struct NIO_ByteBuffer *byteBuffer);
+static void NIO_ByteBuffer_free(struct NIO_ByteBuffer *byteBuffer);
+
+/* Methods */
+static VALUE NIO_ByteBuffer_initialize(VALUE self, VALUE value, VALUE offset, VALUE length);
+static VALUE NIO_ByteBuffer_put(VALUE self, VALUE string);
+static VALUE NIO_ByteBuffer_get(VALUE self);
+static VALUE NIO_ByteBuffer_readnext(VALUE self, VALUE amount);
+static VALUE NIO_ByteBuffer_writeTo(VALUE self, VALUE file);
+static VALUE NIO_ByteBuffer_readFrom(VALUE self, VALUE file);
+static VALUE NIO_ByteBuffer_remaining(VALUE self);
+static VALUE NIO_ByteBuffer_hasRemaining(VALUE self);
+static VALUE NIO_ByteBuffer_getOffset(VALUE self);
+static VALUE NIO_ByteBuffer_equals(VALUE self, VALUE other);
+static VALUE NIO_ByteBuffer_flip(VALUE self);
+static VALUE NIO_ByteBuffer_rewind(VALUE self);
+static VALUE NIO_ByteBuffer_reset(VALUE self);
+static VALUE NIO_ByteBuffer_markBuffer(VALUE self);
+static VALUE NIO_ByteBuffer_clear(VALUE self);
+static VALUE NIO_ByteBuffer_compact(VALUE self);
+static VALUE NIO_ByteBuffer_capacity(VALUE self);
+static VALUE NIO_ByteBuffer_position(VALUE self, VALUE newPosition);
+static VALUE NIO_ByteBuffer_setLimit(VALUE self, VALUE newLimit);
+static VALUE NIO_ByteBuffer_getLimit(VALUE self);
+static VALUE NIO_ByteBuffer_toString(VALUE self);
+
+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);
+
+    rb_define_method(cNIO_ByteBuffer, "initialize", NIO_ByteBuffer_initialize, 3);
+    rb_define_method(cNIO_ByteBuffer, "<<", NIO_ByteBuffer_put, 1);
+    rb_define_method(cNIO_ByteBuffer, "get", NIO_ByteBuffer_get, 0);
+    rb_define_method(cNIO_ByteBuffer, "read_next", NIO_ByteBuffer_readnext, 1);
+    rb_define_method(cNIO_ByteBuffer, "write_to", NIO_ByteBuffer_writeTo, 1);
+    rb_define_method(cNIO_ByteBuffer, "read_from", NIO_ByteBuffer_readFrom, 1);
+    rb_define_method(cNIO_ByteBuffer, "remaining", NIO_ByteBuffer_remaining, 0);
+    rb_define_method(cNIO_ByteBuffer, "remaining?", NIO_ByteBuffer_hasRemaining, 0);
+    rb_define_method(cNIO_ByteBuffer, "offset?", NIO_ByteBuffer_getOffset, 0);
+    rb_define_method(cNIO_ByteBuffer, "equals", NIO_ByteBuffer_equals, 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, "reset", NIO_ByteBuffer_reset, 0);
+    rb_define_method(cNIO_ByteBuffer, "mark", NIO_ByteBuffer_markBuffer, 0);
+    rb_define_method(cNIO_ByteBuffer, "clear", NIO_ByteBuffer_clear, 0);
+    rb_define_method(cNIO_ByteBuffer, "compact", NIO_ByteBuffer_compact, 0);
+    rb_define_method(cNIO_ByteBuffer, "capacity", NIO_ByteBuffer_capacity, 0);
+    rb_define_method(cNIO_ByteBuffer, "position", NIO_ByteBuffer_position, 1);
+    rb_define_method(cNIO_ByteBuffer, "limit", NIO_ByteBuffer_setLimit, 1);
+    rb_define_method(cNIO_ByteBuffer, "limit?", NIO_ByteBuffer_getLimit, 0);
+    rb_define_method(cNIO_ByteBuffer, "to_s", NIO_ByteBuffer_toString, 0);
+}
+
+static VALUE NIO_ByteBuffer_allocate(VALUE klass)
+{
+    struct NIO_ByteBuffer *bytebuffer = (struct NIO_ByteBuffer *)xmalloc(sizeof(struct NIO_ByteBuffer));
+    return Data_Wrap_Struct(klass, NIO_ByteBuffer_mark, NIO_ByteBuffer_free, bytebuffer);
+}
+
+static void NIO_ByteBuffer_mark(struct NIO_ByteBuffer *buffer)
+{
+}
+
+static void NIO_ByteBuffer_free(struct NIO_ByteBuffer *buffer)
+{
+    xfree(buffer);
+}
+
+static VALUE NIO_ByteBuffer_initialize(VALUE self, VALUE value, VALUE i_offset, VALUE i_length)
+{
+    //Value can be either.
+    //NUM -> Size of the buffer
+    //STRING -> Data to be stored on the buffer
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    switch (TYPE(value)) {
+      case T_FIXNUM:
+        byteBuffer->size = NUM2INT(value);
+        byteBuffer->buffer = malloc(sizeof(char) * byteBuffer->size);
+        break;
+      case T_STRING:
+        byteBuffer->size = RSTRING_LEN(value);
+        byteBuffer->buffer = StringValuePtr(value);
+        //buffer = RSTRING_PTR(str);
+        break;
+      default:
+        /* raise exception */
+        rb_raise(rb_eTypeError, "not a valid input");
+        break;
+    }
+
+    byteBuffer->position = 0;
+    byteBuffer->offset = 0;
+    byteBuffer->limit = byteBuffer->size - 1;
+    byteBuffer->self = self;
+
+    if(i_offset != Qnil && TYPE(i_offset) == T_FIXNUM) {
+        byteBuffer->offset = NUM2INT(i_offset);
+        byteBuffer->position = byteBuffer->offset;
+
+        if(i_length != Qnil && TYPE(i_length) == T_FIXNUM) {
+            int length = NUM2INT(i_length);
+
+            if(byteBuffer->offset + length < byteBuffer->size) {
+                byteBuffer->limit = byteBuffer->offset + length;
+            } else {
+                rb_raise(rb_eRuntimeError, "Invalid Arguiments Exception");
+            }
+        }
+    }
+
+    if(byteBuffer->size == 0) {
+        rb_raise(rb_eRuntimeError, "Invalid Arguiments Exception");
+    }
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_put(VALUE self, VALUE string)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    if(TYPE(string) == T_STRING) {
+        char *temp =  StringValuePtr(string);
+        int i = 0;
+        int limit = RSTRING_LEN(string);
+
+        for(byteBuffer->position; i < limit; byteBuffer->position++) {
+            byteBuffer->buffer[byteBuffer->position] = temp[i++];
+        }
+    }
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_get(VALUE self)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    int remaining = NUM2INT(NIO_ByteBuffer_remaining(self));
+
+    if(remaining == 0) {
+        return rb_str_new2("");
+    }
+
+    char tempArray[remaining+1];
+    int i = 0;
+
+    for(byteBuffer->position; byteBuffer->position <= byteBuffer->limit; byteBuffer->position++) {
+        tempArray[i++] = byteBuffer->buffer[byteBuffer->position];
+    }
+
+    tempArray[remaining] = '\0';
+    return rb_str_new2(tempArray);
+}
+
+static VALUE NIO_ByteBuffer_readnext(VALUE self, VALUE amount)
+{
+    int amnt = NUM2INT(amount);
+    if(amnt < 1) {
+        rb_raise(rb_eTypeError, "not a valid input");
+    }
+
+    if(amnt > NUM2INT(NIO_ByteBuffer_remaining(self))) {
+        rb_raise(rb_eTypeError, "Less number of elements remaining");
+    }
+
+    char tempArray[amnt+1];
+    int c = 0;
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    while(c < amnt) {
+        tempArray[c++] = byteBuffer->buffer[byteBuffer->position];
+        byteBuffer->position++;
+    }
+
+    tempArray[amnt] = '\0';
+    return rb_str_new2(tempArray);
+}
+
+static VALUE NIO_ByteBuffer_writeTo(VALUE self, VALUE io)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    int size = byteBuffer->limit + 1 - byteBuffer->position;
+
+    #if HAVE_RB_IO_T
+        rb_io_t        *fptr;
+    #else
+        OpenFile       *fptr;
+    #endif
+
+    GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
+    rb_io_set_nonblock(fptr);
+
+    VALUE content = NIO_ByteBuffer_get(self);
+    char* contentAsPointer = StringValuePtr(content);
+
+    write(FPTR_TO_FD(fptr), contentAsPointer , size);
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_readFrom(VALUE self, VALUE io)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    int size = byteBuffer->limit + 1 - byteBuffer->position;
+
+    #if HAVE_RB_IO_T
+        rb_io_t        *fptr;
+    #else
+        OpenFile       *fptr;
+    #endif
+
+    GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
+    rb_io_set_nonblock(fptr);
+
+    while(NIO_ByteBuffer_hasRemaining(self) == Qtrue) {
+        char* nextByte;
+        read(FPTR_TO_FD(fptr), &nextByte, 1);
+        VALUE byte = rb_str_new2(nextByte);
+        NIO_ByteBuffer_put(self, byte);
+    }
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_remaining(VALUE self)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    return INT2NUM(byteBuffer->limit + 1 - byteBuffer->position);
+}
+
+static VALUE NIO_ByteBuffer_hasRemaining(VALUE self)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    return ((byteBuffer->limit + 1 - byteBuffer->position) > 0) ? Qtrue : Qfalse;
+}
+
+static VALUE NIO_ByteBuffer_getOffset(VALUE self)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    return INT2NUM(byteBuffer->offset);
+}
+
+static VALUE NIO_ByteBuffer_equals(VALUE self, VALUE other)
+{
+    return self == other ? Qtrue : Qfalse;
+}
+
+static VALUE NIO_ByteBuffer_flip(VALUE self)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    byteBuffer->limit = (byteBuffer->position > 0) ? byteBuffer->position - 1 : 0;
+    byteBuffer->position = 0;
+    byteBuffer->mark = -1;
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_rewind(VALUE self)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    byteBuffer->position = 0;
+    byteBuffer->mark = -1;
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_reset(VALUE self)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    if(byteBuffer->mark < 0){
+        rb_raise(rb_eRuntimeError, "Invalid Mark Exception");
+    } else {
+        byteBuffer->position = byteBuffer->mark;
+    }
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_markBuffer(VALUE self)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    byteBuffer->mark = byteBuffer->position;
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_clear(VALUE self)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    byteBuffer->position = 0;
+    byteBuffer->limit = byteBuffer->size - 1;
+    byteBuffer->mark = -1;
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_compact(VALUE self)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    if(NIO_ByteBuffer_hasRemaining(self) == Qtrue) {
+        //move content
+        int i = 0, j = byteBuffer->position;
+        for(j = byteBuffer->position; j <= byteBuffer->limit; j++) {
+            byteBuffer->buffer[i++] = byteBuffer->buffer[j];
+        }
+
+        byteBuffer->position = i;
+        byteBuffer->limit = byteBuffer->size - 1;
+    }
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_capacity(VALUE self)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    return INT2NUM(byteBuffer->size);
+}
+
+static VALUE NIO_ByteBuffer_position(VALUE self, VALUE newposition)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    int newPosition = NUM2INT(newposition);
+
+    if(newPosition < 0 || newPosition > byteBuffer->limit) {
+      rb_raise(rb_eRuntimeError, "Illegal Argument Exception");
+    } else {
+        byteBuffer->position = newPosition;
+
+        if(byteBuffer->mark > newPosition) {
+            byteBuffer->mark = -1;
+        }
+    }
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_setLimit(VALUE self, VALUE newlimit)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    int newLimit = NUM2INT(newlimit);
+
+    if(newLimit < byteBuffer->size && newLimit >= 0)
+    {
+        byteBuffer->limit = newLimit;
+
+        if(byteBuffer->position > byteBuffer->limit) {
+            byteBuffer->position = newLimit;
+        }
+
+        if(byteBuffer->mark > byteBuffer->limit) {
+            byteBuffer->mark  = -1;
+        }
+    } else {
+        rb_raise(rb_eRuntimeError, "Illegal Argument Exception");
+    }
+
+    return self;
+}
+
+static VALUE NIO_ByteBuffer_getLimit(VALUE self)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    return INT2NUM(byteBuffer->limit);
+}
+
+static VALUE NIO_ByteBuffer_toString(VALUE self)
+{
+    struct NIO_ByteBuffer *byteBuffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+
+    return rb_sprintf ("ByteBuffer [pos=%d lim=%d cap=%d]\n", byteBuffer->position, byteBuffer->limit, byteBuffer->size);
+}

data/ext/nio4r/nio4r.h

@@ -41,6 +41,14 @@ struct NIO_Monitor
     struct NIO_Selector *selector;
 };
 
+struct NIO_ByteBuffer
+{
+    int size, offset, limit, position, mark;
+    char *buffer;
+    VALUE self;
+};
+
+
 #ifdef GetReadFile
 # define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
 #else

data/ext/nio4r/nio4r_ext.c

@@ -8,9 +8,11 @@
 
 void Init_NIO_Selector();
 void Init_NIO_Monitor();
+void Init_NIO_ByteBuffer();
 
 void Init_nio4r_ext()
 {
     Init_NIO_Selector();
     Init_NIO_Monitor();
+    Init_NIO_ByteBuffer();
 }