SWAMPy

✎ CARVE FLESH

EDITING: factory.rb

module MessagePack
  class Factory
    # see ext for other methods

# [ {type: id, class: Class(or nil), packer: arg, unpacker: arg}, ... ]
    def registered_types(selector=:both)
      packer, unpacker = registered_types_internal
      # packer: Class -> [tid, proc, arg]
      # unpacker: tid -> [klass, proc, arg]

list = []

case selector
      when :both
        packer.each_pair do |klass, ary|
          type = ary[0]
          packer_arg = ary[2]
          unpacker_arg = nil
          if unpacker.has_key?(type) && unpacker[type][0] == klass
            unpacker_arg = unpacker.delete(type)[2]
          end
          list << {type: type, class: klass, packer: packer_arg, unpacker: unpacker_arg}
        end

# unpacker definition only
        unpacker.each_pair do |type, ary|
          list << {type: type, class: ary[0], packer: nil, unpacker: ary[2]}
        end

when :packer
        packer.each_pair do |klass, ary|
          list << {type: ary[0], class: klass, packer: ary[2]}
        end

when :unpacker
        unpacker.each_pair do |type, ary|
          list << {type: type, class: ary[0], unpacker: ary[2]}
        end

else
        raise ArgumentError, "invalid selector #{selector}"
      end

list.sort{|a, b| a[:type] <=> b[:type] }
    end

def type_registered?(klass_or_type, selector=:both)
      case klass_or_type
      when Class
        klass = klass_or_type
        registered_types(selector).any?{|entry| klass <= entry[:class] }
      when Integer
        type = klass_or_type
        registered_types(selector).any?{|entry| type == entry[:type] }
      else
        raise ArgumentError, "class or type id"
      end
    end

def load(src, param = nil)
      unpacker = nil

if src.is_a? String
        unpacker = unpacker(param)
        unpacker.feed(src)
      else
        unpacker = unpacker(src, param)
      end

unpacker.full_unpack
    end
    alias :unpack :load

def dump(v, *rest)
      packer = packer(*rest)
      packer.write(v)
      packer.full_pack
    end
    alias :pack :dump

def pool(size = 1, **options)
      Pool.new(
        frozen? ? self : dup.freeze,
        size,
        options.empty? ? nil : options,
      )
    end

class Pool
      if RUBY_ENGINE == "ruby"
        class AbstractPool
          def initialize(size, &block)
            @size = size
            @new_member = block
            @members = []
          end

def checkout
            @members.pop || @new_member.call
          end

def checkin(member)
            # If the pool is already full, we simply drop the extra member.
            # This is because contrary to a connection pool, creating an extra instance
            # is extremely unlikely to cause some kind of resource exhaustion.
            #
            # We could cycle the members (keep the newer one) but first It's more work and second
            # the older member might have been created pre-fork, so it might be at least partially
            # in shared memory.
            if member && @members.size < @size
              member.reset
              @members << member
            end
          end
        end
      else
        class AbstractPool
          def initialize(size, &block)
            @size = size
            @new_member = block
            @members = []
            @mutex = Mutex.new
          end

def checkout
            @mutex.synchronize { @members.pop } || @new_member.call
          end

def checkin(member)
            @mutex.synchronize do
              if member && @members.size < @size
                member.reset
                @members << member
              end
            end
          end
        end
      end

class PackerPool < AbstractPool
        private

def reset(packer)
          packer.clear
        end
      end

class UnpackerPool < AbstractPool
        private

def reset(unpacker)
          unpacker.reset
        end
      end

def initialize(factory, size, options = nil)
        options = nil if !options || options.empty?
        @factory = factory
        @packers = PackerPool.new(size) { factory.packer(options) }
        @unpackers = UnpackerPool.new(size) { factory.unpacker(options) }
      end

def load(data)
        unpacker = @unpackers.checkout
        begin
          unpacker.feed_reference(data)
          unpacker.full_unpack
        ensure
          @unpackers.checkin(unpacker)
        end
      end

def dump(object)
        packer = @packers.checkout
        begin
          packer.write(object)
          packer.full_pack
        ensure
          @packers.checkin(packer)
        end
      end
    end
  end
end

CANCEL

Name	Type	Size	Modified	Actions
↩ ..	DIR	—	—
📄 bigint.rb	RB	1.7 KB	2023-09-24 03:47	EDIT
📄 core_ext.rb	RB	2.1 KB	2023-09-24 03:47	EDIT
📄 factory.rb	RB	4.7 KB	2023-09-24 03:47	EDIT
📄 msgpack.so	SO	1.1 MB	2023-09-24 03:47	EDIT
📄 packer.rb	RB	666 B	2023-09-24 03:47	EDIT
📄 symbol.rb	RB	952 B	2023-09-24 03:47	EDIT
📄 time.rb	RB	951 B	2023-09-24 03:47	EDIT
📄 timestamp.rb	RB	2.1 KB	2023-09-24 03:47	EDIT
📄 unpacker.rb	RB	668 B	2023-09-24 03:47	EDIT
📄 version.rb	RB	206 B	2023-09-24 03:47	EDIT