msgpack 0.6.0-x86-mswin32-60

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

@@ -0,0 +1,221 @@
+package org.msgpack.jruby;
+
+
+import java.nio.ByteBuffer;
+
+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;
+
+import org.jcodings.Encoding;
+
+
+@JRubyClass(name="MessagePack::Buffer")
+public class Buffer extends RubyObject {
+  private RubyHash options;
+  private IRubyObject io;
+  private ByteBuffer buffer;
+  private boolean writeMode;
+  private Encoding binaryEncoding;
+
+  private static final int CACHE_LINE_SIZE = 64;
+  private static final int ARRAY_HEADER_SIZE = 24;
+
+  public Buffer(Ruby runtime, RubyClass type) {
+    super(runtime, type);
+  }
+
+  static class BufferAllocator implements ObjectAllocator {
+    public IRubyObject allocate(Ruby runtime, RubyClass type) {
+      return new Buffer(runtime, type);
+    }
+  }
+
+  @JRubyMethod(name = "initialize", optional = 2)
+  public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
+    if (args.length > 0) {
+      if (args[0].respondsTo("read") && args[0].respondsTo("write")) {
+        this.io = args[0];
+      }
+      if (args[args.length - 1] instanceof RubyHash) {
+        this.options = (RubyHash) args[args.length - 1];
+      }
+    }
+    this.buffer = ByteBuffer.allocate(CACHE_LINE_SIZE - ARRAY_HEADER_SIZE);
+    this.writeMode = true;
+    this.binaryEncoding = ctx.getRuntime().getEncodingService().getAscii8bitEncoding();
+    return this;
+  }
+
+  private void ensureRemainingCapacity(int c) {
+    if (!writeMode) {
+      buffer.compact();
+      writeMode = true;
+    }
+    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 void ensureReadMode() {
+    if (writeMode) {
+      buffer.flip();
+      writeMode = false;
+    }
+  }
+
+  private int rawSize() {
+    if (writeMode) {
+      return buffer.position();
+    } else {
+      return buffer.limit() - buffer.position();
+    }
+  }
+
+  @JRubyMethod(name = "clear")
+  public IRubyObject clear(ThreadContext ctx) {
+    buffer.clear();
+    return ctx.getRuntime().getNil();
+  }
+
+  @JRubyMethod(name = "size")
+  public IRubyObject size(ThreadContext ctx) {
+    return ctx.getRuntime().newFixnum(rawSize());
+  }
+
+  @JRubyMethod(name = "empty?")
+  public IRubyObject isEmpty(ThreadContext ctx) {
+    return rawSize() == 0 ? ctx.getRuntime().getTrue() : ctx.getRuntime().getFalse();
+  }
+
+  private IRubyObject bufferWrite(ThreadContext ctx, IRubyObject str) {
+    ByteList bytes = str.asString().getByteList();
+    int length = bytes.length();
+    ensureRemainingCapacity(length);
+    buffer.put(bytes.unsafeBytes(), bytes.begin(), length);
+    return ctx.getRuntime().newFixnum(length);
+
+  }
+
+  @JRubyMethod(name = "write", alias = {"<<"})
+  public IRubyObject write(ThreadContext ctx, IRubyObject str) {
+    if (io == null) {
+      return bufferWrite(ctx, str);
+    } else {
+      return io.callMethod(ctx, "write", str);
+    }
+  }
+
+  private void feed(ThreadContext ctx) {
+    if (io != null) {
+      bufferWrite(ctx, io.callMethod(ctx, "read"));
+    }
+  }
+
+  private IRubyObject readCommon(ThreadContext ctx, IRubyObject[] args, boolean raiseOnUnderflow) {
+    feed(ctx);
+    int length = rawSize();
+    if (args != null && args.length == 1) {
+      length = (int) args[0].convertToInteger().getLongValue();
+    }
+    if (raiseOnUnderflow && rawSize() < length) {
+      throw ctx.getRuntime().newEOFError();
+    }
+    int readLength = Math.min(length, rawSize());
+    if (readLength == 0 && length > 0) {
+      return ctx.getRuntime().getNil();
+    } else if (readLength == 0) {
+      return ctx.getRuntime().newString();
+    } else {
+      ensureReadMode();
+      byte[] bytes = new byte[readLength];
+      buffer.get(bytes);
+      ByteList byteList = new ByteList(bytes, binaryEncoding);
+      return ctx.getRuntime().newString(byteList);
+    }
+  }
+
+  @JRubyMethod(name = "read", optional = 1)
+  public IRubyObject read(ThreadContext ctx, IRubyObject[] args) {
+    return readCommon(ctx, args, false);
+  }
+
+  @JRubyMethod(name = "read_all", optional = 1)
+  public IRubyObject readAll(ThreadContext ctx, IRubyObject[] args) {
+    return readCommon(ctx, args, true);
+  }
+
+  private IRubyObject skipCommon(ThreadContext ctx, IRubyObject _length, boolean raiseOnUnderflow) {
+    feed(ctx);
+    int length = (int) _length.convertToInteger().getLongValue();
+    if (raiseOnUnderflow && rawSize() < length) {
+      throw ctx.getRuntime().newEOFError();
+    }
+    ensureReadMode();
+    int skipLength = Math.min(length, rawSize());
+    buffer.position(buffer.position() + skipLength);
+    return ctx.getRuntime().newFixnum(skipLength);
+  }
+
+  @JRubyMethod(name = "skip")
+  public IRubyObject skip(ThreadContext ctx, IRubyObject length) {
+    return skipCommon(ctx, length, false);
+  }
+
+  @JRubyMethod(name = "skip_all")
+  public IRubyObject skipAll(ThreadContext ctx, IRubyObject length) {
+    return skipCommon(ctx, length, true);
+  }
+
+  @JRubyMethod(name = "to_s", alias = {"to_str"})
+  public IRubyObject toS(ThreadContext ctx) {
+    ensureReadMode();
+    int length = buffer.limit() - buffer.position();
+    ByteList str = new ByteList(buffer.array(), buffer.position(), length, binaryEncoding, true);
+    return ctx.getRuntime().newString(str);
+  }
+
+  @JRubyMethod(name = "to_a")
+  public IRubyObject toA(ThreadContext ctx) {
+    return ctx.getRuntime().newArray(toS(ctx));
+  }
+
+  @JRubyMethod(name = "io")
+  public IRubyObject getIo(ThreadContext ctx) {
+    return io == null ? ctx.getRuntime().getNil() : io;
+  }
+
+  @JRubyMethod(name = "flush")
+  public IRubyObject flush(ThreadContext ctx) {
+    if (io == null) {
+      return ctx.getRuntime().getNil();
+    } else {
+      return io.callMethod(ctx, "flush");
+    }
+  }
+
+  @JRubyMethod(name = "close")
+  public IRubyObject close(ThreadContext ctx) {
+    if (io == null) {
+      return ctx.getRuntime().getNil();
+    } else {
+      return io.callMethod(ctx, "close");
+    }
+  }
+
+  @JRubyMethod(name = "write_to")
+  public IRubyObject writeTo(ThreadContext ctx, IRubyObject io) {
+    return io.callMethod(ctx, "write", readCommon(ctx, null, false));
+  }
+}

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

@@ -0,0 +1,201 @@
+package org.msgpack.jruby;
+
+
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.BufferUnderflowException;
+import java.util.Iterator;
+import java.util.Arrays;
+
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+import org.jruby.RubyClass;
+import org.jruby.RubyBignum;
+import org.jruby.RubyString;
+import org.jruby.RubyHash;
+import org.jruby.exceptions.RaiseException;
+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 Decoder implements Iterator<IRubyObject> {
+  private final Ruby runtime;
+  private final Encoding binaryEncoding;
+  private final Encoding utf8Encoding;
+  private final RubyClass unpackErrorClass;
+  private final RubyClass underflowErrorClass;
+
+  private ByteBuffer buffer;
+  private boolean symbolizeKeys;
+
+  public Decoder(Ruby runtime) {
+    this(runtime, new byte[] {}, 0, 0);
+  }
+
+  public Decoder(Ruby runtime, byte[] bytes) {
+    this(runtime, bytes, 0, bytes.length);
+  }
+
+  public Decoder(Ruby runtime, byte[] bytes, int offset, int length) {
+    this.runtime = runtime;
+    this.binaryEncoding = runtime.getEncodingService().getAscii8bitEncoding();
+    this.utf8Encoding = UTF8Encoding.INSTANCE;
+    this.unpackErrorClass = runtime.getModule("MessagePack").getClass("UnpackError");
+    this.underflowErrorClass = runtime.getModule("MessagePack").getClass("UnderflowError");
+    feed(bytes, offset, length);
+  }
+
+  public void symbolizeKeys(boolean symbolize) {
+    this.symbolizeKeys = symbolize;
+  }
+
+  public void feed(byte[] bytes) {
+    feed(bytes, 0, bytes.length);
+  }
+
+  public void feed(byte[] bytes, int offset, int length) {
+    if (buffer == null) {
+      buffer = ByteBuffer.wrap(bytes, offset, length);
+    } else {
+      ByteBuffer newBuffer = ByteBuffer.allocate(buffer.remaining() + length);
+      newBuffer.put(buffer);
+      newBuffer.put(bytes, offset, length);
+      newBuffer.flip();
+      buffer = newBuffer;
+    }
+  }
+
+  public void reset() {
+    buffer.rewind();
+  }
+
+  public int offset() {
+    return buffer.position();
+  }
+
+  private IRubyObject consumeUnsignedLong() {
+    long value = buffer.getLong();
+    if (value < 0) {
+      return RubyBignum.newBignum(runtime, BigInteger.valueOf(value & ((1L<<63)-1)).setBit(63));
+    } else {
+      return runtime.newFixnum(value);
+    }
+  }
+
+  private IRubyObject consumeString(int size, Encoding encoding) {
+    byte[] bytes = readBytes(size);
+    ByteList byteList = new ByteList(bytes, encoding);
+    return runtime.newString(byteList);
+  }
+
+  private IRubyObject consumeArray(int size) {
+    IRubyObject[] elements = new IRubyObject[size];
+    for (int i = 0; i < size; i++) {
+      elements[i] = next();
+    }
+    return runtime.newArray(elements);
+  }
+
+  private IRubyObject consumeHash(int size) {
+    RubyHash hash = RubyHash.newHash(runtime);
+    for (int i = 0; i < size; i++) {
+      IRubyObject key = next();
+      if (this.symbolizeKeys && key instanceof RubyString) {
+          key = ((RubyString) key).intern();
+      }
+      hash.fastASet(key, next());
+    }
+    return hash;
+  }
+
+  private IRubyObject consumeExtension(int size) {
+    int type = buffer.get();
+    byte[] payload = readBytes(size);
+    return ExtensionValue.newExtensionValue(runtime, type, payload);
+  }
+
+  private byte[] readBytes(int size) {
+    byte[] payload = new byte[size];
+    buffer.get(payload);
+    return payload;
+  }
+
+  @Override
+  public void remove() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public boolean hasNext() {
+    return buffer.remaining() > 0;
+  }
+
+  @Override
+  public IRubyObject next() {
+    int position = buffer.position();
+    try {
+      byte b = buffer.get();
+      outer: switch ((b >> 4) & 0xf) {
+      case 0x8: return consumeHash(b & 0x0f);
+      case 0x9: return consumeArray(b & 0x0f);
+      case 0xa:
+      case 0xb: return consumeString(b & 0x1f, utf8Encoding);
+      case 0xc:
+        switch (b) {
+        case NIL:      return runtime.getNil();
+        case FALSE:    return runtime.getFalse();
+        case TRUE:     return runtime.getTrue();
+        case BIN8:     return consumeString(buffer.get() & 0xff, binaryEncoding);
+        case BIN16:    return consumeString(buffer.getShort() & 0xffff, binaryEncoding);
+        case BIN32:    return consumeString(buffer.getInt(), binaryEncoding);
+        case VAREXT8:  return consumeExtension(buffer.get());
+        case VAREXT16: return consumeExtension(buffer.getShort());
+        case VAREXT32: return consumeExtension(buffer.getInt());
+        case FLOAT32:  return runtime.newFloat(buffer.getFloat());
+        case FLOAT64:  return runtime.newFloat(buffer.getDouble());
+        case UINT8:    return runtime.newFixnum(buffer.get() & 0xffL);
+        case UINT16:   return runtime.newFixnum(buffer.getShort() & 0xffffL);
+        case UINT32:   return runtime.newFixnum(buffer.getInt() & 0xffffffffL);
+        case UINT64:   return consumeUnsignedLong();
+        default: break outer;
+        }
+      case 0xd:
+        switch (b) {
+        case INT8:     return runtime.newFixnum(buffer.get());
+        case INT16:    return runtime.newFixnum(buffer.getShort());
+        case INT32:    return runtime.newFixnum(buffer.getInt());
+        case INT64:    return runtime.newFixnum(buffer.getLong());
+        case FIXEXT1:  return consumeExtension(1);
+        case FIXEXT2:  return consumeExtension(2);
+        case FIXEXT4:  return consumeExtension(4);
+        case FIXEXT8:  return consumeExtension(8);
+        case FIXEXT16: return consumeExtension(16);
+        case STR8:     return consumeString(buffer.get() & 0xff, utf8Encoding);
+        case STR16:    return consumeString(buffer.getShort() & 0xffff, utf8Encoding);
+        case STR32:    return consumeString(buffer.getInt(), utf8Encoding);
+        case ARY16:    return consumeArray(buffer.getShort() & 0xffff);
+        case ARY32:    return consumeArray(buffer.getInt());
+        case MAP16:    return consumeHash(buffer.getShort() & 0xffff);
+        case MAP32:    return consumeHash(buffer.getInt());
+        default: break outer;
+        }
+      case 0xe:
+      case 0xf: return runtime.newFixnum((0x1f & b) - 0x20);
+      default: return runtime.newFixnum(b);
+      }
+      buffer.position(position);
+      throw runtime.newRaiseException(unpackErrorClass, "Illegal byte sequence");
+    } catch (RaiseException re) {
+      buffer.position(position);
+      throw re;
+    } catch (BufferUnderflowException bue) {
+      buffer.position(position);
+      throw runtime.newRaiseException(underflowErrorClass, "Not enough bytes available");
+    }
+  }
+}

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