google-protobuf 3.21.9 → 3.25.5

data/lib/google/protobuf/ffi/object_cache.rb

@@ -0,0 +1,30 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2022 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+module Google
+  module Protobuf
+    private
+
+    SIZEOF_LONG = ::FFI::MemoryPointer.new(:long).size
+    SIZEOF_VALUE = ::FFI::Pointer::SIZE
+
+    def self.interpreter_supports_non_finalized_keys_in_weak_map?
+      ! defined? JRUBY_VERSION
+    end
+
+    def self.cache_implementation
+      if interpreter_supports_non_finalized_keys_in_weak_map? and SIZEOF_LONG >= SIZEOF_VALUE
+        Google::Protobuf::ObjectCache
+      else
+        Google::Protobuf::LegacyObjectCache
+      end
+    end
+
+    public
+    OBJECT_CACHE = cache_implementation.new
+  end
+end

data/lib/google/protobuf/ffi/oneof_descriptor.rb

@@ -0,0 +1,95 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2022 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+module Google
+  module Protobuf
+    class OneofDescriptor
+      attr :descriptor_pool, :oneof_def
+      include Enumerable
+
+      # FFI Interface methods and setup
+      extend ::FFI::DataConverter
+      native_type ::FFI::Type::POINTER
+
+      class << self
+        prepend Google::Protobuf::Internal::TypeSafety
+        include Google::Protobuf::Internal::PointerHelper
+
+        # @param value [OneofDescriptor] FieldDescriptor to convert to an FFI native type
+        # @param _ [Object] Unused
+        def to_native(value, _ = nil)
+          value.instance_variable_get(:@oneof_def) || ::FFI::Pointer::NULL
+        end
+
+        ##
+        # @param oneof_def [::FFI::Pointer] OneofDef pointer to be wrapped
+        # @param _ [Object] Unused
+        def from_native(oneof_def, _ = nil)
+          return nil if oneof_def.nil? or oneof_def.null?
+          message_descriptor = Google::Protobuf::FFI.get_oneof_containing_type oneof_def
+          raise RuntimeError.new "Message Descriptor is nil" if message_descriptor.nil?
+          file_def = Google::Protobuf::FFI.get_message_file_def message_descriptor.to_native
+          descriptor_from_file_def(file_def, oneof_def)
+        end
+      end
+
+      def self.new(*arguments, &block)
+        raise "OneofDescriptor objects may not be created from Ruby."
+      end
+
+      def name
+        Google::Protobuf::FFI.get_oneof_name(self)
+      end
+
+      def each &block
+        n = Google::Protobuf::FFI.get_oneof_field_count(self)
+        0.upto(n-1) do |i|
+          yield(Google::Protobuf::FFI.get_oneof_field_by_index(self, i))
+        end
+        nil
+      end
+
+      def options
+        @options ||= begin
+          size_ptr = ::FFI::MemoryPointer.new(:size_t, 1)
+          temporary_arena = Google::Protobuf::FFI.create_arena
+          buffer = Google::Protobuf::FFI.oneof_options(self, size_ptr, temporary_arena)
+          Google::Protobuf::OneofOptions.decode(buffer.read_string_length(size_ptr.read(:size_t)).force_encoding("ASCII-8BIT").freeze).send(:internal_deep_freeze)
+       end
+      end
+
+      private
+
+      def initialize(oneof_def, descriptor_pool)
+        @descriptor_pool = descriptor_pool
+        @oneof_def = oneof_def
+      end
+
+      def self.private_constructor(oneof_def, descriptor_pool)
+        instance = allocate
+        instance.send(:initialize, oneof_def, descriptor_pool)
+        instance
+      end
+    end
+
+    class FFI
+      # MessageDef
+      attach_function :get_oneof_by_name,        :upb_MessageDef_FindOneofByNameWithSize, [Descriptor, :string, :size_t], OneofDescriptor
+      attach_function :get_oneof_by_index,       :upb_MessageDef_Oneof,                   [Descriptor, :int], OneofDescriptor
+
+      # OneofDescriptor
+      attach_function :get_oneof_name,           :upb_OneofDef_Name,                      [OneofDescriptor], :string
+      attach_function :get_oneof_field_count,    :upb_OneofDef_FieldCount,                [OneofDescriptor], :int
+      attach_function :get_oneof_field_by_index, :upb_OneofDef_Field,                     [OneofDescriptor, :int], FieldDescriptor
+      attach_function :get_oneof_containing_type,:upb_OneofDef_ContainingType,            [:pointer], Descriptor
+      attach_function :oneof_options,            :OneOfDescriptor_serialized_options,     [OneofDescriptor, :pointer, Internal::Arena], :pointer
+
+      # FieldDescriptor
+      attach_function :real_containing_oneof,    :upb_FieldDef_RealContainingOneof,       [FieldDescriptor], OneofDescriptor
+    end
+  end
+end

data/lib/google/protobuf/ffi/repeated_field.rb

@@ -0,0 +1,383 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+#
+# This class makes RepeatedField act (almost-) like a Ruby Array.
+# It has convenience methods that extend the core C or Java based
+# methods.
+#
+# This is a best-effort to mirror Array behavior.  Two comments:
+#  1) patches always welcome :)
+#  2) if performance is an issue, feel free to rewrite the method
+#     in C.  The source code has plenty of examples
+#
+# KNOWN ISSUES
+#   - #[]= doesn't allow less used approaches such as `arr[1, 2] = 'fizz'`
+#   - #concat should return the orig array
+#   - #push should accept multiple arguments and push them all at the same time
+#
+module Google
+  module Protobuf
+    class FFI
+      # Array
+      attach_function :append_array, :upb_Array_Append,        [:Array, MessageValue.by_value, Internal::Arena], :bool
+      attach_function :get_msgval_at,:upb_Array_Get,           [:Array, :size_t], MessageValue.by_value
+      attach_function :create_array, :upb_Array_New,           [Internal::Arena, CType], :Array
+      attach_function :array_resize, :upb_Array_Resize,        [:Array, :size_t, Internal::Arena], :bool
+      attach_function :array_set,    :upb_Array_Set,           [:Array, :size_t, MessageValue.by_value], :void
+      attach_function :array_size,   :upb_Array_Size,          [:Array], :size_t
+    end
+
+    class RepeatedField
+      include Enumerable
+
+      ##
+      # call-seq:
+      #     RepeatedField.new(type, type_class = nil, initial_values = [])
+      #
+      # Creates a new repeated field. The provided type must be a Ruby symbol, and
+      # an take on the same values as those accepted by FieldDescriptor#type=. If
+      # the type is :message or :enum, type_class must be non-nil, and must be the
+      # Ruby class or module returned by Descriptor#msgclass or
+      # EnumDescriptor#enummodule, respectively. An initial list of elements may also
+      # be provided.
+      def self.new(type, type_class = nil, initial_values = [])
+        instance = allocate
+        # TODO This argument mangling doesn't agree with the type signature in the comments
+        # but is required to make unit tests pass;
+        if type_class.is_a?(Enumerable) and initial_values.empty? and ![:enum, :message].include?(type)
+          initial_values = type_class
+          type_class = nil
+        end
+        instance.send(:initialize, type, type_class: type_class, initial_values: initial_values)
+        instance
+      end
+
+      ##
+      # call-seq:
+      #     RepeatedField.each(&block)
+      #
+      # Invokes the block once for each element of the repeated field. RepeatedField
+      # also includes Enumerable; combined with this method, the repeated field thus
+      # acts like an ordinary Ruby sequence.
+      def each &block
+        each_msg_val do |element|
+          yield(convert_upb_to_ruby(element, type, descriptor, arena))
+        end
+        self
+      end
+
+      def [](*args)
+        count = length
+        if args.size < 1
+          raise ArgumentError.new "Index or range is a required argument."
+        end
+        if args[0].is_a? Range
+          if args.size > 1
+            raise ArgumentError.new "Expected 1 when passing Range argument, but got #{args.size}"
+          end
+          range = args[0]
+          # Handle begin-less and/or endless ranges, when supported.
+          index_of_first = range.respond_to?(:begin) ? range.begin : range.last
+          index_of_first = 0 if index_of_first.nil?
+          end_of_range = range.respond_to?(:end) ? range.end : range.last
+          index_of_last = end_of_range.nil? ? -1 : end_of_range
+
+          if index_of_last < 0
+            index_of_last += count
+          end
+          unless range.exclude_end? and !end_of_range.nil?
+            index_of_last += 1
+          end
+          index_of_first += count if index_of_first < 0
+          length = index_of_last - index_of_first
+          return [] if length.zero?
+        elsif args[0].is_a? Integer
+          index_of_first = args[0]
+          index_of_first += count if index_of_first < 0
+          if args.size > 2
+            raise ArgumentError.new "Expected 1 or 2 arguments, but got #{args.size}"
+          end
+          if args.size == 1 # No length specified, return one element
+            if array.null? or index_of_first < 0 or index_of_first >= count
+              return nil
+            else
+              return convert_upb_to_ruby(Google::Protobuf::FFI.get_msgval_at(array, index_of_first), type, descriptor, arena)
+            end
+          else
+            length = [args[1],count].min
+          end
+        else
+          raise NotImplementedError
+        end
+
+        if array.null? or index_of_first < 0 or index_of_first >= count
+          nil
+        else
+          if index_of_first + length > count
+            length = count - index_of_first
+          end
+          if length < 0
+            nil
+          else
+            subarray(index_of_first, length)
+          end
+        end
+      end
+      alias at []
+
+
+      def []=(index, value)
+        raise FrozenError if frozen?
+        count = length
+        index += count if index < 0
+        return nil if index < 0
+        if index >= count
+          resize(index+1)
+          empty_message_value = Google::Protobuf::FFI::MessageValue.new # Implicitly clear
+          count.upto(index-1) do |i|
+            Google::Protobuf::FFI.array_set(array, i, empty_message_value)
+          end
+        end
+        Google::Protobuf::FFI.array_set(array, index, convert_ruby_to_upb(value, arena, type, descriptor))
+        nil
+      end
+
+      def push(*elements)
+        raise FrozenError if frozen?
+        internal_push(*elements)
+      end
+
+      def <<(element)
+        raise FrozenError if frozen?
+        push element
+      end
+
+      def replace(replacements)
+        raise FrozenError if frozen?
+        clear
+        push(*replacements)
+      end
+
+      def clear
+        raise FrozenError if frozen?
+        resize 0
+        self
+      end
+
+      def length
+        array.null? ? 0 : Google::Protobuf::FFI.array_size(array)
+      end
+      alias size :length
+
+      def dup
+        instance = self.class.allocate
+        instance.send(:initialize, type, descriptor: descriptor, arena: arena)
+        each_msg_val do |element|
+          instance.send(:append_msg_val, element)
+        end
+        instance
+      end
+      alias clone dup
+
+      def ==(other)
+        return true if other.object_id == object_id
+        if other.is_a? RepeatedField
+          return false unless other.length == length
+          each_msg_val_with_index do |msg_val, i|
+            other_msg_val = Google::Protobuf::FFI.get_msgval_at(other.send(:array), i)
+            unless Google::Protobuf::FFI.message_value_equal(msg_val, other_msg_val, type, descriptor)
+              return false
+            end
+          end
+          return true
+        elsif other.is_a? Enumerable
+          return to_ary == other.to_a
+        end
+        false
+      end
+
+      ##
+      # call-seq:
+      #    RepeatedField.to_ary => array
+      #
+      # Used when converted implicitly into array, e.g. compared to an Array.
+      # Also called as a fallback of Object#to_a
+      def to_ary
+        return_value = []
+        each do |element|
+          return_value << element
+        end
+        return_value
+      end
+
+      def hash
+        return_value = 0
+        each_msg_val do |msg_val|
+          return_value = Google::Protobuf::FFI.message_value_hash(msg_val, type, descriptor, return_value)
+        end
+        return_value
+      end
+
+      def +(other)
+        if other.is_a? RepeatedField
+          if type != other.instance_variable_get(:@type) or descriptor != other.instance_variable_get(:@descriptor)
+            raise ArgumentError.new "Attempt to append RepeatedField with different element type."
+          end
+          fuse_arena(other.send(:arena))
+          super_set = dup
+          other.send(:each_msg_val) do |msg_val|
+            super_set.send(:append_msg_val, msg_val)
+          end
+          super_set
+        elsif other.is_a? Enumerable
+          super_set = dup
+          super_set.push(*other.to_a)
+        else
+          raise ArgumentError.new "Unknown type appending to RepeatedField"
+        end
+      end
+
+      def concat(other)
+        raise ArgumentError.new "Expected Enumerable, but got #{other.class}" unless other.is_a? Enumerable
+        push(*other.to_a)
+      end
+
+      private
+      include Google::Protobuf::Internal::Convert
+
+      attr :name, :arena, :array, :type, :descriptor
+
+      def internal_deep_freeze
+        freeze
+        if type == :message
+          each do |element|
+            element.send :internal_deep_freeze
+          end
+        end
+        self
+      end
+
+      def internal_push(*elements)
+        elements.each do |element|
+          append_msg_val convert_ruby_to_upb(element, arena, type, descriptor)
+        end
+        self
+      end
+
+      def pop_one
+        raise FrozenError if frozen?
+        count = length
+        return nil if length.zero?
+        last_element = Google::Protobuf::FFI.get_msgval_at(array, count-1)
+        return_value = convert_upb_to_ruby(last_element, type, descriptor, arena)
+        resize(count-1)
+        return_value
+      end
+
+      def subarray(start, length)
+        return_result = []
+        (start..(start + length - 1)).each do |i|
+          element = Google::Protobuf::FFI.get_msgval_at(array, i)
+          return_result << convert_upb_to_ruby(element, type, descriptor, arena)
+        end
+        return_result
+      end
+
+      def each_msg_val_with_index &block
+        n = array.null? ? 0 : Google::Protobuf::FFI.array_size(array)
+        0.upto(n-1) do |i|
+          yield Google::Protobuf::FFI.get_msgval_at(array, i), i
+        end
+      end
+
+      def each_msg_val &block
+        each_msg_val_with_index do |msg_val, _|
+          yield msg_val
+        end
+      end
+
+      # @param msg_val [Google::Protobuf::FFI::MessageValue] Value to append
+      def append_msg_val(msg_val)
+        unless Google::Protobuf::FFI.append_array(array, msg_val, arena)
+          raise NoMemoryError.new "Could not allocate room for #{msg_val} in Arena"
+        end
+      end
+
+      # @param new_size [Integer] New size of the array
+      def resize(new_size)
+        unless Google::Protobuf::FFI.array_resize(array, new_size, arena)
+          raise NoMemoryError.new "Array resize to #{new_size} failed!"
+        end
+      end
+
+      def initialize(type, type_class: nil, initial_values: nil, name: nil, arena: nil, array: nil, descriptor: nil)
+        @name = name || 'RepeatedField'
+        raise ArgumentError.new "Expected argument type to be a Symbol" unless type.is_a? Symbol
+        field_number = Google::Protobuf::FFI::FieldType[type]
+        raise ArgumentError.new "Unsupported type '#{type}'" if field_number.nil?
+        if !descriptor.nil?
+          @descriptor = descriptor
+        elsif [:message, :enum].include? type
+          raise ArgumentError.new "Expected at least 2 arguments for message/enum." if type_class.nil?
+          descriptor = type_class.respond_to?(:descriptor) ? type_class.descriptor : nil
+          raise ArgumentError.new "Type class #{type_class} has no descriptor. Please pass a class or enum as returned by the DescriptorPool." if descriptor.nil?
+          @descriptor = descriptor
+        else
+          @descriptor = nil
+        end
+        @type = type
+
+        @arena = arena || Google::Protobuf::FFI.create_arena
+        @array = array || Google::Protobuf::FFI.create_array(@arena, @type)
+        unless initial_values.nil?
+          unless initial_values.is_a? Enumerable
+            raise ArgumentError.new "Expected array as initializer value for repeated field '#{name}' (given #{initial_values.class})."
+          end
+          internal_push(*initial_values)
+        end
+
+        # Should always be the last expression of the initializer to avoid
+        # leaking references to this object before construction is complete.
+        OBJECT_CACHE.try_add(@array.address, self)
+      end
+
+      # @param field [FieldDescriptor] Descriptor of the field where the RepeatedField will be assigned
+      # @param values [Enumerable] Initial values; may be nil or empty
+      # @param arena [Arena] Owning message's arena
+      def self.construct_for_field(field, arena, values: nil, array: nil)
+        instance = allocate
+        options = {initial_values: values, name: field.name, arena: arena, array: array}
+        if [:enum, :message].include? field.type
+          options[:descriptor] = field.subtype
+        end
+        instance.send(:initialize, field.type, **options)
+        instance
+      end
+
+      def fuse_arena(arena)
+        arena.fuse(arena)
+      end
+
+      extend Google::Protobuf::Internal::Convert
+
+      def self.deep_copy(repeated_field)
+        instance = allocate
+        instance.send(:initialize, repeated_field.send(:type), descriptor: repeated_field.send(:descriptor))
+        instance.send(:resize, repeated_field.length)
+        new_array = instance.send(:array)
+        repeated_field.send(:each_msg_val_with_index) do |element, i|
+          Google::Protobuf::FFI.array_set(new_array, i, message_value_deep_copy(element, repeated_field.send(:type), repeated_field.send(:descriptor), instance.send(:arena)))
+        end
+        instance
+      end
+
+    end
+  end
+end
+
+require 'google/protobuf/repeated_field'

data/lib/google/protobuf/field_mask_pb.rb

@@ -1,14 +1,34 @@
+# frozen_string_literal: true
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: google/protobuf/field_mask.proto
 
 require 'google/protobuf'
 
-Google::Protobuf::DescriptorPool.generated_pool.build do
-  add_file("google/protobuf/field_mask.proto", :syntax => :proto3) do
-    add_message "google.protobuf.FieldMask" do
-      repeated :paths, :string, 1
+
+descriptor_data = "\n google/protobuf/field_mask.proto\x12\x0fgoogle.protobuf\"\x1a\n\tFieldMask\x12\r\n\x05paths\x18\x01 \x03(\tB\x85\x01\n\x13\x63om.google.protobufB\x0e\x46ieldMaskProtoP\x01Z2google.golang.org/protobuf/types/known/fieldmaskpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3"
+
+pool = Google::Protobuf::DescriptorPool.generated_pool
+
+begin
+  pool.add_serialized_file(descriptor_data)
+rescue TypeError
+  # Compatibility code: will be removed in the next major version.
+  require 'google/protobuf/descriptor_pb'
+  parsed = Google::Protobuf::FileDescriptorProto.decode(descriptor_data)
+  parsed.clear_dependency
+  serialized = parsed.class.encode(parsed)
+  file = pool.add_serialized_file(serialized)
+  warn "Warning: Protobuf detected an import path issue while loading generated file #{__FILE__}"
+  imports = [
+  ]
+  imports.each do |type_name, expected_filename|
+    import_file = pool.lookup(type_name).file_descriptor
+    if import_file.name != expected_filename
+      warn "- #{file.name} imports #{expected_filename}, but that import was loaded as #{import_file.name}"
     end
   end
+  warn "Each proto file must use a consistent fully-qualified name."
+  warn "This will become an error in the next major version."
 end
 
 module Google

data/lib/google/protobuf/message_exts.rb

@@ -1,32 +1,9 @@
 # Protocol Buffers - Google's data interchange format
 # Copyright 2008 Google Inc.  All rights reserved.
-# https://developers.google.com/protocol-buffers/
 #
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
 
 module Google
   module Protobuf
@@ -49,5 +26,10 @@ module Google
       end
 
     end
+    class AbstractMessage
+      include MessageExts
+      extend MessageExts::ClassMethods
+    end
+    private_constant :AbstractMessage
   end
 end

data/lib/google/protobuf/object_cache.rb

@@ -0,0 +1,97 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2023 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+module Google
+  module Protobuf
+    # A pointer -> Ruby Object cache that keeps references to Ruby wrapper
+    # objects.  This allows us to look up any Ruby wrapper object by the address
+    # of the object it is wrapping. That way we can avoid ever creating two
+    # different wrapper objects for the same C object, which saves memory and
+    # preserves object identity.
+    #
+    # We use WeakMap for the cache. If sizeof(long) > sizeof(VALUE), we also
+    # need a secondary Hash to store WeakMap keys, because our pointer keys may
+    # need to be stored as Bignum instead of Fixnum.  Since WeakMap is weak for
+    # both keys and values, a Bignum key will cause the WeakMap entry to be
+    # collected immediately unless there is another reference to the Bignum.
+    # This happens on 64-bit Windows, on which pointers are 64 bits but longs
+    # are 32 bits. In this case, we enable the secondary Hash to hold the keys
+    # and prevent them from being collected.
+    class ObjectCache
+      def initialize
+        @map = ObjectSpace::WeakMap.new
+        @mutex = Mutex.new
+      end
+
+      def get(key)
+        @map[key]
+      end
+
+      def try_add(key, value)
+        @map[key] || @mutex.synchronize do
+          @map[key] ||= value
+        end
+      end
+    end
+
+    class LegacyObjectCache
+      def initialize
+        @secondary_map = {}
+        @map = ObjectSpace::WeakMap.new
+        @mutex = Mutex.new
+      end
+
+      def get(key)
+        value = if secondary_key = @secondary_map[key]
+          @map[secondary_key]
+        else
+          @mutex.synchronize do
+            @map[(@secondary_map[key] ||= Object.new)]
+          end
+        end
+
+        # GC if we could remove at least 2000 entries or 20% of the table size
+        # (whichever is greater).  Since the cost of the GC pass is O(N), we
+        # want to make sure that we condition this on overall table size, to
+        # avoid O(N^2) CPU costs.
+        cutoff = (@secondary_map.size * 0.2).ceil
+        cutoff = 2_000 if cutoff < 2_000
+        if (@secondary_map.size - @map.size) > cutoff
+          purge
+        end
+
+        value
+      end
+
+      def try_add(key, value)
+        if secondary_key = @secondary_map[key]
+          if old_value = @map[secondary_key]
+            return old_value
+          end
+        end
+
+        @mutex.synchronize do
+          secondary_key ||= (@secondary_map[key] ||= Object.new)
+          @map[secondary_key] ||= value
+        end
+      end
+
+      private
+
+      def purge
+        @mutex.synchronize do
+          @secondary_map.each do |key, secondary_key|
+            unless @map.key?(secondary_key)
+              @secondary_map.delete(key)
+            end
+          end
+        end
+        nil
+      end
+    end
+  end
+end