Update msgpack

deps.edn

@@ -1,7 +1,7 @@
 {:paths ["target/classes"]
  :deps
  {com.fasterxml.jackson.core/jackson-core {:mvn/version "2.21.0"}
-  org.msgpack/msgpack {:mvn/version "0.6.12"}
+  org.msgpack/msgpack-core {:mvn/version "0.9.11"}
   javax.xml.bind/jaxb-api {:mvn/version "2.3.0"}}
 
  :deps/prep-lib

pom.xml

@@ -47,8 +47,8 @@
     </dependency>
     <dependency>
       <groupId>org.msgpack</groupId>
-      <artifactId>msgpack</artifactId>
-      <version>0.6.12</version>
+      <artifactId>msgpack-core</artifactId>
+      <version>0.9.11</version>
     </dependency>
     <dependency>
       <groupId>javax.xml.bind</groupId>

src/main/java/com/cognitect/transit/impl/MsgpackEmitter.java

@@ -4,7 +4,7 @@
 package com.cognitect.transit.impl;
 
 import com.cognitect.transit.WriteHandler;
-import org.msgpack.packer.Packer;
+import org.msgpack.core.MessagePacker;
 
 import java.io.IOException;
 import java.util.Map;
@@ -13,20 +13,20 @@
 
 public class MsgpackEmitter extends AbstractEmitter {
 
-    private final Packer gen;
+    private final MessagePacker gen;
 
     @Deprecated
-    public MsgpackEmitter(Packer gen, WriteHandlerMap writeHandlerMap) {
+    public MsgpackEmitter(MessagePacker gen, WriteHandlerMap writeHandlerMap) {
         super(writeHandlerMap, null);
         this.gen = gen;
     }
 
-    public MsgpackEmitter(Packer gen, WriteHandlerMap writeHandlerMap, WriteHandler defaultWriteHandler) {
+    public MsgpackEmitter(MessagePacker gen, WriteHandlerMap writeHandlerMap, WriteHandler defaultWriteHandler) {
         super(writeHandlerMap, defaultWriteHandler);
         this.gen = gen;
     }
 
-    public MsgpackEmitter(Packer gen, WriteHandlerMap writeHandlerMap, WriteHandler defaultWriteHandler, Function<Object,Object> transform) {
+    public MsgpackEmitter(MessagePacker gen, WriteHandlerMap writeHandlerMap, WriteHandler defaultWriteHandler, Function<Object,Object> transform) {
         super(writeHandlerMap, defaultWriteHandler, transform);
         this.gen = gen;
     }
@@ -38,60 +38,60 @@ public void emit(Object o, boolean asMapKey, WriteCache cache) throws Exception
 
     @Override
     public void emitNil(boolean asMapKey, WriteCache cache) throws Exception {
-        this.gen.writeNil();
+        this.gen.packNil();
     }
 
 @Override
     public void emitString(String prefix, String tag, String s, boolean asMapKey, WriteCache cache) throws Exception {
         String outString = cache.cacheWrite(Util.maybePrefix(prefix, tag, s), asMapKey);
-        this.gen.write(outString);
+        this.gen.packString(outString);
     }
 
     @Override
     public void emitBoolean(Boolean b, boolean asMapKey, WriteCache cache) throws Exception {
-        this.gen.write(b);
+        this.gen.packBoolean(b);
     }
 
     @Override
     public void emitBoolean(boolean b, boolean asMapKey, WriteCache cache) throws Exception {
-        this.gen.write(b);
+        this.gen.packBoolean(b);
     }
 
     @Override
     public void emitInteger(Object o, boolean asMapKey, WriteCache cache) throws Exception {
         long i = Util.numberToPrimitiveLong(o);
         if ((i > Long.MAX_VALUE) || (i < Long.MIN_VALUE))
             this.emitString(Constants.ESC_STR, "i", o.toString(), asMapKey, cache);
-        this.gen.write(i);
+        this.gen.packLong(i);
     }
 
 
     @Override
     public void emitInteger(long i, boolean asMapKey, WriteCache cache) throws Exception {
         if ((i > Long.MAX_VALUE) || (i < Long.MIN_VALUE))
             this.emitString(Constants.ESC_STR, "i", String.valueOf(i), asMapKey, cache);
-        this.gen.write(i);
+        this.gen.packLong(i);
     }
 
 
     @Override
     public void emitDouble(Object d, boolean asMapKey, WriteCache cache) throws Exception {
         if (d instanceof Double)
-            this.gen.write((Double) d);
+            this.gen.packDouble((Double) d);
         else if (d instanceof Float)
-            this.gen.write((Float) d);
+            this.gen.packFloat((Float) d);
         else
             throw new Exception("Unknown floating point type: " + d.getClass());
     }
 
     @Override
     public void emitDouble(float d, boolean asMapKey, WriteCache cache) throws Exception {
-        this.gen.write(d);
+        this.gen.packFloat(d);
     }
 
     @Override
     public void emitDouble(double d, boolean asMapKey, WriteCache cache) throws Exception {
-        this.gen.write(d);
+        this.gen.packDouble(d);
     }
 
     @Override
@@ -102,22 +102,22 @@ public void emitBinary(Object b, boolean asMapKey, WriteCache cache) throws Exce
 
     @Override
     public void emitArrayStart(Long size) throws Exception {
-        this.gen.writeArrayBegin(size.intValue());
+        this.gen.packArrayHeader(size.intValue());
     }
 
     @Override
     public void emitArrayEnd() throws Exception {
-        this.gen.writeArrayEnd();
+        // msgpack-core uses counted headers, no end marker needed
     }
 
     @Override
     public void emitMapStart(Long size) throws Exception {
-        this.gen.writeMapBegin(size.intValue());
+        this.gen.packMapHeader(size.intValue());
     }
 
     @Override
     public void emitMapEnd() throws Exception {
-        this.gen.writeMapEnd();
+        // msgpack-core uses counted headers, no end marker needed
     }
 
     @Override

src/main/java/com/cognitect/transit/impl/MsgpackParser.java

@@ -4,20 +4,21 @@
 package com.cognitect.transit.impl;
 
 import com.cognitect.transit.*;
-import org.msgpack.type.Value;
-import org.msgpack.type.ValueType;
-import org.msgpack.unpacker.Unpacker;
+import org.msgpack.core.MessageUnpacker;
+
+import org.msgpack.value.ValueType;
 
 import java.io.IOException;
-import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
 import java.util.List;
 import java.util.Map;
 
 
 public class MsgpackParser extends AbstractParser {
-    private final Unpacker mp;
+    private final MessageUnpacker mp;
 
-    public MsgpackParser(Unpacker mp,
+    public MsgpackParser(MessageUnpacker mp,
                          Map<String, ReadHandler<?,?>> handlers,
                          DefaultReadHandler defaultHandler,
                          MapReader<?, Map<Object, Object>, Object, Object> mapBuilder,
@@ -27,16 +28,7 @@ public MsgpackParser(Unpacker mp,
     }
 
     private Object parseLong() throws IOException {
-        Value val = mp.readValue();
-
-        try {
-            return val.asIntegerValue().getLong();
-        }
-        catch (Exception ex) {
-            BigInteger bi = new BigInteger(val.asRawValue().getString());
-        }
-
-        return val;
+        return mp.unpackLong();
     }
 
     @Override
@@ -46,21 +38,21 @@ public Object parse(ReadCache cache) throws IOException {
 
     @Override
     public Object parseVal(boolean asMapKey, ReadCache cache) throws IOException {
-        switch (mp.getNextType()) {
+        switch (mp.getNextFormat().getValueType()) {
             case MAP:
                 return parseMap(asMapKey, cache, null);
             case ARRAY:
                 return parseArray(asMapKey, cache, null);
-            case RAW:
-                return cache.cacheRead(mp.readValue().asRawValue().getString(), asMapKey, this);
+            case STRING:
+                return cache.cacheRead(mp.unpackString(), asMapKey, this);
             case INTEGER:
                 return parseLong();
             case FLOAT:
-                return mp.readValue().asFloatValue().getDouble();
+                return mp.unpackDouble();
             case BOOLEAN:
-                return mp.readValue().asBooleanValue().getBoolean();
+                return mp.unpackBoolean();
             case NIL:
-                mp.readNil();
+                mp.unpackNil();
         }
 
         return null;
@@ -69,7 +61,7 @@ public Object parseVal(boolean asMapKey, ReadCache cache) throws IOException {
     @Override
     public Object parseMap(boolean ignored, ReadCache cache, MapReadHandler<Object, ?, Object, Object, ?> handler) throws IOException {
 
-	    int sz = this.mp.readMapBegin();
+	    int sz = this.mp.unpackMapHeader();
 
         MapReader<Object, ?, Object, Object> mr = (handler != null) ? handler.mapReader() : mapBuilder;
 
@@ -82,10 +74,10 @@ public Object parseMap(boolean ignored, ReadCache cache, MapReadHandler<Object,
                 ReadHandler<Object, Object> val_handler = getHandler(tag);
                 Object val;
                 if (val_handler != null) {
-                    if (this.mp.getNextType() == ValueType.MAP && val_handler instanceof MapReadHandler) {
+                    if (this.mp.getNextFormat().getValueType() == ValueType.MAP && val_handler instanceof MapReadHandler) {
                         // use map reader to decode value
                         val = parseMap(false, cache, (MapReadHandler<Object, ?, Object, Object, ?>) val_handler);
-                    } else if (this.mp.getNextType() == ValueType.ARRAY && val_handler instanceof ArrayReadHandler) {
+                    } else if (this.mp.getNextFormat().getValueType() == ValueType.ARRAY && val_handler instanceof ArrayReadHandler) {
                         // use array reader to decode value
                         val = parseArray(false, cache, (ArrayReadHandler<Object, ?, Object, ?>) val_handler);
                     } else {
@@ -97,21 +89,19 @@ public Object parseMap(boolean ignored, ReadCache cache, MapReadHandler<Object,
                     val = this.decode(tag, parseVal(false, cache));
                 }
 
-                this.mp.readMapEnd(true);
                 return val;
             } else {
                 mb = mr.add(mb, key, parseVal(false, cache));
             }
         }
 
-        this.mp.readMapEnd(true);
         return mr.complete(mb);
     }
 
     @Override
     public Object parseArray(boolean ignored, ReadCache cache, ArrayReadHandler<Object, ?, Object, ?> handler) throws IOException {
 
-	    int sz = this.mp.readArrayBegin();
+	    int sz = this.mp.unpackArrayHeader();
 
         ArrayReader<Object, ?, Object> ar = (handler != null) ? handler.arrayReader() : listBuilder;
 
@@ -124,10 +114,10 @@ public Object parseArray(boolean ignored, ReadCache cache, ArrayReadHandler<Obje
                 String tag = ((Tag) val).getValue();
                 ReadHandler<Object, Object> val_handler = getHandler(tag);
                 if (val_handler != null) {
-                    if (this.mp.getNextType() == ValueType.MAP && val_handler instanceof MapReadHandler) {
+                    if (this.mp.getNextFormat().getValueType() == ValueType.MAP && val_handler instanceof MapReadHandler) {
                         // use map reader to decode value
                         val = parseMap(false, cache, (MapReadHandler<Object, ?, Object, Object, ?>) val_handler);
-                    } else if (this.mp.getNextType() == ValueType.ARRAY && val_handler instanceof ArrayReadHandler) {
+                    } else if (this.mp.getNextFormat().getValueType() == ValueType.ARRAY && val_handler instanceof ArrayReadHandler) {
                         // use array reader to decode value
                         val = parseArray(false, cache, (ArrayReadHandler<Object, ?, Object, ?>) val_handler);
                     } else {
@@ -138,15 +128,13 @@ public Object parseArray(boolean ignored, ReadCache cache, ArrayReadHandler<Obje
                     // default decode
                     val = this.decode(tag, parseVal(false, cache));
                 }
-                this.mp.readArrayEnd();
                 return val;
             } else {
                 // fall through to regular parse
                 ab = ar.add(ab, val);
             }
         }
 
-        this.mp.readArrayEnd();
         return ar.complete(ab);
     }
 }

src/main/java/com/cognitect/transit/impl/ReaderFactory.java

@@ -6,7 +6,7 @@
 import com.cognitect.transit.*;
 import com.cognitect.transit.SPI.ReaderSPI;
 import com.fasterxml.jackson.core.JsonFactory;
-import org.msgpack.MessagePack;
+import org.msgpack.core.MessagePack;
 
 import java.io.InputStream;
 import java.util.HashMap;
@@ -154,8 +154,7 @@ public MsgPackReaderImpl(InputStream in, Map<String, ReadHandler<?,?>> handlers,
 
         @Override
         protected AbstractParser createParser() {
-            MessagePack mp = new MessagePack();
-            return new MsgpackParser(mp.createUnpacker(in), handlers, defaultHandler,
+            return new MsgpackParser(MessagePack.newDefaultUnpacker(in), handlers, defaultHandler,
                     mapBuilder, listBuilder);
         }
     }

src/main/java/com/cognitect/transit/impl/WriterFactory.java

@@ -7,8 +7,8 @@
 import com.cognitect.transit.Writer;
 import com.fasterxml.jackson.core.JsonFactory;
 import com.fasterxml.jackson.core.JsonGenerator;
-import org.msgpack.MessagePack;
-import org.msgpack.packer.Packer;
+import org.msgpack.core.MessagePack;
+import org.msgpack.core.MessagePacker;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -61,7 +61,7 @@ public static <T> Writer<T> getMsgpackInstance(final OutputStream out, Map<Class
 
     public static <T> Writer<T> getMsgpackInstance(final OutputStream out, Map<Class, WriteHandler<?,?>> customHandlers, WriteHandler<?, ?> defaultWriteHandler, Function<Object,Object> transform) throws IOException {
 
-        Packer packer = new MessagePack().createPacker(out);
+        MessagePacker packer = MessagePack.newDefaultPacker(out);
 
         final MsgpackEmitter emitter = new MsgpackEmitter(packer, buildWriteHandlerMap(customHandlers), defaultWriteHandler, transform);