ed-precompiled_msgpack 1.8.0

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

@@ -0,0 +1,128 @@
+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 static final long serialVersionUID = 8451274621449322492L;
+  private transient 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_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) {
+    Ruby runtime = ctx.runtime;
+    if (this == o) {
+	    return runtime.getTrue();
+    }
+    if (o instanceof ExtensionValue) {
+      ExtensionValue other = (ExtensionValue) o;
+      if (!this.type.eql_p(other.type).isTrue()) {
+        return runtime.getFalse();
+      } else {
+        return this.payload.str_eql_p(ctx, other.payload);
+      }
+    }
+    return runtime.getFalse();
+  }
+
+  @JRubyMethod(name = "==")
+  public IRubyObject op_equal(ThreadContext ctx, IRubyObject o) {
+    Ruby runtime = ctx.runtime;
+    if (this == o) {
+	    return runtime.getTrue();
+    }
+    if (o instanceof ExtensionValue) {
+      ExtensionValue other = (ExtensionValue) o;
+      if (!this.type.op_equal(ctx, other.type).isTrue()) {
+        return runtime.getFalse();
+      } else {
+        return this.payload.op_equal(ctx, other.payload);
+      }
+    }
+    return runtime.getFalse();
+  }
+
+  @JRubyMethod(name = "type")
+  public IRubyObject get_type() {
+    return type;
+  }
+
+  @JRubyMethod
+  public IRubyObject payload() {
+    return payload;
+  }
+
+  @JRubyMethod(name = "type=", required = 1)
+  public IRubyObject set_type(final IRubyObject tpe) {
+    type = (RubyFixnum)tpe;
+    return tpe;
+  }
+
+  @JRubyMethod(name = "payload=", required = 1)
+  public IRubyObject set_payload(final IRubyObject pld) {
+    payload = (RubyString)pld;
+    return pld;
+  }
+}

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

@@ -0,0 +1,130 @@
+package org.msgpack.jruby;
+
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyArray;
+import org.jruby.RubyHash;
+import org.jruby.RubyIO;
+import org.jruby.RubyInteger;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+import org.jruby.RubyProc;
+import org.jruby.RubyMethod;
+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 static org.jruby.runtime.Visibility.PRIVATE;
+
+@JRubyClass(name="MessagePack::Factory")
+public class Factory extends RubyObject {
+  private static final long serialVersionUID = 8441284623445322492L;
+  private transient final Ruby runtime;
+  private transient ExtensionRegistry extensionRegistry;
+  private boolean hasSymbolExtType;
+  private boolean hasBigIntExtType;
+
+  public Factory(Ruby runtime, RubyClass type) {
+    super(runtime, type);
+    this.runtime = runtime;
+    this.extensionRegistry = new ExtensionRegistry();
+    this.hasSymbolExtType = false;
+    this.hasBigIntExtType = false;
+  }
+
+  static class FactoryAllocator implements ObjectAllocator {
+    public IRubyObject allocate(Ruby runtime, RubyClass type) {
+      return new Factory(runtime, type);
+    }
+  }
+
+  public ExtensionRegistry extensionRegistry() {
+    return extensionRegistry.dup();
+  }
+
+  @JRubyMethod(name = "initialize")
+  public IRubyObject initialize(ThreadContext ctx) {
+    return this;
+  }
+
+  @JRubyMethod(name = "dup")
+  public IRubyObject dup() {
+    Factory clone = (Factory)super.dup();
+    clone.extensionRegistry = extensionRegistry();
+    clone.hasSymbolExtType = hasSymbolExtType;
+    return clone;
+  }
+
+  @JRubyMethod(name = "packer", optional = 2)
+  public Packer packer(ThreadContext ctx, IRubyObject[] args) {
+    return Packer.newPacker(ctx, extensionRegistry(), hasSymbolExtType, hasBigIntExtType, args);
+  }
+
+  @JRubyMethod(name = "unpacker", optional = 2)
+  public Unpacker unpacker(ThreadContext ctx, IRubyObject[] args) {
+    return Unpacker.newUnpacker(ctx, extensionRegistry(), args);
+  }
+
+  @JRubyMethod(name = "registered_types_internal", visibility = PRIVATE)
+  public IRubyObject registeredTypesInternal(ThreadContext ctx) {
+    return RubyArray.newArray(ctx.runtime, new IRubyObject[] {
+      extensionRegistry.toInternalPackerRegistry(ctx),
+      extensionRegistry.toInternalUnpackerRegistry(ctx)
+    });
+  }
+
+  @JRubyMethod(name = "register_type_internal", required = 3, visibility = PRIVATE)
+  public IRubyObject registerTypeInternal(ThreadContext ctx, IRubyObject type, IRubyObject mod, IRubyObject opts) {
+    testFrozen("MessagePack::Factory");
+
+    Ruby runtime = ctx.runtime;
+    RubyHash options = (RubyHash) opts;
+
+    IRubyObject packerProc = options.fastARef(runtime.newSymbol("packer"));
+    IRubyObject unpackerProc = options.fastARef(runtime.newSymbol("unpacker"));
+
+    long typeId = ((RubyFixnum) type).getLongValue();
+    if (typeId < -128 || typeId > 127) {
+      throw runtime.newRangeError(String.format("integer %d too big to convert to `signed char'", typeId));
+    }
+
+    if (!(mod instanceof RubyModule)) {
+      throw runtime.newArgumentError(String.format("expected Module/Class but found %s.", mod.getType().getName()));
+    }
+    RubyModule extModule = (RubyModule) mod;
+
+    boolean recursive = false;
+    if (options != null) {
+      IRubyObject recursiveExtensionArg = options.fastARef(runtime.newSymbol("recursive"));
+      if (recursiveExtensionArg != null && recursiveExtensionArg.isTrue()) {
+        recursive = true;
+      }
+    }
+
+    extensionRegistry.put(extModule, (int) typeId, recursive, packerProc, unpackerProc);
+
+    if (extModule == runtime.getSymbol() && !packerProc.isNil()) {
+      hasSymbolExtType = true;
+    }
+
+    if (options != null) {
+      IRubyObject oversizedIntegerExtensionArg = options.fastARef(runtime.newSymbol("oversized_integer_extension"));
+      if (oversizedIntegerExtensionArg != null && oversizedIntegerExtensionArg.isTrue()) {
+        if (extModule == runtime.getModule("Integer")) {
+          hasBigIntExtType = true;
+        } else {
+          throw runtime.newArgumentError("oversized_integer_extension: true is only for Integer class");
+        }
+      }
+    }
+
+    return runtime.getNil();
+  }
+}

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

@@ -0,0 +1,45 @@
+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");
+    RubyClass standardErrorClass = runtime.getStandardError();
+    RubyClass unpackErrorClass = msgpackModule.defineClassUnder("UnpackError", standardErrorClass, standardErrorClass.getAllocator());
+    RubyClass underflowErrorClass = msgpackModule.defineClassUnder("UnderflowError", unpackErrorClass, unpackErrorClass.getAllocator());
+    RubyClass malformedFormatErrorClass = msgpackModule.defineClassUnder("MalformedFormatError", unpackErrorClass, unpackErrorClass.getAllocator());
+    RubyClass stackErrorClass = msgpackModule.defineClassUnder("StackError", unpackErrorClass, unpackErrorClass.getAllocator());
+    RubyModule typeErrorModule = msgpackModule.defineModuleUnder("TypeError");
+    RubyClass unexpectedTypeErrorClass = msgpackModule.defineClassUnder("UnexpectedTypeError", unpackErrorClass, unpackErrorClass.getAllocator());
+    unexpectedTypeErrorClass.includeModule(typeErrorModule);
+    RubyClass unknownExtTypeErrorClass = msgpackModule.defineClassUnder("UnknownExtTypeError", 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);
+    RubyClass factoryClass = msgpackModule.defineClassUnder("Factory", runtime.getObject(), new Factory.FactoryAllocator());
+    factoryClass.defineAnnotatedMethods(Factory.class);
+  }
+}

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

@@ -0,0 +1,266 @@
+package org.msgpack.jruby;
+
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyArray;
+import org.jruby.RubyHash;
+import org.jruby.RubyIO;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyInteger;
+import org.jruby.RubyFixnum;
+import org.jruby.runtime.Block;
+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.jruby.util.TypeConverter;
+import org.msgpack.jruby.ExtensionValue;
+
+import org.jcodings.Encoding;
+
+import static org.jruby.runtime.Visibility.PRIVATE;
+
+@JRubyClass(name="MessagePack::Packer")
+public class Packer extends RubyObject {
+  private static final long serialVersionUID = 8451274621499362492L;
+  public transient ExtensionRegistry registry;
+  private Buffer buffer;
+  private transient Encoder encoder;
+  private boolean hasSymbolExtType;
+  private boolean hasBigintExtType;
+  private transient Encoding binaryEncoding;
+
+  public Packer(Ruby runtime, RubyClass type, ExtensionRegistry registry, boolean hasSymbolExtType, boolean hasBigintExtType) {
+    super(runtime, type);
+    this.registry = registry;
+    this.hasSymbolExtType = hasSymbolExtType;
+    this.hasBigintExtType = hasBigintExtType;
+  }
+
+  static class PackerAllocator implements ObjectAllocator {
+    public IRubyObject allocate(Ruby runtime, RubyClass type) {
+      return new Packer(runtime, type, null, false, false);
+    }
+  }
+
+  @JRubyMethod(name = "initialize", optional = 2)
+  public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
+    boolean compatibilityMode = false;
+    Ruby runtime = ctx.runtime;
+    if (args.length > 0) {
+      RubyHash options = null;
+      if (args[args.length - 1] instanceof RubyHash) {
+        options = (RubyHash) args[args.length - 1];
+      } else if (args.length > 1 && args[args.length - 2] instanceof RubyHash) {
+        options = (RubyHash) args[args.length - 2];
+      }
+
+      if (options != null) {
+        IRubyObject mode = options.fastARef(runtime.newSymbol("compatibility_mode"));
+        compatibilityMode = (mode != null) && mode.isTrue();
+      }
+    }
+    if (registry == null) {
+        // registry is null when allocate -> initialize
+        // registry is already initialized (and somthing might be registered) when newPacker from Factory
+        this.registry = new ExtensionRegistry();
+    }
+    this.encoder = new Encoder(runtime, this, compatibilityMode, registry, hasSymbolExtType, hasBigintExtType);
+    this.buffer = new Buffer(runtime, runtime.getModule("MessagePack").getClass("Buffer"));
+    this.buffer.initialize(ctx, args);
+    this.binaryEncoding = runtime.getEncodingService().getAscii8bitEncoding();
+    return this;
+  }
+
+  public static Packer newPacker(ThreadContext ctx, ExtensionRegistry extRegistry, boolean hasSymbolExtType, boolean hasBigintExtType, IRubyObject[] args) {
+    Packer packer = new Packer(ctx.runtime, ctx.runtime.getModule("MessagePack").getClass("Packer"), extRegistry, hasSymbolExtType, hasBigintExtType);
+    packer.initialize(ctx, args);
+    return packer;
+  }
+
+  @JRubyMethod(name = "compatibility_mode?")
+  public IRubyObject isCompatibilityMode(ThreadContext ctx) {
+    return encoder.isCompatibilityMode() ? ctx.runtime.getTrue() : ctx.runtime.getFalse();
+  }
+
+  @JRubyMethod(name = "registered_types_internal", visibility = PRIVATE)
+  public IRubyObject registeredTypesInternal(ThreadContext ctx) {
+    return registry.toInternalPackerRegistry(ctx);
+  }
+
+  @JRubyMethod(name = "register_type_internal", required = 3, visibility = PRIVATE)
+  public IRubyObject registerType(ThreadContext ctx, IRubyObject type, IRubyObject mod, IRubyObject proc) {
+    testFrozen("MessagePack::Packer");
+
+    Ruby runtime = ctx.runtime;
+
+    long typeId = ((RubyFixnum) type).getLongValue();
+    if (typeId < -128 || typeId > 127) {
+      throw runtime.newRangeError(String.format("integer %d too big to convert to `signed char'", typeId));
+    }
+
+    if (!(mod instanceof RubyModule)) {
+      throw runtime.newArgumentError(String.format("expected Module/Class but found %s.", mod.getType().getName()));
+    }
+    RubyModule extModule = (RubyModule) mod;
+
+    registry.put(extModule, (int) typeId, false, proc, null);
+
+    if (extModule == runtime.getSymbol() && !proc.isNil()) {
+      encoder.hasSymbolExtType = true;
+    }
+
+    return runtime.getNil();
+  }
+
+  @JRubyMethod(name = "write", alias = { "pack" })
+  public IRubyObject write(ThreadContext ctx, IRubyObject obj) {
+    buffer.write(ctx, encoder.encode(obj, this));
+    return this;
+  }
+
+  @JRubyMethod(name = "write_float")
+  public IRubyObject writeFloat(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyFloat.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_array")
+  public IRubyObject writeArray(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyArray.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_string")
+  public IRubyObject writeString(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyString.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_bin")
+  public IRubyObject writeBin(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyString.class);
+    obj = ((org.jruby.RubyString) obj).encode(ctx, ctx.runtime.getEncodingService().getEncoding(binaryEncoding));
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_hash")
+  public IRubyObject writeHash(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyHash.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_symbol")
+  public IRubyObject writeSymbol(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubySymbol.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_int")
+  public IRubyObject writeInt(ThreadContext ctx, IRubyObject obj) {
+    if (!(obj instanceof RubyFixnum)) {
+      checkType(ctx, obj, org.jruby.RubyBignum.class);
+    }
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_extension")
+  public IRubyObject writeExtension(ThreadContext ctx, IRubyObject obj) {
+    if (!(obj instanceof ExtensionValue)) {
+      throw ctx.runtime.newTypeError("Expected extension");
+    }
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_true")
+  public IRubyObject writeTrue(ThreadContext ctx) {
+    return write(ctx, ctx.runtime.getTrue());
+  }
+
+  @JRubyMethod(name = "write_false")
+  public IRubyObject writeFalse(ThreadContext ctx) {
+    return write(ctx, ctx.runtime.getFalse());
+  }
+
+  @JRubyMethod(name = "write_nil")
+  public IRubyObject writeNil(ThreadContext ctx) {
+    write(ctx, null);
+    return this;
+  }
+
+  @JRubyMethod(name = "write_float32")
+  public IRubyObject writeFloat32(ThreadContext ctx, IRubyObject numeric) {
+    Ruby runtime = ctx.runtime;
+    if (!(numeric instanceof RubyNumeric)) {
+      throw runtime.newArgumentError("Expected numeric");
+    }
+    buffer.write(ctx, encoder.encodeFloat32((RubyNumeric) numeric));
+    return this;
+  }
+
+  @JRubyMethod(name = "write_array_header")
+  public IRubyObject writeArrayHeader(ThreadContext ctx, IRubyObject size) {
+    int s = (int) size.convertToInteger().getLongValue();
+    buffer.write(ctx, encoder.encodeArrayHeader(s));
+    return this;
+  }
+
+  @JRubyMethod(name = "write_map_header")
+  public IRubyObject writeMapHeader(ThreadContext ctx, IRubyObject size) {
+    int s = (int) size.convertToInteger().getLongValue();
+    buffer.write(ctx, encoder.encodeMapHeader(s));
+    return this;
+  }
+
+  @JRubyMethod(name = "write_bin_header")
+  public IRubyObject writeBinHeader(ThreadContext ctx, IRubyObject size) {
+    int s = (int) size.convertToInteger().getLongValue();
+    buffer.write(ctx, encoder.encodeBinHeader(s));
+    return this;
+  }
+
+  @JRubyMethod(name = "full_pack")
+  public IRubyObject fullPack(ThreadContext ctx) {
+    if (buffer.hasIo()) {
+      return null;
+    }
+    return toS(ctx);
+  }
+
+  @JRubyMethod(name = "to_s", alias = { "to_str" })
+  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);
+  }
+
+  @JRubyMethod(name = "size")
+  public IRubyObject size(ThreadContext ctx) {
+    return buffer.size(ctx);
+  }
+
+  @JRubyMethod(name = "clear", alias = { "reset" })
+  public IRubyObject clear(ThreadContext ctx) {
+    return buffer.clear(ctx);
+  }
+
+  private void checkType(ThreadContext ctx, IRubyObject obj, Class<? extends IRubyObject> expectedType) {
+    if (!expectedType.isInstance(obj)) {
+      String expectedName = expectedType.getName().substring("org.jruby.Ruby".length());
+      throw ctx.runtime.newTypeError(String.format("wrong argument type %s (expected %s)", obj.getMetaClass().toString(), expectedName));
+    }
+  }
+}

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