msgpack 0.6.0pre1-x64-mingw32

data/ext/java/org/msgpack/jruby/Encoder.java

@@ -0,0 +1,308 @@
+package org.msgpack.jruby;
+
+
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+import org.jruby.RubyNil;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyBignum;
+import org.jruby.RubyInteger;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+import org.jruby.RubyArray;
+import org.jruby.RubyHash;
+import org.jruby.RubyEncoding;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+import org.jcodings.Encoding;
+import org.jcodings.specific.UTF8Encoding;
+
+import static org.msgpack.jruby.Types.*;
+
+
+public class Encoder {
+
+  private static final int CACHE_LINE_SIZE = 64;
+  private static final int ARRAY_HEADER_SIZE = 24;
+
+  private final Ruby runtime;
+  private final Encoding binaryEncoding;
+  private final Encoding utf8Encoding;
+
+  private ByteBuffer buffer;
+
+  public Encoder(Ruby runtime) {
+    this.runtime = runtime;
+    this.buffer = ByteBuffer.allocate(CACHE_LINE_SIZE - ARRAY_HEADER_SIZE);
+    this.binaryEncoding = runtime.getEncodingService().getAscii8bitEncoding();
+    this.utf8Encoding = UTF8Encoding.INSTANCE;
+  }
+
+  private void ensureRemainingCapacity(int c) {
+    if (buffer.remaining() < c) {
+      int newLength = Math.max(buffer.capacity() + (buffer.capacity() >> 1), buffer.capacity() + c);
+      newLength += CACHE_LINE_SIZE - ((ARRAY_HEADER_SIZE + newLength) % CACHE_LINE_SIZE);
+      buffer = ByteBuffer.allocate(newLength).put(buffer.array(), 0, buffer.position());
+    }
+  }
+
+  private IRubyObject readRubyString() {
+    IRubyObject str = runtime.newString(new ByteList(buffer.array(), 0, buffer.position(), binaryEncoding, false));
+    buffer.clear();
+    return str;
+  }
+
+  public IRubyObject encode(IRubyObject object) {
+    appendObject(object);
+    return readRubyString();
+  }
+
+  public IRubyObject encode(IRubyObject object, IRubyObject destination) {
+    appendObject(object, destination);
+    return readRubyString();
+  }
+
+  public IRubyObject encodeArrayHeader(int size) {
+    appendArrayHeader(size);
+    return readRubyString();
+  }
+
+  public IRubyObject encodeMapHeader(int size) {
+    appendHashHeader(size);
+    return readRubyString();
+  }
+
+  private void appendObject(IRubyObject object) {
+    appendObject(object, null);
+  }
+
+  private void appendObject(IRubyObject object, IRubyObject destination) {
+    if (object == null || object instanceof RubyNil) {
+      ensureRemainingCapacity(1);
+      buffer.put(NIL);
+    } else if (object instanceof RubyBoolean) {
+      ensureRemainingCapacity(1);
+      buffer.put(((RubyBoolean) object).isTrue() ? TRUE : FALSE);
+    } else if (object instanceof RubyBignum) {
+      appendBignum((RubyBignum) object);
+    } else if (object instanceof RubyInteger) {
+      appendInteger((RubyInteger) object);
+    } else if (object instanceof RubyFloat) {
+      appendFloat((RubyFloat) object);
+    } else if (object instanceof RubyString) {
+      appendString((RubyString) object);
+    } else if (object instanceof RubySymbol) {
+      appendString(((RubySymbol) object).asString());
+    } else if (object instanceof RubyArray) {
+      appendArray((RubyArray) object);
+    } else if (object instanceof RubyHash) {
+      appendHash((RubyHash) object);
+    } else if (object.respondsTo("to_msgpack")) {
+      appendCustom(object, destination);
+    } else {
+      throw runtime.newArgumentError(String.format("Cannot pack type: %s", object.getClass().getName()));
+    }
+  }
+
+  private void appendBignum(RubyBignum object) {
+    BigInteger value = ((RubyBignum) object).getBigIntegerValue();
+    if (value.bitLength() > 64 || (value.bitLength() > 63 && value.signum() < 0)) {
+      throw runtime.newArgumentError(String.format("Cannot pack big integer: %s", value));
+    }
+    ensureRemainingCapacity(9);
+    buffer.put(value.signum() < 0 ? INT64 : UINT64);
+    byte[] b = value.toByteArray();
+    buffer.put(b, b.length - 8, 8);
+  }
+
+  private void appendInteger(RubyInteger object) {
+    long value = ((RubyInteger) object).getLongValue();
+    if (value < 0) {
+      if (value < Short.MIN_VALUE) {
+        if (value < Integer.MIN_VALUE) {
+          ensureRemainingCapacity(9);
+          buffer.put(INT64);
+          buffer.putLong(value);
+        } else {
+          ensureRemainingCapacity(5);
+          buffer.put(INT32);
+          buffer.putInt((int) value);
+        }
+      } else if (value >= -0x20L) {
+        ensureRemainingCapacity(1);
+        byte b = (byte) (value | 0xe0);
+        buffer.put(b);
+      } else if (value < Byte.MIN_VALUE) {
+        ensureRemainingCapacity(3);
+        buffer.put(INT16);
+        buffer.putShort((short) value);
+      } else {
+        ensureRemainingCapacity(2);
+        buffer.put(INT8);
+        buffer.put((byte) value);
+      }
+    } else {
+      if (value < 0x10000L) {
+        if (value < 128L) {
+          ensureRemainingCapacity(1);
+          buffer.put((byte) value);
+        } else if (value < 0x100L) {
+          ensureRemainingCapacity(2);
+          buffer.put(UINT8);
+          buffer.put((byte) value);
+        } else {
+          ensureRemainingCapacity(3);
+          buffer.put(UINT16);
+          buffer.putShort((short) value);
+        }
+      } else if (value < 0x100000000L) {
+        ensureRemainingCapacity(5);
+        buffer.put(UINT32);
+        buffer.putInt((int) value);
+      } else {
+        ensureRemainingCapacity(9);
+        buffer.put(INT64);
+        buffer.putLong(value);
+      }
+    }
+  }
+
+  private void appendFloat(RubyFloat object) {
+    double value = object.getDoubleValue();
+    float f = (float) value;
+    //TODO: msgpack-ruby original does encode this value as Double, not float
+    // if (Double.compare(f, value) == 0) {
+    //   ensureRemainingCapacity(5);
+    //   buffer.put(FLOAT32);
+    //   buffer.putFloat(f);
+    // } else {
+      ensureRemainingCapacity(9);
+      buffer.put(FLOAT64);
+      buffer.putDouble(value);
+    // }
+  }
+
+  private void appendString(RubyString object) {
+    Encoding encoding = object.getEncoding();
+    boolean binary = encoding == binaryEncoding;
+    if (encoding != utf8Encoding && encoding != binaryEncoding) {
+      object = (RubyString) ((RubyString) object).encode(runtime.getCurrentContext(), runtime.getEncodingService().getEncoding(utf8Encoding));
+    }
+    ByteList bytes = object.getByteList();
+    int length = bytes.length();
+    if (length < 32 && !binary) {
+      ensureRemainingCapacity(1 + length);
+      buffer.put((byte) (length | FIXSTR));
+    } else if (length <= 0xff) {
+      ensureRemainingCapacity(2 + length);
+      buffer.put(binary ? BIN8 : STR8);
+      buffer.put((byte) length);
+    } else if (length <= 0xffff) {
+      ensureRemainingCapacity(3 + length);
+      buffer.put(binary ? BIN16 : STR16);
+      buffer.putShort((short) length);
+    } else {
+      ensureRemainingCapacity(5 + length);
+      buffer.put(binary ? BIN32 : STR32);
+      buffer.putInt((int) length);
+    }
+    buffer.put(bytes.unsafeBytes(), bytes.begin(), length);
+  }
+
+  private void appendArray(RubyArray object) {
+    appendArrayHeader(object);
+    appendArrayElements(object);
+  }
+
+  private void appendArrayHeader(RubyArray object) {
+    appendArrayHeader(object.size());
+  }
+
+  private void appendArrayHeader(int size) {
+    if (size < 16) {
+      ensureRemainingCapacity(1);
+      buffer.put((byte) (size | 0x90));
+    } else if (size < 0x10000) {
+      ensureRemainingCapacity(3);
+      buffer.put(ARY16);
+      buffer.putShort((short) size);
+    } else {
+      ensureRemainingCapacity(5);
+      buffer.put(ARY32);
+      buffer.putInt(size);
+    }
+  }
+
+  private void appendArrayElements(RubyArray object) {
+    int size = object.size();
+    for (int i = 0; i < size; i++) {
+      appendObject(object.eltOk(i));
+    }
+  }
+
+  private void appendHash(RubyHash object) {
+    appendHashHeader(object);
+    appendHashElements(object);
+  }
+
+  private void appendHashHeader(RubyHash object) {
+    appendHashHeader(object.size());
+  }
+
+  private void appendHashHeader(int size) {
+    if (size < 16) {
+      ensureRemainingCapacity(1);
+      buffer.put((byte) (size | 0x80));
+    } else if (size < 0x10000) {
+      ensureRemainingCapacity(3);
+      buffer.put(MAP16);
+      buffer.putShort((short) size);
+    } else {
+      ensureRemainingCapacity(5);
+      buffer.put(MAP32);
+      buffer.putInt(size);
+    }
+  }
+
+  private void appendHashElements(RubyHash object) {
+    int size = object.size();
+    HashVisitor visitor = new HashVisitor(size);
+    object.visitAll(visitor);
+    if (visitor.remain != 0) {
+      object.getRuntime().newConcurrencyError("Hash size changed while packing");
+    }
+  }
+
+  private class HashVisitor extends RubyHash.Visitor {
+    public int remain;
+
+    public HashVisitor(int size) {
+      remain = size;
+    }
+
+    public void visit(IRubyObject key, IRubyObject value) {
+      if (remain-- > 0) {
+        appendObject(key);
+        appendObject(value);
+      }
+    }
+  }
+
+  private void appendCustom(IRubyObject object, IRubyObject destination) {
+    if (destination == null) {
+      IRubyObject result = object.callMethod(runtime.getCurrentContext(), "to_msgpack");
+      ByteList bytes = result.asString().getByteList();
+      int length = bytes.length();
+      ensureRemainingCapacity(length);
+      buffer.put(bytes.unsafeBytes(), bytes.begin(), length);
+    } else {
+      object.callMethod(runtime.getCurrentContext(), "to_msgpack", destination);
+    }
+  }
+}

data/ext/java/org/msgpack/jruby/ExtensionValue.java

@@ -0,0 +1,136 @@
+package org.msgpack.jruby;
+
+
+import java.util.Arrays;
+import java.nio.ByteBuffer;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyString;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.util.ByteList;
+
+import static org.jruby.runtime.Visibility.PRIVATE;
+
+import org.jcodings.Encoding;
+
+import static org.msgpack.jruby.Types.*;
+
+
+@JRubyClass(name="MessagePack::ExtensionValue")
+public class ExtensionValue extends RubyObject {
+  private final Encoding binaryEncoding;
+
+  private RubyFixnum type;
+  private RubyString payload;
+
+  public ExtensionValue(Ruby runtime, RubyClass type) {
+    super(runtime, type);
+    this.binaryEncoding = runtime.getEncodingService().getAscii8bitEncoding();
+  }
+
+  public static class ExtensionValueAllocator implements ObjectAllocator {
+    public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+      return new ExtensionValue(runtime, klass);
+    }
+  }
+
+  public static ExtensionValue newExtensionValue(Ruby runtime, int type, byte[] payload) {
+    ExtensionValue v = new ExtensionValue(runtime, runtime.getModule("MessagePack").getClass("ExtensionValue"));
+    ByteList byteList = new ByteList(payload, runtime.getEncodingService().getAscii8bitEncoding());
+    v.initialize(runtime.getCurrentContext(), runtime.newFixnum(type), runtime.newString(byteList));
+    return v;
+  }
+
+  @JRubyMethod(name = "initialize", required = 2, visibility = PRIVATE)
+  public IRubyObject initialize(ThreadContext ctx, IRubyObject type, IRubyObject payload) {
+    this.type = (RubyFixnum) type;
+    this.payload = (RubyString) payload;
+    return this;
+  }
+
+  @JRubyMethod(name = "to_msgpack")
+  public IRubyObject toMsgpack() {
+    ByteList payloadBytes = payload.getByteList();
+    int payloadSize = payloadBytes.length();
+    int outputSize = 0;
+    boolean fixSize = payloadSize == 1 || payloadSize == 2 || payloadSize == 4 || payloadSize == 8 || payloadSize == 16;
+    if (fixSize) {
+      outputSize = 2 + payloadSize;
+    } else if (payloadSize < 0x100) {
+      outputSize = 3 + payloadSize;
+    } else if (payloadSize < 0x10000) {
+      outputSize = 4 + payloadSize;
+    } else {
+      outputSize = 6 + payloadSize;
+    }
+    byte[] bytes = new byte[outputSize];
+    ByteBuffer buffer = ByteBuffer.wrap(bytes);
+    if (payloadSize == 1) {
+      buffer.put(FIXEXT1);
+      buffer.put((byte) type.getLongValue());
+      buffer.put((byte) payloadBytes.get(0));
+    } else if (payloadSize == 2) {
+      buffer.put(FIXEXT2);
+      buffer.put((byte) type.getLongValue());
+      buffer.put(payloadBytes.unsafeBytes(), payloadBytes.begin(), 2);
+    } else if (payloadSize == 4) {
+      buffer.put(FIXEXT4);
+      buffer.put((byte) type.getLongValue());
+      buffer.put(payloadBytes.unsafeBytes(), payloadBytes.begin(), 4);
+    } else if (payloadSize == 8) {
+      buffer.put(FIXEXT8);
+      buffer.put((byte) type.getLongValue());
+      buffer.put(payloadBytes.unsafeBytes(), payloadBytes.begin(), 8);
+    } else if (payloadSize == 16) {
+      buffer.put(FIXEXT16);
+      buffer.put((byte) type.getLongValue());
+      buffer.put(payloadBytes.unsafeBytes(), payloadBytes.begin(), 16);
+    } else if (payloadSize < 0x100) {
+      buffer.put(VAREXT8);
+      buffer.put((byte) payloadSize);
+      buffer.put((byte) type.getLongValue());
+      buffer.put(payloadBytes.unsafeBytes(), payloadBytes.begin(), payloadSize);
+    } else if (payloadSize < 0x10000) {
+      buffer.put(VAREXT16);
+      buffer.putShort((short) payloadSize);
+      buffer.put((byte) type.getLongValue());
+      buffer.put(payloadBytes.unsafeBytes(), payloadBytes.begin(), payloadSize);
+    } else {
+      buffer.put(VAREXT32);
+      buffer.putInt(payloadSize);
+      buffer.put((byte) type.getLongValue());
+      buffer.put(payloadBytes.unsafeBytes(), payloadBytes.begin(), payloadSize);
+    }
+    return getRuntime().newString(new ByteList(bytes, binaryEncoding, false));
+  }
+
+  @JRubyMethod(name = {"to_s", "inspect"})
+  @Override
+  public IRubyObject to_s() {
+    IRubyObject payloadStr = payload.callMethod(getRuntime().getCurrentContext(), "inspect");
+    return getRuntime().newString(String.format("#<MessagePack::ExtensionValue @type=%d, @payload=%s>", type.getLongValue(), payloadStr));
+  }
+
+  @JRubyMethod(name = "hash")
+  @Override
+  public RubyFixnum hash() {
+    long hash = payload.hashCode() & (type.getLongValue() << 56);
+    return RubyFixnum.newFixnum(getRuntime(), hash);
+  }
+
+  @JRubyMethod(name = "eql?")
+  public IRubyObject eql_p(ThreadContext ctx, IRubyObject o) {
+    if (o instanceof ExtensionValue) {
+      ExtensionValue other = (ExtensionValue) o;
+      return getRuntime().newBoolean(this.type.callMethod(ctx, "eql?", other.type).isTrue() && this.payload.callMethod(ctx, "eql?", other.payload).isTrue());
+    }
+    return getRuntime().getFalse();
+  }
+}

data/ext/java/org/msgpack/jruby/MessagePackLibrary.java

@@ -0,0 +1,107 @@
+package org.msgpack.jruby;
+
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyClass;
+import org.jruby.RubyString;
+import org.jruby.RubyNil;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyHash;
+import org.jruby.runtime.load.Library;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.Visibility;
+import org.jruby.anno.JRubyModule;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.internal.runtime.methods.CallConfiguration;
+import org.jruby.internal.runtime.methods.DynamicMethod;
+
+
+public class MessagePackLibrary implements Library {
+  public void load(Ruby runtime, boolean wrap) {
+    RubyModule msgpackModule = runtime.defineModule("MessagePack");
+    msgpackModule.defineAnnotatedMethods(MessagePackModule.class);
+    RubyClass standardErrorClass = runtime.getStandardError();
+    RubyClass unpackErrorClass = msgpackModule.defineClassUnder("UnpackError", standardErrorClass, standardErrorClass.getAllocator());
+    RubyClass underflowErrorClass = msgpackModule.defineClassUnder("UnderflowError", unpackErrorClass, unpackErrorClass.getAllocator());
+    RubyClass extensionValueClass = msgpackModule.defineClassUnder("ExtensionValue", runtime.getObject(), new ExtensionValue.ExtensionValueAllocator());
+    extensionValueClass.defineAnnotatedMethods(ExtensionValue.class);
+    RubyClass packerClass = msgpackModule.defineClassUnder("Packer", runtime.getObject(), new Packer.PackerAllocator());
+    packerClass.defineAnnotatedMethods(Packer.class);
+    RubyClass unpackerClass = msgpackModule.defineClassUnder("Unpacker", runtime.getObject(), new Unpacker.UnpackerAllocator());
+    unpackerClass.defineAnnotatedMethods(Unpacker.class);
+    RubyClass bufferClass = msgpackModule.defineClassUnder("Buffer", runtime.getObject(), new Buffer.BufferAllocator());
+    bufferClass.defineAnnotatedMethods(Buffer.class);
+    installCoreExtensions(runtime);
+  }
+
+  private void installCoreExtensions(Ruby runtime) {
+    installCoreExtensions(
+      runtime,
+      runtime.getNilClass(),
+      runtime.getTrueClass(),
+      runtime.getFalseClass(),
+      runtime.getFixnum(),
+      runtime.getBignum(),
+      runtime.getFloat(),
+      runtime.getString(),
+      runtime.getArray(),
+      runtime.getHash(),
+      runtime.getSymbol()
+    );
+  }
+
+  private void installCoreExtensions(Ruby runtime, RubyClass... classes) {
+    for (RubyClass cls : classes) {
+      cls.addMethod("to_msgpack", createToMsgpackMethod(runtime, cls));
+    }
+  }
+
+  private DynamicMethod createToMsgpackMethod(final Ruby runtime, RubyClass cls) {
+    return new DynamicMethod(cls, Visibility.PUBLIC, CallConfiguration.FrameNoneScopeNone) {
+      @Override
+      public IRubyObject call(ThreadContext context, IRubyObject recv, RubyModule clazz, String name, IRubyObject[] args, Block block) {
+        IRubyObject[] allArgs = new IRubyObject[1 + args.length];
+        allArgs[0] = recv;
+        System.arraycopy(args, 0, allArgs, 1, args.length);
+        return MessagePackModule.pack(runtime.getCurrentContext(), null, allArgs);
+      }
+
+      @Override
+      public DynamicMethod dup() {
+        return this;
+      }
+    };
+  }
+
+  @JRubyModule(name = "MessagePack")
+  public static class MessagePackModule {
+    @JRubyMethod(module = true, required = 1, optional = 1, alias = {"dump"})
+    public static IRubyObject pack(ThreadContext ctx, IRubyObject recv, IRubyObject[] args) {
+      IRubyObject[] extraArgs = null;
+      if (args.length == 0) {
+        extraArgs = new IRubyObject[] {};
+      } else {
+        extraArgs = new IRubyObject[args.length - 1];
+        System.arraycopy(args, 1, extraArgs, 0, args.length - 1);
+      }
+      Packer packer = new Packer(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Packer"));
+      packer.initialize(ctx, extraArgs);
+      packer.write(ctx, args[0]);
+      return packer.toS(ctx);
+    }
+
+    @JRubyMethod(module = true, required = 1, optional = 1, alias = {"load"})
+    public static IRubyObject unpack(ThreadContext ctx, IRubyObject recv, IRubyObject[] args) {
+      Decoder decoder = new Decoder(ctx.getRuntime(), args[0].asString().getBytes());
+      if (args.length > 1 && !args[args.length - 1].isNil()) {
+        RubyHash hash = args[args.length - 1].convertToHash();
+        IRubyObject symbolizeKeys = hash.fastARef(ctx.getRuntime().newSymbol("symbolize_keys"));
+        decoder.symbolizeKeys(symbolizeKeys != null && symbolizeKeys.isTrue());
+      }
+      return decoder.next();
+    }
+  }
+}

data/ext/java/org/msgpack/jruby/Packer.java

@@ -0,0 +1,78 @@
+package org.msgpack.jruby;
+
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyHash;
+import org.jruby.RubyIO;
+import org.jruby.RubyInteger;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.util.ByteList;
+
+
+@JRubyClass(name="MessagePack::Packer")
+public class Packer extends RubyObject {
+  private Buffer buffer;
+  private Encoder encoder;
+
+  public Packer(Ruby runtime, RubyClass type) {
+    super(runtime, type);
+  }
+
+  static class PackerAllocator implements ObjectAllocator {
+    public IRubyObject allocate(Ruby runtime, RubyClass type) {
+      return new Packer(runtime, type);
+    }
+  }
+
+  @JRubyMethod(name = "initialize", optional = 2)
+  public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
+    this.encoder = new Encoder(ctx.getRuntime());
+    this.buffer = new Buffer(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Buffer"));
+    this.buffer.initialize(ctx, args);
+    return this;
+  }
+
+  @JRubyMethod(name = "write")
+  public IRubyObject write(ThreadContext ctx, IRubyObject obj) {
+    return buffer.write(ctx, encoder.encode(obj, this));
+  }
+
+  @JRubyMethod(name = "write_nil")
+  public IRubyObject writeNil(ThreadContext ctx) {
+    return write(ctx, null);
+  }
+
+  @JRubyMethod(name = "write_array_header")
+  public IRubyObject writeArrayHeader(ThreadContext ctx, IRubyObject size) {
+    int s = (int) size.convertToInteger().getLongValue();
+    return buffer.write(ctx, encoder.encodeArrayHeader(s));
+  }
+
+  @JRubyMethod(name = "write_map_header")
+  public IRubyObject writeMapHeader(ThreadContext ctx, IRubyObject size) {
+    int s = (int) size.convertToInteger().getLongValue();
+    return buffer.write(ctx, encoder.encodeMapHeader(s));
+  }
+
+  @JRubyMethod(name = "to_s")
+  public IRubyObject toS(ThreadContext ctx) {
+    return buffer.toS(ctx);
+  }
+
+  @JRubyMethod(name = "buffer")
+  public IRubyObject buffer(ThreadContext ctx) {
+    return buffer;
+  }
+
+  @JRubyMethod(name = "flush")
+  public IRubyObject flush(ThreadContext ctx) {
+    return buffer.flush(ctx);
+  }
+
+}

data/ext/java/org/msgpack/jruby/Types.java

@@ -0,0 +1,37 @@
+package org.msgpack.jruby;
+
+
+public interface Types {
+  public static final byte FIXSTR   = (byte) 0xa0; // This is actually not header byte, but prefix bit mask
+  public static final byte NIL      = (byte) 0xc0;
+  public static final byte FALSE    = (byte) 0xc2;
+  public static final byte TRUE     = (byte) 0xc3;
+  public static final byte BIN8     = (byte) 0xc4;
+  public static final byte BIN16    = (byte) 0xc5;
+  public static final byte BIN32    = (byte) 0xc6;
+  public static final byte VAREXT8  = (byte) 0xc7;
+  public static final byte VAREXT16 = (byte) 0xc8;
+  public static final byte VAREXT32 = (byte) 0xc9;
+  public static final byte FLOAT32  = (byte) 0xca;
+  public static final byte FLOAT64  = (byte) 0xcb;
+  public static final byte UINT8    = (byte) 0xcc;
+  public static final byte UINT16   = (byte) 0xcd;
+  public static final byte UINT32   = (byte) 0xce;
+  public static final byte UINT64   = (byte) 0xcf;
+  public static final byte INT8     = (byte) 0xd0;
+  public static final byte INT16    = (byte) 0xd1;
+  public static final byte INT32    = (byte) 0xd2;
+  public static final byte INT64    = (byte) 0xd3;
+  public static final byte FIXEXT1  = (byte) 0xd4;
+  public static final byte FIXEXT2  = (byte) 0xd5;
+  public static final byte FIXEXT4  = (byte) 0xd6;
+  public static final byte FIXEXT8  = (byte) 0xd7;
+  public static final byte FIXEXT16 = (byte) 0xd8;
+  public static final byte STR8     = (byte) 0xd9;
+  public static final byte STR16    = (byte) 0xda;
+  public static final byte STR32    = (byte) 0xdb;
+  public static final byte ARY16    = (byte) 0xdc;
+  public static final byte ARY32    = (byte) 0xdd;
+  public static final byte MAP16    = (byte) 0xde;
+  public static final byte MAP32    = (byte) 0xdf;
+}