msgpack 1.4.3 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 750c05b37865e3da4e2ca909840dfb4afd732799f756a89465c26f2e6e77ef91
-  data.tar.gz: afc8dfd5103e65068fa054d7daf2811c65fbb7627e2986a1a50ad0307d643113
+  metadata.gz: c9e04f0f240684f2b81a5f00f9afd951feac68ee06cf4dd6e229fa8d5925c5b0
+  data.tar.gz: 8bf61d049bcf041bcff6e33631dbc3a821de096aca8b1c5069478934a49cd2e6
 SHA512:
-  metadata.gz: 01af679c600ae449256f30a3beb5f9993266e1e8bcd11e5ec8e635301a713c3175131e112540660d8adc67ae06470043eee48d1a3b1ecc69b2e436eb0010579c
-  data.tar.gz: 13a82671e440447415c22d930dd795d4f1d6e07ea9328078ed25c887890bbc27080f38fb5d33da6cb15dc8dac2789e3a930548a64d298b1ca44b510bb3978d5f
+  metadata.gz: 58acbb7f3c139dfa153b21445242d202335dea3b1dab6f3f8cd6eac9d427122ea6ec9d4629a5f82674dda53fd9f8b546051d704555c1e1db40c566d9cb617ff9
+  data.tar.gz: cb3ec4aba6ef01722ef39fc3188ed43f1f3305daae900dc7bab2a15ff1e074512f75b482331c9d962f8e9ce258bee93bf2d6dbfb29cd2a0c8abccd3fcff58fd8

data/.github/workflows/ci.yaml

@@ -12,6 +12,7 @@ on:
 jobs:
   mri:
     strategy:
+      fail-fast: false
       matrix:
         os: [ubuntu, macos, windows]
         ruby: ['2.4', '2.5', '2.6', '2.7', '3.0', '3.1']
@@ -21,28 +22,28 @@ jobs:
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
-      - run: bundle install
+          bundler-cache: true # 'bundle install' and cache
       - run: bundle exec rake
 
   jruby:
     strategy:
+      fail-fast: false
       matrix:
         os: [ubuntu]
-        # TODO: update to 9.3.3.0 once supported
-        # https://github.com/ruby/setup-ruby#supported-versions
-        ruby: ['jruby-9.2.19.0', 'jruby-9.3.2.0']
+        ruby: ['jruby-9.2.19.0', 'jruby-9.3.3.0']
     runs-on: ${{ matrix.os }}-latest
     steps:
       - uses: actions/checkout@v2
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
-      - run: bundle install
+          bundler-cache: true # 'bundle install' and cache
       - run: bundle exec rake
 
   head-versions:
     continue-on-error: true
     strategy:
+      fail-fast: false
       matrix:
         os: [ubuntu]
         ruby: ['ruby-head', 'jruby-head', 'truffleruby']
@@ -52,5 +53,5 @@ jobs:
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
-      - run: bundle install
+          bundler-cache: true # 'bundle install' and cache
       - run: bundle exec rake || echo "failed, but ignore it"

data/ChangeLog

@@ -1,3 +1,21 @@
+2022-04-06 version 1.5.0:
+
+* Add recursive option on Factory#register_type to operate Packer/Unpacker manually
+* Add oversized_integer_extension option on Factory#register_type to pack/unpack bigint using ext types
+* Add Factory#pool method and Factory::Pool class to provide pooled Packer and Unpacker instances
+
+2022-02-15 version 1.4.5:
+
+* Fix to create UTF-8 Symbol keys when symbolize_keys: true
+* Fix to assume Symbols as US-ASCII or UTF-8
+* Optimize Packer/Unpacker initialization
+* Optimize extension class lookup
+* Rename Packer#clear as Packer#reset (#clear is still available as an alias)
+
+2022-01-22 version 1.4.4:
+
+* Specify the build option --platform=8 for older Java platforms
+
 2022-01-20 version 1.4.3:
 
 * Optimize serialization/deserialization of Symbols

data/README.md

@@ -187,6 +187,28 @@ MessagePack::DefaultFactory.register_type(0x03, MyClass3)
 MessagePack.unpack(data_with_ext_typeid_03) #=> MyClass3 instance
 ```
 
+Alternatively, extension types can call the packer or unpacker recursively to generate the extension data:
+
+```ruby
+Point = Struct.new(:x, :y)
+factory = MessagePack::Factory.new
+factory.register_type(
+  0x01,
+  Point,
+  packer: ->(point, packer) {
+    packer.write(point.x)
+    packer.write(point.y)
+  },
+  unpacker: ->(unpacker) {
+    x = unpacker.read
+    y = unpacker.read
+    Point.new(x, y)
+  },
+  recursive: true,
+)
+factory.load(factory.dump(Point.new(12, 34))) # => #<struct Point x=12, y=34>
+```
+
 ## Buffer API
 
 MessagePack for Ruby provides a buffer API so that you can read or write data by hand, not via Packer or Unpacker API.

data/Rakefile

@@ -34,8 +34,7 @@ if RUBY_PLATFORM =~ /java/
     jars = ["#{jruby_home}/lib/jruby.jar"]
     ext.classpath = jars.map { |x| File.expand_path(x) }.join(':')
     ext.lib_dir = File.join(*['lib', 'msgpack', ENV['FAT_DIR']].compact)
-    ext.source_version = '1.8'
-    ext.target_version = '1.8'
+    ext.release = '8'
   end
 else
   require 'rake/extensiontask'

data/doclib/msgpack/factory.rb

@@ -31,7 +31,7 @@ module MessagePack
     #
     # See Packer#initialize for supported options.
     #
-    def dump(obj, options={})
+    def dump(obj, options=nil)
     end
     alias pack dump
 
@@ -57,13 +57,13 @@ module MessagePack
     #
     # See Unpacker#initialize for supported options.
     #
-    def load(data, options={})
+    def load(data, options=nil)
     end
     alias unpack load
 
     #
     # Register a type and Class to be registered for packer and/or unpacker.
-    # If options are not speicified, factory will use :to_msgpack_ext for packer, and
+    # If options are not specified, factory will use :to_msgpack_ext for packer, and
     # :from_msgpack_ext for unpacker.
     #
     # @param type [Fixnum] type id of registered Class (0-127)
@@ -76,6 +76,7 @@ module MessagePack
     # * *:packer* specify symbol or proc object for packer
     # * *:unpacker* specify symbol or proc object for unpacker
     # * *:optimized_symbols_parsing* specify true to use the optimized symbols parsing (not supported on JRuby now)
+    # * *recursive* specify true to receive the packer or unpacker as argument to generate the extension body manually.
     #
     def register_type(type, klass, options={})
     end
@@ -98,5 +99,47 @@ module MessagePack
     #
     def type_registered?(klass_or_type, selector=:both)
     end
+
+    #
+    # Creates a MessagePack::PooledFactory instance of the given size.
+    #
+    # PooledFactory keeps Packer and Unpacker instance in a pool for improved performance.
+    # Note that the size defines how many instances are kept in cache, not the maximum of instances
+    # that can be created. If the pool limit is reached, a new instance is created anyway.
+    #
+    # @param size [Fixnum] specify how many Packer and Unpacker to keep in cache (default 1)
+    # @param options [Hash] Combined options for Packer and Unpacker. See Packer#initialize and Unpacker#initialize
+    #                       for supported options.
+    def pool(size=1, **options)
+    end
+
+    class Pool
+      #
+      # Deserializes an object from the string or io and returns it.
+      #
+      # If there're not enough data to deserialize one object, this method raises EOFError.
+      # If data format is invalid, this method raises MessagePack::MalformedFormatError.
+      # If the object nests too deeply, this method raises MessagePack::StackError.
+      #
+      # @param data [String]
+      # @return [Object] deserialized object
+      #
+      # See Unpacker#initialize for supported options.
+      #
+      def load(data)
+      end
+
+      #
+      # Serialize the passed value
+      #
+      # If it could not serialize the object, it raises
+      # NoMethodError: undefined method `to_msgpack' for #<the_object>.
+      #
+      # @param obj [Object] object to serialize
+      # @return [String] serialized object
+      #
+      def dump(object)
+      end
+    end
   end
 end

data/doclib/msgpack/packer.rb

@@ -14,7 +14,7 @@ module MessagePack
     # @overload initialize(io, options={})
     #   @param io [IO]
     #   @param options [Hash]
-    #   This packer writes serialzied objects into the IO when the internal buffer is filled.
+    #   This packer writes serialized objects into the IO when the internal buffer is filled.
     #   _io_ must respond to write(string) or append(string) method.
     #
     # Supported options:
@@ -33,12 +33,12 @@ module MessagePack
     #
     # @overload register_type(type, klass, &block)
     #   @param type [Fixnum] type id (0-127) user defined type id for specified Class
-    #   @param klass [Class] Class to be serialized with speicifed type id
+    #   @param klass [Class] Class to be serialized with specified type id
     #   @yieldparam object [Object] object to be serialized
     #
     # @overload register_type(type, klass, method_name)
     #   @param type [Fixnum] type id (0-127) user defined type id for specified Class
-    #   @param klass [Class] Class to be serialized with speicifed type id
+    #   @param klass [Class] Class to be serialized with specified type id
     #   @param method_name [Symbol] method which returns bytes of serialized representation
     #
     # @return nil
@@ -155,8 +155,9 @@ module MessagePack
     #
     # @return nil
     #
-    def clear
+    def reset
     end
+    alias clear reset
 
     #
     # Returns size of the internal buffer. Same as buffer.size.

data/doclib/msgpack/unpacker.rb

@@ -36,7 +36,7 @@ module MessagePack
     #
     # @overload register_type(type, klass, class_method_name)
     #   @param type [Fixnum] type id (0-127) user defined type id for specified Class
-    #   @param klass [Class] Class to be serialized with speicifed type id
+    #   @param klass [Class] Class to be serialized with specified type id
     #   @param class_method_name [Symbol] class method which returns an instance object
     #
     # @return nil
@@ -149,7 +149,7 @@ module MessagePack
     #
     # It repeats until the io or internal buffer does not include any complete objects.
     #
-    # If the an IO is set, it repeats to read data from the IO when the buffer
+    # If an IO is set, it repeats to read data from the IO when the buffer
     # becomes empty until the IO raises EOFError.
     #
     # This method could raise same errors with _read_ excepting EOFError.

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

@@ -224,4 +224,10 @@ public class Buffer extends RubyObject {
   public IRubyObject writeTo(ThreadContext ctx, IRubyObject io) {
     return io.callMethod(ctx, "write", readCommon(ctx, null, false));
   }
+
+  public ByteList getBytes() {
+    byte[] bytes = new byte[rawSize()];
+    buffer.get(bytes);
+    return new ByteList(bytes, binaryEncoding);
+  }
 }

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

@@ -14,6 +14,7 @@ import org.jruby.RubyBignum;
 import org.jruby.RubyString;
 import org.jruby.RubyArray;
 import org.jruby.RubyHash;
+import org.jruby.RubyInteger;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
@@ -35,7 +36,7 @@ public class Decoder implements Iterator<IRubyObject> {
   private final RubyClass unexpectedTypeErrorClass;
   private final RubyClass unknownExtTypeErrorClass;
 
-  private ExtensionRegistry registry;
+  private Unpacker unpacker;
   private ByteBuffer buffer;
   private boolean symbolizeKeys;
   private boolean freeze;
@@ -45,29 +46,29 @@ public class Decoder implements Iterator<IRubyObject> {
     this(runtime, null, new byte[] {}, 0, 0, false, false, false);
   }
 
-  public Decoder(Ruby runtime, ExtensionRegistry registry) {
-    this(runtime, registry, new byte[] {}, 0, 0, false, false, false);
+  public Decoder(Ruby runtime, Unpacker unpacker) {
+    this(runtime, unpacker, new byte[] {}, 0, 0, false, false, false);
   }
 
   public Decoder(Ruby runtime, byte[] bytes) {
     this(runtime, null, bytes, 0, bytes.length, false, false, false);
   }
 
-  public Decoder(Ruby runtime, ExtensionRegistry registry, byte[] bytes) {
-    this(runtime, registry, bytes, 0, bytes.length, false, false, false);
+  public Decoder(Ruby runtime, Unpacker unpacker, byte[] bytes) {
+    this(runtime, unpacker, bytes, 0, bytes.length, false, false, false);
   }
 
-  public Decoder(Ruby runtime, ExtensionRegistry registry, byte[] bytes, boolean symbolizeKeys, boolean freeze, boolean allowUnknownExt) {
-    this(runtime, registry, bytes, 0, bytes.length, symbolizeKeys, freeze, allowUnknownExt);
+  public Decoder(Ruby runtime, Unpacker unpacker, byte[] bytes, boolean symbolizeKeys, boolean freeze, boolean allowUnknownExt) {
+    this(runtime, unpacker, bytes, 0, bytes.length, symbolizeKeys, freeze, allowUnknownExt);
   }
 
-  public Decoder(Ruby runtime, ExtensionRegistry registry, byte[] bytes, int offset, int length) {
-    this(runtime, registry, bytes, offset, length, false, false, false);
+  public Decoder(Ruby runtime, Unpacker unpacker, byte[] bytes, int offset, int length) {
+    this(runtime, unpacker, bytes, offset, length, false, false, false);
   }
 
-  public Decoder(Ruby runtime, ExtensionRegistry registry, byte[] bytes, int offset, int length, boolean symbolizeKeys, boolean freeze, boolean allowUnknownExt) {
+  public Decoder(Ruby runtime, Unpacker unpacker, byte[] bytes, int offset, int length, boolean symbolizeKeys, boolean freeze, boolean allowUnknownExt) {
     this.runtime = runtime;
-    this.registry = registry;
+    this.unpacker = unpacker;
     this.symbolizeKeys = symbolizeKeys;
     this.freeze = freeze;
     this.allowUnknownExt = allowUnknownExt;
@@ -154,18 +155,21 @@ public class Decoder implements Iterator<IRubyObject> {
 
   private IRubyObject consumeExtension(int size) {
     int type = buffer.get();
-    byte[] payload = readBytes(size);
-
-    if (registry != null) {
-      IRubyObject proc = registry.lookupUnpackerByTypeId(type);
-      if (proc != null) {
-        ByteList byteList = new ByteList(payload, runtime.getEncodingService().getAscii8bitEncoding());
-        return proc.callMethod(runtime.getCurrentContext(), "call", runtime.newString(byteList));
+    if (unpacker != null) {
+      ExtensionRegistry.ExtensionEntry entry = unpacker.lookupExtensionByTypeId(type);
+      if (entry != null) {
+        IRubyObject proc = entry.getUnpackerProc();
+        if (entry.isRecursive()) {
+          return proc.callMethod(runtime.getCurrentContext(), "call", unpacker);
+        } else {
+          ByteList byteList = new ByteList(readBytes(size), runtime.getEncodingService().getAscii8bitEncoding());
+          return proc.callMethod(runtime.getCurrentContext(), "call", runtime.newString(byteList));
+        }
       }
     }
 
     if (this.allowUnknownExt) {
-      return ExtensionValue.newExtensionValue(runtime, type, payload);
+      return ExtensionValue.newExtensionValue(runtime, type, readBytes(size));
     }
 
     throw runtime.newRaiseException(unknownExtTypeErrorClass, "unexpected extension type");

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

@@ -38,12 +38,16 @@ public class Encoder {
   private final Encoding utf8Encoding;
   private final boolean compatibilityMode;
   private final ExtensionRegistry registry;
+  private final Packer packer;
 
   public boolean hasSymbolExtType;
+  private boolean hasBigintExtType;
+  private boolean recursiveExtension;
 
   private ByteBuffer buffer;
 
-  public Encoder(Ruby runtime, boolean compatibilityMode, ExtensionRegistry registry, boolean hasSymbolExtType) {
+  public Encoder(Ruby runtime, Packer packer, boolean compatibilityMode, ExtensionRegistry registry, boolean hasSymbolExtType, boolean hasBigintExtType) {
+    this.packer = packer;
     this.runtime = runtime;
     this.buffer = ByteBuffer.allocate(CACHE_LINE_SIZE - ARRAY_HEADER_SIZE);
     this.binaryEncoding = runtime.getEncodingService().getAscii8bitEncoding();
@@ -51,6 +55,7 @@ public class Encoder {
     this.compatibilityMode = compatibilityMode;
     this.registry = registry;
     this.hasSymbolExtType = hasSymbolExtType;
+    this.hasBigintExtType = hasBigintExtType;
   }
 
   public boolean isCompatibilityMode() {
@@ -66,9 +71,17 @@ public class Encoder {
   }
 
   private IRubyObject readRubyString() {
-    IRubyObject str = runtime.newString(new ByteList(buffer.array(), 0, buffer.position(), binaryEncoding, false));
-    buffer.clear();
-    return str;
+    if (recursiveExtension) {
+      // If recursiveExtension is true, it means we re-entered encode, so we MUST NOT flush the buffer.
+	  // Instead we return an empty string to act as a null object for the caller. The buffer will actually
+	  // be flushed once we're done serializing the recursive extension.
+	  // All other method that consume the buffer should do so through readRubyString or implement the same logic.
+      return runtime.newString();
+    } else {
+      IRubyObject str = runtime.newString(new ByteList(buffer.array(), 0, buffer.position(), binaryEncoding, false));
+      buffer.clear();
+      return str;
+    }
   }
 
   public IRubyObject encode(IRubyObject object) {
@@ -147,7 +160,10 @@ public class Encoder {
     BigInteger value = object.getBigIntegerValue();
     if (value.compareTo(RubyBignum.LONG_MIN) < 0 || value.compareTo(RubyBignum.LONG_MAX) > 0) {
       if (value.bitLength() > 64 || (value.bitLength() > 63 && value.signum() < 0)) {
-        throw runtime.newArgumentError(String.format("Cannot pack big integer: %s", value));
+        if (hasBigintExtType && tryAppendWithExtTypeLookup(object)) {
+          return;
+        }
+        throw runtime.newRangeError(String.format("Cannot pack big integer: %s", value));
       }
       ensureRemainingCapacity(9);
       buffer.put(value.signum() < 0 ? INT64 : UINT64);
@@ -391,19 +407,30 @@ public class Encoder {
 
   private boolean tryAppendWithExtTypeLookup(IRubyObject object) {
     if (registry != null) {
-      RubyModule lookupClass;
-
-      if (object.getType() == runtime.getSymbol()) {
-        lookupClass = object.getType();
-      } else {
-        lookupClass = object.getSingletonClass();
-      }
-
-      IRubyObject[] pair = registry.lookupPackerForObject(object);
-      if (pair != null) {
-        RubyString bytes = pair[0].callMethod(runtime.getCurrentContext(), "call", object).asString();
-        int type = (int) ((RubyFixnum) pair[1]).getLongValue();
-        appendExt(type, bytes.getByteList());
+      ExtensionRegistry.ExtensionEntry entry = registry.lookupExtensionForObject(object);
+      if (entry != null) {
+        IRubyObject proc = entry.getPackerProc();
+        int type = entry.getTypeId();
+
+        if (entry.isRecursive()) {
+          ByteBuffer oldBuffer = buffer;
+          buffer = ByteBuffer.allocate(CACHE_LINE_SIZE - ARRAY_HEADER_SIZE);
+          recursiveExtension = true;
+
+          ByteList payload;
+          try {
+            IRubyObject args[] = { object, packer };
+            proc.callMethod(runtime.getCurrentContext(), "call", args);
+            payload = new ByteList(buffer.array(), 0, buffer.position(), binaryEncoding, false);
+          } finally {
+            recursiveExtension = false;
+            buffer = oldBuffer;
+          }
+          appendExt(type, payload);
+        } else {
+          RubyString bytes = proc.callMethod(runtime.getCurrentContext(), "call", object).asString();
+          appendExt(type, bytes.getByteList());
+        }
         return true;
       }
     }

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

@@ -59,64 +59,46 @@ public class ExtensionRegistry {
     return hash;
   }
 
-  public void put(RubyModule mod, int typeId, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
-    ExtensionEntry entry = new ExtensionEntry(mod, typeId, packerProc, packerArg, unpackerProc, unpackerArg);
+  public void put(RubyModule mod, int typeId, boolean recursive, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
+    ExtensionEntry entry = new ExtensionEntry(mod, typeId, recursive, packerProc, packerArg, unpackerProc, unpackerArg);
     extensionsByModule.put(mod, entry);
     extensionsByTypeId[typeId + 128] = entry;
     extensionsByAncestor.clear();
   }
 
-  public IRubyObject lookupUnpackerByTypeId(int typeId) {
+  public ExtensionEntry lookupExtensionByTypeId(int typeId) {
     ExtensionEntry e = extensionsByTypeId[typeId + 128];
     if (e != null && e.hasUnpacker()) {
-      return e.getUnpackerProc();
-    } else {
-      return null;
+      return e;
     }
+    return null;
   }
 
-  public IRubyObject[] lookupPackerForObject(IRubyObject object) {
+  public ExtensionEntry lookupExtensionForObject(IRubyObject object) {
     RubyModule lookupClass = null;
-    IRubyObject[] pair;
+    ExtensionEntry entry = null;
     /*
      * Objects of type Integer (Fixnum, Bignum), Float, Symbol and frozen
      * String have no singleton class and raise a TypeError when trying to get
      * it.
-     *
-     * Since all but symbols are already filtered out when reaching this code
-     * only symbols are checked here.
      */
-    if (!(object instanceof RubySymbol)) {
-      lookupClass = object.getSingletonClass();
-      pair = fetchEntryByModule(lookupClass);
-      if (pair != null) {
-          return pair;
-      }
+    lookupClass = object.getMetaClass();
+    entry = extensionsByModule.get(lookupClass);
+    if (entry != null && entry.hasPacker()) {
+      return entry;
     }
 
-    pair = fetchEntryByModule(object.getType());
-    if (pair != null) {
-      return pair;
+    RubyModule realClass = object.getType();
+    if (realClass != lookupClass) {
+      entry = extensionsByModule.get(realClass);
+      if (entry != null && entry.hasPacker()) {
+        return entry;
+      }
     }
 
-    if (lookupClass == null) {
-      lookupClass = object.getType(); // only for Symbol
-    }
-    ExtensionEntry e = findEntryByModuleOrAncestor(lookupClass);
-    if (e != null && e.hasPacker()) {
-      extensionsByAncestor.put(e.getExtensionModule(), e);
-      return e.toPackerProcTypeIdPair(lookupClass.getRuntime().getCurrentContext());
-    }
-    return null;
-  }
-
-  private IRubyObject[] fetchEntryByModule(final RubyModule mod) {
-    ExtensionEntry e = extensionsByModule.get(mod);
-    if (e == null) {
-      e = extensionsByAncestor.get(mod);
-    }
-    if (e != null && e.hasPacker()) {
-      return e.toPackerProcTypeIdPair(mod.getRuntime().getCurrentContext());
+    entry = findEntryByModuleOrAncestor(lookupClass);
+    if (entry != null && entry.hasPacker()) {
+      return entry;
     }
     return null;
   }
@@ -132,17 +114,19 @@ public class ExtensionRegistry {
     return null;
   }
 
-  private static class ExtensionEntry {
+  public static class ExtensionEntry {
     private final RubyModule mod;
     private final int typeId;
+    private final boolean recursive;
     private final IRubyObject packerProc;
     private final IRubyObject packerArg;
     private final IRubyObject unpackerProc;
     private final IRubyObject unpackerArg;
 
-    public ExtensionEntry(RubyModule mod, int typeId, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
+    public ExtensionEntry(RubyModule mod, int typeId, boolean recursive, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
       this.mod = mod;
       this.typeId = typeId;
+      this.recursive = recursive;
       this.packerProc = packerProc;
       this.packerArg = packerArg;
       this.unpackerProc = unpackerProc;
@@ -157,6 +141,10 @@ public class ExtensionRegistry {
       return typeId;
     }
 
+    public boolean isRecursive() {
+      return recursive;
+    }
+
     public boolean hasPacker() {
       return packerProc != null;
     }